diff --git a/src/plugins/intel_cpu/CMakeLists.txt b/src/plugins/intel_cpu/CMakeLists.txt
index 04909c7d8f5a5a..eb56a3fb39503e 100644
--- a/src/plugins/intel_cpu/CMakeLists.txt
+++ b/src/plugins/intel_cpu/CMakeLists.txt
@@ -242,7 +242,8 @@ ov_add_plugin(NAME ${TARGET_NAME}
               DEVICE_NAME "CPU"
               AS_EXTENSION
               VERSION_DEFINES_FOR src/plugin.cpp
-              SOURCES ${SOURCES} ${HEADERS})
+              SOURCES ${SOURCES} ${HEADERS}
+              ADD_CLANG_FORMAT)
 
 # give a different file name depending on target platform architecture
 if(ARM OR AARCH64)
diff --git a/src/plugins/intel_cpu/src/cache/cache_entry.h b/src/plugins/intel_cpu/src/cache/cache_entry.h
index 135a1090a60045..6e71e207b0a71c 100644
--- a/src/plugins/intel_cpu/src/cache/cache_entry.h
+++ b/src/plugins/intel_cpu/src/cache/cache_entry.h
@@ -4,8 +4,9 @@
 
 #pragma once
 
-#include <memory>
 #include <functional>
+#include <memory>
+
 #include "lru_cache.h"
 
 namespace ov {
@@ -13,27 +14,24 @@ namespace intel_cpu {
 
 class CacheEntryBase {
 public:
-    enum class LookUpStatus : int8_t {
-        Hit,
-        Miss
-    };
+    enum class LookUpStatus : int8_t { Hit, Miss };
+
 public:
     virtual ~CacheEntryBase() = default;
 };
 
 /**
  * @brief Class represents a templated record in multi cache
- * @tparam KeyType is a key type that must define hash() const method with return type convertible to size_t and define comparison operator.
+ * @tparam KeyType is a key type that must define hash() const method with return type convertible to size_t and define
+ * comparison operator.
  * @tparam ValType is a type that must meet all the requirements to the std::unordered_map mapped type
- * @tparam ImplType is a type for the internal storage. It must provide put(KeyType, ValueType) and ValueType get(const KeyType&)
- *         interface and must have constructor of type ImplType(size_t).
+ * @tparam ImplType is a type for the internal storage. It must provide put(KeyType, ValueType) and ValueType get(const
+ * KeyType&) interface and must have constructor of type ImplType(size_t).
  *
  * @note In this implementation default constructed value objects are treated as empty objects.
  */
 
-template<typename KeyType,
-         typename ValType,
-         typename ImplType = LruCache<KeyType, ValType>>
+template <typename KeyType, typename ValType, typename ImplType = LruCache<KeyType, ValType>>
 class CacheEntry : public CacheEntryBase {
 public:
     using ResultType = std::pair<ValType, LookUpStatus>;
@@ -42,11 +40,12 @@ class CacheEntry : public CacheEntryBase {
     explicit CacheEntry(size_t capacity) : _impl(capacity) {}
 
     /**
-     * @brief Searches the key in the underlying storage and returns value if it exists, or creates a value using the builder functor and adds it to
-     *        the underlying storage.
+     * @brief Searches the key in the underlying storage and returns value if it exists, or creates a value using the
+     * builder functor and adds it to the underlying storage.
      * @param key is the search key
      * @param builder is a callable object that creates the ValType object from the KeyType lval reference
-     * @return result of the operation which is a pair of the requested object of ValType and the status of whether the cache hit or miss occurred
+     * @return result of the operation which is a pair of the requested object of ValType and the status of whether the
+     * cache hit or miss occurred
      */
 
     ResultType getOrCreate(const KeyType& key, std::function<ValType(const KeyType&)> builder) {
@@ -70,5 +69,5 @@ class CacheEntry : public CacheEntryBase {
     ImplType _impl;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/cache/lru_cache.h b/src/plugins/intel_cpu/src/cache/lru_cache.h
index 792451da16c484..c3a4d47aa9de9f 100644
--- a/src/plugins/intel_cpu/src/cache/lru_cache.h
+++ b/src/plugins/intel_cpu/src/cache/lru_cache.h
@@ -10,7 +10,8 @@
 
 /**
  * @brief This is yet another implementation of a preemptive cache with LRU eviction policy.
- * @tparam Key is a key type that must define hash() const method with return type convertible to size_t and define comparison operator.
+ * @tparam Key is a key type that must define hash() const method with return type convertible to size_t and define
+ * comparison operator.
  * @tparam Value is a type that must meet all the requirements to the std::unordered_map mapped type
  *
  * @attention This cache implementation IS NOT THREAD SAFE!
@@ -19,7 +20,7 @@
 namespace ov {
 namespace intel_cpu {
 
-template<typename Key, typename Value>
+template <typename Key, typename Value>
 class LruCache {
 public:
     using value_type = std::pair<Key, Value>;
@@ -33,7 +34,7 @@ class LruCache {
      * @param value
      */
 
-    void put(const Key &key, const Value &val) {
+    void put(const Key& key, const Value& val) {
         if (0 == _capacity) {
             return;
         }
@@ -56,7 +57,7 @@ class LruCache {
      * @return Value associated with the key or default constructed instance of the Value type.
      */
 
-    Value get(const Key &key) {
+    Value get(const Key& key) {
         auto itr = _cacheMapper.find(key);
         if (itr == _cacheMapper.end()) {
             return Value();
@@ -82,13 +83,13 @@ class LruCache {
      * @brief Returns the current capacity value
      * @return the current capacity value
      */
-     size_t getCapacity() const noexcept {
-         return _capacity;
-     }
+    size_t getCapacity() const noexcept {
+        return _capacity;
+    }
 
 private:
     struct key_hasher {
-        std::size_t operator()(const Key &k) const {
+        std::size_t operator()(const Key& k) const {
             return k.hash();
         }
     };
@@ -105,5 +106,5 @@ class LruCache {
     size_t _capacity;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/cache/multi_cache.cpp b/src/plugins/intel_cpu/src/cache/multi_cache.cpp
index 29dad18a41c770..325dfb517831b5 100644
--- a/src/plugins/intel_cpu/src/cache/multi_cache.cpp
+++ b/src/plugins/intel_cpu/src/cache/multi_cache.cpp
@@ -9,5 +9,5 @@ namespace intel_cpu {
 
 std::atomic_size_t MultiCache::_typeIdCounter{0};
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/cache/multi_cache.h b/src/plugins/intel_cpu/src/cache/multi_cache.h
index d9b6e5f8bfe19a..e216efe6fea801 100644
--- a/src/plugins/intel_cpu/src/cache/multi_cache.h
+++ b/src/plugins/intel_cpu/src/cache/multi_cache.h
@@ -4,9 +4,10 @@
 
 #pragma once
 
+#include <atomic>
 #include <functional>
 #include <unordered_map>
-#include <atomic>
+
 #include "cache_entry.h"
 
 namespace ov {
@@ -20,27 +21,28 @@ namespace intel_cpu {
 
 class MultiCache {
 public:
-    template<typename KeyType, typename ValueType>
+    template <typename KeyType, typename ValueType>
     using EntryTypeT = CacheEntry<KeyType, ValueType>;
     using EntryBasePtr = std::shared_ptr<CacheEntryBase>;
-    template<typename KeyType, typename ValueType>
+    template <typename KeyType, typename ValueType>
     using EntryPtr = std::shared_ptr<EntryTypeT<KeyType, ValueType>>;
 
 public:
     /**
-    * @param capacity here means maximum records limit FOR EACH entry specified by a pair of Key/Value types.
-    * @note zero capacity means empty cache so no records are stored and no entries are created
-    */
+     * @param capacity here means maximum records limit FOR EACH entry specified by a pair of Key/Value types.
+     * @note zero capacity means empty cache so no records are stored and no entries are created
+     */
     explicit MultiCache(size_t capacity) : _capacity(capacity) {}
 
     /**
-    * @brief Searches a value of ValueType in the cache using the provided key or creates a new ValueType instance (if nothing was found)
-    *       using the key and the builder functor and adds the new record to the cache
-    * @param key is the search key
-    * @param builder is a callable object that creates the ValType object from the KeyType lval reference.
-    *       Also the builder type is used for the ValueType deduction
-    * @return result of the operation which is a pair of the requested object of ValType and the status of whether the cache hit or miss occurred
-    */
+     * @brief Searches a value of ValueType in the cache using the provided key or creates a new ValueType instance (if
+     * nothing was found) using the key and the builder functor and adds the new record to the cache
+     * @param key is the search key
+     * @param builder is a callable object that creates the ValType object from the KeyType lval reference.
+     *       Also the builder type is used for the ValueType deduction
+     * @return result of the operation which is a pair of the requested object of ValType and the status of whether the
+     * cache hit or miss occurred
+     */
     template <typename KeyType,
               typename BuilderType,
 #if (defined(_MSVC_LANG) && (_MSVC_LANG > 201703L)) || (defined(__cplusplus) && (__cplusplus > 201703L))
@@ -54,9 +56,9 @@ class MultiCache {
     }
 
 private:
-    template<typename T>
+    template <typename T>
     size_t getTypeId();
-    template<typename KeyType, typename ValueType>
+    template <typename KeyType, typename ValueType>
     EntryPtr<KeyType, ValueType> getEntry();
 
 private:
@@ -65,13 +67,13 @@ class MultiCache {
     std::unordered_map<size_t, EntryBasePtr> _storage;
 };
 
-template<typename T>
+template <typename T>
 size_t MultiCache::getTypeId() {
     static size_t id = _typeIdCounter.fetch_add(1);
     return id;
 }
 
-template<typename KeyType, typename ValueType>
+template <typename KeyType, typename ValueType>
 MultiCache::EntryPtr<KeyType, ValueType> MultiCache::getEntry() {
     using EntryType = EntryTypeT<KeyType, ValueType>;
     size_t id = getTypeId<EntryType>();
@@ -88,5 +90,5 @@ using MultiCacheWeakCPtr = std::weak_ptr<const MultiCache>;
 using MultiCachePtr = std::shared_ptr<MultiCache>;
 using MultiCacheCPtr = std::shared_ptr<const MultiCache>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/compiled_model.cpp b/src/plugins/intel_cpu/src/compiled_model.cpp
index 275fd0dbfff755..b237d507526d49 100644
--- a/src/plugins/intel_cpu/src/compiled_model.cpp
+++ b/src/plugins/intel_cpu/src/compiled_model.cpp
@@ -3,29 +3,30 @@
 //
 
 #include "compiled_model.h"
+
+#include <cstring>
+#include <utility>
+
 #include "async_infer_request.h"
+#include "cpu/x64/cpu_isa_traits.hpp"
 #include "infer_request.h"
 #include "itt.h"
 #include "low_precision/low_precision.hpp"
 #include "memory_state.h"
 #include "openvino/core/type/element_type.hpp"
 #include "openvino/runtime/intel_cpu/properties.hpp"
-#include "openvino/runtime/threading/executor_manager.hpp"
-#include "transformations/transformation_pipeline.h"
 #include "openvino/runtime/properties.hpp"
-#include "openvino/util/common_util.hpp"
+#include "openvino/runtime/threading/cpu_message.hpp"
 #include "openvino/runtime/threading/cpu_streams_executor.hpp"
-#include "transformations/utils/utils.hpp"
 #include "openvino/runtime/threading/cpu_streams_info.hpp"
-#include "openvino/runtime/threading/cpu_message.hpp"
+#include "openvino/runtime/threading/executor_manager.hpp"
+#include "openvino/util/common_util.hpp"
+#include "transformations/transformation_pipeline.h"
+#include "transformations/utils/utils.hpp"
 #include "utils/serialize.hpp"
 
-#include "cpu/x64/cpu_isa_traits.hpp"
-#include <cstring>
-#include <utility>
-
 #if defined(OV_CPU_WITH_ACL)
-#include "nodes/executors/acl/acl_ie_scheduler.hpp"
+#    include "nodes/executors/acl/acl_ie_scheduler.hpp"
 #endif
 
 using namespace ov::threading;
@@ -333,8 +334,7 @@ ov::Any CompiledModel::get_property(const std::string& name) const {
         return decltype(ov::intel_cpu::sparse_weights_decompression_rate)::value_type(
             config.fcSparseWeiDecompressionRate);
     } else if (name == ov::hint::dynamic_quantization_group_size) {
-        return decltype(ov::hint::dynamic_quantization_group_size)::value_type(
-            config.fcDynamicQuantizationGroupSize);
+        return decltype(ov::hint::dynamic_quantization_group_size)::value_type(config.fcDynamicQuantizationGroupSize);
     } else if (name == ov::hint::kv_cache_precision) {
         return decltype(ov::hint::kv_cache_precision)::value_type(config.kvCachePrecision);
     } else if (name == ov::hint::key_cache_precision) {
diff --git a/src/plugins/intel_cpu/src/compiled_model.h b/src/plugins/intel_cpu/src/compiled_model.h
index faedf1ae5a744c..dc3735b4f3b63e 100644
--- a/src/plugins/intel_cpu/src/compiled_model.h
+++ b/src/plugins/intel_cpu/src/compiled_model.h
@@ -94,5 +94,5 @@ class CompiledModel : public ov::ICompiledModel {
     bool m_has_sub_compiled_models = false;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/config.cpp b/src/plugins/intel_cpu/src/config.cpp
index 6262027e344032..86f8dea14db4e1 100644
--- a/src/plugins/intel_cpu/src/config.cpp
+++ b/src/plugins/intel_cpu/src/config.cpp
@@ -4,19 +4,19 @@
 
 #include "config.h"
 
+#include <algorithm>
+#include <map>
+#include <string>
+
 #include "cpu/x64/cpu_isa_traits.hpp"
 #include "openvino/core/parallel.hpp"
 #include "openvino/core/type/element_type_traits.hpp"
 #include "openvino/runtime/intel_cpu/properties.hpp"
 #include "openvino/runtime/internal_properties.hpp"
 #include "openvino/runtime/properties.hpp"
+#include "utils/cpu_utils.hpp"
 #include "utils/debug_capabilities.h"
 #include "utils/precision_support.h"
-#include "utils/cpu_utils.hpp"
-
-#include <algorithm>
-#include <map>
-#include <string>
 
 namespace ov {
 namespace intel_cpu {
@@ -61,9 +61,7 @@ Config::Config() {
  */
 void Config::applyDebugCapsProperties() {
     // always enable perf counters for verbose, performance summary and average counters
-    if (!debugCaps.verbose.empty() ||
-        !debugCaps.summaryPerf.empty() ||
-        !debugCaps.averageCountersPath.empty()) {
+    if (!debugCaps.verbose.empty() || !debugCaps.summaryPerf.empty() || !debugCaps.averageCountersPath.empty()) {
         collectPerfCounters = true;
     }
 }
@@ -151,10 +149,10 @@ void Config::readProperties(const ov::AnyMap& prop, const ModelType modelType) {
                 logLevel = val.as<ov::log::Level>();
             } catch (const ov::Exception&) {
                 OPENVINO_THROW("Wrong value ",
-                        val.as<std::string>(),
-                        " for property key ",
-                        key,
-                        ". Expected only ov::log::Level::NO/ERR/WARNING/INFO/DEBUG/TRACE.");
+                               val.as<std::string>(),
+                               " for property key ",
+                               key,
+                               ". Expected only ov::log::Level::NO/ERR/WARNING/INFO/DEBUG/TRACE.");
             }
         } else if (key == ov::hint::num_requests.name()) {
             try {
@@ -243,8 +241,8 @@ void Config::readProperties(const ov::AnyMap& prop, const ModelType modelType) {
                 fcDynamicQuantizationGroupSize = val.as<uint64_t>();
             } catch (const ov::Exception&) {
                 OPENVINO_THROW("Wrong value for property key ",
-                                ov::hint::dynamic_quantization_group_size.name(),
-                                ". Expected only unsinged integer numbers");
+                               ov::hint::dynamic_quantization_group_size.name(),
+                               ". Expected only unsinged integer numbers");
             }
         } else if (key == ov::enable_profiling.name()) {
             try {
@@ -366,7 +364,7 @@ void Config::readProperties(const ov::AnyMap& prop, const ModelType modelType) {
                 if (one_of(prec, ov::element::f32, ov::element::f16, ov::element::bf16, ov::element::u8)) {
                     kvCachePrecision = prec;
                 } else {
-                     OPENVINO_THROW("invalid value");
+                    OPENVINO_THROW("invalid value");
                 }
             } catch (ov::Exception&) {
                 OPENVINO_THROW("Wrong value ",
@@ -511,10 +509,13 @@ void Config::updateProperties() {
 
 void Config::applyRtInfo(const std::shared_ptr<const ov::Model>& model) {
     // if user sets explicitly, it will be higher priority than rt_info
-    if (!kvCachePrecisionSetExplicitly && model->has_rt_info({"runtime_options", ov::hint::kv_cache_precision.name()})) {
-        this->kvCachePrecision = model->get_rt_info<ov::element::Type>({"runtime_options", ov::hint::kv_cache_precision.name()});
+    if (!kvCachePrecisionSetExplicitly &&
+        model->has_rt_info({"runtime_options", ov::hint::kv_cache_precision.name()})) {
+        this->kvCachePrecision =
+            model->get_rt_info<ov::element::Type>({"runtime_options", ov::hint::kv_cache_precision.name()});
     }
-    if (!fcDynamicQuantizationGroupSizeSetExplicitly && model->has_rt_info({"runtime_options", ov::hint::dynamic_quantization_group_size.name()})) {
+    if (!fcDynamicQuantizationGroupSizeSetExplicitly &&
+        model->has_rt_info({"runtime_options", ov::hint::dynamic_quantization_group_size.name()})) {
         this->fcDynamicQuantizationGroupSize =
             model->get_rt_info<uint64_t>({"runtime_options", ov::hint::dynamic_quantization_group_size.name()});
     }
diff --git a/src/plugins/intel_cpu/src/config.h b/src/plugins/intel_cpu/src/config.h
index bcde841814d09c..94d4b6e90c531d 100644
--- a/src/plugins/intel_cpu/src/config.h
+++ b/src/plugins/intel_cpu/src/config.h
@@ -4,18 +4,17 @@
 
 #pragma once
 
+#include <bitset>
+#include <map>
+#include <mutex>
+
+#include "internal_properties.hpp"
 #include "openvino/core/type/element_type.hpp"
 #include "openvino/runtime/properties.hpp"
 #include "openvino/runtime/threading/istreams_executor.hpp"
 #include "openvino/util/common_util.hpp"
-
-#include "internal_properties.hpp"
 #include "utils/debug_caps_config.h"
 
-#include <bitset>
-#include <map>
-#include <mutex>
-
 namespace ov {
 namespace intel_cpu {
 struct Config {
@@ -38,11 +37,7 @@ struct Config {
         Disable,
     };
 
-    enum class ModelType {
-        CNN,
-        LLM,
-        Unknown
-    };
+    enum class ModelType { CNN, LLM, Unknown };
 
     bool collectPerfCounters = false;
     bool exclusiveAsyncRequests = false;
@@ -75,7 +70,8 @@ struct Config {
     bool streamsChanged = false;
     int threads = 0;
     int threadsPerStream = 0;
-    ov::threading::IStreamsExecutor::ThreadBindingType threadBindingType = ov::threading::IStreamsExecutor::ThreadBindingType::NONE;
+    ov::threading::IStreamsExecutor::ThreadBindingType threadBindingType =
+        ov::threading::IStreamsExecutor::ThreadBindingType::NONE;
     ov::hint::PerformanceMode hintPerfMode = ov::hint::PerformanceMode::LATENCY;
     std::vector<std::vector<int>> streamsRankTable;
     bool changedHintPerfMode = false;
@@ -128,4 +124,4 @@ struct Config {
 };
 
 }  // namespace intel_cpu
-}   // namespace ov
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/cpu_memory.cpp b/src/plugins/intel_cpu/src/cpu_memory.cpp
index 8e5fe8d72fd1f2..7cb4abc2161f14 100644
--- a/src/plugins/intel_cpu/src/cpu_memory.cpp
+++ b/src/plugins/intel_cpu/src/cpu_memory.cpp
@@ -3,14 +3,17 @@
 //
 
 #include "cpu_memory.h"
-#include "memory_desc/cpu_memory_desc_utils.h"
+
 #include <common/memory_desc_wrapper.hpp>
-#include "nodes/reorder.h"
+
+#include "memory_desc/cpu_memory_desc_utils.h"
 #include "nodes/common/cpu_memcpy.h"
+#include "nodes/reorder.h"
 #include "utils/debug_capabilities.h"
 #if defined(__linux__)
 #    include <sys/syscall.h> /* Definition of SYS_* constants */
 #    include <unistd.h>
+
 #    include <cstring> /* strerror(errno) */
 #endif
 
@@ -27,69 +30,72 @@ BlockedMemoryDescPtr IMemory::getDescWithType<BlockedMemoryDesc, 0, 0>() const {
 }
 
 namespace {
-    inline void setSubnormalsToZero(float *data, size_t size) {
-        uint32_t *u32data = reinterpret_cast<uint32_t *>(data);
-        for (size_t i = 0; i < size; ++i) {
-            if ((u32data[i] & (0xFF << 23)) == 0) {
-                u32data[i] = 0;
-            }
+inline void setSubnormalsToZero(float* data, size_t size) {
+    uint32_t* u32data = reinterpret_cast<uint32_t*>(data);
+    for (size_t i = 0; i < size; ++i) {
+        if ((u32data[i] & (0xFF << 23)) == 0) {
+            u32data[i] = 0;
         }
     }
+}
 
-    void transferData(const IMemory& src, const IMemory& dst, bool ftz) {
-        node::Reorder::reorderData(src, dst);
+void transferData(const IMemory& src, const IMemory& dst, bool ftz) {
+    node::Reorder::reorderData(src, dst);
 
-        if (!ftz) {
-            return;
-        }
-        if (src.getDesc().getPrecision() != ov::element::f32 || dst.getDesc().getPrecision() == ov::element::bf16) {
+    if (!ftz) {
+        return;
+    }
+    if (src.getDesc().getPrecision() != ov::element::f32 || dst.getDesc().getPrecision() == ov::element::bf16) {
+        return;
+    }
+    size_t offset = 0;
+    if (dst.getDesc().getType() & MemoryDescType::Dnnl) {
+        // here we can safely cast to DnnlMemoryDesc
+        auto dnnl_desc = dst.getDescWithType<DnnlMemoryDesc>();
+        auto desc = dnnl_desc->getDnnlDesc();
+        dnnl::impl::memory_desc_wrapper wrapper(desc.get());
+        offset = wrapper.offset0();
+        if (wrapper.is_wino_desc() || wrapper.is_rnn_packed_desc()) {
             return;
         }
-        size_t offset = 0;
-        if (dst.getDesc().getType() & MemoryDescType::Dnnl) {
-            // here we can safely cast to DnnlMemoryDesc
-            auto dnnl_desc = dst.getDescWithType<DnnlMemoryDesc>();
-            auto desc = dnnl_desc->getDnnlDesc();
-            dnnl::impl::memory_desc_wrapper wrapper(desc.get());
-            offset = wrapper.offset0();
-            if (wrapper.is_wino_desc() || wrapper.is_rnn_packed_desc()) {
-                return;
-            }
-        }
-        // actual FTZ
-        auto* memData = static_cast<float*>(dst.getData());
-        memData += offset;
-        setSubnormalsToZero(memData, dst.getSize() / sizeof(float));
     }
+    // actual FTZ
+    auto* memData = static_cast<float*>(dst.getData());
+    memData += offset;
+    setSubnormalsToZero(memData, dst.getSize() / sizeof(float));
+}
 
-}   // namespace
+}  // namespace
 
-Memory::Memory(const dnnl::engine& eng, MemoryDescPtr desc, const void* data, bool pads_zeroing) :
-    m_eng(eng),
-    m_pMemDesc(desc),
-    m_blockHandle(std::make_shared<DnnlMemoryBlock>(make_unique<MemoryBlockWithReuse>()), this),
-    dnnlMemHandle(this) {
-        if (desc->getPrecision() == element::string) {
-            OPENVINO_THROW("[CPU] Memory object cannot be created for string data.");
-        }
-        create(m_pMemDesc, data, pads_zeroing);
+Memory::Memory(const dnnl::engine& eng, MemoryDescPtr desc, const void* data, bool pads_zeroing)
+    : m_eng(eng),
+      m_pMemDesc(desc),
+      m_blockHandle(std::make_shared<DnnlMemoryBlock>(make_unique<MemoryBlockWithReuse>()), this),
+      dnnlMemHandle(this) {
+    if (desc->getPrecision() == element::string) {
+        OPENVINO_THROW("[CPU] Memory object cannot be created for string data.");
     }
+    create(m_pMemDesc, data, pads_zeroing);
+}
 
-Memory::Memory(const dnnl::engine& eng, const MemoryDesc& desc, const void* data, bool pads_zeroing) :
-    Memory::Memory(eng, desc.clone(), data, pads_zeroing) {}
-
-Memory::Memory(const dnnl::engine& eng, MemoryDescPtr desc, MemoryBlockPtr block) :
-    m_eng(eng), m_pMemDesc(desc), m_blockHandle(block, this), dnnlMemHandle(this) {
-        if (desc->getPrecision() == element::string) {
-            OPENVINO_THROW("[CPU] Memory object can't be created for string data.");
-        }
-        bool memAllocated = m_blockHandle->getRawPtr();
+Memory::Memory(const dnnl::engine& eng, const MemoryDesc& desc, const void* data, bool pads_zeroing)
+    : Memory::Memory(eng, desc.clone(), data, pads_zeroing) {}
 
-        create(desc, nullptr, !memAllocated);
+Memory::Memory(const dnnl::engine& eng, MemoryDescPtr desc, MemoryBlockPtr block)
+    : m_eng(eng),
+      m_pMemDesc(desc),
+      m_blockHandle(block, this),
+      dnnlMemHandle(this) {
+    if (desc->getPrecision() == element::string) {
+        OPENVINO_THROW("[CPU] Memory object can't be created for string data.");
     }
+    bool memAllocated = m_blockHandle->getRawPtr();
 
-Memory::Memory(const dnnl::engine& eng, const MemoryDesc& desc, MemoryBlockPtr block) :
-    Memory::Memory(eng, desc.clone(), block) {}
+    create(desc, nullptr, !memAllocated);
+}
+
+Memory::Memory(const dnnl::engine& eng, const MemoryDesc& desc, MemoryBlockPtr block)
+    : Memory::Memory(eng, desc.clone(), block) {}
 
 size_t Memory::getSize() const {
     auto size = getDesc().getCurrentMemSize();
@@ -99,7 +105,7 @@ size_t Memory::getSize() const {
     return size;
 }
 
-void Memory::create(const MemoryDesc &desc, const void *data, bool pads_zeroing) {
+void Memory::create(const MemoryDesc& desc, const void* data, bool pads_zeroing) {
     create(desc.clone(), data, pads_zeroing);
 }
 
@@ -187,9 +193,7 @@ dnnl::memory Memory::DnnlMemPrimHandle::getPrim() const {
 
 void* Memory::getData() const {
     void* data = getDataNoThrow();
-    if (data == nullptr &&
-        m_pMemDesc->getShape().isStatic() &&
-        m_pMemDesc->getShape().getElementsCount() != 0)
+    if (data == nullptr && m_pMemDesc->getShape().isStatic() && m_pMemDesc->getShape().getElementsCount() != 0)
         OPENVINO_THROW("Memory has not been allocated");
     return data;
 }
@@ -198,7 +202,7 @@ void* MemoryBlockWithReuse::getRawPtr() const noexcept {
     return m_data.get();
 }
 
-void MemoryBlockWithReuse::setExtBuff(void *ptr, size_t size) {
+void MemoryBlockWithReuse::setExtBuff(void* ptr, size_t size) {
     m_useExternalStorage = true;
     m_memUpperBound = size;
     m_data = decltype(m_data)(ptr, release);
@@ -208,7 +212,7 @@ bool MemoryBlockWithReuse::resize(size_t size) {
     constexpr int cacheLineSize = 64;
     bool sizeChanged = false;
     if (size > m_memUpperBound) {
-        void *ptr = dnnl::impl::malloc(size, cacheLineSize);
+        void* ptr = dnnl::impl::malloc(size, cacheLineSize);
         if (!ptr) {
             OPENVINO_THROW("Failed to allocate ", size, " bytes of memory");
         }
@@ -236,15 +240,17 @@ void MemoryBlockWithReuse::free() {
     m_useExternalStorage = false;
 }
 
-void MemoryBlockWithReuse::release(void *ptr) {}
+void MemoryBlockWithReuse::release(void* ptr) {}
 
-void MemoryBlockWithReuse::destroy(void *ptr) {
+void MemoryBlockWithReuse::destroy(void* ptr) {
     dnnl::impl::free(ptr);
 }
 
 /////////////// StringMemory ///////////////
 
-StringMemory::StringMemory(const dnnl::engine& engine, const MemoryDescPtr& desc, const void* data) : m_engine(engine), m_mem_desc(desc) {
+StringMemory::StringMemory(const dnnl::engine& engine, const MemoryDescPtr& desc, const void* data)
+    : m_engine(engine),
+      m_mem_desc(desc) {
     if (m_mem_desc->getPrecision() != element::string) {
         OPENVINO_THROW("[CPU] StringMemory supports String type only.");
     }
@@ -258,8 +264,8 @@ StringMemory::StringMemory(const dnnl::engine& engine, const MemoryDescPtr& desc
     const auto string_size = m_mem_desc->getShape().getElementsCount();
 
     if (data != nullptr) {
-        auto not_const_data = const_cast<void *>(data);
-        m_memoryBlock->setExtBuff(reinterpret_cast<OvString *>(not_const_data), string_size);
+        auto not_const_data = const_cast<void*>(data);
+        m_memoryBlock->setExtBuff(reinterpret_cast<OvString*>(not_const_data), string_size);
     } else {
         m_memoryBlock->resize(string_size);
     }
@@ -273,7 +279,7 @@ void StringMemory::load(const IMemory& src, bool ftz) const {
     transferData(src, *this, false);
 }
 
-void* StringMemory::getData() const  {
+void* StringMemory::getData() const {
     return m_memoryBlock->getRawPtr();
 }
 
@@ -297,7 +303,7 @@ void StringMemory::nullify() {
     }
 }
 
-size_t StringMemory::getSize() const { // In bytes
+size_t StringMemory::getSize() const {  // In bytes
     auto size = getDesc().getCurrentMemSize();
     if (size == MemoryDesc::UNDEFINED_SIZE) {
         OPENVINO_THROW("Can't get memory size for undefined shape.");
@@ -329,7 +335,7 @@ bool StringMemory::StringMemoryBlock::resize(size_t size) {
         if (size > PTRDIFF_MAX) {
             OPENVINO_THROW("Requested allocation size { ", size, " } exceeds PTRDIFF_MAX.");
         }
-        auto ptr_size = static_cast<ptrdiff_t>(size); // WA for warning alloc-size-larger-than
+        auto ptr_size = static_cast<ptrdiff_t>(size);  // WA for warning alloc-size-larger-than
         auto ptr = new OvString[ptr_size];
         if (!ptr) {
             OPENVINO_THROW("Failed to allocate ", size, " bytes of memory");
@@ -355,7 +361,7 @@ void StringMemory::StringMemoryBlock::destroy(OvString* ptr) {
 }
 
 void* StringMemory::StringMemoryBlock::getRawPtr() const noexcept {
-    return reinterpret_cast<void *>(m_data.get());
+    return reinterpret_cast<void*>(m_data.get());
 }
 
 /////////////// DnnlMemoryBlock ///////////////
@@ -364,7 +370,7 @@ void* DnnlMemoryBlock::getRawPtr() const noexcept {
     return m_pMemBlock->getRawPtr();
 }
 
-void DnnlMemoryBlock::setExtBuff(void *ptr, size_t size) {
+void DnnlMemoryBlock::setExtBuff(void* ptr, size_t size) {
     m_pMemBlock->setExtBuff(ptr, size);
     notifyUpdate();
 }
@@ -401,8 +407,9 @@ void DnnlMemoryBlock::notifyUpdate() {
     }
 }
 
-StaticMemory::StaticMemory(const dnnl::engine& eng, MemoryDescPtr desc, const void* data, bool pads_zeroing) :
-    m_eng(eng), m_pMemDesc(desc) {
+StaticMemory::StaticMemory(const dnnl::engine& eng, MemoryDescPtr desc, const void* data, bool pads_zeroing)
+    : m_eng(eng),
+      m_pMemDesc(desc) {
     if (desc->getPrecision() == element::string) {
         OPENVINO_THROW("[CPU] StaticMemory object cannot be created for string data.");
     }
@@ -427,14 +434,13 @@ StaticMemory::StaticMemory(const dnnl::engine& eng, MemoryDescPtr desc, const vo
         //
         // ========================
         m_prim.set_data_handle(m_pMemBlock->getRawPtr());
-    }
-    catch (const std::exception& exc) {
+    } catch (const std::exception& exc) {
         dnnlErrorCtx = exc.what();
     }
 }
 
-StaticMemory::StaticMemory(const dnnl::engine& eng, const MemoryDesc& desc, const void* data, bool pads_zeroing) :
-    StaticMemory::StaticMemory(eng, desc.clone(), data, pads_zeroing) {}
+StaticMemory::StaticMemory(const dnnl::engine& eng, const MemoryDesc& desc, const void* data, bool pads_zeroing)
+    : StaticMemory::StaticMemory(eng, desc.clone(), data, pads_zeroing) {}
 
 const MemoryDesc& StaticMemory::getDesc() const {
     return *m_pMemDesc;
@@ -475,7 +481,7 @@ MemoryBlockPtr StaticMemory::getMemoryBlock() const {
     return m_pMemBlock;
 }
 
-//oneDNN specifics for backward compatibility
+// oneDNN specifics for backward compatibility
 dnnl::memory StaticMemory::getPrimitive() const {
     if (!m_prim) {
         OPENVINO_THROW("Couldn't create dnnl::memory object: ", dnnlErrorCtx);
@@ -517,11 +523,11 @@ bool StaticMemory::StaticMemoryBlock::hasExtBuffer() const noexcept {
 }
 
 void StaticMemory::StaticMemoryBlock::registerMemory(Memory* memPtr) {
-    //do nothing
+    // do nothing
 }
 
 void StaticMemory::StaticMemoryBlock::unregisterMemory(Memory* memPtr) {
-    //do nothing
+    // do nothing
 }
 
 #if defined(__linux__)
@@ -529,9 +535,9 @@ void StaticMemory::StaticMemoryBlock::unregisterMemory(Memory* memPtr) {
 #    define MPOL_BIND      2
 #    define MPOL_MF_STRICT (1 << 0)
 #    define MPOL_MF_MOVE   (1 << 1)
-#if !defined(__NR_mbind) && defined(__x86_64__)
-#    define __NR_mbind 237
-#endif
+#    if !defined(__NR_mbind) && defined(__x86_64__)
+#        define __NR_mbind 237
+#    endif
 static long mbind(void* start,
                   unsigned long len,
                   int mode,
@@ -585,7 +591,12 @@ bool mbind_move(const dnnl::memory mem, int numaNodeID) {
     return mbind_move(data, size, numaNodeID);
 }
 
-MemoryPtr split_horizontal(const dnnl::engine& eng, const MemoryPtr src, int dim, int w_rank, int w_size, bool need_fill) {
+MemoryPtr split_horizontal(const dnnl::engine& eng,
+                           const MemoryPtr src,
+                           int dim,
+                           int w_rank,
+                           int w_size,
+                           bool need_fill) {
     auto desc = src->getDescPtr();
     auto shape = src->getShape();
     auto dims = shape.getDims();
@@ -620,7 +631,9 @@ MemoryPtr split_horizontal(const dnnl::engine& eng, const MemoryPtr src, int dim
     // reference stride
     VectorDims stride_dims = dims;
     stride_dims[dim] = splited_dim_vec[0];
-    size_t stride = std::accumulate(stride_dims.begin(), stride_dims.end(), static_cast<size_t>(1), std::multiplies<size_t>()) * prec.size();
+    size_t stride =
+        std::accumulate(stride_dims.begin(), stride_dims.end(), static_cast<size_t>(1), std::multiplies<size_t>()) *
+        prec.size();
 
     // create new shape for target memory
     VectorDims new_dims = dims;
@@ -641,7 +654,12 @@ MemoryPtr split_horizontal(const dnnl::engine& eng, const MemoryPtr src, int dim
     return ptr;
 }
 
-MemoryPtr split_vertical(const dnnl::engine& eng, const MemoryPtr src, int dim, int w_rank, int w_size, bool need_fill) {
+MemoryPtr split_vertical(const dnnl::engine& eng,
+                         const MemoryPtr src,
+                         int dim,
+                         int w_rank,
+                         int w_size,
+                         bool need_fill) {
     auto desc = src->getDescPtr();
     auto shape = src->getShape();
     auto dims = shape.getDims();
@@ -697,7 +715,7 @@ MemoryPtr split_vertical(const dnnl::engine& eng, const MemoryPtr src, int dim,
         strideSize /= 2;
         copySize /= 2;
     }
-    parallel_for(step, [&](int i){
+    parallel_for(step, [&](int i) {
         int dst_offset = i * copySize;
         int src_offset = i * splited_size + w_rank * strideSize;
         cpu_parallel_memcpy(dstPtr + dst_offset, srcPtr + src_offset, copySize);
@@ -705,5 +723,5 @@ MemoryPtr split_vertical(const dnnl::engine& eng, const MemoryPtr src, int dim,
     return ptr;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/cpu_memory.h b/src/plugins/intel_cpu/src/cpu_memory.h
index 70e6713e36b886..f6837064babfa6 100644
--- a/src/plugins/intel_cpu/src/cpu_memory.h
+++ b/src/plugins/intel_cpu/src/cpu_memory.h
@@ -4,18 +4,18 @@
 
 #pragma once
 
-#include "memory_desc/cpu_memory_desc.h"
-#include "dnnl_extension_utils.h"
-#include <onednn/dnnl.h>
 #include <cpu_shape.h>
-
-#include "openvino/core/type/element_type.hpp"
-#include "openvino/core/type/element_type_traits.hpp"
+#include <onednn/dnnl.h>
 
 #include <memory>
 #include <mutex>
 #include <unordered_set>
 
+#include "dnnl_extension_utils.h"
+#include "memory_desc/cpu_memory_desc.h"
+#include "openvino/core/type/element_type.hpp"
+#include "openvino/core/type/element_type_traits.hpp"
+
 /**
  * @file contains a concept classes to work with memory/tensor/blob abstractions on plugin level.
  *
@@ -47,7 +47,8 @@ class IMemoryBlock {
     virtual void* getRawPtr() const noexcept = 0;
 
     /**
-     * @brief Allows to set externally allocated memory buffer. In that case, the object has no control over the provided memory.
+     * @brief Allows to set externally allocated memory buffer. In that case, the object has no control over the
+     * provided memory.
      * @param ptr - pointer to the memory
      * @param size - size of the memory buffer
      */
@@ -82,11 +83,11 @@ class MemoryBlockWithReuse : public IMemoryBlock {
 private:
     bool m_useExternalStorage = false;
     size_t m_memUpperBound = 0ul;
-    std::unique_ptr<void, void (*)(void *)> m_data;
+    std::unique_ptr<void, void (*)(void*)> m_data;
     int numa_node;
 
-    static void release(void *ptr);
-    static void destroy(void *ptr);
+    static void release(void* ptr);
+    static void destroy(void* ptr);
 };
 
 class IMemoryBlockObserver : public IMemoryBlock {
@@ -128,13 +129,13 @@ class DnnlMemBlockHandle {
     }
 
     DnnlMemBlockHandle(const DnnlMemBlockHandle&) = delete;
-    DnnlMemBlockHandle& operator= (const DnnlMemBlockHandle&) = delete;
+    DnnlMemBlockHandle& operator=(const DnnlMemBlockHandle&) = delete;
 
     DnnlMemBlockHandle(DnnlMemBlockHandle&& source) {
         std::swap(m_pMemBlock, source.m_pMemBlock);
         std::swap(m_pMem, source.m_pMem);
     }
-    DnnlMemBlockHandle& operator= (DnnlMemBlockHandle&& rhs) {
+    DnnlMemBlockHandle& operator=(DnnlMemBlockHandle&& rhs) {
         std::swap(m_pMemBlock, rhs.m_pMemBlock);
         std::swap(m_pMem, rhs.m_pMem);
         return *this;
@@ -166,7 +167,7 @@ class IMemory {
     virtual const MemoryDesc& getDesc() const = 0;
     virtual MemoryDescPtr getDescPtr() const = 0;
 
-    virtual void* getData() const = 0; // pointer to the actual memory
+    virtual void* getData() const = 0;  // pointer to the actual memory
 
     template <typename T, typename datatype = typename std::decay<T>::type>
     T* getDataAs() const {
@@ -177,7 +178,7 @@ class IMemory {
         return static_cast<T*>(getData());
     }
 
-    virtual size_t getSize() const = 0; // in bytes
+    virtual size_t getSize() const = 0;  // in bytes
     virtual const Shape& getShape() const = 0;
     virtual const VectorDims& getStaticDims() const = 0;
 
@@ -199,7 +200,7 @@ class IMemory {
         return false;
     }
 
-    //oneDNN specifics for backward compatibility
+    // oneDNN specifics for backward compatibility
     virtual dnnl::memory getPrimitive() const = 0;
 
     ov::element::Type getPrecision() const {
@@ -211,8 +212,8 @@ class IMemory {
     }
 
     template <typename T,
-            typename std::enable_if<!std::is_pointer<T>::value && !std::is_reference<T>::value, int>::type = 0,
-            typename std::enable_if<std::is_base_of<MemoryDesc, T>::value, int>::type = 0>
+              typename std::enable_if<!std::is_pointer<T>::value && !std::is_reference<T>::value, int>::type = 0,
+              typename std::enable_if<std::is_base_of<MemoryDesc, T>::value, int>::type = 0>
     std::shared_ptr<T> getDescWithType() const;
 };
 
@@ -241,17 +242,17 @@ class StaticMemory final : public IMemory {
     StaticMemory(const dnnl::engine& eng, const MemoryDesc& desc, const void* data = nullptr, bool pads_zeroing = true);
 
     StaticMemory(const StaticMemory&) = delete;
-    StaticMemory& operator= (const StaticMemory&) = delete;
+    StaticMemory& operator=(const StaticMemory&) = delete;
 
     StaticMemory(Memory&&) = delete;
-    StaticMemory& operator= (StaticMemory&&) = delete;
+    StaticMemory& operator=(StaticMemory&&) = delete;
 
     const MemoryDesc& getDesc() const override;
     MemoryDescPtr getDescPtr() const override;
 
-    void* getData() const override; // pointer to the actual memory
+    void* getData() const override;  // pointer to the actual memory
 
-    size_t getSize() const override; // in bytes
+    size_t getSize() const override;  // in bytes
     const Shape& getShape() const override;
     const VectorDims& getStaticDims() const override;
 
@@ -262,7 +263,7 @@ class StaticMemory final : public IMemory {
 
     MemoryBlockPtr getMemoryBlock() const override;
 
-    //oneDNN specifics for backward compatibility
+    // oneDNN specifics for backward compatibility
     dnnl::memory getPrimitive() const override;
 
     void nullify() override;
@@ -284,10 +285,10 @@ class Memory : public IMemory {
     Memory(const dnnl::engine& eng, const MemoryDesc& desc, MemoryBlockPtr block);
 
     Memory(const Memory&) = delete;
-    Memory& operator= (const Memory&) = delete;
+    Memory& operator=(const Memory&) = delete;
 
     Memory(Memory&&) = delete;
-    Memory& operator= (Memory&&) = delete;
+    Memory& operator=(Memory&&) = delete;
 
     dnnl::memory getPrimitive() const override;
 
@@ -341,7 +342,7 @@ class Memory : public IMemory {
     bool m_padsZeroing = true;
     class DnnlMemPrimHandle {
     public:
-        explicit DnnlMemPrimHandle(const Memory* memObjPtr): m_memObjPtr(memObjPtr) {}
+        explicit DnnlMemPrimHandle(const Memory* memObjPtr) : m_memObjPtr(memObjPtr) {}
         bool isInit() const;
         dnnl::memory getPrim() const;
         void resetDnnlPrim();
@@ -376,7 +377,7 @@ class StringMemory : public IMemory {
     private:
         bool m_use_external_storage = false;
         size_t m_str_upper_bound = 0lu;
-        std::unique_ptr<OvString, void (*)(OvString *)> m_data;
+        std::unique_ptr<OvString, void (*)(OvString*)> m_data;
 
         static void release(OvString* ptr) {}
         static void destroy(OvString* ptr);
@@ -390,7 +391,9 @@ class StringMemory : public IMemory {
         : StringMemory(engine, desc.clone(), data) {}
 
     StringMemory(const dnnl::engine& engine, const MemoryDescPtr& desc, const StringMemoryBlockPtr& block)
-        : m_engine(engine), m_mem_desc(desc), m_memoryBlock(block) {}
+        : m_engine(engine),
+          m_mem_desc(desc),
+          m_memoryBlock(block) {}
 
     StringMemory(const dnnl::engine& engine, const MemoryDesc& desc, const StringMemoryBlockPtr& block)
         : StringMemory(engine, desc.clone(), block) {}
@@ -405,7 +408,7 @@ class StringMemory : public IMemory {
 
     void* getData() const override;
 
-    size_t getSize() const override; // In bytes
+    size_t getSize() const override;  // In bytes
 
     const Shape& getShape() const override {
         return m_mem_desc->getShape();
@@ -443,8 +446,18 @@ bool mbind_move(void* data, size_t size, int numaNodeID);
 bool mbind_move(const MemoryCPtr mem, int numaNodeID);
 bool mbind_move(const dnnl::memory mem, int numaNodeID);
 
-MemoryPtr split_horizontal(const dnnl::engine& eng, const MemoryPtr src, int dim, int w_rank, int w_size, bool need_fill = true);
-MemoryPtr split_vertical(const dnnl::engine& eng, const MemoryPtr src, int dim, int w_rank, int w_size, bool need_fill = true);
-
-}   // namespace intel_cpu
-}   // namespace ov
+MemoryPtr split_horizontal(const dnnl::engine& eng,
+                           const MemoryPtr src,
+                           int dim,
+                           int w_rank,
+                           int w_size,
+                           bool need_fill = true);
+MemoryPtr split_vertical(const dnnl::engine& eng,
+                         const MemoryPtr src,
+                         int dim,
+                         int w_rank,
+                         int w_size,
+                         bool need_fill = true);
+
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/cpu_shape.cpp b/src/plugins/intel_cpu/src/cpu_shape.cpp
index 4c6b5793d9f2ef..2b7011af1a1f5e 100644
--- a/src/plugins/intel_cpu/src/cpu_shape.cpp
+++ b/src/plugins/intel_cpu/src/cpu_shape.cpp
@@ -3,12 +3,13 @@
 //
 
 #include "cpu_shape.h"
+
 #include "utils/general_utils.h"
 
 namespace ov {
 namespace intel_cpu {
 
-bool Shape::isCompatible(const VectorDims &vecDims) const {
+bool Shape::isCompatible(const VectorDims& vecDims) const {
     if (getRank() != vecDims.size()) {
         return false;
     }
@@ -21,17 +22,21 @@ bool Shape::isCompatible(const VectorDims &vecDims) const {
         return false;
     }
 
-    if (!std::equal(getMaxDims().begin(), getMaxDims().end(), vecDims.begin(), [](Dim lhs, Dim rhs) { return lhs >= rhs; })) {
+    if (!std::equal(getMaxDims().begin(), getMaxDims().end(), vecDims.begin(), [](Dim lhs, Dim rhs) {
+            return lhs >= rhs;
+        })) {
         return false;
     }
 
-    if (!std::equal(getMinDims().begin(), getMinDims().end(), vecDims.begin(), [](Dim lhs, Dim rhs) { return lhs <= rhs; })) {
+    if (!std::equal(getMinDims().begin(), getMinDims().end(), vecDims.begin(), [](Dim lhs, Dim rhs) {
+            return lhs <= rhs;
+        })) {
         return false;
     }
     return true;
 }
 
-std::string Shape::toString() const  {
+std::string Shape::toString() const {
     std::stringstream output;
     output << "{";
 
@@ -50,10 +55,10 @@ std::string Shape::toString() const  {
 
 Shape mergeShapes(const Shape& lhs, const Shape& rhs) {
     OPENVINO_ASSERT(lhs.getRank() == rhs.getRank(),
-        "Couldn't merge shapes of different ranks: shape 1:",
-        lhs.toString(),
-        " shape 2: ",
-        rhs.toString());
+                    "Couldn't merge shapes of different ranks: shape 1:",
+                    lhs.toString(),
+                    " shape 2: ",
+                    rhs.toString());
 
     const auto& lhsMinDims = lhs.getMinDims();
     const auto& lhsMaxDims = lhs.getMaxDims();
@@ -66,10 +71,11 @@ Shape mergeShapes(const Shape& lhs, const Shape& rhs) {
     for (size_t i = 0; i < resultMinDims.size(); ++i) {
         resultMinDims[i] = std::max(lhsMinDims[i], rhsMinDims[i]);
         resultMaxDims[i] = std::min(lhsMaxDims[i], rhsMaxDims[i]);
-        OPENVINO_ASSERT(resultMinDims[i] <= resultMaxDims[i], "Couldn't merge shapes as the dims intervals are not overlapping.");
+        OPENVINO_ASSERT(resultMinDims[i] <= resultMaxDims[i],
+                        "Couldn't merge shapes as the dims intervals are not overlapping.");
     }
     return Shape{resultMinDims, resultMaxDims};
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/cpu_shape.h b/src/plugins/intel_cpu/src/cpu_shape.h
index a04b043689e520..f2895287e2f8fe 100644
--- a/src/plugins/intel_cpu/src/cpu_shape.h
+++ b/src/plugins/intel_cpu/src/cpu_shape.h
@@ -31,13 +31,17 @@ class Shape {
         type = shape.is_static() ? ShapeType::Static : ShapeType::Dynamic;
         initDims();
 
-        hasZeroDimensions = std::any_of(dims.begin(), dims.end(), [](size_t dim) { return dim == 0; } );
+        hasZeroDimensions = std::any_of(dims.begin(), dims.end(), [](size_t dim) {
+            return dim == 0;
+        });
     }
 
     explicit Shape(const VectorDims& shape) {
         dims = minDims = maxDims = shape;
         type = ShapeType::Static;
-        hasZeroDimensions = std::any_of(dims.begin(), dims.end(), [](size_t dim) { return dim == 0; } );
+        hasZeroDimensions = std::any_of(dims.begin(), dims.end(), [](size_t dim) {
+            return dim == 0;
+        });
     }
 
     Shape(const VectorDims& minDims, const VectorDims& maxDims) {
@@ -49,13 +53,17 @@ class Shape {
 
         initDims();
 
-        if (std::any_of(dims.begin(), dims.end(), [](size_t dim) { return dim == Shape::UNDEFINED_DIM; } ))  {
+        if (std::any_of(dims.begin(), dims.end(), [](size_t dim) {
+                return dim == Shape::UNDEFINED_DIM;
+            })) {
             type = ShapeType::Dynamic;
         } else {
             type = ShapeType::Static;
         }
 
-        hasZeroDimensions = std::any_of(dims.begin(), dims.end(), [](size_t dim) { return dim == 0; } );
+        hasZeroDimensions = std::any_of(dims.begin(), dims.end(), [](size_t dim) {
+            return dim == 0;
+        });
     }
 
     Shape(const std::initializer_list<Dim>& shape) {
@@ -69,7 +77,9 @@ class Shape {
 
         initDims();
 
-        hasZeroDimensions = std::any_of(dims.begin(), dims.end(), [](size_t dim) { return dim == 0; } );
+        hasZeroDimensions = std::any_of(dims.begin(), dims.end(), [](size_t dim) {
+            return dim == 0;
+        });
     }
 
     /**
@@ -181,21 +191,21 @@ class Shape {
 
     std::string toString() const;
 
-    bool operator == (const Shape& rhs) const {
+    bool operator==(const Shape& rhs) const {
         return minDims == rhs.minDims && maxDims == rhs.maxDims;
     }
 
-    bool operator != (const Shape& rhs) const {
+    bool operator!=(const Shape& rhs) const {
         return !(*this == rhs);
     }
 
     bool hasDefinedUpperBounds() const {
-        return std::all_of(maxDims.begin(), maxDims.end(), [](Dim dim){ return dim != UNDEFINED_DIM; });
+        return std::all_of(maxDims.begin(), maxDims.end(), [](Dim dim) {
+            return dim != UNDEFINED_DIM;
+        });
     }
 
-    enum : Dim {
-        UNDEFINED_DIM = std::numeric_limits<Dim>::max()
-    };
+    enum : Dim { UNDEFINED_DIM = std::numeric_limits<Dim>::max() };
 
 private:
     void initDims() {
@@ -205,10 +215,7 @@ class Shape {
         }
     }
 
-    enum class ShapeType {
-        Static,
-        Dynamic
-    } type {ShapeType::Static};
+    enum class ShapeType { Static, Dynamic } type{ShapeType::Static};
 
     bool hasZeroDimensions = false;
 
@@ -229,5 +236,5 @@ class Shape {
 
 Shape mergeShapes(const Shape& lhs, const Shape& rhs);
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/cpu_streams_calculation.cpp b/src/plugins/intel_cpu/src/cpu_streams_calculation.cpp
index 244adb7c40c23c..be6f5c4035d1ee 100644
--- a/src/plugins/intel_cpu/src/cpu_streams_calculation.cpp
+++ b/src/plugins/intel_cpu/src/cpu_streams_calculation.cpp
@@ -4,6 +4,11 @@
 
 #include "cpu_streams_calculation.hpp"
 
+#include <algorithm>
+#include <cstdio>
+#include <numeric>
+#include <unordered_set>
+
 #include "cpu_map_scheduling.hpp"
 #include "graph.h"
 #include "openvino/op/fake_quantize.hpp"
@@ -13,29 +18,25 @@
 #include "transformations/utils.hpp"
 #include "transformations/utils/utils.hpp"
 
-#include <algorithm>
-#include <cstdio>
-#include <numeric>
-#include <unordered_set>
-
 using namespace ov;
 using namespace ov::threading;
 
-#define INIT_VAL -100
+#define INIT_VAL     -100
 #define TP_CPU_LIMIT 32
 
 namespace ov {
 namespace intel_cpu {
 
-std::vector<std::vector<int>> get_streams_info_table(const int input_streams,
-                                                     const bool input_streams_changed,
-                                                     const int input_threads,
-                                                     const int input_infer_requests,
-                                                     const int model_prefer_threads,
-                                                     const int input_current_socket_id,
-                                                     const std::string input_perf_hint,
-                                                     const std::set<ov::hint::ModelDistributionPolicy> hint_model_distribution_policy,
-                                                     const std::vector<std::vector<int>>& proc_type_table) {
+std::vector<std::vector<int>> get_streams_info_table(
+    const int input_streams,
+    const bool input_streams_changed,
+    const int input_threads,
+    const int input_infer_requests,
+    const int model_prefer_threads,
+    const int input_current_socket_id,
+    const std::string input_perf_hint,
+    const std::set<ov::hint::ModelDistributionPolicy> hint_model_distribution_policy,
+    const std::vector<std::vector<int>>& proc_type_table) {
     std::vector<int> stream_info(CPU_STREAMS_TABLE_SIZE, INIT_VAL);
     std::vector<std::vector<int>> streams_info_table;
     std::vector<std::vector<int>> proc_socket_table;
@@ -339,8 +340,7 @@ std::vector<std::vector<int>> get_streams_info_table(const int input_streams,
                     n_threads_per_stream = static_cast<int>(n_threads / n_streams);
                     check_threads_per_stream();
                 } else {
-                    n_threads_per_stream =
-                        model_threads > 0 ? model_threads : static_cast<int>(n_threads / n_streams);
+                    n_threads_per_stream = model_threads > 0 ? model_threads : static_cast<int>(n_threads / n_streams);
                 }
             }
         }
@@ -590,7 +590,7 @@ int get_model_prefer_threads(const int num_streams,
                     (networkToleranceForLowCache.ratio_mem_limited_gemms > ov::MemBandwidthPressure::LIMITED))) {
             config.modelPreferThreads = 8;
         }
-#elif((defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)) && defined(__APPLE__))
+#elif ((defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)) && defined(__APPLE__))
         config.modelPreferThreads = 1;
         if (networkToleranceForLowCache.max_mem_tolerance == ov::MemBandwidthPressure::UNKNOWN) {
             if ((networkToleranceForLowCache.ratio_compute_convs == ov::MemBandwidthPressure::ALL) ||
diff --git a/src/plugins/intel_cpu/src/cpu_streams_calculation.hpp b/src/plugins/intel_cpu/src/cpu_streams_calculation.hpp
index e362c0373d8d1d..0a0b4a1449b7cb 100644
--- a/src/plugins/intel_cpu/src/cpu_streams_calculation.hpp
+++ b/src/plugins/intel_cpu/src/cpu_streams_calculation.hpp
@@ -44,15 +44,16 @@ namespace intel_cpu {
  * in previous function.
  * @return     streams information table which will be used by StreamsExecutor.
  */
-std::vector<std::vector<int>> get_streams_info_table(const int input_streams,
-                                                     const bool input_streams_changed,
-                                                     const int input_threads,
-                                                     const int input_infer_requests,
-                                                     const int model_prefer_threads,
-                                                     const int input_current_socket_id,
-                                                     const std::string input_perf_hint,
-                                                     const std::set<ov::hint::ModelDistributionPolicy> hint_llm_distribution_policy,
-                                                     const std::vector<std::vector<int>>& proc_type_table);
+std::vector<std::vector<int>> get_streams_info_table(
+    const int input_streams,
+    const bool input_streams_changed,
+    const int input_threads,
+    const int input_infer_requests,
+    const int model_prefer_threads,
+    const int input_current_socket_id,
+    const std::string input_perf_hint,
+    const std::set<ov::hint::ModelDistributionPolicy> hint_llm_distribution_policy,
+    const std::vector<std::vector<int>>& proc_type_table);
 
 /**
  * @brief      Generate streams rank table for tensor parallel according to streams info table.
@@ -106,9 +107,7 @@ std::vector<std::vector<int>> generate_stream_info(const int streams,
  * @param[in]  model graph handle
  * @param[in]  config intel cpu configuration
  */
-void get_num_streams(const int streams,
-                     const std::shared_ptr<ov::Model>& model,
-                     Config& config);
+void get_num_streams(const int streams, const std::shared_ptr<ov::Model>& model, Config& config);
 
 }  // namespace intel_cpu
 }  // namespace ov
diff --git a/src/plugins/intel_cpu/src/cpu_tensor.cpp b/src/plugins/intel_cpu/src/cpu_tensor.cpp
index 1a045ca117a538..0f82a8a9a4dfec 100644
--- a/src/plugins/intel_cpu/src/cpu_tensor.cpp
+++ b/src/plugins/intel_cpu/src/cpu_tensor.cpp
@@ -16,7 +16,8 @@ Tensor::Tensor(MemoryPtr memptr) : m_memptr{memptr} {
 
     // only support plain data format ncsp.
     auto memdesc = m_memptr->getDescPtr();
-    OPENVINO_ASSERT(memdesc->hasLayoutType(LayoutType::ncsp), "intel_cpu::Tensor only supports memory with ncsp layout.");
+    OPENVINO_ASSERT(memdesc->hasLayoutType(LayoutType::ncsp),
+                    "intel_cpu::Tensor only supports memory with ncsp layout.");
 
     m_element_type = memdesc->getPrecision();
 }
@@ -24,8 +25,14 @@ Tensor::Tensor(MemoryPtr memptr) : m_memptr{memptr} {
 void Tensor::set_shape(ov::Shape new_shape) {
     const auto& shape = m_memptr->getDescPtr()->getShape();
     if (shape.isStatic()) {
-        DEBUG_LOG("tensor's memory object ", m_memptr.get(), ", ", vec2str(shape.getStaticDims()), " -> ", new_shape.to_string());
-        if (shape.getStaticDims() == new_shape) return;
+        DEBUG_LOG("tensor's memory object ",
+                  m_memptr.get(),
+                  ", ",
+                  vec2str(shape.getStaticDims()),
+                  " -> ",
+                  new_shape.to_string());
+        if (shape.getStaticDims() == new_shape)
+            return;
     }
 
     auto desc = m_memptr->getDescPtr();
@@ -69,7 +76,7 @@ void Tensor::update_strides() const {
     OPENVINO_ASSERT(blocked_desc, "not a valid blocked memory descriptor.");
     auto& strides = blocked_desc->getStrides();
     m_strides.resize(strides.size());
-    std::transform(strides.cbegin(), strides.cend(), m_strides.begin(), [this] (const size_t stride) {
+    std::transform(strides.cbegin(), strides.cend(), m_strides.begin(), [this](const size_t stride) {
         return stride * m_element_type.size();
     });
 }
@@ -96,5 +103,5 @@ std::shared_ptr<ITensor> make_tensor(MemoryPtr mem) {
     return std::make_shared<Tensor>(mem);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/cpu_tensor.h b/src/plugins/intel_cpu/src/cpu_tensor.h
index 0f073e0d298faf..86648ce969b168 100644
--- a/src/plugins/intel_cpu/src/cpu_tensor.h
+++ b/src/plugins/intel_cpu/src/cpu_tensor.h
@@ -4,8 +4,8 @@
 
 #pragma once
 
-#include "openvino/runtime/itensor.hpp"
 #include "cpu_memory.h"
+#include "openvino/runtime/itensor.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -29,7 +29,9 @@ class Tensor : public ITensor {
 
     void* data(const element::Type& type = {}) const override;
 
-    MemoryPtr get_memory() {return m_memptr;}
+    MemoryPtr get_memory() {
+        return m_memptr;
+    }
 
 private:
     void update_strides() const;
@@ -44,5 +46,5 @@ class Tensor : public ITensor {
 
 std::shared_ptr<ITensor> make_tensor(MemoryPtr mem);
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/cpu_types.cpp b/src/plugins/intel_cpu/src/cpu_types.cpp
index 30884bbe649962..67c538bd78341a 100644
--- a/src/plugins/intel_cpu/src/cpu_types.cpp
+++ b/src/plugins/intel_cpu/src/cpu_types.cpp
@@ -2,10 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 #include "cpu_types.h"
-#include "cpu_shape.h"
 
-#include <string>
 #include <sstream>
+#include <string>
+
+#include "cpu_shape.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -260,8 +261,7 @@ static const TypeToNameMap& get_type_to_name_tbl() {
         {"QKVProjection", Type::QKVProjection},
         {"RMS", Type::RMS},
         {"SearchSorted", Type::SearchSorted},
-        {"LoraSubgraph", Type::LoRA}
-    };
+        {"LoraSubgraph", Type::LoRA}};
     return type_to_name_tbl;
 }
 
diff --git a/src/plugins/intel_cpu/src/dnnl_extension_utils.cpp b/src/plugins/intel_cpu/src/dnnl_extension_utils.cpp
index 3d9b2f69bd8f66..457f8368f734dd 100644
--- a/src/plugins/intel_cpu/src/dnnl_extension_utils.cpp
+++ b/src/plugins/intel_cpu/src/dnnl_extension_utils.cpp
@@ -47,79 +47,79 @@ uint8_t DnnlExtensionUtils::sizeOfDataType(dnnl::memory::data_type dataType) {
 
 dnnl::memory::data_type DnnlExtensionUtils::ElementTypeToDataType(const ov::element::Type& elementType) {
     switch (elementType) {
-        case ov::element::f32:
-            return memory::data_type::f32;
-        case ov::element::i32:
-            return memory::data_type::s32;
-        case ov::element::bf16:
-            return memory::data_type::bf16;
-        case ov::element::i8:
-            return memory::data_type::s8;
-        case ov::element::u8:
-        case ov::element::boolean:
-            return memory::data_type::u8;
-        case ov::element::u1:
-            return memory::data_type::bin;
-        case ov::element::f16:
-            return memory::data_type::f16;
-        case ov::element::nf4:
-            return memory::data_type::nf4;
-        case ov::element::i4:
-            return memory::data_type::s4;
-        case ov::element::u4:
-            return memory::data_type::u4;
-        case ov::element::f8e8m0:
-            return memory::data_type::f8_e8m0;
-        case ov::element::f4e2m1:
-            return memory::data_type::f4_e2m1;
-        case ov::element::undefined:
-            return memory::data_type::undef;
-        default: {
-            OPENVINO_THROW("CPU plugin does not support ", elementType.to_string(), " for use with oneDNN.");
-        }
+    case ov::element::f32:
+        return memory::data_type::f32;
+    case ov::element::i32:
+        return memory::data_type::s32;
+    case ov::element::bf16:
+        return memory::data_type::bf16;
+    case ov::element::i8:
+        return memory::data_type::s8;
+    case ov::element::u8:
+    case ov::element::boolean:
+        return memory::data_type::u8;
+    case ov::element::u1:
+        return memory::data_type::bin;
+    case ov::element::f16:
+        return memory::data_type::f16;
+    case ov::element::nf4:
+        return memory::data_type::nf4;
+    case ov::element::i4:
+        return memory::data_type::s4;
+    case ov::element::u4:
+        return memory::data_type::u4;
+    case ov::element::f8e8m0:
+        return memory::data_type::f8_e8m0;
+    case ov::element::f4e2m1:
+        return memory::data_type::f4_e2m1;
+    case ov::element::undefined:
+        return memory::data_type::undef;
+    default: {
+        OPENVINO_THROW("CPU plugin does not support ", elementType.to_string(), " for use with oneDNN.");
+    }
     }
 }
 
 ov::element::Type DnnlExtensionUtils::DataTypeToElementType(const dnnl::memory::data_type& dataType) {
     switch (dataType) {
-        case memory::data_type::f32:
-            return ov::element::f32;
-        case memory::data_type::s32:
-            return ov::element::i32;
-        case memory::data_type::bf16:
-            return ov::element::bf16;
-        case memory::data_type::s8:
-            return ov::element::i8;
-        case memory::data_type::u8:
-            return ov::element::u8;
-        case memory::data_type::bin:
-            return ov::element::u1;
-        case memory::data_type::f16:
-            return ov::element::f16;
-        case memory::data_type::f64:
-            return ov::element::f64;
-        case memory::data_type::nf4:
-            return ov::element::nf4;
-        case memory::data_type::s4:
-            return ov::element::i4;
-        case memory::data_type::u4:
-            return ov::element::u4;
-        case memory::data_type::f8_e8m0:
-            return ov::element::f8e8m0;
-        case memory::data_type::f4_e2m1:
-            return ov::element::f4e2m1;
-        case memory::data_type::undef:
-            return ov::element::undefined;
-        default: {
-            OPENVINO_THROW("Unsupported data type.");
-        }
+    case memory::data_type::f32:
+        return ov::element::f32;
+    case memory::data_type::s32:
+        return ov::element::i32;
+    case memory::data_type::bf16:
+        return ov::element::bf16;
+    case memory::data_type::s8:
+        return ov::element::i8;
+    case memory::data_type::u8:
+        return ov::element::u8;
+    case memory::data_type::bin:
+        return ov::element::u1;
+    case memory::data_type::f16:
+        return ov::element::f16;
+    case memory::data_type::f64:
+        return ov::element::f64;
+    case memory::data_type::nf4:
+        return ov::element::nf4;
+    case memory::data_type::s4:
+        return ov::element::i4;
+    case memory::data_type::u4:
+        return ov::element::u4;
+    case memory::data_type::f8_e8m0:
+        return ov::element::f8e8m0;
+    case memory::data_type::f4_e2m1:
+        return ov::element::f4e2m1;
+    case memory::data_type::undef:
+        return ov::element::undefined;
+    default: {
+        OPENVINO_THROW("Unsupported data type.");
+    }
     }
 }
 
-Dim DnnlExtensionUtils::convertToDim(const dnnl::memory::dim &dim) {
-    return dim == DNNL_RUNTIME_DIM_VAL ?  Shape::UNDEFINED_DIM : static_cast<size_t>(dim);
+Dim DnnlExtensionUtils::convertToDim(const dnnl::memory::dim& dim) {
+    return dim == DNNL_RUNTIME_DIM_VAL ? Shape::UNDEFINED_DIM : static_cast<size_t>(dim);
 }
-dnnl::memory::dim DnnlExtensionUtils::convertToDnnlDim(const Dim &dim) {
+dnnl::memory::dim DnnlExtensionUtils::convertToDnnlDim(const Dim& dim) {
     return dim == Shape::UNDEFINED_DIM ? DNNL_RUNTIME_DIM_VAL : static_cast<dnnl::memory::dim>(dim);
 }
 
@@ -141,25 +141,25 @@ memory::dims DnnlExtensionUtils::convertToDnnlDims(const VectorDims& dims) {
 
 memory::format_tag DnnlExtensionUtils::GetPlainFormatByRank(size_t rank) {
     switch (rank) {
-        case 0:
-        case 1:
-            return memory::format_tag::a;
-        case 2:
-            return memory::format_tag::ab;
-        case 3:
-            return memory::format_tag::abc;
-        case 4:
-            return memory::format_tag::abcd;
-        case 5:
-            return memory::format_tag::abcde;
-        case 6:
-            return memory::format_tag::abcdef;
-        default:
-            return memory::format_tag::undef;
+    case 0:
+    case 1:
+        return memory::format_tag::a;
+    case 2:
+        return memory::format_tag::ab;
+    case 3:
+        return memory::format_tag::abc;
+    case 4:
+        return memory::format_tag::abcd;
+    case 5:
+        return memory::format_tag::abcde;
+    case 6:
+        return memory::format_tag::abcdef;
+    default:
+        return memory::format_tag::undef;
     }
 }
 
-DnnlMemoryDescPtr DnnlExtensionUtils::makeDescriptor(const dnnl::memory::desc &desc) {
+DnnlMemoryDescPtr DnnlExtensionUtils::makeDescriptor(const dnnl::memory::desc& desc) {
     return makeDescriptor(desc.get());
 }
 
@@ -182,7 +182,8 @@ size_t DnnlExtensionUtils::getMemSizeForDnnlDesc(const dnnl::memory::desc& desc)
     return size;
 }
 
-std::shared_ptr<DnnlBlockedMemoryDesc> DnnlExtensionUtils::makeUndefinedDesc(const memory::desc &desc, const Shape &shape) {
+std::shared_ptr<DnnlBlockedMemoryDesc> DnnlExtensionUtils::makeUndefinedDesc(const memory::desc& desc,
+                                                                             const Shape& shape) {
     if (desc.get_format_kind() == memory::format_kind::blocked) {
         return std::shared_ptr<DnnlBlockedMemoryDesc>(new DnnlBlockedMemoryDesc(desc, shape));
     } else {
@@ -190,7 +191,9 @@ std::shared_ptr<DnnlBlockedMemoryDesc> DnnlExtensionUtils::makeUndefinedDesc(con
     }
 }
 
-DnnlMemoryDescPtr DnnlExtensionUtils::query_md(const const_dnnl_primitive_desc_t& pd, const dnnl::query& what, int idx) {
+DnnlMemoryDescPtr DnnlExtensionUtils::query_md(const const_dnnl_primitive_desc_t& pd,
+                                               const dnnl::query& what,
+                                               int idx) {
     auto query = dnnl::convert_to_c(what);
     const auto* cdesc = dnnl_primitive_desc_query_md(pd, query, idx);
 
@@ -201,7 +204,7 @@ DnnlMemoryDescPtr DnnlExtensionUtils::query_md(const const_dnnl_primitive_desc_t
 }
 
 std::string DnnlExtensionUtils::query_impl_info_str(const const_dnnl_primitive_desc_t& pd) {
-    const char *res;
+    const char* res;
     dnnl_status_t status = dnnl_primitive_desc_query(pd, dnnl_query_impl_info_str, 0, &res);
     if (status != dnnl_success)
         OPENVINO_THROW("query_impl_info_str failed.");
@@ -209,10 +212,9 @@ std::string DnnlExtensionUtils::query_impl_info_str(const const_dnnl_primitive_d
 }
 
 bool DnnlExtensionUtils::find_implementation(dnnl::primitive_desc& desc, impl_desc_type impl_type) {
-    return DnnlExtensionUtils::find_implementation(desc,
-                                                   [impl_type](impl_desc_type cur_impl_type){
-                                                       return cur_impl_type == impl_type;
-                                                   });
+    return DnnlExtensionUtils::find_implementation(desc, [impl_type](impl_desc_type cur_impl_type) {
+        return cur_impl_type == impl_type;
+    });
 }
 
 dnnl_memory_desc_t DnnlExtensionUtils::clone_desc(const_dnnl_memory_desc_t cdesc) {
@@ -233,31 +235,33 @@ const char* DnnlExtensionUtils::query_pd_info(const_dnnl_primitive_desc_t pd) {
 
 bool DnnlExtensionUtils::isUnarySupportedAsPostOp(Algorithm alg) {
 #if defined(OV_CPU_WITH_ACL)
-    return one_of(alg, Algorithm::EltwiseRelu,
-                       Algorithm::EltwiseTanh,
-                       Algorithm::EltwiseElu,
-                       Algorithm::EltwiseAbs,
-                       Algorithm::EltwiseSqrt,
-                       Algorithm::EltwiseSoftRelu,
-                       Algorithm::EltwiseSigmoid,
-                       Algorithm::EltwiseClamp);
+    return one_of(alg,
+                  Algorithm::EltwiseRelu,
+                  Algorithm::EltwiseTanh,
+                  Algorithm::EltwiseElu,
+                  Algorithm::EltwiseAbs,
+                  Algorithm::EltwiseSqrt,
+                  Algorithm::EltwiseSoftRelu,
+                  Algorithm::EltwiseSigmoid,
+                  Algorithm::EltwiseClamp);
 #elif defined(OPENVINO_ARCH_X86_64)
-    return one_of(alg, Algorithm::EltwiseRelu,
-                       Algorithm::EltwiseGeluErf,
-                       Algorithm::EltwiseGeluTanh,
-                       Algorithm::EltwiseElu,
-                       Algorithm::EltwiseSigmoid,
-                       Algorithm::EltwiseClamp,
-                       Algorithm::EltwiseTanh,
-                       Algorithm::EltwiseSwish,
-                       Algorithm::EltwiseHswish,
-                       Algorithm::EltwiseMish,
-                       Algorithm::EltwiseHsigmoid,
-                       Algorithm::EltwiseRoundHalfToEven,
-                       Algorithm::EltwiseRoundHalfAwayFromZero,
-                       Algorithm::EltwiseAbs,
-                       Algorithm::EltwiseSqrt,
-                       Algorithm::EltwiseSoftRelu);
+    return one_of(alg,
+                  Algorithm::EltwiseRelu,
+                  Algorithm::EltwiseGeluErf,
+                  Algorithm::EltwiseGeluTanh,
+                  Algorithm::EltwiseElu,
+                  Algorithm::EltwiseSigmoid,
+                  Algorithm::EltwiseClamp,
+                  Algorithm::EltwiseTanh,
+                  Algorithm::EltwiseSwish,
+                  Algorithm::EltwiseHswish,
+                  Algorithm::EltwiseMish,
+                  Algorithm::EltwiseHsigmoid,
+                  Algorithm::EltwiseRoundHalfToEven,
+                  Algorithm::EltwiseRoundHalfAwayFromZero,
+                  Algorithm::EltwiseAbs,
+                  Algorithm::EltwiseSqrt,
+                  Algorithm::EltwiseSoftRelu);
 #else
     return false;
 #endif
@@ -269,5 +273,5 @@ std::string DnnlExtensionUtils::computeWeightsStringHash(const std::shared_ptr<c
     return std::to_string(desc_hash) + "_" + std::to_string(reinterpret_cast<uint64_t>(memory->getData()));
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/dnnl_extension_utils.h b/src/plugins/intel_cpu/src/dnnl_extension_utils.h
index 7a968ea3c71c3d..ecf223b48497cd 100644
--- a/src/plugins/intel_cpu/src/dnnl_extension_utils.h
+++ b/src/plugins/intel_cpu/src/dnnl_extension_utils.h
@@ -10,11 +10,11 @@
 
 #include <string>
 
+#include "common/c_types_map.hpp"
 #include "cpu_types.h"
 #include "onednn/dnnl.h"
 #include "onednn/iml_type_mapper.h"
 #include "openvino/core/type/element_type.hpp"
-#include "common/c_types_map.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -29,8 +29,8 @@ class DnnlExtensionUtils {
     static uint8_t sizeOfDataType(dnnl::memory::data_type dataType);
     static dnnl::memory::data_type ElementTypeToDataType(const ov::element::Type& elementType);
     static ov::element::Type DataTypeToElementType(const dnnl::memory::data_type& dataType);
-    static Dim convertToDim(const dnnl::memory::dim &dim);
-    static dnnl::memory::dim convertToDnnlDim(const Dim &dim);
+    static Dim convertToDim(const dnnl::memory::dim& dim);
+    static dnnl::memory::dim convertToDnnlDim(const Dim& dim);
     static VectorDims convertToVectorDims(const dnnl::memory::dims& dims);
     static VectorDims convertToVectorDims(const dnnl::impl::dims_t dims, const int ndims);
     static std::vector<dnnl::memory::dim> convertToDnnlDims(const VectorDims& dims);
@@ -41,25 +41,28 @@ class DnnlExtensionUtils {
      * @param desc dnnl::memory::desc from which one of the descriptors will be created
      * @return pointer to DnnlBlockedMemoryDesc or DnnlMemoryDesc
      */
-    static std::shared_ptr<DnnlMemoryDesc> makeDescriptor(const dnnl::memory::desc &desc);
+    static std::shared_ptr<DnnlMemoryDesc> makeDescriptor(const dnnl::memory::desc& desc);
     static std::shared_ptr<DnnlMemoryDesc> makeDescriptor(const_dnnl_memory_desc_t desc);
 
     /**
      * @brief Helper function that creates DnnlBlockedMemoryDesc from defined dnnl::memory::desc and undefined shape.
-     * It uses desc as an basis for the new undefined one. Specifically, type, layout, precision, blocks, extra data will be preserved.
+     * It uses desc as an basis for the new undefined one. Specifically, type, layout, precision, blocks, extra data
+     * will be preserved.
      * @param desc dnnl::memory::desc dnnl desc which will be used as a basis of the new descriptor
      * @param shape a new undefined shape
      * @return pointer to the created DnnlBlockedMemoryDesc
      * @note Obly blocked descriptors are allowed at the moment
      */
 
-    static std::shared_ptr<DnnlBlockedMemoryDesc> makeUndefinedDesc(const dnnl::memory::desc &desc, const Shape& shape);
+    static std::shared_ptr<DnnlBlockedMemoryDesc> makeUndefinedDesc(const dnnl::memory::desc& desc, const Shape& shape);
     static size_t getMemSizeForDnnlDesc(const dnnl::memory::desc& desc);
 
-    static std::shared_ptr<DnnlMemoryDesc> query_md(const const_dnnl_primitive_desc_t& pd, const dnnl::query& what, int idx = 0);
+    static std::shared_ptr<DnnlMemoryDesc> query_md(const const_dnnl_primitive_desc_t& pd,
+                                                    const dnnl::query& what,
+                                                    int idx = 0);
     static std::string query_impl_info_str(const const_dnnl_primitive_desc_t& pd);
 
-    template<typename T>
+    template <typename T>
     static bool find_implementation(dnnl::primitive_desc& desc, T&& comparator) {
         dnnl::primitive_desc_iterator& itpd = desc;
 
@@ -77,7 +80,7 @@ class DnnlExtensionUtils {
         return false;
     }
 
-    template<typename T, typename L>
+    template <typename T, typename L>
     static void for_each_implementation(dnnl::primitive_desc& desc, bool first_match, T&& comparator, L&& func) {
         dnnl::primitive_desc_iterator& itpd = desc;
 
@@ -113,5 +116,5 @@ class DnnlExtensionUtils {
                                                 const std::shared_ptr<DnnlMemoryDesc>& dstDesc);
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/dnnl_postops_composer.cpp b/src/plugins/intel_cpu/src/dnnl_postops_composer.cpp
index 70d28f1f4ac739..7d62e5cb6b673d 100644
--- a/src/plugins/intel_cpu/src/dnnl_postops_composer.cpp
+++ b/src/plugins/intel_cpu/src/dnnl_postops_composer.cpp
@@ -656,7 +656,7 @@ static MemoryPtr prepackDecompressionParams(const MemoryCPtr& paramsPtr,
     // weights without batch: (OC, G)
     // weights with batch: (B, OC, G)
     const size_t OC = shape[shape.size() - 2];
-    const size_t G =  shape[shape.size() - 1];
+    const size_t G = shape[shape.size() - 1];
 
     Shape dstShape = Shape({OC, G});
 
@@ -698,8 +698,7 @@ void DnnlPostOpsComposer::appendDecompressionZeroPoints(const MemoryCPtr& zero_p
     if (zero_points_ptr == nullptr)
         return;
 
-    auto zeroPointsMem =
-        prepackDecompressionParams(zero_points_ptr, needTranspose, dstPrecision, engine);
+    auto zeroPointsMem = prepackDecompressionParams(zero_points_ptr, needTranspose, dstPrecision, engine);
     attr.set_zero_points_dims(DNNL_ARG_WEIGHTS,
                               DnnlExtensionUtils::convertToDnnlDims(zeroPointsMem->getStaticDims()),
                               DnnlExtensionUtils::ElementTypeToDataType(dstPrecision));
diff --git a/src/plugins/intel_cpu/src/dnnl_postops_composer.h b/src/plugins/intel_cpu/src/dnnl_postops_composer.h
index 8c2718aaaed4d5..7ae634658b005f 100644
--- a/src/plugins/intel_cpu/src/dnnl_postops_composer.h
+++ b/src/plugins/intel_cpu/src/dnnl_postops_composer.h
@@ -12,8 +12,8 @@
 
 #include "cpu_memory.h"
 #include "nodes/executors/dnnl/dnnl_aliases.hpp"
-#include "post_ops.hpp"
 #include "nodes/executors/dnnl/dnnl_post_op_data.hpp"
+#include "post_ops.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -31,7 +31,9 @@ class DnnlPostOpsComposer {
                         const dnnl::memory::data_type outDataType);
     DnnlPrimitiveAttrs compose();
     void appendDecompressionScales(const MemoryCPtr& scales_ptr, bool needTranspose, ov::element::Type dstPrecision);
-    void appendDecompressionZeroPoints(const MemoryCPtr& zero_points_ptr, bool needTranspose, ov::element::Type dstPrecision);
+    void appendDecompressionZeroPoints(const MemoryCPtr& zero_points_ptr,
+                                       bool needTranspose,
+                                       ov::element::Type dstPrecision);
     void setDynamicQuantizationParams(uint64_t groupSize);
 
 private:
diff --git a/src/plugins/intel_cpu/src/dnnl_postops_composer_legacy.cpp b/src/plugins/intel_cpu/src/dnnl_postops_composer_legacy.cpp
index cb59492463f410..3e40ead65d6cc3 100644
--- a/src/plugins/intel_cpu/src/dnnl_postops_composer_legacy.cpp
+++ b/src/plugins/intel_cpu/src/dnnl_postops_composer_legacy.cpp
@@ -3,9 +3,11 @@
 //
 
 #include "dnnl_postops_composer_legacy.h"
+
 #include <oneapi/dnnl/dnnl_types.h>
 
 #include <common/primitive_attr.hpp>
+
 #include "utils/debug_capabilities.h"
 
 namespace ov {
@@ -39,10 +41,10 @@ DnnlPostOpsComposerLegacy::DnnlPostOpsComposerLegacy(const dnnl::engine& engine,
         wei_scale_mask = wei_scale_values.size() > 1 ? weiScaleMaskPerChannel : 0;
         dst_scale_val = 1.0;
 
-        //set the DQscale into attr weight scale before appending any post-ops.
+        // set the DQscale into attr weight scale before appending any post-ops.
         updateWeiScales();
-        //If having the bias, attr weight scale can't be updated for further ops-ops optimization.
-        //ONEDNN 3.x quantization for scheme: QuantizedInput * QuantizedWeight * DQScale + Bias.
+        // If having the bias, attr weight scale can't be updated for further ops-ops optimization.
+        // ONEDNN 3.x quantization for scheme: QuantizedInput * QuantizedWeight * DQScale + Bias.
         weightScaleAvailable = !hasBias;
     } else if (!DQScales.empty()) {
         // DQ scale is fused but swiching back to non-INT8 for execution in some cases.
@@ -115,22 +117,22 @@ bool DnnlPostOpsComposerLegacy::appendScale(const std::vector<float>& scale, boo
         return true;
     }
     if (weightScaleAvailable) {
-        //oneDNN v3.* weight scale can also be used in the further optimization patterns.
-        // there are so many possible optimizations can be done, for example:
+        // oneDNN v3.* weight scale can also be used in the further optimization patterns.
+        //  there are so many possible optimizations can be done, for example:
         //
-        // we can switch the existing postOps's order to take
-        // advantage of output scale if it's available:
-        //    relu(x)*scale = relu(x*scale)
-        // or we can fuse it into previous one as long as they are
-        // compatible in shape
-        //    x*A*s = x*(A*s)
-        // or even with add:
-        //    (x*A + B)*s = x*(A*s) + (B*s)
-        // or we can combine these two tricks:
-        //    relu(x*A)*s = relu(x*(A*s))
+        //  we can switch the existing postOps's order to take
+        //  advantage of output scale if it's available:
+        //     relu(x)*scale = relu(x*scale)
+        //  or we can fuse it into previous one as long as they are
+        //  compatible in shape
+        //     x*A*s = x*(A*s)
+        //  or even with add:
+        //     (x*A + B)*s = x*(A*s) + (B*s)
+        //  or we can combine these two tricks:
+        //     relu(x*A)*s = relu(x*(A*s))
         //
-        // we cannot implement all of them, so we just add the one
-        // that we observed in real models.
+        //  we cannot implement all of them, so we just add the one
+        //  that we observed in real models.
         if ((ops.len() == 0))
             fuseIntoWeiScale = true;
 
@@ -201,9 +203,9 @@ bool DnnlPostOpsComposerLegacy::appendShift(const std::vector<float>& shift, boo
 }
 
 bool DnnlPostOpsComposerLegacy::appendLinear(const std::vector<float>& scale,
-                                       const std::vector<float>& shift,
-                                       bool isLastPostOp,
-                                       bool allowBinary) {
+                                             const std::vector<float>& shift,
+                                             bool isLastPostOp,
+                                             bool allowBinary) {
     if (scale.size() == 1 && shift.size() == 1) {
         if (shift[0] == 0.0f)
             return appendScale(scale, isLastPostOp, allowBinary);
diff --git a/src/plugins/intel_cpu/src/dnnl_postops_composer_legacy.h b/src/plugins/intel_cpu/src/dnnl_postops_composer_legacy.h
index 82fdda94012f15..485fa31fb5d956 100644
--- a/src/plugins/intel_cpu/src/dnnl_postops_composer_legacy.h
+++ b/src/plugins/intel_cpu/src/dnnl_postops_composer_legacy.h
@@ -8,11 +8,10 @@
  */
 #pragma once
 
-#include "dnnl_types.h"
-
 #include <string>
 
 #include "cpu_memory.h"
+#include "dnnl_types.h"
 #include "memory_desc/cpu_memory_desc.h"
 #include "memory_desc/dnnl_blocked_memory_desc.h"
 #include "onednn/dnnl.h"
@@ -39,7 +38,10 @@ class DnnlPostOpsComposerLegacy {
     void appendRoundHTE();
     bool appendScale(const std::vector<float>& scale, bool isLastPostOp, bool allowBinary = true);
     bool appendShift(const std::vector<float>& shift, bool allowBinary = true);
-    bool appendLinear(const std::vector<float>& scale, const std::vector<float>& shift, bool isLastPostOp, bool allowBinary = true);
+    bool appendLinear(const std::vector<float>& scale,
+                      const std::vector<float>& shift,
+                      bool isLastPostOp,
+                      bool allowBinary = true);
     void appendClip(const std::vector<float>& low, const std::vector<float>& high);
 
     const VectorDims& getOutputDims() {
diff --git a/src/plugins/intel_cpu/src/edge.cpp b/src/plugins/intel_cpu/src/edge.cpp
index c49b924477f694..1eabc6275bf4b0 100644
--- a/src/plugins/intel_cpu/src/edge.cpp
+++ b/src/plugins/intel_cpu/src/edge.cpp
@@ -3,8 +3,9 @@
 //
 
 #include "edge.h"
-#include "node.h"
+
 #include "dnnl_extension_utils.h"
+#include "node.h"
 #include "openvino/core/type/element_type.hpp"
 #include "openvino/util/pp.hpp"
 
@@ -12,8 +13,11 @@ using namespace dnnl;
 namespace ov {
 namespace intel_cpu {
 
-Edge::Edge(const NodePtr &parent, const NodePtr &child, int pr_port, int ch_port) :
-        parent(parent), child(child), parent_port(pr_port), child_port(ch_port) {}
+Edge::Edge(const NodePtr& parent, const NodePtr& child, int pr_port, int ch_port)
+    : parent(parent),
+      child(child),
+      parent_port(pr_port),
+      child_port(ch_port) {}
 
 const NodePtr Edge::getParent() const {
     auto parentPtr = parent.lock();
@@ -39,14 +43,14 @@ bool Edge::isDropped() const {
 
     auto parent_ptr = parent.lock();
     if (parent_ptr) {
-        for (auto &edge : parent_ptr->childEdges)
+        for (auto& edge : parent_ptr->childEdges)
             if (edge.lock().get() == this)
                 not_in_parent = false;
     }
 
     auto child_ptr = child.lock();
     if (child_ptr) {
-        for (auto &edge : child_ptr->parentEdges)
+        for (auto& edge : child_ptr->parentEdges)
             if (edge.lock().get() == this)
                 not_in_child = false;
     }
@@ -131,8 +135,8 @@ bool Edge::enforceReorder() {
 }
 
 static inline bool isPhycicalMemCompatible(const MemoryDesc& lhsMemDesc, const MemoryDesc& rhsMemDesc) {
-    if (!lhsMemDesc.isDefined() || !rhsMemDesc.isDefined() ||
-        !(lhsMemDesc.getType() & MemoryDescType::Blocked) || !(rhsMemDesc.getType() & MemoryDescType::Blocked) ||
+    if (!lhsMemDesc.isDefined() || !rhsMemDesc.isDefined() || !(lhsMemDesc.getType() & MemoryDescType::Blocked) ||
+        !(rhsMemDesc.getType() & MemoryDescType::Blocked) ||
         (lhsMemDesc.getType() == DnnlBlocked && !lhsMemDesc.as<const DnnlMemoryDesc>()->hasEmptyExtraData()) ||
         (rhsMemDesc.getType() == DnnlBlocked && !rhsMemDesc.as<const DnnlMemoryDesc>()->hasEmptyExtraData()))
         return false;
@@ -140,13 +144,21 @@ static inline bool isPhycicalMemCompatible(const MemoryDesc& lhsMemDesc, const M
     const auto lhsBlockMemDesc = lhsMemDesc.as<BlockedMemoryDesc>();
     const auto rhsBlockMemDesc = rhsMemDesc.as<BlockedMemoryDesc>();
 
-    if (lhsBlockMemDesc->getShape() != rhsBlockMemDesc->getShape() || lhsBlockMemDesc->getPrecision() != rhsBlockMemDesc->getPrecision())
+    if (lhsBlockMemDesc->getShape() != rhsBlockMemDesc->getShape() ||
+        lhsBlockMemDesc->getPrecision() != rhsBlockMemDesc->getPrecision())
         return false;
 
     // dims padding check
-    bool isZeroDimsPaddings =
-        std::all_of(lhsBlockMemDesc->getOffsetPaddingToData().begin(), lhsBlockMemDesc->getOffsetPaddingToData().end(), [](size_t x){ return x == 0; }) &&
-        std::all_of(rhsBlockMemDesc->getOffsetPaddingToData().begin(), rhsBlockMemDesc->getOffsetPaddingToData().end(), [](size_t x){ return x == 0; });
+    bool isZeroDimsPaddings = std::all_of(lhsBlockMemDesc->getOffsetPaddingToData().begin(),
+                                          lhsBlockMemDesc->getOffsetPaddingToData().end(),
+                                          [](size_t x) {
+                                              return x == 0;
+                                          }) &&
+                              std::all_of(rhsBlockMemDesc->getOffsetPaddingToData().begin(),
+                                          rhsBlockMemDesc->getOffsetPaddingToData().end(),
+                                          [](size_t x) {
+                                              return x == 0;
+                                          });
     bool isSameElementsCount = lhsBlockMemDesc->getPaddedElementsCount() == rhsBlockMemDesc->getPaddedElementsCount();
     if (!isZeroDimsPaddings || !isSameElementsCount)
         return false;
@@ -161,7 +173,8 @@ static inline bool isPhycicalMemCompatible(const MemoryDesc& lhsMemDesc, const M
     std::vector<size_t> lhsStridesDefault(lhsBlockDims.size());
     lhsStridesDefault[lhsBlockDims.size() - 1] = 1;
     for (size_t i = 2; i <= lhsBlockDims.size(); i++) {
-        lhsStridesDefault[lhsBlockDims.size() - i] = lhsStridesDefault[lhsBlockDims.size() - (i - 1)] * lhsBlockDims[lhsBlockDims.size() - (i - 1)];
+        lhsStridesDefault[lhsBlockDims.size() - i] =
+            lhsStridesDefault[lhsBlockDims.size() - (i - 1)] * lhsBlockDims[lhsBlockDims.size() - (i - 1)];
     }
 
     auto rhsBlockDims = rhsBlockMemDesc->getBlockDims();
@@ -169,11 +182,11 @@ static inline bool isPhycicalMemCompatible(const MemoryDesc& lhsMemDesc, const M
     rhsStridesDefault[rhsBlockDims.size() - 1] = 1;
     for (size_t i = 2; i <= rhsBlockDims.size(); i++) {
         rhsStridesDefault[rhsBlockDims.size() - i] =
-             rhsStridesDefault[rhsBlockDims.size() - (i - 1)] * rhsBlockDims[rhsBlockDims.size() - (i - 1)];
+            rhsStridesDefault[rhsBlockDims.size() - (i - 1)] * rhsBlockDims[rhsBlockDims.size() - (i - 1)];
     }
 
-    // this check needed to avoid inserting unnecessary reorders if the memory is used in place and the batch size is equal to 1
-    // in nodes like concate and split
+    // this check needed to avoid inserting unnecessary reorders if the memory is used in place and the batch size is
+    // equal to 1 in nodes like concate and split
     size_t lhsSkipAxis = lhsBlockDims.size() > 0 && lhsBlockDims[0] == 1 ? 0 : Shape::UNDEFINED_DIM;
     size_t rhsSkipAxis = rhsBlockDims.size() > 0 && rhsBlockDims[0] == 1 ? 0 : Shape::UNDEFINED_DIM;
 
@@ -219,8 +232,10 @@ Edge::ReorderStatus Edge::needReorder() {
 
     // Check whether the child node may accept the parent produced tensor
     if (!outPortDesc->isCompatible(*inputPortDesc)) {
-        // Performance optimization which exploit the fact that some tensors do not need actual data reordering to be read using different descriptors
-        if (isPhycicalMemCompatible(*inputPortDesc->getMemDesc(), *outPortDesc->getMemDesc()) && !getParent()->isConstant()) {
+        // Performance optimization which exploit the fact that some tensors do not need actual data reordering to be
+        // read using different descriptors
+        if (isPhycicalMemCompatible(*inputPortDesc->getMemDesc(), *outPortDesc->getMemDesc()) &&
+            !getParent()->isConstant()) {
             optimized = true;
         } else {
             return ReorderStatus::Regular;
@@ -297,8 +312,8 @@ std::string Edge::hash() const {
 
     std::stringstream result;
 
-    return parentPtr->getName() + "_" + std::to_string(parent_port) + "_" +
-        childPtr->getName() + "_" + std::to_string(child_port);
+    return parentPtr->getName() + "_" + std::to_string(parent_port) + "_" + childPtr->getName() + "_" +
+           std::to_string(child_port);
 }
 
 void Edge::externalAllocate(WeightsSharing::Ptr weightsCache) {
@@ -306,10 +321,13 @@ void Edge::externalAllocate(WeightsSharing::Ptr weightsCache) {
         return;
 
     if (weightsCache) {
-        auto alloc = [this] () {
+        auto alloc = [this]() {
             auto allocateFunc = [this](const MemoryDesc& inputDesc) -> MemoryPtr {
                 auto parentPtr = getParent();
-                return std::make_shared<StaticMemory>(parentPtr->getEngine(), inputDesc, nullptr, false);  // no pads zeroing
+                return std::make_shared<StaticMemory>(parentPtr->getEngine(),
+                                                      inputDesc,
+                                                      nullptr,
+                                                      false);  // no pads zeroing
             };
 
             allocateCommon(allocateFunc);
@@ -424,7 +442,7 @@ const MemoryDesc& Edge::getDesc() const {
     return getInputDesc();
 }
 
-const IMemory &Edge::getMemory() {
+const IMemory& Edge::getMemory() {
     auto memPtr = getMemoryPtr();
     OPENVINO_ASSERT(memPtr != nullptr, " Dereferencing NULL memory in edge: ", *this);
     return *memPtr;
@@ -434,7 +452,7 @@ MemoryPtr Edge::getMemoryPtr() const {
     return memoryPtr;
 }
 
-void Edge::sharedMemFrom(const EdgePtr &edge) {
+void Edge::sharedMemFrom(const EdgePtr& edge) {
     memoryFromEdge = edge;
     DEBUG_LOG(*this, " sharedMemFrom ", *edge);
     status = Status::NotAllocated;
@@ -474,10 +492,8 @@ void Edge::init() {
         DEBUG_LOG(*this, " getBaseEdge() return itself");
         changeStatus(Status::NeedAllocation);
     } else {
-        if (Type::Input == edgePtr->getParent()->getType() &&
-            Type::MemoryInput != getParent()->getType() &&
-            edgePtr->getParent()->isConstant() &&
-            !edgePtr->getChild()->isConstant()) {
+        if (Type::Input == edgePtr->getParent()->getType() && Type::MemoryInput != getParent()->getType() &&
+            edgePtr->getParent()->isConstant() && !edgePtr->getChild()->isConstant()) {
             changeStatus(Status::NeedAllocation);
             DEBUG_LOG(*this, " edge inplace from ", *edgePtr, " is broken!");
             return;
@@ -505,11 +521,11 @@ EdgePtr Edge::getBaseEdge(int look) {
 
     if ((childInPlacePort >= 0) && (look & LOOK_DOWN)) {
         auto ch_edges = getChild()->getChildEdgesAtPort(childInPlacePort);
-        auto &next_ch_edge = ch_edges[0];
+        auto& next_ch_edge = ch_edges[0];
 
         // Multiple connection to some out port
         // Will try to find inplace consumer
-        for (auto &ch_edge : ch_edges) {
+        for (auto& ch_edge : ch_edges) {
             if (ch_edge->getChild()->inPlaceInputPort(ch_edge->getOutputNum()) >= 0) {
                 next_ch_edge = ch_edge;
                 // To align with upstream-inplace, we stop searching once found the first inplace consumer
@@ -525,14 +541,16 @@ EdgePtr Edge::getBaseEdge(int look) {
     for (auto edge : edgesForSamePort) {
         if (edge.get() != this) {
             // Return once found the first inplace consumer
-            if (edge->inPlace()) return edge;
+            if (edge->inPlace())
+                return edge;
         }
     }
 
     // Return the first output edge as the base if there is no inPlace consumers
     // thus benefits zero-copy of outputs.
     for (auto edge : edgesForSamePort) {
-        if (Type::Output == edge->getChild()->getType()) return edge;
+        if (Type::Output == edge->getChild()->getType())
+            return edge;
     }
 
     return edgesForSamePort[0];
@@ -579,7 +597,7 @@ NodePtr Edge::modifiedInPlace() const {
         for (size_t i = 0; i < outConfs.size(); ++i) {
             const auto& conf = outConfs[i];
             if (childPort < 0 || conf.inPlace() != childPort ||
-                Type::MemoryInput == childNode->getType()) { //exception type, it doesn't modify memory
+                Type::MemoryInput == childNode->getType()) {  // exception type, it doesn't modify memory
                 continue;
             }
             if (childNode->isExecutable()) {
@@ -599,12 +617,14 @@ NodePtr Edge::modifiedInPlace() const {
     return nullptr;
 }
 
-std::ostream& operator<<(std::ostream &os, const Edge& edge) {
-    return os << "(" << edge.getParent()->getName() << ")" << "[" << edge.getInputNum() << "] "
+std::ostream& operator<<(std::ostream& os, const Edge& edge) {
+    return os << "(" << edge.getParent()->getName() << ")"
+              << "[" << edge.getInputNum() << "] "
               << "<->"
-              << "(" << edge.getChild()->getName() << ")" << "[" << edge.getOutputNum() << "]"
+              << "(" << edge.getChild()->getName() << ")"
+              << "[" << edge.getOutputNum() << "]"
               << ":" << Edge::statusToString(edge.getStatus());
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/edge.h b/src/plugins/intel_cpu/src/edge.h
index 5c418b2665924d..38f49ff00db075 100644
--- a/src/plugins/intel_cpu/src/edge.h
+++ b/src/plugins/intel_cpu/src/edge.h
@@ -4,15 +4,15 @@
 
 #pragma once
 
+#include <memory>
+#include <vector>
+
 #include "cpu_shape.h"
 #include "internal_properties.hpp"
 #include "memory_desc/cpu_memory_desc.h"
 #include "nodes/node_config.h"
 #include "weights_cache.hpp"
 
-#include <memory>
-#include <vector>
-
 namespace ov {
 namespace intel_cpu {
 
@@ -24,23 +24,11 @@ using EdgeWeakPtr = std::weak_ptr<Edge>;
 
 class Edge {
 public:
-    Edge(const std::shared_ptr<Node>& parent,
-         const std::shared_ptr<Node>& child,
-         int pr_port = 0, int ch_port = 0);
-
-    enum class Status {
-        Uninitialized,
-        NeedAllocation,
-        NotAllocated,
-        Allocated,
-        Validated
-    };
-
-    enum class ReorderStatus {
-        Regular = 0,
-        Optimized = 1,
-        No = 2
-    };
+    Edge(const std::shared_ptr<Node>& parent, const std::shared_ptr<Node>& child, int pr_port = 0, int ch_port = 0);
+
+    enum class Status { Uninitialized, NeedAllocation, NotAllocated, Allocated, Validated };
+
+    enum class ReorderStatus { Regular = 0, Optimized = 1, No = 2 };
 
     enum LOOK { LOOK_UP = 1, LOOK_DOWN = 2, LOOK_BOTH = LOOK_UP | LOOK_DOWN };
 
@@ -52,15 +40,15 @@ class Edge {
 #define CASE(_status)     \
     case Status::_status: \
         return #_status;
-    switch (status) {
-        CASE(Uninitialized);
-        CASE(NeedAllocation);
-        CASE(NotAllocated);
-        CASE(Allocated);
-        CASE(Validated);
-    }
+        switch (status) {
+            CASE(Uninitialized);
+            CASE(NeedAllocation);
+            CASE(NotAllocated);
+            CASE(Allocated);
+            CASE(Validated);
+        }
 #undef CASE
-    return "Unexpected";
+        return "Unexpected";
     }
 
     void changeStatus(Status state);
@@ -87,7 +75,9 @@ class Edge {
     int getInputNum() const;
     int getOutputNum() const;
 
-    void setChildPort(const size_t port) { child_port = port; }
+    void setChildPort(const size_t port) {
+        child_port = port;
+    }
 
     void sharedMemFrom(const EdgePtr& edge);
     EdgePtr getSharedEdge() const;
@@ -126,8 +116,7 @@ class Edge {
     friend class Graph;
 };
 
-std::ostream& operator<<(std::ostream &os, const Edge& edge);
-
-}   // namespace intel_cpu
-}   // namespace ov
+std::ostream& operator<<(std::ostream& os, const Edge& edge);
 
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/debug_capabilities.cpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/debug_capabilities.cpp
index 01af9dbde7fe01..c2c6ddf6f271fc 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/debug_capabilities.cpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/debug_capabilities.cpp
@@ -4,9 +4,10 @@
 
 #ifdef CPU_DEBUG_CAPS
 
-#include "debug_capabilities.hpp"
-#include <iostream>
-#include <sstream>
+#    include "debug_capabilities.hpp"
+
+#    include <iostream>
+#    include <sstream>
 
 namespace ov {
 namespace intel_cpu {
@@ -14,25 +15,26 @@ namespace intel_cpu {
 using namespace Xbyak;
 using namespace dnnl::impl::cpu::x64;
 
-template void RegPrinter::print<float, Xmm>(jit_generator &h, Xmm reg, const char *name);
-template void RegPrinter::print<int, Xmm>(jit_generator &h, Xmm reg, const char *name);
-template void RegPrinter::print<float, Ymm>(jit_generator &h, Ymm reg, const char *name);
-template void RegPrinter::print<int, Ymm>(jit_generator &h, Ymm reg, const char *name);
-template void RegPrinter::print<float, Zmm>(jit_generator &h, Zmm reg, const char *name);
-template void RegPrinter::print<int, Zmm>(jit_generator &h, Zmm reg, const char *name);
-template void RegPrinter::print<float, Reg64>(jit_generator &h, Reg64 reg, const char *name);
-template void RegPrinter::print<int, Reg64>(jit_generator &h, Reg64 reg, const char *name);
-template void RegPrinter::print<float, Reg32>(jit_generator &h, Reg32 reg, const char *name);
-template void RegPrinter::print<int, Reg32>(jit_generator &h, Reg32 reg, const char *name);
-template void RegPrinter::print<char, Reg16>(jit_generator &h, Reg16 reg, const char *name);
-template void RegPrinter::print<unsigned char, Reg16>(jit_generator &h, Reg16 reg, const char *name);
-template void RegPrinter::print<char, Reg8>(jit_generator &h, Reg8 reg, const char *name);
-template void RegPrinter::print<unsigned char, Reg8>(jit_generator &h, Reg8 reg, const char *name);
+template void RegPrinter::print<float, Xmm>(jit_generator& h, Xmm reg, const char* name);
+template void RegPrinter::print<int, Xmm>(jit_generator& h, Xmm reg, const char* name);
+template void RegPrinter::print<float, Ymm>(jit_generator& h, Ymm reg, const char* name);
+template void RegPrinter::print<int, Ymm>(jit_generator& h, Ymm reg, const char* name);
+template void RegPrinter::print<float, Zmm>(jit_generator& h, Zmm reg, const char* name);
+template void RegPrinter::print<int, Zmm>(jit_generator& h, Zmm reg, const char* name);
+template void RegPrinter::print<float, Reg64>(jit_generator& h, Reg64 reg, const char* name);
+template void RegPrinter::print<int, Reg64>(jit_generator& h, Reg64 reg, const char* name);
+template void RegPrinter::print<float, Reg32>(jit_generator& h, Reg32 reg, const char* name);
+template void RegPrinter::print<int, Reg32>(jit_generator& h, Reg32 reg, const char* name);
+template void RegPrinter::print<char, Reg16>(jit_generator& h, Reg16 reg, const char* name);
+template void RegPrinter::print<unsigned char, Reg16>(jit_generator& h, Reg16 reg, const char* name);
+template void RegPrinter::print<char, Reg8>(jit_generator& h, Reg8 reg, const char* name);
+template void RegPrinter::print<unsigned char, Reg8>(jit_generator& h, Reg8 reg, const char* name);
 
 template <typename T>
-void RegPrinter::print_reg_prc(const char *name, const char *ori_name, T *ptr) {
+void RegPrinter::print_reg_prc(const char* name, const char* ori_name, T* ptr) {
     std::stringstream ss;
-    if (name) ss << name << " | ";
+    if (name)
+        ss << name << " | ";
     ss << ori_name << ": ";
     if (std::is_floating_point<T>::value) {
         ss << *ptr;
@@ -48,9 +50,10 @@ void RegPrinter::print_reg_prc(const char *name, const char *ori_name, T *ptr) {
 }
 
 template <typename PRC_T, size_t vlen>
-void RegPrinter::print_vmm_prc(const char *name, const char *ori_name, PRC_T *ptr) {
+void RegPrinter::print_vmm_prc(const char* name, const char* ori_name, PRC_T* ptr) {
     std::stringstream ss;
-    if (name) ss << name << " | ";
+    if (name)
+        ss << name << " | ";
     ss << ori_name << ": {" << ptr[0];
     for (size_t i = 1; i < vlen / sizeof(float); i++) {
         ss << ", " << ptr[i];
@@ -58,15 +61,15 @@ void RegPrinter::print_vmm_prc(const char *name, const char *ori_name, PRC_T *pt
     ss << "}" << std::endl;
     std::cout << ss.str();
 }
-template void RegPrinter::print_vmm_prc<float, 16>(const char *name, const char *ori_name, float *ptr);
-template void RegPrinter::print_vmm_prc<float, 32>(const char *name, const char *ori_name, float *ptr);
-template void RegPrinter::print_vmm_prc<float, 64>(const char *name, const char *ori_name, float *ptr);
-template void RegPrinter::print_vmm_prc<int, 16>(const char *name, const char *ori_name, int *ptr);
-template void RegPrinter::print_vmm_prc<int, 32>(const char *name, const char *ori_name, int *ptr);
-template void RegPrinter::print_vmm_prc<int, 64>(const char *name, const char *ori_name, int *ptr);
+template void RegPrinter::print_vmm_prc<float, 16>(const char* name, const char* ori_name, float* ptr);
+template void RegPrinter::print_vmm_prc<float, 32>(const char* name, const char* ori_name, float* ptr);
+template void RegPrinter::print_vmm_prc<float, 64>(const char* name, const char* ori_name, float* ptr);
+template void RegPrinter::print_vmm_prc<int, 16>(const char* name, const char* ori_name, int* ptr);
+template void RegPrinter::print_vmm_prc<int, 32>(const char* name, const char* ori_name, int* ptr);
+template void RegPrinter::print_vmm_prc<int, 64>(const char* name, const char* ori_name, int* ptr);
 
 template <typename Vmm>
-struct vmm_traits{};
+struct vmm_traits {};
 
 template <>
 struct vmm_traits<Xmm> {
@@ -87,7 +90,7 @@ struct vmm_traits<Zmm> {
 };
 
 template <typename T>
-void RegPrinter::save_vmm(jit_generator &h) {
+void RegPrinter::save_vmm(jit_generator& h) {
     h.sub(h.rsp, vmm_traits<T>::vmm_len * vmm_traits<T>::vmm_cnt);
     for (size_t i = 0; i < vmm_traits<T>::vmm_cnt; i++) {
         h.uni_vmovups(h.ptr[h.rsp + i * vmm_traits<T>::vmm_len], T(i));
@@ -95,52 +98,52 @@ void RegPrinter::save_vmm(jit_generator &h) {
 }
 
 template <typename T>
-void RegPrinter::restore_vmm(jit_generator &h) {
+void RegPrinter::restore_vmm(jit_generator& h) {
     for (size_t i = 0; i < vmm_traits<T>::vmm_cnt; i++) {
         h.uni_vmovups(T(i), h.ptr[h.rsp + i * vmm_traits<T>::vmm_len]);
     }
     h.add(h.rsp, vmm_traits<T>::vmm_len * vmm_traits<T>::vmm_cnt);
 }
 
-void RegPrinter::save_reg(jit_generator &h) {
+void RegPrinter::save_reg(jit_generator& h) {
     h.sub(h.rsp, reg_len * reg_cnt);
     for (size_t i = 0; i < reg_cnt; i++) {
         h.mov(h.ptr[h.rsp + i * reg_len], Reg64(i));
     }
 }
 
-void RegPrinter::restore_reg(jit_generator &h) {
+void RegPrinter::restore_reg(jit_generator& h) {
     for (size_t i = 0; i < reg_cnt; i++) {
         h.mov(Reg64(i), h.ptr[h.rsp + i * reg_len]);
     }
     h.add(h.rsp, reg_len * reg_cnt);
 }
 
-void RegPrinter::preamble(jit_generator &h) {
+void RegPrinter::preamble(jit_generator& h) {
     save_reg(h);
-    mayiuse(cpu_isa_t::avx512_core) ? save_vmm<Zmm>(h) : (mayiuse(cpu_isa_t::avx2) ?
-                   save_vmm<Ymm>(h) : save_vmm<Xmm>(h));
+    mayiuse(cpu_isa_t::avx512_core) ? save_vmm<Zmm>(h)
+                                    : (mayiuse(cpu_isa_t::avx2) ? save_vmm<Ymm>(h) : save_vmm<Xmm>(h));
 }
 
-void RegPrinter::postamble(jit_generator &h) {
-    mayiuse(cpu_isa_t::avx512_core) ? restore_vmm<Zmm>(h) : (mayiuse(cpu_isa_t::avx2) ?
-                restore_vmm<Ymm>(h) : restore_vmm<Xmm>(h));
+void RegPrinter::postamble(jit_generator& h) {
+    mayiuse(cpu_isa_t::avx512_core) ? restore_vmm<Zmm>(h)
+                                    : (mayiuse(cpu_isa_t::avx2) ? restore_vmm<Ymm>(h) : restore_vmm<Xmm>(h));
     restore_reg(h);
 }
 
 // ABI requires 16-bype stack alignment before a call
-void RegPrinter::align_rsp(jit_generator &h) {
+void RegPrinter::align_rsp(jit_generator& h) {
     constexpr int alignment = 16;
     h.mov(h.r15, h.rsp);
     h.and_(h.rsp, ~(alignment - 1));
 }
 
-void RegPrinter::restore_rsp(jit_generator &h) {
+void RegPrinter::restore_rsp(jit_generator& h) {
     h.mov(h.rsp, h.r15);
 }
 
 template <typename PRC_T, typename REG_T>
-void RegPrinter::print_vmm(jit_generator &h, REG_T vmm, const char *name) {
+void RegPrinter::print_vmm(jit_generator& h, REG_T vmm, const char* name) {
     preamble(h);
 
     h.push(h.rax);
@@ -181,7 +184,7 @@ void RegPrinter::print_vmm(jit_generator &h, REG_T vmm, const char *name) {
 }
 
 template <typename PRC_T, typename REG_T>
-void RegPrinter::print_reg(jit_generator &h, REG_T reg, const char *name) {
+void RegPrinter::print_reg(jit_generator& h, REG_T reg, const char* name) {
     preamble(h);
 
     h.push(h.rax);
@@ -213,8 +216,7 @@ void RegPrinter::print_reg(jit_generator &h, REG_T reg, const char *name) {
     postamble(h);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
-
+}  // namespace intel_cpu
+}  // namespace ov
 
-#endif // CPU_DEBUG_CAPS
+#endif  // CPU_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/debug_capabilities.hpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/debug_capabilities.hpp
index fd7135b17bf5b9..dcac847dfd1e0f 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/debug_capabilities.hpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/debug_capabilities.hpp
@@ -6,7 +6,7 @@
 
 #ifdef CPU_DEBUG_CAPS
 
-#include "cpu/x64/jit_generator.hpp"
+#    include "cpu/x64/jit_generator.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -56,42 +56,44 @@ namespace intel_cpu {
 class RegPrinter {
 public:
     using jit_generator = dnnl::impl::cpu::x64::jit_generator;
-    template <typename PRC_T, typename REG_T,
-    typename std::enable_if<std::is_base_of<Xbyak::Xmm, REG_T>::value, int>::type = 0>
-    static void print(jit_generator &h, REG_T reg, const char *name = nullptr) {
+    template <typename PRC_T,
+              typename REG_T,
+              typename std::enable_if<std::is_base_of<Xbyak::Xmm, REG_T>::value, int>::type = 0>
+    static void print(jit_generator& h, REG_T reg, const char* name = nullptr) {
         print_vmm<PRC_T, REG_T>(h, reg, name);
     }
-    template <typename PRC_T, typename REG_T,
-    typename std::enable_if<!std::is_base_of<Xbyak::Xmm, REG_T>::value, int>::type = 0>
-    static void print(jit_generator &h, REG_T reg, const char *name = nullptr) {
+    template <typename PRC_T,
+              typename REG_T,
+              typename std::enable_if<!std::is_base_of<Xbyak::Xmm, REG_T>::value, int>::type = 0>
+    static void print(jit_generator& h, REG_T reg, const char* name = nullptr) {
         print_reg<PRC_T, REG_T>(h, reg, name);
     }
 
 private:
     RegPrinter() {}
     template <typename PRC_T, typename REG_T>
-    static void print_vmm(jit_generator &h, REG_T vmm, const char *name);
+    static void print_vmm(jit_generator& h, REG_T vmm, const char* name);
     template <typename PRC_T, typename REG_T>
-    static void print_reg(jit_generator &h, REG_T reg, const char *name);
+    static void print_reg(jit_generator& h, REG_T reg, const char* name);
     template <typename PRC_T, size_t vlen>
-    static void print_vmm_prc(const char *name, const char *ori_name, PRC_T *ptr);
+    static void print_vmm_prc(const char* name, const char* ori_name, PRC_T* ptr);
     template <typename T>
-    static void print_reg_prc(const char *name, const char *ori_name, T *val);
-    static void preamble(jit_generator &h);
-    static void postamble(jit_generator &h);
+    static void print_reg_prc(const char* name, const char* ori_name, T* val);
+    static void preamble(jit_generator& h);
+    static void postamble(jit_generator& h);
     template <typename T>
-    static void save_vmm(jit_generator &h);
+    static void save_vmm(jit_generator& h);
     template <typename T>
-    static void restore_vmm(jit_generator &h);
-    static void save_reg(jit_generator &h);
-    static void restore_reg(jit_generator &h);
-    static void align_rsp(jit_generator &h);
-    static void restore_rsp(jit_generator &h);
+    static void restore_vmm(jit_generator& h);
+    static void save_reg(jit_generator& h);
+    static void restore_reg(jit_generator& h);
+    static void align_rsp(jit_generator& h);
+    static void restore_rsp(jit_generator& h);
     static constexpr size_t reg_len = 8;
     static constexpr size_t reg_cnt = 16;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
-#endif // CPU_DEBUG_CAPS
+#endif  // CPU_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_bf16_emitters.hpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_bf16_emitters.hpp
index 43a2c2eb6b045f..2bfbaa68880aa8 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_bf16_emitters.hpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_bf16_emitters.hpp
@@ -11,14 +11,18 @@ namespace intel_cpu {
 
 class jit_uni_vcvtneps2bf16 : public jit_emitter {
 public:
-    jit_uni_vcvtneps2bf16(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-        ov::element::Type exec_prc = ov::element::bf16) : jit_emitter(host, host_isa, exec_prc) {
+    jit_uni_vcvtneps2bf16(dnnl::impl::cpu::x64::jit_generator* host,
+                          dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                          ov::element::Type exec_prc = ov::element::bf16)
+        : jit_emitter(host, host_isa, exec_prc) {
         if (!dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_bf16) &&
             !dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2_vnni_2))
             prepare_table();
     }
 
-    size_t get_inputs_num() const override { return 1; }
+    size_t get_inputs_num() const override {
+        return 1;
+    }
 
 private:
     void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override {
@@ -36,7 +40,8 @@ class jit_uni_vcvtneps2bf16 : public jit_emitter {
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
     void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
         using namespace Xbyak;
-        using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41, Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
+        using Vmm = typename dnnl::impl::utils::
+            conditional3<isa == dnnl::impl::cpu::x64::sse41, Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
 
         Vmm in = Vmm(in_vec_idxs[0]);
 
@@ -79,7 +84,7 @@ class jit_uni_vcvtneps2bf16 : public jit_emitter {
             h->uni_vpackusdw(aux, aux, aux);
 
             if (host_isa_ == dnnl::impl::cpu::x64::cpu_isa_t::avx2) {
-                h->vpermq(Ymm(aux.getIdx()), Ymm(aux.getIdx()), 0xD8); //11 01 10 00
+                h->vpermq(Ymm(aux.getIdx()), Ymm(aux.getIdx()), 0xD8);  // 11 01 10 00
                 h->vextracti128(out, Ymm(aux.getIdx()), 0);
             } else {
                 h->uni_vmovups(out, aux);
@@ -123,5 +128,5 @@ class jit_uni_vcvtneps2bf16 : public jit_emitter {
     }
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_conversion_emitters.cpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_conversion_emitters.cpp
index 544960008c9158..2e90af39fb9cf1 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_conversion_emitters.cpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_conversion_emitters.cpp
@@ -6,7 +6,6 @@
 
 #include "utils/bfloat16.hpp"
 
-
 using namespace dnnl::impl::utils;
 using namespace dnnl::impl;
 using namespace dnnl::impl::cpu::x64;
@@ -15,19 +14,23 @@ using namespace Xbyak;
 namespace ov {
 namespace intel_cpu {
 
-jit_convert_emitter::jit_convert_emitter(jit_generator *host, cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {
+jit_convert_emitter::jit_convert_emitter(jit_generator* host,
+                                         cpu_isa_t host_isa,
+                                         const std::shared_ptr<ov::Node>& node,
+                                         ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {
     input_type = node->get_input_element_type(0);
     output_type = node->get_output_element_type(0);
 
     if (output_type == ov::element::bf16)
-       uni_vcvtneps2bf16.reset(new jit_uni_vcvtneps2bf16(host, host_isa));
+        uni_vcvtneps2bf16.reset(new jit_uni_vcvtneps2bf16(host, host_isa));
 }
 
 void jit_convert_emitter::validate_types() const {
     auto is_supported_type = [this](const ov::element::Type& type) {
-        return any_of(supported_types.begin(), supported_types.end(),
-                      [&type](const ov::element::Type& supported_type) { return supported_type == type; } );
+        return any_of(supported_types.begin(), supported_types.end(), [&type](const ov::element::Type& supported_type) {
+            return supported_type == type;
+        });
     };
 
     if (!is_supported_type(input_type))
@@ -36,7 +39,9 @@ void jit_convert_emitter::validate_types() const {
         OV_CPU_JIT_EMITTER_THROW("Unsupported output type: ", output_type.get_type_name());
 }
 
-size_t jit_convert_emitter::get_inputs_num() const { return 1; }
+size_t jit_convert_emitter::get_inputs_num() const {
+    return 1;
+}
 
 void jit_convert_emitter::emit_data() const {
     jit_emitter::emit_data();
@@ -45,19 +50,22 @@ void jit_convert_emitter::emit_data() const {
 }
 
 template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-void jit_convert_emitter::float2bfloat(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_convert_emitter::float2bfloat(const std::vector<size_t>& in_vec_idxs,
+                                       const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == cpu::x64::sse41, Xmm, isa == cpu::x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src = Vmm(in_vec_idxs[0]);
-    Vmm vmm_dst  = Vmm(out_vec_idxs[0]);
+    Vmm vmm_dst = Vmm(out_vec_idxs[0]);
     if (!uni_vcvtneps2bf16)
         OV_CPU_JIT_EMITTER_THROW("Converter from float to bf16 isn't initialized!");
 
     uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())});
 }
 
-jit_convert_truncation_emitter::jit_convert_truncation_emitter(jit_generator *host, cpu_isa_t host_isa,
-                                                               const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
-        : jit_convert_emitter(host, host_isa, node, exec_prc) {
+jit_convert_truncation_emitter::jit_convert_truncation_emitter(jit_generator* host,
+                                                               cpu_isa_t host_isa,
+                                                               const std::shared_ptr<ov::Node>& node,
+                                                               ov::element::Type exec_prc)
+    : jit_convert_emitter(host, host_isa, node, exec_prc) {
     prepare_table();
 }
 
@@ -66,7 +74,8 @@ bool jit_convert_truncation_emitter::is_i8_and_u8_case() const {
            one_of(output_type, ov::element::i8, ov::element::u8);
 }
 
-void jit_convert_truncation_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_convert_truncation_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                               const std::vector<size_t>& out_vec_idxs) const {
     validate_types();
     if (host_isa_ == cpu::x64::sse41) {
         emit_isa<cpu::x64::sse41>(in_vec_idxs, out_vec_idxs);
@@ -80,10 +89,11 @@ void jit_convert_truncation_emitter::emit_impl(const std::vector<size_t> &in_vec
 }
 
 template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-void jit_convert_truncation_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_convert_truncation_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                              const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == cpu::x64::sse41, Xmm, isa == cpu::x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src = Vmm(in_vec_idxs[0]);
-    Vmm vmm_dst  = Vmm(out_vec_idxs[0]);
+    Vmm vmm_dst = Vmm(out_vec_idxs[0]);
 
     Xmm xmm_dst = Xmm(out_vec_idxs[0]);
     Ymm ymm_dst = Ymm(out_vec_idxs[0]);
@@ -97,95 +107,95 @@ void jit_convert_truncation_emitter::emit_isa(const std::vector<size_t> &in_vec_
     }
 
     switch (input_type) {
-        case ov::element::f32:
-            if (one_of(output_type, ov::element::i32, ov::element::i8, ov::element::u8))
-                h->uni_vcvttps2dq(vmm_dst, vmm_src);
-            break;
-        case ov::element::i32:
-            if (one_of(output_type, ov::element::f32, ov::element::bf16, ov::element::f16))
-                h->uni_vcvtdq2ps(vmm_dst, vmm_src);
-            break;
-        case ov::element::bf16:
-            h->vpmovzxwd(vmm_dst, vmm_src);
-            h->uni_vpslld(vmm_dst, vmm_dst, 16);
-            if (one_of(output_type, ov::element::i32, ov::element::i8, ov::element::u8))
-                h->uni_vcvttps2dq(vmm_dst, vmm_dst);
-            break;
-        case ov::element::f16:
-            if (isa == dnnl::impl::cpu::x64::avx512_core)
-                h->vcvtph2ps(vmm_dst, Ymm(vmm_src.getIdx()));
-            else
-                h->vcvtph2ps(vmm_dst,
-                             Xmm(vmm_src.getIdx()));  // for avx2_vnni_2?
-            if (one_of(output_type, ov::element::i32, ov::element::i8, ov::element::u8))
-                h->uni_vcvttps2dq(vmm_dst, vmm_dst);
-            break;
-        case ov::element::i8:
-            h->uni_vpmovsxbd(vmm_dst, vmm_src);
-            break;
-        case ov::element::u8:
-            h->uni_vpmovzxbd(vmm_dst, vmm_src);
-            break;
-        default:
-            OV_CPU_JIT_EMITTER_THROW("Unsupported input data type");
+    case ov::element::f32:
+        if (one_of(output_type, ov::element::i32, ov::element::i8, ov::element::u8))
+            h->uni_vcvttps2dq(vmm_dst, vmm_src);
+        break;
+    case ov::element::i32:
+        if (one_of(output_type, ov::element::f32, ov::element::bf16, ov::element::f16))
+            h->uni_vcvtdq2ps(vmm_dst, vmm_src);
+        break;
+    case ov::element::bf16:
+        h->vpmovzxwd(vmm_dst, vmm_src);
+        h->uni_vpslld(vmm_dst, vmm_dst, 16);
+        if (one_of(output_type, ov::element::i32, ov::element::i8, ov::element::u8))
+            h->uni_vcvttps2dq(vmm_dst, vmm_dst);
+        break;
+    case ov::element::f16:
+        if (isa == dnnl::impl::cpu::x64::avx512_core)
+            h->vcvtph2ps(vmm_dst, Ymm(vmm_src.getIdx()));
+        else
+            h->vcvtph2ps(vmm_dst,
+                         Xmm(vmm_src.getIdx()));  // for avx2_vnni_2?
+        if (one_of(output_type, ov::element::i32, ov::element::i8, ov::element::u8))
+            h->uni_vcvttps2dq(vmm_dst, vmm_dst);
+        break;
+    case ov::element::i8:
+        h->uni_vpmovsxbd(vmm_dst, vmm_src);
+        break;
+    case ov::element::u8:
+        h->uni_vpmovzxbd(vmm_dst, vmm_src);
+        break;
+    default:
+        OV_CPU_JIT_EMITTER_THROW("Unsupported input data type");
     }
 
     switch (output_type) {
-        case ov::element::f32:
-            if (!one_of(input_type, ov::element::i32, ov::element::bf16, ov::element::f16)) {
+    case ov::element::f32:
+        if (!one_of(input_type, ov::element::i32, ov::element::bf16, ov::element::f16)) {
+            h->uni_vcvtdq2ps(vmm_dst, vmm_dst);
+        }
+        break;
+    case ov::element::i32:
+        break;
+    case ov::element::bf16:
+        if (input_type == ov::element::f32) {
+            float2bfloat<isa>({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())});
+        } else {
+            if (one_of(input_type, ov::element::i8, ov::element::u8)) {
                 h->uni_vcvtdq2ps(vmm_dst, vmm_dst);
             }
-            break;
-        case ov::element::i32:
-            break;
-        case ov::element::bf16:
-            if (input_type == ov::element::f32) {
-                float2bfloat<isa>({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())});
-            } else {
-                if (one_of(input_type, ov::element::i8, ov::element::u8)) {
-                    h->uni_vcvtdq2ps(vmm_dst, vmm_dst);
-                }
-                float2bfloat<isa>({static_cast<size_t>(vmm_dst.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())});
-            }
-            break;
-        case ov::element::f16:
-            if (input_type == ov::element::f32) {
-                if (isa == dnnl::impl::cpu::x64::avx512_core)
-                    h->vcvtps2ph(ymm_dst, vmm_src, 0x4);
-                else
-                    h->vcvtps2ph(xmm_dst, vmm_src, 0x4);
-            } else {
-                if (one_of(input_type, ov::element::i8, ov::element::u8)) {
-                    h->uni_vcvtdq2ps(vmm_dst, vmm_dst);
-                }
-                if (isa == dnnl::impl::cpu::x64::avx512_core)
-                    h->vcvtps2ph(ymm_dst, vmm_dst, 0x4);
-                else
-                    h->vcvtps2ph(xmm_dst, vmm_dst, 0x4);
-            }
-            break;
-        case ov::element::i8:
-        case ov::element::u8:
-            if (input_type == ov::element::i32) {
-                dword2int8<isa>({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())});
-            } else {
-                dword2int8<isa>({static_cast<size_t>(vmm_dst.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())});
+            float2bfloat<isa>({static_cast<size_t>(vmm_dst.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())});
+        }
+        break;
+    case ov::element::f16:
+        if (input_type == ov::element::f32) {
+            if (isa == dnnl::impl::cpu::x64::avx512_core)
+                h->vcvtps2ph(ymm_dst, vmm_src, 0x4);
+            else
+                h->vcvtps2ph(xmm_dst, vmm_src, 0x4);
+        } else {
+            if (one_of(input_type, ov::element::i8, ov::element::u8)) {
+                h->uni_vcvtdq2ps(vmm_dst, vmm_dst);
             }
-            break;
-        default:
-           OV_CPU_JIT_EMITTER_THROW("Unsupported output data type");
+            if (isa == dnnl::impl::cpu::x64::avx512_core)
+                h->vcvtps2ph(ymm_dst, vmm_dst, 0x4);
+            else
+                h->vcvtps2ph(xmm_dst, vmm_dst, 0x4);
+        }
+        break;
+    case ov::element::i8:
+    case ov::element::u8:
+        if (input_type == ov::element::i32) {
+            dword2int8<isa>({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())});
+        } else {
+            dword2int8<isa>({static_cast<size_t>(vmm_dst.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())});
+        }
+        break;
+    default:
+        OV_CPU_JIT_EMITTER_THROW("Unsupported output data type");
     }
 }
 
 void jit_convert_truncation_emitter::register_table_entries() {
-    if (host_isa_ == dnnl::impl::cpu::x64::avx2 &&
-        one_of(output_type, ov::element::i8, ov::element::u8) &&
+    if (host_isa_ == dnnl::impl::cpu::x64::avx2 && one_of(output_type, ov::element::i8, ov::element::u8) &&
         !is_i8_and_u8_case())
         push_arg_entry_of("mask_byte", 0x000000ff, true);
 }
 
 template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-void jit_convert_truncation_emitter::dword2int8(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_convert_truncation_emitter::dword2int8(const std::vector<size_t>& in_vec_idxs,
+                                                const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == cpu::x64::sse41, Xmm, isa == cpu::x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src = Vmm(in_vec_idxs[0]);
 
@@ -204,12 +214,14 @@ void jit_convert_truncation_emitter::dword2int8(const std::vector<size_t> &in_ve
     }
 }
 
-jit_convert_saturation_emitter::jit_convert_saturation_emitter(jit_generator *host, cpu_isa_t host_isa,
-                                                               const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
-    : jit_convert_emitter(host, host_isa, node, exec_prc) {
-}
+jit_convert_saturation_emitter::jit_convert_saturation_emitter(jit_generator* host,
+                                                               cpu_isa_t host_isa,
+                                                               const std::shared_ptr<ov::Node>& node,
+                                                               ov::element::Type exec_prc)
+    : jit_convert_emitter(host, host_isa, node, exec_prc) {}
 
-void jit_convert_saturation_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_convert_saturation_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                               const std::vector<size_t>& out_vec_idxs) const {
     validate_types();
     if (host_isa_ == cpu::x64::sse41) {
         emit_isa<cpu::x64::sse41>(in_vec_idxs, out_vec_idxs);
@@ -223,10 +235,11 @@ void jit_convert_saturation_emitter::emit_impl(const std::vector<size_t> &in_vec
 }
 
 template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-void jit_convert_saturation_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_convert_saturation_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                              const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == cpu::x64::sse41, Xmm, isa == cpu::x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src = Vmm(in_vec_idxs[0]);
-    Vmm vmm_dst  = Vmm(out_vec_idxs[0]);
+    Vmm vmm_dst = Vmm(out_vec_idxs[0]);
 
     Xmm xmm_dst = Xmm(out_vec_idxs[0]);
     Ymm ymm_dst = Ymm(out_vec_idxs[0]);
@@ -237,88 +250,94 @@ void jit_convert_saturation_emitter::emit_isa(const std::vector<size_t> &in_vec_
     }
 
     switch (input_type) {
-        case ov::element::f32:
-            if (one_of(output_type, ov::element::i32, ov::element::i8, ov::element::u8))
-                h->uni_vcvtps2dq(vmm_dst, vmm_src);
-            break;
-        case ov::element::i32:
-            if (one_of(output_type, ov::element::f32, ov::element::bf16, ov::element::f16))
-                h->uni_vcvtdq2ps(vmm_dst, vmm_src);
-            break;
-        case ov::element::bf16:
-            h->vpmovzxwd(vmm_dst, vmm_src);
-            h->uni_vpslld(vmm_dst, vmm_dst, 16);
-            if (one_of(output_type, ov::element::i32, ov::element::i8, ov::element::u8))
-                h->uni_vcvttps2dq(vmm_dst, vmm_dst);
-            break;
-        case ov::element::f16:
-            if (isa == dnnl::impl::cpu::x64::avx512_core)
-                h->vcvtph2ps(vmm_dst, Ymm(vmm_src.getIdx()));
-            else
-                h->vcvtph2ps(vmm_dst,
-                             Xmm(vmm_src.getIdx()));  // for avx2_vnni_2?
-            if (one_of(output_type, ov::element::i32, ov::element::i8, ov::element::u8))
-                h->uni_vcvttps2dq(vmm_dst, vmm_dst);
-            break;
-        case ov::element::i8:
-            h->uni_vpmovsxbd(vmm_dst, vmm_src);
-            break;
-        case ov::element::u8:
-            h->uni_vpmovzxbd(vmm_dst, vmm_src);
-            break;
-        default:
-           OV_CPU_JIT_EMITTER_THROW("Unsupported input data type");
+    case ov::element::f32:
+        if (one_of(output_type, ov::element::i32, ov::element::i8, ov::element::u8))
+            h->uni_vcvtps2dq(vmm_dst, vmm_src);
+        break;
+    case ov::element::i32:
+        if (one_of(output_type, ov::element::f32, ov::element::bf16, ov::element::f16))
+            h->uni_vcvtdq2ps(vmm_dst, vmm_src);
+        break;
+    case ov::element::bf16:
+        h->vpmovzxwd(vmm_dst, vmm_src);
+        h->uni_vpslld(vmm_dst, vmm_dst, 16);
+        if (one_of(output_type, ov::element::i32, ov::element::i8, ov::element::u8))
+            h->uni_vcvttps2dq(vmm_dst, vmm_dst);
+        break;
+    case ov::element::f16:
+        if (isa == dnnl::impl::cpu::x64::avx512_core)
+            h->vcvtph2ps(vmm_dst, Ymm(vmm_src.getIdx()));
+        else
+            h->vcvtph2ps(vmm_dst,
+                         Xmm(vmm_src.getIdx()));  // for avx2_vnni_2?
+        if (one_of(output_type, ov::element::i32, ov::element::i8, ov::element::u8))
+            h->uni_vcvttps2dq(vmm_dst, vmm_dst);
+        break;
+    case ov::element::i8:
+        h->uni_vpmovsxbd(vmm_dst, vmm_src);
+        break;
+    case ov::element::u8:
+        h->uni_vpmovzxbd(vmm_dst, vmm_src);
+        break;
+    default:
+        OV_CPU_JIT_EMITTER_THROW("Unsupported input data type");
     }
 
     switch (output_type) {
-        case ov::element::f32:
-            if (!one_of(input_type, ov::element::i32, ov::element::bf16, ov::element::f16)) {
+    case ov::element::f32:
+        if (!one_of(input_type, ov::element::i32, ov::element::bf16, ov::element::f16)) {
+            h->uni_vcvtdq2ps(vmm_dst, vmm_dst);
+        }
+        break;
+    case ov::element::i32:
+        break;
+    case ov::element::bf16:
+        if (input_type == ov::element::f32) {
+            float2bfloat<isa>({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())});
+        } else {
+            if (one_of(input_type, ov::element::i8, ov::element::u8)) {
                 h->uni_vcvtdq2ps(vmm_dst, vmm_dst);
             }
-            break;
-        case ov::element::i32:
-            break;
-        case ov::element::bf16:
-            if (input_type == ov::element::f32) {
-                float2bfloat<isa>({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())});
-            } else {
-                if (one_of(input_type, ov::element::i8, ov::element::u8)) {
-                    h->uni_vcvtdq2ps(vmm_dst, vmm_dst);
-                }
-                float2bfloat<isa>({static_cast<size_t>(vmm_dst.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())});
-            }
-            break;
-        case ov::element::f16:
-            if (input_type == ov::element::f32) {
-                if (isa == dnnl::impl::cpu::x64::avx512_core)
-                    h->vcvtps2ph(ymm_dst, vmm_src, 0x4);
-                else
-                    h->vcvtps2ph(xmm_dst, vmm_src, 0x4);
-            } else {
-                if (one_of(input_type, ov::element::i8, ov::element::u8)) {
-                    h->uni_vcvtdq2ps(vmm_dst, vmm_dst);
-                }
-                if (isa == dnnl::impl::cpu::x64::avx512_core)
-                    h->vcvtps2ph(ymm_dst, vmm_dst, 0x4);
-                else
-                    h->vcvtps2ph(xmm_dst, vmm_dst, 0x4);
-            }
-            break;
-        case ov::element::i8:
-        case ov::element::u8:
-            if (input_type == ov::element::i32) {
-                dword2int8<isa>({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())}, output_type.is_signed());
-            } else {
-                dword2int8<isa>({static_cast<size_t>(vmm_dst.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())}, output_type.is_signed());
+            float2bfloat<isa>({static_cast<size_t>(vmm_dst.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())});
+        }
+        break;
+    case ov::element::f16:
+        if (input_type == ov::element::f32) {
+            if (isa == dnnl::impl::cpu::x64::avx512_core)
+                h->vcvtps2ph(ymm_dst, vmm_src, 0x4);
+            else
+                h->vcvtps2ph(xmm_dst, vmm_src, 0x4);
+        } else {
+            if (one_of(input_type, ov::element::i8, ov::element::u8)) {
+                h->uni_vcvtdq2ps(vmm_dst, vmm_dst);
             }
-            break;
-        default:
-            OV_CPU_JIT_EMITTER_THROW("Unsupported output data type");
+            if (isa == dnnl::impl::cpu::x64::avx512_core)
+                h->vcvtps2ph(ymm_dst, vmm_dst, 0x4);
+            else
+                h->vcvtps2ph(xmm_dst, vmm_dst, 0x4);
+        }
+        break;
+    case ov::element::i8:
+    case ov::element::u8:
+        if (input_type == ov::element::i32) {
+            dword2int8<isa>({static_cast<size_t>(vmm_src.getIdx())},
+                            {static_cast<size_t>(vmm_dst.getIdx())},
+                            output_type.is_signed());
+        } else {
+            dword2int8<isa>({static_cast<size_t>(vmm_dst.getIdx())},
+                            {static_cast<size_t>(vmm_dst.getIdx())},
+                            output_type.is_signed());
+        }
+        break;
+    default:
+        OV_CPU_JIT_EMITTER_THROW("Unsupported output data type");
     }
 }
 
 template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-void jit_convert_saturation_emitter::dword2int8(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs, bool is_signed) const {
+void jit_convert_saturation_emitter::dword2int8(const std::vector<size_t>& in_vec_idxs,
+                                                const std::vector<size_t>& out_vec_idxs,
+                                                bool is_signed) const {
     using Vmm = typename conditional3<isa == cpu::x64::sse41, Xmm, isa == cpu::x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src = Vmm(in_vec_idxs[0]);
 
@@ -330,7 +349,7 @@ void jit_convert_saturation_emitter::dword2int8(const std::vector<size_t> &in_ve
         if (is_signed) {
             h->vpmovsdb(xmm_dst, vmm_src);
         } else {
-            Vmm vmm_zero  = Vmm(aux_vec_idxs[0]);
+            Vmm vmm_zero = Vmm(aux_vec_idxs[0]);
             h->vpxord(vmm_zero, vmm_zero, vmm_zero);
             h->vpmaxsd(vmm_dst, vmm_src, vmm_zero);
             h->vpmovusdb(xmm_dst, vmm_dst);
@@ -353,8 +372,8 @@ void jit_convert_saturation_emitter::dword2int8(const std::vector<size_t> &in_ve
 
 size_t jit_convert_saturation_emitter::aux_vecs_count() const {
     // 1 register is for dword2int8 unsigned
-    return output_type == ov::element::u8 && host_isa_ == dnnl::impl::cpu::x64::avx512_core? 1 : 0;
+    return output_type == ov::element::u8 && host_isa_ == dnnl::impl::cpu::x64::avx512_core ? 1 : 0;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_conversion_emitters.hpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_conversion_emitters.hpp
index ee451ed358dd1a..29b85079573bee 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_conversion_emitters.hpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_conversion_emitters.hpp
@@ -4,16 +4,18 @@
 
 #pragma once
 
-#include "jit_emitter.hpp"
 #include "jit_bf16_emitters.hpp"
+#include "jit_emitter.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
 class jit_convert_emitter : public jit_emitter {
 public:
-    jit_convert_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                        const std::shared_ptr<ov::Node>& n, ov::element::Type exec_prc = ov::element::f32);
+    jit_convert_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                        const std::shared_ptr<ov::Node>& n,
+                        ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
 
@@ -22,19 +24,13 @@ class jit_convert_emitter : public jit_emitter {
     void validate_types() const;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void float2bfloat(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void float2bfloat(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     ov::element::Type input_type;
     ov::element::Type output_type;
 
-    const ov::element::TypeVector supported_types = {
-            ov::element::f32,
-            ov::element::i32,
-            ov::element::bf16,
-            ov::element::f16,
-            ov::element::i8,
-            ov::element::u8
-    };
+    const ov::element::TypeVector supported_types =
+        {ov::element::f32, ov::element::i32, ov::element::bf16, ov::element::f16, ov::element::i8, ov::element::u8};
 
     std::shared_ptr<jit_uni_vcvtneps2bf16> uni_vcvtneps2bf16 = nullptr;
 };
@@ -45,16 +41,18 @@ class jit_convert_emitter : public jit_emitter {
 //   129   -> -127
 class jit_convert_truncation_emitter : public jit_convert_emitter {
 public:
-    jit_convert_truncation_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                                   const std::shared_ptr<ov::Node>& n, ov::element::Type exec_prc = ov::element::f32);
+    jit_convert_truncation_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                   dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                                   const std::shared_ptr<ov::Node>& n,
+                                   ov::element::Type exec_prc = ov::element::f32);
 
 private:
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void dword2int8(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void dword2int8(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     bool is_i8_and_u8_case() const;
     void register_table_entries() override;
@@ -66,19 +64,23 @@ class jit_convert_truncation_emitter : public jit_convert_emitter {
 //   129   -> 127
 class jit_convert_saturation_emitter : public jit_convert_emitter {
 public:
-    jit_convert_saturation_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                                   const std::shared_ptr<ov::Node>& n, ov::element::Type exec_prc = ov::element::f32);
+    jit_convert_saturation_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                   dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                                   const std::shared_ptr<ov::Node>& n,
+                                   ov::element::Type exec_prc = ov::element::f32);
 
 private:
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void dword2int8(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs, bool is_signed) const;
+    void dword2int8(const std::vector<size_t>& in_vec_idxs,
+                    const std::vector<size_t>& out_vec_idxs,
+                    bool is_signed) const;
 
     size_t aux_vecs_count() const override;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_dnnl_emitters.cpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_dnnl_emitters.cpp
index 0b315cdd309715..51e801208b927c 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_dnnl_emitters.cpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_dnnl_emitters.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "jit_dnnl_emitters.hpp"
+
 #include <nodes/eltwise.h>
 
 using namespace dnnl::impl::utils;
@@ -17,9 +18,11 @@ std::set<std::vector<element::Type>> jit_dnnl_emitter::get_supported_precisions(
     return {{element::f32}};
 }
 
-jit_dnnl_emitter::jit_dnnl_emitter(jit_generator *host, cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
+jit_dnnl_emitter::jit_dnnl_emitter(jit_generator* host,
+                                   cpu_isa_t host_isa,
+                                   const std::shared_ptr<ov::Node>& node,
+                                   ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {
-
     kind = dnnl_eltwise_tanh;
     alpha = 0.f;
     beta = 0.f;
@@ -27,33 +30,42 @@ jit_dnnl_emitter::jit_dnnl_emitter(jit_generator *host, cpu_isa_t host_isa, cons
     set_injector();
 }
 
-jit_dnnl_emitter::jit_dnnl_emitter(jit_generator *host, cpu_isa_t host_isa,
-                                   dnnl_alg_kind_t algKind, float alpha, float beta,
+jit_dnnl_emitter::jit_dnnl_emitter(jit_generator* host,
+                                   cpu_isa_t host_isa,
+                                   dnnl_alg_kind_t algKind,
+                                   float alpha,
+                                   float beta,
                                    ov::element::Type exec_prc)
-    : jit_emitter(host, host_isa, exec_prc), kind(algKind), alpha(alpha), beta(beta) {
-
+    : jit_emitter(host, host_isa, exec_prc),
+      kind(algKind),
+      alpha(alpha),
+      beta(beta) {
     set_injector();
 }
 
 void jit_dnnl_emitter::set_injector() {
     if (host_isa_ == cpu::x64::sse41) {
-        eltwise_injector_sse42 = std::make_shared<jit_uni_eltwise_injector_f32<cpu::x64::sse41>>(
-                h, kind, alpha, beta, 1.f);
+        eltwise_injector_sse42 =
+            std::make_shared<jit_uni_eltwise_injector_f32<cpu::x64::sse41>>(h, kind, alpha, beta, 1.f);
     } else if (host_isa_ == cpu::x64::avx2) {
-        eltwise_injector_avx2 = std::make_shared<jit_uni_eltwise_injector_f32<cpu::x64::avx2>>(
-                h, kind, alpha, beta, 1.f);
+        eltwise_injector_avx2 =
+            std::make_shared<jit_uni_eltwise_injector_f32<cpu::x64::avx2>>(h, kind, alpha, beta, 1.f);
     } else if (host_isa_ == cpu::x64::avx512_core) {
-        eltwise_injector_avx512_core = std::make_shared<jit_uni_eltwise_injector_f32<cpu::x64::avx512_core>>(
-                h, kind, alpha, beta, 1.f);
+        eltwise_injector_avx512_core =
+            std::make_shared<jit_uni_eltwise_injector_f32<cpu::x64::avx512_core>>(h, kind, alpha, beta, 1.f);
     } else {
         OV_CPU_JIT_EMITTER_THROW("Unsupported ISA ", host_isa_);
     }
 }
 
-size_t jit_dnnl_emitter::get_inputs_num() const { return 1; }
+size_t jit_dnnl_emitter::get_inputs_num() const {
+    return 1;
+}
 
-void jit_dnnl_emitter::emit_code(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs,
-                                 const std::vector<size_t> &pool_vec_idxs, const std::vector<size_t> &pool_gpr_idxs) const {
+void jit_dnnl_emitter::emit_code(const std::vector<size_t>& in_vec_idxs,
+                                 const std::vector<size_t>& out_vec_idxs,
+                                 const std::vector<size_t>& pool_vec_idxs,
+                                 const std::vector<size_t>& pool_gpr_idxs) const {
     if (host_isa_ == cpu::x64::sse41) {
         if (out_vec_idxs[0] != in_vec_idxs[0])
             h->uni_vmovups(Xmm(out_vec_idxs[0]), Xmm(in_vec_idxs[0]));
@@ -83,11 +95,13 @@ void jit_dnnl_emitter::emit_data() const {
     }
 }
 
-jit_dnnl_aux_emitter::jit_dnnl_aux_emitter(jit_generator *host, cpu_isa_t host_isa,
-                                           dnnl_alg_kind_t algKind, float inpAlpha, float inpBeta,
+jit_dnnl_aux_emitter::jit_dnnl_aux_emitter(jit_generator* host,
+                                           cpu_isa_t host_isa,
+                                           dnnl_alg_kind_t algKind,
+                                           float inpAlpha,
+                                           float inpBeta,
                                            ov::element::Type exec_prc)
-    : jit_dnnl_emitter(host, host_isa, algKind, inpAlpha, inpBeta, exec_prc) {
-}
+    : jit_dnnl_emitter(host, host_isa, algKind, inpAlpha, inpBeta, exec_prc) {}
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_dnnl_emitters.hpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_dnnl_emitters.hpp
index bdf04108370ed5..22e003ad261555 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_dnnl_emitters.hpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_dnnl_emitters.hpp
@@ -4,8 +4,8 @@
 
 #pragma once
 
-#include "cpu/x64/jit_generator.hpp"
 #include "cpu/x64/injectors/jit_uni_eltwise_injector.hpp"
+#include "cpu/x64/jit_generator.hpp"
 #include "jit_emitter.hpp"
 
 namespace ov {
@@ -13,30 +13,41 @@ namespace intel_cpu {
 
 class jit_dnnl_emitter : public jit_emitter {
 public:
-    void emit_code(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs,
-                   const std::vector<size_t> &pool_vec_idxs, const std::vector<size_t> &pool_gpr_idxs) const override;
+    void emit_code(const std::vector<size_t>& in_vec_idxs,
+                   const std::vector<size_t>& out_vec_idxs,
+                   const std::vector<size_t>& pool_vec_idxs,
+                   const std::vector<size_t>& pool_gpr_idxs) const override;
 
     void emit_data() const override;
 
-    void emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const override {};
+    void emit_impl(const std::vector<size_t>& in_idxs, const std::vector<size_t>& out_idxs) const override{};
 
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 protected:
-    jit_dnnl_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                       dnnl_alg_kind_t algKind, float inpAlpha, float inpBeta,
-                       ov::element::Type exec_prc = ov::element::f32);
-    jit_dnnl_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-                       ov::element::Type exec_prc = ov::element::f32);
+    jit_dnnl_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                     dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                     dnnl_alg_kind_t algKind,
+                     float inpAlpha,
+                     float inpBeta,
+                     ov::element::Type exec_prc = ov::element::f32);
+    jit_dnnl_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                     dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                     const std::shared_ptr<ov::Node>& n,
+                     ov::element::Type exec_prc = ov::element::f32);
     void set_injector();
 
-    dnnl_alg_kind_t kind {dnnl_alg_kind_undef};
-    float alpha {0.f};
-    float beta {0.f};
+    dnnl_alg_kind_t kind{dnnl_alg_kind_undef};
+    float alpha{0.f};
+    float beta{0.f};
 
-    std::shared_ptr<dnnl::impl::cpu::x64::jit_uni_eltwise_injector_f32<dnnl::impl::cpu::x64::sse41>> eltwise_injector_sse42;
-    std::shared_ptr<dnnl::impl::cpu::x64::jit_uni_eltwise_injector_f32<dnnl::impl::cpu::x64::avx2>> eltwise_injector_avx2;
-    std::shared_ptr<dnnl::impl::cpu::x64::jit_uni_eltwise_injector_f32<dnnl::impl::cpu::x64::avx512_core>> eltwise_injector_avx512_core;
+    std::shared_ptr<dnnl::impl::cpu::x64::jit_uni_eltwise_injector_f32<dnnl::impl::cpu::x64::sse41>>
+        eltwise_injector_sse42;
+    std::shared_ptr<dnnl::impl::cpu::x64::jit_uni_eltwise_injector_f32<dnnl::impl::cpu::x64::avx2>>
+        eltwise_injector_avx2;
+    std::shared_ptr<dnnl::impl::cpu::x64::jit_uni_eltwise_injector_f32<dnnl::impl::cpu::x64::avx512_core>>
+        eltwise_injector_avx512_core;
 
 private:
     size_t get_inputs_num() const override;
@@ -44,12 +55,15 @@ class jit_dnnl_emitter : public jit_emitter {
 
 class jit_dnnl_aux_emitter : public jit_dnnl_emitter {
 public:
-    jit_dnnl_aux_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                           dnnl_alg_kind_t algKind, float inpAlpha, float inpBeta,
-                           ov::element::Type exec_prc = ov::element::f32);
+    jit_dnnl_aux_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                         dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                         dnnl_alg_kind_t algKind,
+                         float inpAlpha,
+                         float inpBeta,
+                         ov::element::Type exec_prc = ov::element::f32);
 
 private:
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_dnnl_ext_emitters.hpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_dnnl_ext_emitters.hpp
index 7a4d1e31277e3b..0b7396b6fcd830 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_dnnl_ext_emitters.hpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_dnnl_ext_emitters.hpp
@@ -4,9 +4,9 @@
 
 #pragma once
 
+#include "jit_dnnl_emitters.hpp"
 #include "openvino/opsets/opset5.hpp"
 #include "transformations/cpu_opset/common/op/swish_cpu.hpp"
-#include "jit_dnnl_emitters.hpp"
 #include "utils/ngraph_utils.hpp"
 
 namespace ov {
@@ -14,88 +14,102 @@ namespace intel_cpu {
 
 class jit_relu_emitter : public jit_dnnl_emitter {
 public:
-    jit_relu_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-                       ov::element::Type exec_prc = ov::element::f32)
+    jit_relu_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                     dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                     const std::shared_ptr<ov::Node>& n,
+                     ov::element::Type exec_prc = ov::element::f32)
         : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
-            kind = dnnl_eltwise_relu;
-            alpha = 0.f;
-            beta = 0.f;
+        kind = dnnl_eltwise_relu;
+        alpha = 0.f;
+        beta = 0.f;
 
-            set_injector();
-        }
+        set_injector();
+    }
 };
 
 class jit_sigmoid_emitter : public jit_dnnl_emitter {
 public:
-    jit_sigmoid_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-                       ov::element::Type exec_prc = ov::element::f32)
+    jit_sigmoid_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                        const std::shared_ptr<ov::Node>& n,
+                        ov::element::Type exec_prc = ov::element::f32)
         : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
-            kind = dnnl_eltwise_logistic;
-            alpha = 0.f;
-            beta = 0.f;
+        kind = dnnl_eltwise_logistic;
+        alpha = 0.f;
+        beta = 0.f;
 
-            set_injector();
-        }
+        set_injector();
+    }
 };
 
 class jit_tanh_emitter : public jit_dnnl_emitter {
 public:
-    jit_tanh_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-                       ov::element::Type exec_prc = ov::element::f32)
+    jit_tanh_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                     dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                     const std::shared_ptr<ov::Node>& n,
+                     ov::element::Type exec_prc = ov::element::f32)
         : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
-            kind = dnnl_eltwise_tanh;
-            alpha = 0.f;
-            beta = 0.f;
+        kind = dnnl_eltwise_tanh;
+        alpha = 0.f;
+        beta = 0.f;
 
-            set_injector();
-        }
+        set_injector();
+    }
 };
 
 class jit_elu_emitter : public jit_dnnl_emitter {
 public:
-    jit_elu_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-                       ov::element::Type exec_prc = ov::element::f32)
+    jit_elu_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                    dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                    const std::shared_ptr<ov::Node>& n,
+                    ov::element::Type exec_prc = ov::element::f32)
         : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
-            kind = dnnl_eltwise_elu;
-            alpha = ov::as_type_ptr<ov::op::v0::Elu>(n)->get_alpha();
-            beta = 0.f;
+        kind = dnnl_eltwise_elu;
+        alpha = ov::as_type_ptr<ov::op::v0::Elu>(n)->get_alpha();
+        beta = 0.f;
 
-            set_injector();
-        }
+        set_injector();
+    }
 };
 
 class jit_abs_emitter : public jit_dnnl_emitter {
 public:
-    jit_abs_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-                       ov::element::Type exec_prc = ov::element::f32)
+    jit_abs_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                    dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                    const std::shared_ptr<ov::Node>& n,
+                    ov::element::Type exec_prc = ov::element::f32)
         : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
-            kind = dnnl_eltwise_abs;
-            alpha = 0.f;
-            beta = 0.f;
+        kind = dnnl_eltwise_abs;
+        alpha = 0.f;
+        beta = 0.f;
 
-            set_injector();
-        }
+        set_injector();
+    }
 };
 
 class jit_clamp_emitter : public jit_dnnl_emitter {
 public:
-    jit_clamp_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-                       ov::element::Type exec_prc = ov::element::f32)
+    jit_clamp_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                      dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                      const std::shared_ptr<ov::Node>& n,
+                      ov::element::Type exec_prc = ov::element::f32)
         : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
-            kind = dnnl_eltwise_clip;
-            auto op = ov::as_type_ptr<ov::op::v0::Clamp>(n);
-            alpha = op->get_min();
-            beta = op->get_max();
+        kind = dnnl_eltwise_clip;
+        auto op = ov::as_type_ptr<ov::op::v0::Clamp>(n);
+        alpha = op->get_min();
+        beta = op->get_max();
 
-            set_injector();
-        }
+        set_injector();
+    }
 };
 
 class jit_swish_emitter : public jit_dnnl_emitter {
 public:
-    jit_swish_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-                        ov::element::Type exec_prc = ov::element::f32)
-            : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
+    jit_swish_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                      dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                      const std::shared_ptr<ov::Node>& n,
+                      ov::element::Type exec_prc = ov::element::f32)
+        : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
         kind = dnnl_eltwise_swish;
         auto op = ov::as_type_ptr<ov::intel_cpu::SwishNode>(n);
         alpha = op->get_alpha();
@@ -107,9 +121,11 @@ class jit_swish_emitter : public jit_dnnl_emitter {
 
 class jit_hswish_emitter : public jit_dnnl_emitter {
 public:
-    jit_hswish_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-                        ov::element::Type exec_prc = ov::element::f32)
-            : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
+    jit_hswish_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                       dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                       const std::shared_ptr<ov::Node>& n,
+                       ov::element::Type exec_prc = ov::element::f32)
+        : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
         // since v3.0 oneDNN has flexible version of hardswish, ov still uses the one with hardcoded alpha and beta
         kind = dnnl_eltwise_hardswish;
         alpha = 1.f / 6.f;
@@ -121,9 +137,11 @@ class jit_hswish_emitter : public jit_dnnl_emitter {
 
 class jit_gelu_v0_emitter : public jit_dnnl_emitter {
 public:
-    jit_gelu_v0_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_gelu_v0_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                        const std::shared_ptr<ov::Node>& n,
                         ov::element::Type exec_prc = ov::element::f32)
-            : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
+        : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
         kind = dnnl_eltwise_gelu_erf;
 
         set_injector();
@@ -132,9 +150,11 @@ class jit_gelu_v0_emitter : public jit_dnnl_emitter {
 
 class jit_gelu_v7_emitter : public jit_dnnl_emitter {
 public:
-    jit_gelu_v7_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_gelu_v7_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                        const std::shared_ptr<ov::Node>& n,
                         ov::element::Type exec_prc = ov::element::f32)
-            : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
+        : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
         auto gelu = getNgraphOpAs<ov::op::v7::Gelu>(n);
         ov::op::GeluApproximationMode approximationMode = gelu->get_approximation_mode();
         if (approximationMode == ov::op::GeluApproximationMode::ERF)
@@ -152,11 +172,11 @@ class jit_gelu_v7_emitter : public jit_dnnl_emitter {
 
 class jit_round_emitter : public jit_dnnl_emitter {
 public:
-    jit_round_emitter(
-        dnnl::impl::cpu::x64::jit_generator *host,
-        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-        const std::shared_ptr<ov::Node>& n,
-        ov::element::Type exec_prc = ov::element::f32) : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
+    jit_round_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                      dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                      const std::shared_ptr<ov::Node>& n,
+                      ov::element::Type exec_prc = ov::element::f32)
+        : jit_dnnl_emitter(host, host_isa, n, exec_prc) {
         const auto round = getNgraphOpAs<ov::op::v5::Round>(n);
         const auto mode = round->get_mode();
         if ((mode != ov::opset5::Round::RoundMode::HALF_AWAY_FROM_ZERO) &&
@@ -165,12 +185,11 @@ class jit_round_emitter : public jit_dnnl_emitter {
                                            static_cast<int>(mode));
         }
 
-        kind = mode == ov::opset5::Round::RoundMode::HALF_AWAY_FROM_ZERO ?
-            dnnl_eltwise_round_half_away_from_zero :
-            dnnl_eltwise_round_half_to_even;
+        kind = mode == ov::opset5::Round::RoundMode::HALF_AWAY_FROM_ZERO ? dnnl_eltwise_round_half_away_from_zero
+                                                                         : dnnl_eltwise_round_half_to_even;
         set_injector();
     }
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_eltwise_emitters.cpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_eltwise_emitters.cpp
index 0331a3ee4908b9..7a091fc946c2d8 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_eltwise_emitters.cpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_eltwise_emitters.cpp
@@ -8,8 +8,8 @@ using namespace dnnl::impl::utils;
 using namespace dnnl::impl::cpu;
 using namespace Xbyak;
 
-#define CONST_1_F 0x3f800000 // 1.f
-#define INF_MASK  0x7F800000
+#define CONST_1_F    0x3f800000  // 1.f
+#define INF_MASK     0x7F800000
 #define INF_NEG_MASK 0xFF800000
 
 namespace ov {
@@ -22,23 +22,30 @@ ov::element::Type get_arithmetic_binary_exec_precision(const std::shared_ptr<ov:
         input_precisions.push_back(input.get_source_output().get_element_type());
     }
 
-    OV_CPU_JIT_EMITTER_ASSERT(std::all_of(input_precisions.cbegin(), input_precisions.cend(),
-                                          [&input_precisions](const ov::element::Type& precision) { return precision == input_precisions[0]; }),
-                           "Arithmetic binary node has not equal input precisions");
+    OV_CPU_JIT_EMITTER_ASSERT(std::all_of(input_precisions.cbegin(),
+                                          input_precisions.cend(),
+                                          [&input_precisions](const ov::element::Type& precision) {
+                                              return precision == input_precisions[0];
+                                          }),
+                              "Arithmetic binary node has not equal input precisions");
 
     return input_precisions[0];
 }
 }  // namespace
 
 /// ADD ///
-jit_add_emitter::jit_add_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node)
-: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
-jit_add_emitter::jit_add_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
+jit_add_emitter::jit_add_emitter(x64::jit_generator* host,
+                                 x64::cpu_isa_t host_isa,
+                                 const std::shared_ptr<ov::Node>& node)
+    : jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
+jit_add_emitter::jit_add_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_add_emitter::get_inputs_num() const { return 2; }
+size_t jit_add_emitter::get_inputs_num() const {
+    return 2;
+}
 
-void jit_add_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_add_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -51,7 +58,7 @@ void jit_add_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const st
 }
 
 template <x64::cpu_isa_t isa>
-void jit_add_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_add_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -59,9 +66,14 @@ void jit_add_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std
 
     auto uni_vadd = [this](Vmm vmm_dst, Vmm vmm_src0, Vmm vmm_src1) {
         switch (exec_prc_) {
-            case ov::element::f32: h->uni_vaddps(vmm_dst, vmm_src0, vmm_src1); break;
-            case ov::element::i32:  h->uni_vpaddd(vmm_dst, vmm_src0, vmm_src1); break;
-            default: OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
+        case ov::element::f32:
+            h->uni_vaddps(vmm_dst, vmm_src0, vmm_src1);
+            break;
+        case ov::element::i32:
+            h->uni_vpaddd(vmm_dst, vmm_src0, vmm_src1);
+            break;
+        default:
+            OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
         }
     };
 
@@ -78,14 +90,19 @@ std::set<std::vector<element::Type>> jit_add_emitter::get_supported_precisions(c
 }
 
 /// MUL_ADD ///
-jit_mul_add_emitter::jit_mul_add_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node)
-: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
-jit_mul_add_emitter::jit_mul_add_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
+jit_mul_add_emitter::jit_mul_add_emitter(x64::jit_generator* host,
+                                         x64::cpu_isa_t host_isa,
+                                         const std::shared_ptr<ov::Node>& node)
+    : jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
+jit_mul_add_emitter::jit_mul_add_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_mul_add_emitter::get_inputs_num() const { return 3; }
+size_t jit_mul_add_emitter::get_inputs_num() const {
+    return 3;
+}
 
-void jit_mul_add_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_mul_add_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                    const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -98,7 +115,8 @@ void jit_mul_add_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, cons
 }
 
 template <x64::cpu_isa_t isa>
-void jit_mul_add_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_mul_add_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                   const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -109,47 +127,49 @@ void jit_mul_add_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const
     auto uni_vfmadd231_xmm = [this](Xmm vmm_dst, Xmm vmm_src0, Xmm vmm_src1, Xmm vmm_src2) {
         h->uni_vmovups(vmm_dst, vmm_src0);
         switch (exec_prc_) {
-            case ov::element::f32: {
-                h->uni_vmulps(vmm_dst, vmm_dst, vmm_src1);
-                h->uni_vaddps(vmm_dst, vmm_dst, vmm_src2);
-            } break;
-            case ov::element::i32: {
-                h->uni_vpmulld(vmm_dst, vmm_dst, vmm_src1);
-                h->uni_vpaddd(vmm_dst, vmm_dst, vmm_src2);
-            } break;
-            default: OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
+        case ov::element::f32: {
+            h->uni_vmulps(vmm_dst, vmm_dst, vmm_src1);
+            h->uni_vaddps(vmm_dst, vmm_dst, vmm_src2);
+        } break;
+        case ov::element::i32: {
+            h->uni_vpmulld(vmm_dst, vmm_dst, vmm_src1);
+            h->uni_vpaddd(vmm_dst, vmm_dst, vmm_src2);
+        } break;
+        default:
+            OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
         }
     };
 
     auto uni_vfmadd231_vmm = [this, vmm_aux0](Vmm vmm_dst, Vmm vmm_src0, Vmm vmm_src1, Vmm vmm_src2) {
         switch (exec_prc_) {
-            case ov::element::f32: {
-                Vmm vmm_mul0;
-                if (vmm_dst.getIdx() == vmm_src0.getIdx()) {
-                    h->uni_vmovups(vmm_aux0, vmm_src0);
-                    vmm_mul0 = vmm_aux0;
-                } else {
-                    vmm_mul0 = vmm_src0;
-                }
-
-                Vmm vmm_mul1;
-                if (vmm_dst.getIdx() == vmm_src1.getIdx()) {
-                    h->uni_vmovups(vmm_aux0, vmm_src1);
-                    vmm_mul1 = vmm_aux0;
-                } else {
-                    vmm_mul1 = vmm_src1;
-                }
-
-                if (vmm_dst.getIdx() != vmm_src2.getIdx())
-                    h->uni_vmovups(vmm_dst, vmm_src2);
-
-                h->uni_vfmadd231ps(vmm_dst, vmm_mul0, vmm_mul1);
-            } break;
-            case ov::element::i32: {
-                h->uni_vpmulld(vmm_dst, vmm_src0, vmm_src1);
-                h->uni_vpaddd(vmm_dst, vmm_dst, vmm_src2);
-            } break;
-            default: OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
+        case ov::element::f32: {
+            Vmm vmm_mul0;
+            if (vmm_dst.getIdx() == vmm_src0.getIdx()) {
+                h->uni_vmovups(vmm_aux0, vmm_src0);
+                vmm_mul0 = vmm_aux0;
+            } else {
+                vmm_mul0 = vmm_src0;
+            }
+
+            Vmm vmm_mul1;
+            if (vmm_dst.getIdx() == vmm_src1.getIdx()) {
+                h->uni_vmovups(vmm_aux0, vmm_src1);
+                vmm_mul1 = vmm_aux0;
+            } else {
+                vmm_mul1 = vmm_src1;
+            }
+
+            if (vmm_dst.getIdx() != vmm_src2.getIdx())
+                h->uni_vmovups(vmm_dst, vmm_src2);
+
+            h->uni_vfmadd231ps(vmm_dst, vmm_mul0, vmm_mul1);
+        } break;
+        case ov::element::i32: {
+            h->uni_vpmulld(vmm_dst, vmm_src0, vmm_src1);
+            h->uni_vpaddd(vmm_dst, vmm_dst, vmm_src2);
+        } break;
+        default:
+            OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
         }
     };
 
@@ -164,19 +184,27 @@ size_t jit_mul_add_emitter::aux_vecs_count() const {
     return 1;
 }
 
-std::set<std::vector<element::Type>> jit_mul_add_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_mul_add_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32, element::f32}, {element::i32, element::i32, element::i32}};
 }
 
 /// SUB ///
-jit_subtract_emitter::jit_subtract_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node)
-: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
-jit_subtract_emitter::jit_subtract_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
+jit_subtract_emitter::jit_subtract_emitter(x64::jit_generator* host,
+                                           x64::cpu_isa_t host_isa,
+                                           const std::shared_ptr<ov::Node>& node)
+    : jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
+jit_subtract_emitter::jit_subtract_emitter(x64::jit_generator* host,
+                                           x64::cpu_isa_t host_isa,
+                                           ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_subtract_emitter::get_inputs_num() const { return 2; }
+size_t jit_subtract_emitter::get_inputs_num() const {
+    return 2;
+}
 
-void jit_subtract_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_subtract_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                     const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -189,7 +217,8 @@ void jit_subtract_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, con
 }
 
 template <x64::cpu_isa_t isa>
-void jit_subtract_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_subtract_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                    const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -197,9 +226,14 @@ void jit_subtract_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, cons
 
     auto uni_vsub = [this](Vmm vmm_dst, Vmm vmm_src0, Vmm vmm_src1) {
         switch (exec_prc_) {
-            case ov::element::f32: h->uni_vsubps(vmm_dst, vmm_src0, vmm_src1); break;
-            case ov::element::i32:  h->uni_vpsubd(vmm_dst, vmm_src0, vmm_src1); break;
-            default: OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
+        case ov::element::f32:
+            h->uni_vsubps(vmm_dst, vmm_src0, vmm_src1);
+            break;
+        case ov::element::i32:
+            h->uni_vpsubd(vmm_dst, vmm_src0, vmm_src1);
+            break;
+        default:
+            OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
         }
     };
 
@@ -211,19 +245,27 @@ void jit_subtract_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, cons
     }
 }
 
-std::set<std::vector<element::Type>> jit_subtract_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_subtract_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}, {element::i32, element::i32}};
 }
 
 /// MULTIPLY ///
-jit_multiply_emitter::jit_multiply_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node)
-: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
-jit_multiply_emitter::jit_multiply_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
+jit_multiply_emitter::jit_multiply_emitter(x64::jit_generator* host,
+                                           x64::cpu_isa_t host_isa,
+                                           const std::shared_ptr<ov::Node>& node)
+    : jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
+jit_multiply_emitter::jit_multiply_emitter(x64::jit_generator* host,
+                                           x64::cpu_isa_t host_isa,
+                                           ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_multiply_emitter::get_inputs_num() const { return 2; }
+size_t jit_multiply_emitter::get_inputs_num() const {
+    return 2;
+}
 
-void jit_multiply_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_multiply_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                     const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -236,7 +278,8 @@ void jit_multiply_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, con
 }
 
 template <x64::cpu_isa_t isa>
-void jit_multiply_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_multiply_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                    const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -244,9 +287,14 @@ void jit_multiply_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, cons
 
     auto uni_vmul = [this](Vmm vmm_dst, Vmm vmm_src0, Vmm vmm_src1) {
         switch (exec_prc_) {
-            case ov::element::f32: h->uni_vmulps(vmm_dst, vmm_src0, vmm_src1); break;
-            case ov::element::i32:  h->uni_vpmulld(vmm_dst, vmm_src0, vmm_src1); break;
-            default: OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
+        case ov::element::f32:
+            h->uni_vmulps(vmm_dst, vmm_src0, vmm_src1);
+            break;
+        case ov::element::i32:
+            h->uni_vpmulld(vmm_dst, vmm_src0, vmm_src1);
+            break;
+        default:
+            OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
         }
     };
 
@@ -258,19 +306,26 @@ void jit_multiply_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, cons
     }
 }
 
-std::set<std::vector<element::Type>> jit_multiply_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_multiply_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}, {element::i32, element::i32}};
 }
 
 /// DIVIDE ///
-jit_divide_emitter::jit_divide_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
-jit_divide_emitter::jit_divide_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
+jit_divide_emitter::jit_divide_emitter(x64::jit_generator* host,
+                                       x64::cpu_isa_t host_isa,
+                                       const std::shared_ptr<ov::Node>& node,
+                                       ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
+jit_divide_emitter::jit_divide_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_divide_emitter::get_inputs_num() const { return 2; }
+size_t jit_divide_emitter::get_inputs_num() const {
+    return 2;
+}
 
-void jit_divide_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_divide_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                   const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -283,7 +338,8 @@ void jit_divide_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const
 }
 
 template <x64::cpu_isa_t isa>
-void jit_divide_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_divide_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                  const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -291,23 +347,24 @@ void jit_divide_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const
 
     auto uni_vdiv = [this](Vmm vmm_dst, Vmm vmm_src0, Vmm vmm_src1) {
         switch (exec_prc_) {
-            case ov::element::f32: {
-                h->uni_vdivps(vmm_dst, vmm_src0, vmm_src1);
-                break;
-            }
-            case ov::element::i32: {
-                Vmm vmm_aux0 = Vmm(aux_vec_idxs[0]);
-
-                // The opset doesn't contain vector instruction for integer divide operation
-                // As WA we emulate its behavior via fp divide followed by rounding to zero
-                h->uni_vcvtdq2ps(vmm_dst, vmm_src0);
-                h->uni_vcvtdq2ps(vmm_aux0, vmm_src1);
-                h->uni_vdivps(vmm_dst, vmm_dst, vmm_aux0);
-                h->uni_vroundps(vmm_dst, vmm_dst, 3); // rounding to zero
-                h->uni_vcvtps2dq(vmm_dst, vmm_dst);
-                break;
-            }
-            default: OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
+        case ov::element::f32: {
+            h->uni_vdivps(vmm_dst, vmm_src0, vmm_src1);
+            break;
+        }
+        case ov::element::i32: {
+            Vmm vmm_aux0 = Vmm(aux_vec_idxs[0]);
+
+            // The opset doesn't contain vector instruction for integer divide operation
+            // As WA we emulate its behavior via fp divide followed by rounding to zero
+            h->uni_vcvtdq2ps(vmm_dst, vmm_src0);
+            h->uni_vcvtdq2ps(vmm_aux0, vmm_src1);
+            h->uni_vdivps(vmm_dst, vmm_dst, vmm_aux0);
+            h->uni_vroundps(vmm_dst, vmm_dst, 3);  // rounding to zero
+            h->uni_vcvtps2dq(vmm_dst, vmm_dst);
+            break;
+        }
+        default:
+            OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
         }
     };
 
@@ -319,7 +376,8 @@ void jit_divide_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const
     }
 }
 
-std::set<std::vector<element::Type>> jit_divide_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_divide_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}, {element::i32, element::i32}};
 }
 
@@ -328,18 +386,25 @@ size_t jit_divide_emitter::aux_vecs_count() const {
 }
 
 /// FLOOR ///
-jit_floor_emitter::jit_floor_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
-jit_floor_emitter::jit_floor_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
+jit_floor_emitter::jit_floor_emitter(x64::jit_generator* host,
+                                     x64::cpu_isa_t host_isa,
+                                     const std::shared_ptr<ov::Node>& node,
+                                     ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
+jit_floor_emitter::jit_floor_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_floor_emitter::get_inputs_num() const { return 1; }
+size_t jit_floor_emitter::get_inputs_num() const {
+    return 1;
+}
 
-std::set<std::vector<element::Type>> jit_floor_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_floor_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32}};
 }
 
-void jit_floor_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_floor_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                  const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -352,7 +417,8 @@ void jit_floor_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const
 }
 
 template <x64::cpu_isa_t isa>
-void jit_floor_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_floor_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                 const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src = Vmm(in_vec_idxs[0]);
     Vmm vmm_dst = Vmm(out_vec_idxs[0]);
@@ -360,14 +426,20 @@ void jit_floor_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const s
 }
 
 /// CEILING ///
-jit_ceiling_emitter::jit_ceiling_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
-jit_ceiling_emitter::jit_ceiling_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+jit_ceiling_emitter::jit_ceiling_emitter(x64::jit_generator* host,
+                                         x64::cpu_isa_t host_isa,
+                                         const std::shared_ptr<ov::Node>& node,
+                                         ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
+jit_ceiling_emitter::jit_ceiling_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_ceiling_emitter::get_inputs_num() const { return 1; }
+size_t jit_ceiling_emitter::get_inputs_num() const {
+    return 1;
+}
 
-std::set<std::vector<element::Type>> jit_ceiling_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_ceiling_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32}};
 }
 
@@ -385,7 +457,8 @@ void jit_ceiling_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
 }
 
 template <x64::cpu_isa_t isa>
-void jit_ceiling_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_ceiling_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                   const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src = Vmm(in_vec_idxs[0]);
     Vmm vmm_dst = Vmm(out_vec_idxs[0]);
@@ -403,13 +476,17 @@ jit_floor_mod_emitter::jit_floor_mod_emitter(x64::jit_generator* host,
                                              ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_floor_mod_emitter::get_inputs_num() const { return 2; }
+size_t jit_floor_mod_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_floor_mod_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_floor_mod_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}};
 }
 
-void jit_floor_mod_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_floor_mod_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                      const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -422,7 +499,8 @@ void jit_floor_mod_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, co
 }
 
 template <x64::cpu_isa_t isa>
-void jit_floor_mod_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_floor_mod_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                     const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -434,14 +512,14 @@ void jit_floor_mod_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, con
             h->uni_vmovups(vmm_dst, vmm_src0);
         h->uni_vmovups(vmm_aux0, vmm_src0);
         h->uni_vdivps(vmm_aux0, vmm_aux0, vmm_src1);
-        h->uni_vroundps(vmm_aux0, vmm_aux0, 1); // rounding down
+        h->uni_vroundps(vmm_aux0, vmm_aux0, 1);  // rounding down
         h->uni_vmulps(vmm_aux0, vmm_aux0, vmm_src1);
         h->uni_vsubps(vmm_dst, vmm_dst, vmm_aux0);
     } else {
         if (vmm_dst.getIdx() != vmm_src0.getIdx())
             h->uni_vmovups(vmm_dst, vmm_src0);
         h->uni_vdivps(vmm_aux0, vmm_src0, vmm_src1);
-        h->uni_vroundps(vmm_aux0, vmm_aux0, 1); // rounding down
+        h->uni_vroundps(vmm_aux0, vmm_aux0, 1);  // rounding down
         h->uni_vmulps(vmm_aux0, vmm_aux0, vmm_src1);
         h->uni_vsubps(vmm_dst, vmm_dst, vmm_aux0);
     }
@@ -452,12 +530,17 @@ size_t jit_floor_mod_emitter::aux_vecs_count() const {
 }
 
 /// MOD ///
-jit_mod_emitter::jit_mod_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
-jit_mod_emitter::jit_mod_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
+jit_mod_emitter::jit_mod_emitter(x64::jit_generator* host,
+                                 x64::cpu_isa_t host_isa,
+                                 const std::shared_ptr<ov::Node>& node,
+                                 ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
+jit_mod_emitter::jit_mod_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_mod_emitter::get_inputs_num() const { return 2; }
+size_t jit_mod_emitter::get_inputs_num() const {
+    return 2;
+}
 
 std::set<std::vector<element::Type>> jit_mod_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}};
@@ -476,7 +559,7 @@ void jit_mod_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const st
 }
 
 template <x64::cpu_isa_t isa>
-void jit_mod_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_mod_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -488,14 +571,14 @@ void jit_mod_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std
             h->uni_vmovups(vmm_dst, vmm_src0);
         h->uni_vmovups(vmm_aux0, vmm_src0);
         h->uni_vdivps(vmm_aux0, vmm_aux0, vmm_src1);
-        h->uni_vroundps(vmm_aux0, vmm_aux0, 3); // truncate
+        h->uni_vroundps(vmm_aux0, vmm_aux0, 3);  // truncate
         h->uni_vmulps(vmm_aux0, vmm_aux0, vmm_src1);
         h->uni_vsubps(vmm_dst, vmm_dst, vmm_aux0);
     } else {
         if (vmm_dst.getIdx() != vmm_src0.getIdx())
             h->uni_vmovups(vmm_dst, vmm_src0);
         h->uni_vdivps(vmm_aux0, vmm_src0, vmm_src1);
-        h->uni_vroundps(vmm_aux0, vmm_aux0, 3); // truncate
+        h->uni_vroundps(vmm_aux0, vmm_aux0, 3);  // truncate
         h->uni_vmulps(vmm_aux0, vmm_aux0, vmm_src1);
         h->uni_vsubps(vmm_dst, vmm_dst, vmm_aux0);
     }
@@ -506,14 +589,19 @@ size_t jit_mod_emitter::aux_vecs_count() const {
 }
 
 /// MAXIMUM ///
-jit_maximum_emitter::jit_maximum_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node)
-: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
-jit_maximum_emitter::jit_maximum_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
+jit_maximum_emitter::jit_maximum_emitter(x64::jit_generator* host,
+                                         x64::cpu_isa_t host_isa,
+                                         const std::shared_ptr<ov::Node>& node)
+    : jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
+jit_maximum_emitter::jit_maximum_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_maximum_emitter::get_inputs_num() const { return 2; }
+size_t jit_maximum_emitter::get_inputs_num() const {
+    return 2;
+}
 
-void jit_maximum_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_maximum_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                    const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -526,7 +614,8 @@ void jit_maximum_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, cons
 }
 
 template <x64::cpu_isa_t isa>
-void jit_maximum_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_maximum_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                   const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -534,9 +623,14 @@ void jit_maximum_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const
 
     auto uni_vmax = [this](Vmm vmm_dst, Vmm vmm_src0, Vmm vmm_src1) {
         switch (exec_prc_) {
-            case ov::element::f32: h->uni_vmaxps(vmm_dst, vmm_src0, vmm_src1); break;
-            case ov::element::i32:  h->uni_vpmaxsd(vmm_dst, vmm_src0, vmm_src1); break;
-            default: OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
+        case ov::element::f32:
+            h->uni_vmaxps(vmm_dst, vmm_src0, vmm_src1);
+            break;
+        case ov::element::i32:
+            h->uni_vpmaxsd(vmm_dst, vmm_src0, vmm_src1);
+            break;
+        default:
+            OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
         }
     };
 
@@ -549,19 +643,25 @@ void jit_maximum_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const
     }
 }
 
-std::set<std::vector<element::Type>> jit_maximum_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_maximum_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}, {element::i32, element::i32}};
 }
 
 /// MINIMUM ///
-jit_minimum_emitter::jit_minimum_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node)
-: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
-jit_minimum_emitter::jit_minimum_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
+jit_minimum_emitter::jit_minimum_emitter(x64::jit_generator* host,
+                                         x64::cpu_isa_t host_isa,
+                                         const std::shared_ptr<ov::Node>& node)
+    : jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
+jit_minimum_emitter::jit_minimum_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_minimum_emitter::get_inputs_num() const { return 2; }
+size_t jit_minimum_emitter::get_inputs_num() const {
+    return 2;
+}
 
-void jit_minimum_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_minimum_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                    const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -574,7 +674,8 @@ void jit_minimum_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, cons
 }
 
 template <x64::cpu_isa_t isa>
-void jit_minimum_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_minimum_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                   const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -582,9 +683,14 @@ void jit_minimum_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const
 
     auto uni_vmin = [this](Vmm vmm_dst, Vmm vmm_src0, Vmm vmm_src1) {
         switch (exec_prc_) {
-            case ov::element::f32: h->uni_vminps(vmm_dst, vmm_src0, vmm_src1); break;
-            case ov::element::i32:  h->uni_vpminsd(vmm_dst, vmm_src0, vmm_src1); break;
-            default: OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
+        case ov::element::f32:
+            h->uni_vminps(vmm_dst, vmm_src0, vmm_src1);
+            break;
+        case ov::element::i32:
+            h->uni_vpminsd(vmm_dst, vmm_src0, vmm_src1);
+            break;
+        default:
+            OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
         }
     };
 
@@ -597,20 +703,28 @@ void jit_minimum_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const
     }
 }
 
-std::set<std::vector<element::Type>> jit_minimum_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_minimum_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}, {element::i32, element::i32}};
 }
 
 /// SQUARED_DIFFERENCE ///
-jit_squared_difference_emitter::jit_squared_difference_emitter(
-    x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
-jit_squared_difference_emitter::jit_squared_difference_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {}
+jit_squared_difference_emitter::jit_squared_difference_emitter(x64::jit_generator* host,
+                                                               x64::cpu_isa_t host_isa,
+                                                               const std::shared_ptr<ov::Node>& node,
+                                                               ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
+jit_squared_difference_emitter::jit_squared_difference_emitter(x64::jit_generator* host,
+                                                               x64::cpu_isa_t host_isa,
+                                                               ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_squared_difference_emitter::get_inputs_num() const { return 2; }
+size_t jit_squared_difference_emitter::get_inputs_num() const {
+    return 2;
+}
 
-void jit_squared_difference_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_squared_difference_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                               const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -623,7 +737,8 @@ void jit_squared_difference_emitter::emit_impl(const std::vector<size_t> &in_vec
 }
 
 template <x64::cpu_isa_t isa>
-void jit_squared_difference_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_squared_difference_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                              const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -631,15 +746,16 @@ void jit_squared_difference_emitter::emit_isa(const std::vector<size_t> &in_vec_
 
     auto uni_vsqdiff = [this](Vmm vmm_dst, Vmm vmm_src0, Vmm vmm_src1) {
         switch (exec_prc_) {
-            case ov::element::f32: {
-                h->uni_vsubps(vmm_dst, vmm_src0, vmm_src1);
-                h->uni_vmulps(vmm_dst, vmm_dst, vmm_dst);
-            } break;
-            case ov::element::i32: {
-                h->uni_vpsubd(vmm_dst, vmm_src0, vmm_src1);
-                h->uni_vpmulld(vmm_dst, vmm_dst, vmm_dst);
-            } break;
-            default: OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
+        case ov::element::f32: {
+            h->uni_vsubps(vmm_dst, vmm_src0, vmm_src1);
+            h->uni_vmulps(vmm_dst, vmm_dst, vmm_dst);
+        } break;
+        case ov::element::i32: {
+            h->uni_vpsubd(vmm_dst, vmm_src0, vmm_src1);
+            h->uni_vpmulld(vmm_dst, vmm_dst, vmm_dst);
+        } break;
+        default:
+            OV_CPU_JIT_EMITTER_THROW("Unsupported precision");
         }
     };
 
@@ -652,24 +768,33 @@ void jit_squared_difference_emitter::emit_isa(const std::vector<size_t> &in_vec_
     }
 }
 
-std::set<std::vector<element::Type>> jit_squared_difference_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_squared_difference_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}, {element::i32, element::i32}};
 }
 
 /// POWER_DYNAMIC ///
-jit_power_dynamic_emitter::jit_power_dynamic_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node,
+jit_power_dynamic_emitter::jit_power_dynamic_emitter(x64::jit_generator* host,
+                                                     x64::cpu_isa_t host_isa,
+                                                     const std::shared_ptr<ov::Node>& node,
                                                      ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {}
-jit_power_dynamic_emitter::jit_power_dynamic_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+jit_power_dynamic_emitter::jit_power_dynamic_emitter(x64::jit_generator* host,
+                                                     x64::cpu_isa_t host_isa,
+                                                     ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_power_dynamic_emitter::get_inputs_num() const { return 2; }
+size_t jit_power_dynamic_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_power_dynamic_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_power_dynamic_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}};
 }
 
-void jit_power_dynamic_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_power_dynamic_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                          const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -682,7 +807,8 @@ void jit_power_dynamic_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs
 }
 
 template <x64::cpu_isa_t isa>
-void jit_power_dynamic_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_power_dynamic_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                         const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -692,8 +818,8 @@ void jit_power_dynamic_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs,
 
     // caller obligation to save gprs as callee may use them
     size_t gpr_size = 8;
-    Xbyak::Operand gprs_to_save[] = {h->r8, h->r9, h->r10, h->r11, h->rax,
-                                     h->rcx, h->rdx, h->rdi, h->rsi, h->rbp, h->rbx};
+    Xbyak::Operand gprs_to_save[] =
+        {h->r8, h->r9, h->r10, h->r11, h->rax, h->rcx, h->rdx, h->rdi, h->rsi, h->rbp, h->rbx};
     size_t n_gprs_to_save = sizeof(gprs_to_save) / sizeof(gprs_to_save[0]);
 
     h->sub(h->rsp, n_gprs_to_save * gpr_size);
@@ -722,8 +848,8 @@ void jit_power_dynamic_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs,
     h->sub(h->rsp, (get_max_vecs_count() + 2) * get_vec_length());
     for (size_t i = 2; i < get_max_vecs_count() + 2; ++i)
         h->uni_vmovups(h->ptr[h->rsp + i * get_vec_length()], Vmm(i - 2));
-    h->uni_vmovups(h->ptr[h->rsp + 0 * get_vec_length()], vmm_src0); // src
-    h->uni_vmovups(h->ptr[h->rsp + 1 * get_vec_length()], vmm_src1); // beta
+    h->uni_vmovups(h->ptr[h->rsp + 0 * get_vec_length()], vmm_src0);  // src
+    h->uni_vmovups(h->ptr[h->rsp + 1 * get_vec_length()], vmm_src1);  // beta
 
     // save function address in gpr to pass in in call instruction
     h->mov(h->rbp, reinterpret_cast<uintptr_t>(powf));
@@ -735,7 +861,7 @@ void jit_power_dynamic_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs,
 
     // Take src, apply powf on it and replace value on a stack with dst.
     for (size_t i = 0; i < get_vec_length() / sizeof(float); ++i) {
-        const Address &source = h->ptr[h->rsp + h->rbx + i * sizeof(float)];
+        const Address& source = h->ptr[h->rsp + h->rbx + i * sizeof(float)];
         h->uni_vmovss(xmm0, source);
         h->uni_vmovss(xmm1, h->ptr[h->rsp + h->rbx + get_vec_length() + i * sizeof(float)]);
         h->call(h->rbp);
@@ -767,24 +893,30 @@ void jit_power_dynamic_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs,
     h->add(h->rsp, n_gprs_to_save * gpr_size);
 }
 
-
 /// EQUAL ///
-jit_equal_emitter::jit_equal_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {
+jit_equal_emitter::jit_equal_emitter(x64::jit_generator* host,
+                                     x64::cpu_isa_t host_isa,
+                                     const std::shared_ptr<ov::Node>& node,
+                                     ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {
     prepare_table();
 }
-jit_equal_emitter::jit_equal_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {
+jit_equal_emitter::jit_equal_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {
     prepare_table();
 }
 
-size_t jit_equal_emitter::get_inputs_num() const { return 2; }
+size_t jit_equal_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_equal_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_equal_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}};
 }
 
-void jit_equal_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_equal_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                  const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -797,7 +929,8 @@ void jit_equal_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const
 }
 
 template <x64::cpu_isa_t isa>
-void jit_equal_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_equal_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                 const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -846,13 +979,17 @@ jit_not_equal_emitter::jit_not_equal_emitter(x64::jit_generator* host,
     prepare_table();
 }
 
-size_t jit_not_equal_emitter::get_inputs_num() const { return 2; }
+size_t jit_not_equal_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_not_equal_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_not_equal_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}};
 }
 
-void jit_not_equal_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_not_equal_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                      const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -865,7 +1002,8 @@ void jit_not_equal_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, co
 }
 
 template <x64::cpu_isa_t isa>
-void jit_not_equal_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_not_equal_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                     const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -900,22 +1038,29 @@ size_t jit_not_equal_emitter::aux_vecs_count() const {
 }
 
 /// GREATER ///
-jit_greater_emitter::jit_greater_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {
+jit_greater_emitter::jit_greater_emitter(x64::jit_generator* host,
+                                         x64::cpu_isa_t host_isa,
+                                         const std::shared_ptr<ov::Node>& node,
+                                         ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {
     prepare_table();
 }
-jit_greater_emitter::jit_greater_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {
+jit_greater_emitter::jit_greater_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {
     prepare_table();
 }
 
-size_t jit_greater_emitter::get_inputs_num() const { return 2; }
+size_t jit_greater_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_greater_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_greater_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}};
 }
 
-void jit_greater_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_greater_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                    const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -928,7 +1073,8 @@ void jit_greater_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, cons
 }
 
 template <x64::cpu_isa_t isa>
-void jit_greater_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_greater_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                   const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -963,23 +1109,31 @@ size_t jit_greater_emitter::aux_vecs_count() const {
 }
 
 /// GREATER_EQUAL ///
-jit_greater_equal_emitter::jit_greater_equal_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node,
+jit_greater_equal_emitter::jit_greater_equal_emitter(x64::jit_generator* host,
+                                                     x64::cpu_isa_t host_isa,
+                                                     const std::shared_ptr<ov::Node>& node,
                                                      ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {
+    : jit_emitter(host, host_isa, exec_prc) {
     prepare_table();
 }
-jit_greater_equal_emitter::jit_greater_equal_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {
+jit_greater_equal_emitter::jit_greater_equal_emitter(x64::jit_generator* host,
+                                                     x64::cpu_isa_t host_isa,
+                                                     ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {
     prepare_table();
 }
 
-size_t jit_greater_equal_emitter::get_inputs_num() const { return 2; }
+size_t jit_greater_equal_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_greater_equal_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_greater_equal_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}};
 }
 
-void jit_greater_equal_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_greater_equal_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                          const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -992,7 +1146,8 @@ void jit_greater_equal_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs
 }
 
 template <x64::cpu_isa_t isa>
-void jit_greater_equal_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_greater_equal_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                         const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -1027,22 +1182,28 @@ size_t jit_greater_equal_emitter::aux_vecs_count() const {
 }
 
 /// LESS ///
-jit_less_emitter::jit_less_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {
+jit_less_emitter::jit_less_emitter(x64::jit_generator* host,
+                                   x64::cpu_isa_t host_isa,
+                                   const std::shared_ptr<ov::Node>& node,
+                                   ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {
     prepare_table();
 }
-jit_less_emitter::jit_less_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc) {
+jit_less_emitter::jit_less_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+    : jit_emitter(host, host_isa, exec_prc) {
     prepare_table();
 }
 
-size_t jit_less_emitter::get_inputs_num() const { return 2; }
+size_t jit_less_emitter::get_inputs_num() const {
+    return 2;
+}
 
 std::set<std::vector<element::Type>> jit_less_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}};
 }
 
-void jit_less_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_less_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                 const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -1055,7 +1216,7 @@ void jit_less_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const s
 }
 
 template <x64::cpu_isa_t isa>
-void jit_less_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_less_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -1104,13 +1265,17 @@ jit_less_equal_emitter::jit_less_equal_emitter(x64::jit_generator* host,
     prepare_table();
 }
 
-size_t jit_less_equal_emitter::get_inputs_num() const { return 2; }
+size_t jit_less_equal_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_less_equal_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_less_equal_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}};
 }
 
-void jit_less_equal_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_less_equal_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                       const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -1123,7 +1288,8 @@ void jit_less_equal_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, c
 }
 
 template <x64::cpu_isa_t isa>
-void jit_less_equal_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_less_equal_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                      const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -1173,13 +1339,17 @@ jit_logical_and_emitter::jit_logical_and_emitter(x64::jit_generator* host,
     prepare_table();
 }
 
-size_t jit_logical_and_emitter::get_inputs_num() const { return 2; }
+size_t jit_logical_and_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_logical_and_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_logical_and_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}};
 }
 
-void jit_logical_and_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_logical_and_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                        const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -1192,7 +1362,8 @@ void jit_logical_and_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
 }
 
 template <x64::cpu_isa_t isa>
-void jit_logical_and_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_logical_and_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                       const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -1261,13 +1432,17 @@ jit_logical_or_emitter::jit_logical_or_emitter(x64::jit_generator* host,
     prepare_table();
 }
 
-size_t jit_logical_or_emitter::get_inputs_num() const { return 2; }
+size_t jit_logical_or_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_logical_or_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_logical_or_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}};
 }
 
-void jit_logical_or_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_logical_or_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                       const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -1280,7 +1455,8 @@ void jit_logical_or_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, c
 }
 
 template <x64::cpu_isa_t isa>
-void jit_logical_or_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_logical_or_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                      const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -1349,13 +1525,17 @@ jit_logical_xor_emitter::jit_logical_xor_emitter(x64::jit_generator* host,
     prepare_table();
 }
 
-size_t jit_logical_xor_emitter::get_inputs_num() const { return 2; }
+size_t jit_logical_xor_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_logical_xor_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_logical_xor_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}};
 }
 
-void jit_logical_xor_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_logical_xor_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                        const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -1368,7 +1548,8 @@ void jit_logical_xor_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
 }
 
 template <x64::cpu_isa_t isa>
-void jit_logical_xor_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_logical_xor_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                       const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -1437,13 +1618,17 @@ jit_logical_not_emitter::jit_logical_not_emitter(x64::jit_generator* host,
     prepare_table();
 }
 
-size_t jit_logical_not_emitter::get_inputs_num() const { return 1; }
+size_t jit_logical_not_emitter::get_inputs_num() const {
+    return 1;
+}
 
-std::set<std::vector<element::Type>> jit_logical_not_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_logical_not_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32}};
 }
 
-void jit_logical_not_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_logical_not_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                        const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -1456,7 +1641,8 @@ void jit_logical_not_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
 }
 
 template <x64::cpu_isa_t isa>
-void jit_logical_not_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_logical_not_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                       const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_dst = Vmm(out_vec_idxs[0]);
@@ -1507,20 +1693,30 @@ jit_power_static_emitter::jit_power_static_emitter(x64::jit_generator* host,
     prepare_table();
 }
 
-jit_power_static_emitter::jit_power_static_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa,
-                                                   float inpPower, float inpScale, float inpShift,
+jit_power_static_emitter::jit_power_static_emitter(x64::jit_generator* host,
+                                                   x64::cpu_isa_t host_isa,
+                                                   float inpPower,
+                                                   float inpScale,
+                                                   float inpShift,
                                                    ov::element::Type exec_prc)
-: jit_emitter(host, host_isa, exec_prc), power(inpPower), scale(inpScale), shift(inpShift) {
+    : jit_emitter(host, host_isa, exec_prc),
+      power(inpPower),
+      scale(inpScale),
+      shift(inpShift) {
     prepare_table();
 }
 
-size_t jit_power_static_emitter::get_inputs_num() const { return 1; }
+size_t jit_power_static_emitter::get_inputs_num() const {
+    return 1;
+}
 
-std::set<std::vector<element::Type>> jit_power_static_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_power_static_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32}};
 }
 
-void jit_power_static_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_power_static_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                         const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -1533,7 +1729,8 @@ void jit_power_static_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
 }
 
 template <x64::cpu_isa_t isa>
-void jit_power_static_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_power_static_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                        const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_dst = Vmm(out_vec_idxs[0]);
@@ -1600,8 +1797,8 @@ void jit_power_static_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs,
 
         // caller obligation to save gprs as callee may use them
         size_t gpr_size = 8;
-        Xbyak::Operand gprs_to_save[] = {h->r8, h->r9, h->r10, h->r11, h->rax,
-                                         h->rcx, h->rdx, h->rdi, h->rsi, h->rbp, h->rbx};
+        Xbyak::Operand gprs_to_save[] =
+            {h->r8, h->r9, h->r10, h->r11, h->rax, h->rcx, h->rdx, h->rdi, h->rsi, h->rbp, h->rbx};
         size_t n_gprs_to_save = sizeof(gprs_to_save) / sizeof(gprs_to_save[0]);
 
         h->sub(h->rsp, n_gprs_to_save * gpr_size);
@@ -1630,8 +1827,8 @@ void jit_power_static_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs,
         h->sub(h->rsp, (get_max_vecs_count() + 2) * get_vec_length());
         for (size_t i = 2; i < get_max_vecs_count() + 2; ++i)
             h->uni_vmovups(h->ptr[h->rsp + i * get_vec_length()], Vmm(i - 2));
-        h->uni_vmovups(h->ptr[h->rsp + 0 * get_vec_length()], vmm_dst); // src
-        h->uni_vmovups(h->ptr[h->rsp + 1 * get_vec_length()], vmm_aux0); // beta
+        h->uni_vmovups(h->ptr[h->rsp + 0 * get_vec_length()], vmm_dst);   // src
+        h->uni_vmovups(h->ptr[h->rsp + 1 * get_vec_length()], vmm_aux0);  // beta
 
         // save function address in gpr to pass in in call instruction
         h->mov(h->rbp, reinterpret_cast<uintptr_t>(powf));
@@ -1643,7 +1840,7 @@ void jit_power_static_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs,
 
         // Take src, apply powf on it and replace value on a stack with dst.
         for (size_t i = 0; i < get_vec_length() / sizeof(float); ++i) {
-            const Address &source = h->ptr[h->rsp + h->rbx + i * sizeof(float)];
+            const Address& source = h->ptr[h->rsp + h->rbx + i * sizeof(float)];
             h->uni_vmovss(xmm0, source);
             h->uni_vmovss(xmm1, h->ptr[h->rsp + h->rbx + get_vec_length() + i * sizeof(float)]);
             h->call(h->rbp);
@@ -1680,7 +1877,7 @@ void jit_power_static_emitter::register_table_entries() {
     push_arg_entry_of("power", x64::float2int(power), true);
     push_arg_entry_of("scale", x64::float2int(scale), true);
     push_arg_entry_of("shift", x64::float2int(shift), true);
-    push_arg_entry_of("one",   x64::float2int(1.f), true);
+    push_arg_entry_of("one", x64::float2int(1.f), true);
 }
 
 size_t jit_power_static_emitter::aux_vecs_count() const {
@@ -1699,13 +1896,17 @@ jit_prelu_emitter::jit_prelu_emitter(x64::jit_generator* host, x64::cpu_isa_t ho
     : jit_emitter(host, host_isa, exec_prc) {
     prepare_table();
 }
-size_t jit_prelu_emitter::get_inputs_num() const { return 2; }
+size_t jit_prelu_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_prelu_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_prelu_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32}};
 }
 
-void jit_prelu_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_prelu_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                  const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -1718,7 +1919,8 @@ void jit_prelu_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const
 }
 
 template <x64::cpu_isa_t isa>
-void jit_prelu_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_prelu_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                 const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -1761,13 +1963,16 @@ jit_sqrt_emitter::jit_sqrt_emitter(x64::jit_generator* host,
 jit_sqrt_emitter::jit_sqrt_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_sqrt_emitter::get_inputs_num() const { return 1; }
+size_t jit_sqrt_emitter::get_inputs_num() const {
+    return 1;
+}
 
 std::set<std::vector<element::Type>> jit_sqrt_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
     return {{element::f32}};
 }
 
-void jit_sqrt_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_sqrt_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                 const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -1780,12 +1985,12 @@ void jit_sqrt_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const s
 }
 
 template <x64::cpu_isa_t isa>
-void jit_sqrt_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_sqrt_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_dst = Vmm(out_vec_idxs[0]);
 
-     h->uni_vsqrtps(vmm_dst, vmm_src0);
+    h->uni_vsqrtps(vmm_dst, vmm_src0);
 }
 
 /// Negate ///
@@ -1795,13 +2000,17 @@ jit_negative_emitter::jit_negative_emitter(x64::jit_generator* host,
                                            ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_negative_emitter::get_inputs_num() const { return 1; }
+size_t jit_negative_emitter::get_inputs_num() const {
+    return 1;
+}
 
-std::set<std::vector<element::Type>> jit_negative_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_negative_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32}};
 }
 
-void jit_negative_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_negative_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                     const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -1814,33 +2023,38 @@ void jit_negative_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, con
 }
 
 template <x64::cpu_isa_t isa>
-void jit_negative_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_negative_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                    const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src = Vmm(in_vec_idxs[0]);
-    Vmm vmm_dst  = Vmm(out_vec_idxs[0]);
+    Vmm vmm_dst = Vmm(out_vec_idxs[0]);
     h->uni_vpxor(vmm_dst, vmm_dst, vmm_dst);
     h->uni_vsubps(vmm_dst, vmm_dst, vmm_src);
 }
 
-
 /// EXP ///
 jit_exp_emitter::jit_exp_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {
     prepare_table();
 }
 
-jit_exp_emitter::jit_exp_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
+jit_exp_emitter::jit_exp_emitter(x64::jit_generator* host,
+                                 x64::cpu_isa_t host_isa,
+                                 const std::shared_ptr<ov::Node>& node,
+                                 ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {
     prepare_table();
 }
 
-size_t jit_exp_emitter::get_inputs_num() const { return 1; }
+size_t jit_exp_emitter::get_inputs_num() const {
+    return 1;
+}
 
 std::set<std::vector<element::Type>> jit_exp_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
     return {{element::f32}};
 }
 
-void jit_exp_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_exp_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -1853,7 +2067,7 @@ void jit_exp_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const st
 }
 
 template <x64::cpu_isa_t isa>
-void jit_exp_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_exp_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src = Vmm(in_vec_idxs[0]);
     Vmm vmm_dst = Vmm(out_vec_idxs[0]);
@@ -1862,7 +2076,7 @@ void jit_exp_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std
     Vmm vmm_aux0 = Vmm(aux_vec_idxs[0 + static_cast<size_t>(need_vmm_mask())]);
     Vmm vmm_aux1 = Vmm(aux_vec_idxs[1 + static_cast<size_t>(need_vmm_mask())]);
 
-    auto compute_cmp_mask = [&](const Vmm &vmm_src, const Xbyak::Operand &compare_operand, int cmp_predicate) {
+    auto compute_cmp_mask = [&](const Vmm& vmm_src, const Xbyak::Operand& compare_operand, int cmp_predicate) {
         if (host_isa_ == x64::avx512_core) {
             h->vcmpps(k_mask, vmm_src, compare_operand, cmp_predicate);
         } else {
@@ -1870,7 +2084,7 @@ void jit_exp_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std
         }
     };
 
-    auto blend_with_mask = [&](const Vmm &vmm_dst, const Xbyak::Operand &src) {
+    auto blend_with_mask = [&](const Vmm& vmm_dst, const Xbyak::Operand& src) {
         if (host_isa_ == x64::avx512_core) {
             h->vblendmps(vmm_dst | k_mask, vmm_dst, src);
         } else {
@@ -1924,11 +2138,11 @@ void jit_exp_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std
 }
 
 void jit_exp_emitter::register_table_entries() {
-    push_arg_entry_of("pol1", 0x3f7ffffb, true); // p1 = 0.999999701f
-    push_arg_entry_of("pol2", 0x3efffee3, true); // p2 = 0.499991506f
-    push_arg_entry_of("pol3", 0x3e2aad40, true); // p3 = 0.166676521f
-    push_arg_entry_of("pol4", 0x3d2b9d0d, true); // p4 = 0.0418978221f
-    push_arg_entry_of("pol5", 0x3c07cfce, true); // p5 = 0.00828929059f
+    push_arg_entry_of("pol1", 0x3f7ffffb, true);  // p1 = 0.999999701f
+    push_arg_entry_of("pol2", 0x3efffee3, true);  // p2 = 0.499991506f
+    push_arg_entry_of("pol3", 0x3e2aad40, true);  // p3 = 0.166676521f
+    push_arg_entry_of("pol4", 0x3d2b9d0d, true);  // p4 = 0.0418978221f
+    push_arg_entry_of("pol5", 0x3c07cfce, true);  // p5 = 0.00828929059f
 
     push_arg_entry_of("one", CONST_1_F, true);
     push_arg_entry_of("half", 0x3f000000, true);
@@ -1950,16 +2164,21 @@ jit_erf_emitter::jit_erf_emitter(x64::jit_generator* host, x64::cpu_isa_t host_i
     prepare_table();
 }
 
-jit_erf_emitter::jit_erf_emitter(x64::jit_generator* host,  x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, ov::element::Type exec_prc)
+jit_erf_emitter::jit_erf_emitter(x64::jit_generator* host,
+                                 x64::cpu_isa_t host_isa,
+                                 const std::shared_ptr<ov::Node>& node,
+                                 ov::element::Type exec_prc)
     : jit_erf_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_erf_emitter::get_inputs_num() const { return 1; }
+size_t jit_erf_emitter::get_inputs_num() const {
+    return 1;
+}
 
 std::set<std::vector<element::Type>> jit_erf_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
     return {{element::f32}};
 }
 
-void jit_erf_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_erf_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -1972,7 +2191,7 @@ void jit_erf_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const st
 }
 
 template <x64::cpu_isa_t isa>
-void jit_erf_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_erf_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src = Vmm(in_vec_idxs[0]);
     Vmm vmm_dst = Vmm(out_vec_idxs[0]);
@@ -1991,8 +2210,11 @@ void jit_erf_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std
 
     // pass the current `aux_vec_idxs` to `exp_emitter` excepting `vmm_aux3`
     auto exp_aux_vec_idxs = aux_vec_idxs;
-    exp_aux_vec_idxs.erase(std::find(exp_aux_vec_idxs.begin(), exp_aux_vec_idxs.end(), static_cast<size_t>(vmm_aux3.getIdx())));
-    m_exp_emitter->emit_code({static_cast<size_t>(vmm_dst.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())}, exp_aux_vec_idxs);
+    exp_aux_vec_idxs.erase(
+        std::find(exp_aux_vec_idxs.begin(), exp_aux_vec_idxs.end(), static_cast<size_t>(vmm_aux3.getIdx())));
+    m_exp_emitter->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
+                             {static_cast<size_t>(vmm_dst.getIdx())},
+                             exp_aux_vec_idxs);
 
     h->uni_vxorps(vmm_dst, vmm_dst, table_val("sign_mask"));
 
@@ -2027,16 +2249,16 @@ void jit_erf_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std
 }
 
 void jit_erf_emitter::register_table_entries() {
-    push_arg_entry_of("approx_const", 0x3ea7ba05, true); // 0.3275911
+    push_arg_entry_of("approx_const", 0x3ea7ba05, true);  // 0.3275911
     push_arg_entry_of("one", CONST_1_F, true);
     push_arg_entry_of("sign_mask", 0x80000000, true);
     push_arg_entry_of("positive_mask", 0x7fffffff, true);
 
-    push_arg_entry_of("pol1", 0x3e827906, true); // p1 = 0.254829592f
-    push_arg_entry_of("pol2", 0xbe91a98e, true); // p2 = -0.284496736f
-    push_arg_entry_of("pol3", 0x3fb5f0e3, true); // p3 = 1.421413741f
-    push_arg_entry_of("pol4", 0xbfba00e3, true); // p4 = -1.453152027f
-    push_arg_entry_of("pol5", 0x3f87dc22, true); // p5 = 1.061405429f
+    push_arg_entry_of("pol1", 0x3e827906, true);  // p1 = 0.254829592f
+    push_arg_entry_of("pol2", 0xbe91a98e, true);  // p2 = -0.284496736f
+    push_arg_entry_of("pol3", 0x3fb5f0e3, true);  // p3 = 1.421413741f
+    push_arg_entry_of("pol4", 0xbfba00e3, true);  // p4 = -1.453152027f
+    push_arg_entry_of("pol5", 0x3f87dc22, true);  // p5 = 1.061405429f
 }
 
 size_t jit_erf_emitter::aux_vecs_count() const {
@@ -2063,13 +2285,17 @@ jit_soft_sign_emitter::jit_soft_sign_emitter(x64::jit_generator* host,
     prepare_table();
 }
 
-size_t jit_soft_sign_emitter::get_inputs_num() const { return 1; }
+size_t jit_soft_sign_emitter::get_inputs_num() const {
+    return 1;
+}
 
-std::set<std::vector<element::Type>> jit_soft_sign_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_soft_sign_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32}};
 }
 
-void jit_soft_sign_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_soft_sign_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                      const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -2082,7 +2308,8 @@ void jit_soft_sign_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, co
 }
 
 template <x64::cpu_isa_t isa>
-void jit_soft_sign_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_soft_sign_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                     const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src = Vmm(in_vec_idxs[0]);
     Vmm vmm_dst = Vmm(out_vec_idxs[0]);
@@ -2100,10 +2327,11 @@ void jit_soft_sign_emitter::register_table_entries() {
 
 /// IS_FINITE ///
 template <>
-void jit_is_finite_emitter::emit_isa<x64::avx512_core>(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_is_finite_emitter::emit_isa<x64::avx512_core>(const std::vector<size_t>& in_vec_idxs,
+                                                       const std::vector<size_t>& out_vec_idxs) const {
     auto vmm_src = Zmm(in_vec_idxs[0]);
     auto vmm_dst = Zmm(out_vec_idxs[0]);
-    auto &ones_mask = h->k1;
+    auto& ones_mask = h->k1;
     auto reg32_one = Reg32(aux_gpr_idxs[0]);
 
     h->mov(reg32_one, CONST_1_F);
@@ -2113,13 +2341,14 @@ void jit_is_finite_emitter::emit_isa<x64::avx512_core>(const std::vector<size_t>
 }
 
 template <x64::cpu_isa_t isa>
-void jit_is_finite_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_is_finite_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                     const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional<isa == x64::sse41, Xmm, Ymm>::type;
     auto vmm_src = Vmm(in_vec_idxs[0]);
     auto vmm_dst = Vmm(out_vec_idxs[0]);
 
     h->uni_vandps(vmm_src, vmm_src, table_val("inf"));
-    h->uni_vcmpps(vmm_src, vmm_src, table_val("inf"), 0B00000100); // NEq
+    h->uni_vcmpps(vmm_src, vmm_src, table_val("inf"), 0B00000100);  // NEq
 
     if (isa == x64::avx2) {
         h->uni_vandps(vmm_dst, vmm_src, table_val("one"));
@@ -2131,7 +2360,8 @@ void jit_is_finite_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, con
     }
 }
 
-void jit_is_finite_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_is_finite_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                      const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::avx512_core) {
         emit_isa<x64::avx512_core>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -2152,12 +2382,13 @@ void jit_is_finite_emitter::register_table_entries() {
 
 /// IS_INF ///
 template <>
-void jit_is_inf_emitter::emit_isa<x64::avx512_core>(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_is_inf_emitter::emit_isa<x64::avx512_core>(const std::vector<size_t>& in_vec_idxs,
+                                                    const std::vector<size_t>& out_vec_idxs) const {
     Zmm vmm_src = Zmm(in_vec_idxs[0]);
     Zmm vmm_dst = Zmm(out_vec_idxs[0]);
 
     if (detect_negative || detect_positive) {
-        auto &ones_mask = h->k1;
+        auto& ones_mask = h->k1;
         auto reg32_one = Reg32(aux_gpr_idxs[0]);
         uint8_t imm = detect_negative ? 0B00010000 : 0B00000000;
         if (detect_positive) {
@@ -2173,7 +2404,8 @@ void jit_is_inf_emitter::emit_isa<x64::avx512_core>(const std::vector<size_t> &i
 }
 
 template <x64::cpu_isa_t isa>
-void jit_is_inf_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_is_inf_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                  const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional<isa == x64::sse41, Xmm, Ymm>::type;
 
     if (detect_negative || detect_positive) {
@@ -2204,7 +2436,8 @@ void jit_is_inf_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const
     }
 }
 
-void jit_is_inf_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_is_inf_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                   const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::avx512_core) {
         emit_isa<x64::avx512_core>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -2226,10 +2459,11 @@ void jit_is_inf_emitter::register_table_entries() {
 
 /// IS_NAN ///
 template <>
-void jit_is_nan_emitter::emit_isa<x64::avx512_core>(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_is_nan_emitter::emit_isa<x64::avx512_core>(const std::vector<size_t>& in_vec_idxs,
+                                                    const std::vector<size_t>& out_vec_idxs) const {
     auto vmm_src = Zmm(in_vec_idxs[0]);
     auto vmm_dst = Zmm(out_vec_idxs[0]);
-    auto &ones_mask = h->k1;
+    auto& ones_mask = h->k1;
     auto reg32_one = Reg32(aux_gpr_idxs[0]);
 
     h->mov(reg32_one, CONST_1_F);
@@ -2238,7 +2472,8 @@ void jit_is_nan_emitter::emit_isa<x64::avx512_core>(const std::vector<size_t> &i
 }
 
 template <x64::cpu_isa_t isa>
-void jit_is_nan_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_is_nan_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                  const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional<isa == x64::sse41, Xmm, Ymm>::type;
     auto vmm_src = Vmm(in_vec_idxs[0]);
     auto vmm_dst = Vmm(out_vec_idxs[0]);
@@ -2254,7 +2489,8 @@ void jit_is_nan_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const
     }
 }
 
-void jit_is_nan_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_is_nan_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                   const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::avx512_core) {
         emit_isa<x64::avx512_core>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -2281,9 +2517,12 @@ jit_select_emitter::jit_select_emitter(x64::jit_generator* host,
 jit_select_emitter::jit_select_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_select_emitter::get_inputs_num() const { return 3; }
+size_t jit_select_emitter::get_inputs_num() const {
+    return 3;
+}
 
-std::set<std::vector<element::Type>> jit_select_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_select_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     return {{element::f32, element::f32, element::f32}};
 }
 
@@ -2292,11 +2531,12 @@ size_t jit_select_emitter::aux_vecs_count() const {
         return 0;
     else if (host_isa_ == x64::avx2)  // tmp vec for mask
         return 1;
-    else // mask should be xmm0 on sse41 +  tmp vec for mask
+    else  // mask should be xmm0 on sse41 +  tmp vec for mask
         return 2;
 }
 
-void jit_select_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_select_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                   const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -2309,7 +2549,8 @@ void jit_select_emitter::emit_impl(const std::vector<size_t> &in_vec_idxs, const
 }
 
 template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-void jit_select_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const {
+void jit_select_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                  const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_cond = Vmm(in_vec_idxs[0]);
     Vmm vmm_src0 = Vmm(in_vec_idxs[1]);
@@ -2346,20 +2587,22 @@ jit_bitwise_and_emitter::jit_bitwise_and_emitter(x64::jit_generator* host,
                                                  ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {}
 
-jit_bitwise_and_emitter::jit_bitwise_and_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+jit_bitwise_and_emitter::jit_bitwise_and_emitter(x64::jit_generator* host,
+                                                 x64::cpu_isa_t host_isa,
+                                                 ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_bitwise_and_emitter::get_inputs_num() const { return 2; }
+size_t jit_bitwise_and_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_bitwise_and_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
-    return {
-        {element::i8, element::i8},
-        {element::u8, element::u8},
-        {element::i32, element::i32}
-    };
+std::set<std::vector<element::Type>> jit_bitwise_and_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
+    return {{element::i8, element::i8}, {element::u8, element::u8}, {element::i32, element::i32}};
 }
 
-void jit_bitwise_and_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_bitwise_and_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                        const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -2372,7 +2615,8 @@ void jit_bitwise_and_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
 }
 
 template <x64::cpu_isa_t isa>
-void jit_bitwise_and_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_bitwise_and_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                       const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -2399,24 +2643,28 @@ jit_bitwise_not_emitter::jit_bitwise_not_emitter(x64::jit_generator* host,
     prepare_table();
 }
 
-jit_bitwise_not_emitter::jit_bitwise_not_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+jit_bitwise_not_emitter::jit_bitwise_not_emitter(x64::jit_generator* host,
+                                                 x64::cpu_isa_t host_isa,
+                                                 ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {
     prepare_table();
 }
 
-size_t jit_bitwise_not_emitter::get_inputs_num() const { return 1; }
+size_t jit_bitwise_not_emitter::get_inputs_num() const {
+    return 1;
+}
 
-std::set<std::vector<element::Type>> jit_bitwise_not_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
-    return {
-        {element::i8},
-        {element::u8},
-        {element::i32}
-    };
+std::set<std::vector<element::Type>> jit_bitwise_not_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
+    return {{element::i8}, {element::u8}, {element::i32}};
 }
 
-size_t jit_bitwise_not_emitter::aux_vecs_count() const { return 1; }
+size_t jit_bitwise_not_emitter::aux_vecs_count() const {
+    return 1;
+}
 
-void jit_bitwise_not_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_bitwise_not_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                        const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -2429,7 +2677,8 @@ void jit_bitwise_not_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
 }
 
 template <x64::cpu_isa_t isa>
-void jit_bitwise_not_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_bitwise_not_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                       const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src = Vmm(in_vec_idxs[0]);
     Vmm vmm_dst = Vmm(out_vec_idxs[0]);
@@ -2457,20 +2706,22 @@ jit_bitwise_or_emitter::jit_bitwise_or_emitter(x64::jit_generator* host,
                                                ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {}
 
-jit_bitwise_or_emitter::jit_bitwise_or_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+jit_bitwise_or_emitter::jit_bitwise_or_emitter(x64::jit_generator* host,
+                                               x64::cpu_isa_t host_isa,
+                                               ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_bitwise_or_emitter::get_inputs_num() const { return 2; }
+size_t jit_bitwise_or_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_bitwise_or_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
-    return {
-        {element::i8, element::i8},
-        {element::u8, element::u8},
-        {element::i32, element::i32}
-    };
+std::set<std::vector<element::Type>> jit_bitwise_or_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
+    return {{element::i8, element::i8}, {element::u8, element::u8}, {element::i32, element::i32}};
 }
 
-void jit_bitwise_or_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_bitwise_or_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                       const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -2483,7 +2734,8 @@ void jit_bitwise_or_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, c
 }
 
 template <x64::cpu_isa_t isa>
-void jit_bitwise_or_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_bitwise_or_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                      const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -2508,20 +2760,22 @@ jit_bitwise_xor_emitter::jit_bitwise_xor_emitter(x64::jit_generator* host,
                                                  ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {}
 
-jit_bitwise_xor_emitter::jit_bitwise_xor_emitter(x64::jit_generator* host, x64::cpu_isa_t host_isa, ov::element::Type exec_prc)
+jit_bitwise_xor_emitter::jit_bitwise_xor_emitter(x64::jit_generator* host,
+                                                 x64::cpu_isa_t host_isa,
+                                                 ov::element::Type exec_prc)
     : jit_emitter(host, host_isa, exec_prc) {}
 
-size_t jit_bitwise_xor_emitter::get_inputs_num() const { return 2; }
+size_t jit_bitwise_xor_emitter::get_inputs_num() const {
+    return 2;
+}
 
-std::set<std::vector<element::Type>> jit_bitwise_xor_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
-    return {
-        {element::i8, element::i8},
-        {element::u8, element::u8},
-        {element::i32, element::i32}
-    };
+std::set<std::vector<element::Type>> jit_bitwise_xor_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
+    return {{element::i8, element::i8}, {element::u8, element::u8}, {element::i32, element::i32}};
 }
 
-void jit_bitwise_xor_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_bitwise_xor_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                        const std::vector<size_t>& out_vec_idxs) const {
     if (host_isa_ == x64::sse41) {
         emit_isa<x64::sse41>(in_vec_idxs, out_vec_idxs);
     } else if (host_isa_ == x64::avx2) {
@@ -2534,7 +2788,8 @@ void jit_bitwise_xor_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
 }
 
 template <x64::cpu_isa_t isa>
-void jit_bitwise_xor_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_bitwise_xor_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs,
+                                       const std::vector<size_t>& out_vec_idxs) const {
     using Vmm = typename conditional3<isa == x64::sse41, Xmm, isa == x64::avx2, Ymm, Zmm>::type;
     Vmm vmm_src0 = Vmm(in_vec_idxs[0]);
     Vmm vmm_src1 = Vmm(in_vec_idxs[1]);
@@ -2543,5 +2798,5 @@ void jit_bitwise_xor_emitter::emit_isa(const std::vector<size_t>& in_vec_idxs, c
     h->uni_vxorps(vmm_dst, vmm_src0, vmm_src1);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_eltwise_emitters.hpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_eltwise_emitters.hpp
index c8c4b06d6f3347..84c65d44a12280 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_eltwise_emitters.hpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_eltwise_emitters.hpp
@@ -11,418 +11,488 @@ namespace intel_cpu {
 
 class jit_add_emitter : public jit_emitter {
 public:
-    jit_add_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_add_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                    dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                     ov::element::Type exec_prc = ov::element::f32);
-    jit_add_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n);
+    jit_add_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                    dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                    const std::shared_ptr<ov::Node>& n);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
 class jit_mul_add_emitter : public jit_emitter {
 public:
-    jit_mul_add_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_mul_add_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                         ov::element::Type exec_prc = ov::element::f32);
-    jit_mul_add_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n);
+    jit_mul_add_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                        const std::shared_ptr<ov::Node>& n);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     size_t aux_vecs_count() const override;
 };
 
-
 class jit_subtract_emitter : public jit_emitter {
 public:
-    jit_subtract_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_subtract_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                         dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                          ov::element::Type exec_prc = ov::element::f32);
-    jit_subtract_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n);
+    jit_subtract_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                         dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                         const std::shared_ptr<ov::Node>& n);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
-
 class jit_multiply_emitter : public jit_emitter {
 public:
-    jit_multiply_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_multiply_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                         dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                          ov::element::Type exec_prc = ov::element::f32);
-    jit_multiply_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n);
+    jit_multiply_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                         dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                         const std::shared_ptr<ov::Node>& n);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
-
 class jit_divide_emitter : public jit_emitter {
 public:
-    jit_divide_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_divide_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                       dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                        ov::element::Type exec_prc = ov::element::f32);
-    jit_divide_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_divide_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                       dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                       const std::shared_ptr<ov::Node>& n,
                        ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
     size_t aux_vecs_count() const override;
 };
 
 class jit_floor_emitter : public jit_emitter {
 public:
-    jit_floor_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_floor_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                      dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                       ov::element::Type exec_prc = ov::element::f32);
-    jit_floor_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_floor_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                      dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                      const std::shared_ptr<ov::Node>& n,
                       ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
 class jit_ceiling_emitter : public jit_emitter {
 public:
-    jit_ceiling_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                      ov::element::Type exec_prc = ov::element::f32);
-    jit_ceiling_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-                      ov::element::Type exec_prc = ov::element::f32);
+    jit_ceiling_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                        ov::element::Type exec_prc = ov::element::f32);
+    jit_ceiling_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                        const std::shared_ptr<ov::Node>& n,
+                        ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
 class jit_floor_mod_emitter : public jit_emitter {
 public:
-    jit_floor_mod_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_floor_mod_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                          dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                           ov::element::Type exec_prc = ov::element::f32);
-    jit_floor_mod_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_floor_mod_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                          dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                          const std::shared_ptr<ov::Node>& n,
                           ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
     size_t aux_vecs_count() const override;
 };
 
-
 class jit_mod_emitter : public jit_emitter {
 public:
-    jit_mod_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_mod_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                    dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                     ov::element::Type exec_prc = ov::element::f32);
-    jit_mod_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_mod_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                    dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                    const std::shared_ptr<ov::Node>& n,
                     ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
     size_t aux_vecs_count() const override;
 };
 
-
 class jit_maximum_emitter : public jit_emitter {
 public:
-    jit_maximum_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_maximum_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                         ov::element::Type exec_prc = ov::element::f32);
-    jit_maximum_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n);
+    jit_maximum_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                        const std::shared_ptr<ov::Node>& n);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
-
 class jit_minimum_emitter : public jit_emitter {
 public:
-    jit_minimum_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_minimum_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                         ov::element::Type exec_prc = ov::element::f32);
-    jit_minimum_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n);
+    jit_minimum_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                        const std::shared_ptr<ov::Node>& n);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
-
 class jit_squared_difference_emitter : public jit_emitter {
 public:
-    jit_squared_difference_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_squared_difference_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                   dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                                    ov::element::Type exec_prc = ov::element::f32);
-    jit_squared_difference_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_squared_difference_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                   dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                                    const std::shared_ptr<ov::Node>& n,
                                    ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
-
 class jit_power_dynamic_emitter : public jit_emitter {
 public:
-    jit_power_dynamic_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_power_dynamic_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                              dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                               ov::element::Type exec_prc = ov::element::f32);
-    jit_power_dynamic_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_power_dynamic_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                              dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                              const std::shared_ptr<ov::Node>& n,
                               ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
-
 class jit_equal_emitter : public jit_emitter {
 public:
-    jit_equal_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_equal_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                      dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                       ov::element::Type exec_prc = ov::element::f32);
-    jit_equal_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_equal_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                      dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                      const std::shared_ptr<ov::Node>& n,
                       ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     void register_table_entries() override;
     size_t aux_vecs_count() const override;
 };
 
-
 class jit_not_equal_emitter : public jit_emitter {
 public:
-    jit_not_equal_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_not_equal_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                          dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                           ov::element::Type exec_prc = ov::element::f32);
-    jit_not_equal_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_not_equal_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                          dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                          const std::shared_ptr<ov::Node>& n,
                           ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     void register_table_entries() override;
     size_t aux_vecs_count() const override;
 };
 
-
 class jit_greater_emitter : public jit_emitter {
 public:
-    jit_greater_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_greater_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                         ov::element::Type exec_prc = ov::element::f32);
-    jit_greater_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_greater_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                        const std::shared_ptr<ov::Node>& n,
                         ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     void register_table_entries() override;
     size_t aux_vecs_count() const override;
 };
 
-
 class jit_greater_equal_emitter : public jit_emitter {
 public:
-    jit_greater_equal_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_greater_equal_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                              dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                               ov::element::Type exec_prc = ov::element::f32);
-    jit_greater_equal_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_greater_equal_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                              dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                              const std::shared_ptr<ov::Node>& n,
                               ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     void register_table_entries() override;
     size_t aux_vecs_count() const override;
 };
 
-
 class jit_less_emitter : public jit_emitter {
 public:
-    jit_less_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_less_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                     dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                      ov::element::Type exec_prc = ov::element::f32);
-    jit_less_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_less_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                     dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                     const std::shared_ptr<ov::Node>& n,
                      ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     void register_table_entries() override;
     size_t aux_vecs_count() const override;
 };
 
-
 class jit_less_equal_emitter : public jit_emitter {
 public:
-    jit_less_equal_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_less_equal_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                           dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                            ov::element::Type exec_prc = ov::element::f32);
 
-    jit_less_equal_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_less_equal_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                           dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                           const std::shared_ptr<ov::Node>& n,
                            ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     void register_table_entries() override;
     size_t aux_vecs_count() const override;
 };
 
-
 class jit_logical_and_emitter : public jit_emitter {
 public:
-    jit_logical_and_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_logical_and_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                            dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                             ov::element::Type exec_prc = ov::element::f32);
-    jit_logical_and_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_logical_and_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                            dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                            const std::shared_ptr<ov::Node>& n,
                             ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     void register_table_entries() override;
     size_t aux_vecs_count() const override;
 };
 
-
 class jit_logical_or_emitter : public jit_emitter {
 public:
-    jit_logical_or_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_logical_or_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                           dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                            ov::element::Type exec_prc = ov::element::f32);
-    jit_logical_or_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_logical_or_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                           dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                           const std::shared_ptr<ov::Node>& n,
                            ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     void register_table_entries() override;
     size_t aux_vecs_count() const override;
 };
 
-
 class jit_logical_xor_emitter : public jit_emitter {
 public:
-    jit_logical_xor_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_logical_xor_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                            dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                             ov::element::Type exec_prc = ov::element::f32);
-    jit_logical_xor_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_logical_xor_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                            dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                            const std::shared_ptr<ov::Node>& n,
                             ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     void register_table_entries() override;
     size_t aux_vecs_count() const override;
@@ -430,19 +500,23 @@ class jit_logical_xor_emitter : public jit_emitter {
 
 class jit_logical_not_emitter : public jit_emitter {
 public:
-    jit_logical_not_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_logical_not_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                            dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                             ov::element::Type exec_prc = ov::element::f32);
-    jit_logical_not_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_logical_not_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                            dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                            const std::shared_ptr<ov::Node>& n,
                             ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     void register_table_entries() override;
     size_t aux_vecs_count() const override;
@@ -450,21 +524,26 @@ class jit_logical_not_emitter : public jit_emitter {
 
 class jit_power_static_emitter : public jit_emitter {
 public:
-    jit_power_static_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                             float inpPower, float inpScale, float inpShift,
+    jit_power_static_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                             dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                             float inpPower,
+                             float inpScale,
+                             float inpShift,
                              ov::element::Type exec_prc = ov::element::f32);
-    jit_power_static_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_power_static_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                             dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                             const std::shared_ptr<ov::Node>& n,
                              ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
-
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     void register_table_entries() override;
     size_t aux_vecs_count() const override;
@@ -476,73 +555,90 @@ class jit_power_static_emitter : public jit_emitter {
 
 class jit_prelu_emitter : public jit_emitter {
 public:
-    jit_prelu_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_prelu_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                      dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                       ov::element::Type exec_prc = ov::element::f32);
-    jit_prelu_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_prelu_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                      dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                      const std::shared_ptr<ov::Node>& n,
                       ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     size_t aux_vecs_count() const override;
 };
 
 class jit_sqrt_emitter : public jit_emitter {
 public:
-    jit_sqrt_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                    ov::element::Type exec_prc = ov::element::f32);
-    jit_sqrt_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-                    ov::element::Type exec_prc = ov::element::f32);
+    jit_sqrt_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                     dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                     ov::element::Type exec_prc = ov::element::f32);
+    jit_sqrt_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                     dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                     const std::shared_ptr<ov::Node>& n,
+                     ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
 class jit_negative_emitter : public jit_emitter {
 public:
-    jit_negative_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-                    ov::element::Type exec_prc = ov::element::f32);
+    jit_negative_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                         dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                         const std::shared_ptr<ov::Node>& n,
+                         ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
 class jit_exp_emitter : public jit_emitter {
 public:
-    jit_exp_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_exp_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                    dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                     ov::element::Type exec_prc = ov::element::f32);
 
-    jit_exp_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_exp_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                    dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                    const std::shared_ptr<ov::Node>& n,
                     ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
-    bool need_vmm_mask() const { return host_isa_ != dnnl::impl::cpu::x64::avx512_core; }
+    bool need_vmm_mask() const {
+        return host_isa_ != dnnl::impl::cpu::x64::avx512_core;
+    }
 
     void register_table_entries() override;
     size_t aux_vecs_count() const override;
@@ -550,103 +646,132 @@ class jit_exp_emitter : public jit_emitter {
 
 class jit_erf_emitter : public jit_emitter {
 public:
-    jit_erf_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-        ov::element::Type exec_prc = ov::element::f32);
+    jit_erf_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                    dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                    ov::element::Type exec_prc = ov::element::f32);
 
-    jit_erf_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_erf_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                    dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                    const std::shared_ptr<ov::Node>& n,
                     ov::element::Type exec_prc = ov::element::f32);
 
     void emit_data() const override;
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(
-        const std::vector<size_t> &in_vec_idxs,
-        const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     void register_table_entries() override;
     size_t aux_vecs_count() const override;
 
-    std::unique_ptr<jit_exp_emitter> m_exp_emitter {nullptr};
+    std::unique_ptr<jit_exp_emitter> m_exp_emitter{nullptr};
 };
 
 class jit_soft_sign_emitter : public jit_emitter {
 public:
-    jit_soft_sign_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_soft_sign_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                          dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                           ov::element::Type exec_prc = ov::element::f32);
-    jit_soft_sign_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_soft_sign_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                          dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                          const std::shared_ptr<ov::Node>& n,
                           ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     void register_table_entries() override;
 };
 
 class jit_is_finite_emitter : public jit_emitter {
 public:
-    jit_is_finite_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t hostIsa,
-                    ov::element::Type execPrc = ov::element::f32) : jit_emitter(host, hostIsa, execPrc) {
+    jit_is_finite_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                          dnnl::impl::cpu::x64::cpu_isa_t hostIsa,
+                          ov::element::Type execPrc = ov::element::f32)
+        : jit_emitter(host, hostIsa, execPrc) {
         prepare_table();
     }
-    jit_is_finite_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t hostIsa, const std::shared_ptr<ov::Node>& node,
-                    ov::element::Type execPrc = ov::element::f32) : jit_emitter(host, hostIsa, execPrc) {
+    jit_is_finite_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                          dnnl::impl::cpu::x64::cpu_isa_t hostIsa,
+                          const std::shared_ptr<ov::Node>& node,
+                          ov::element::Type execPrc = ov::element::f32)
+        : jit_emitter(host, hostIsa, execPrc) {
         prepare_table();
     }
 
-    size_t get_inputs_num() const override { return 1; };
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr) {
+    size_t get_inputs_num() const override {
+        return 1;
+    };
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr) {
         return {{element::f32}};
     }
 
 protected:
-    size_t aux_gprs_count() const override { return (entry_map_.empty() ? 0 : 1) + 1; }
+    size_t aux_gprs_count() const override {
+        return (entry_map_.empty() ? 0 : 1) + 1;
+    }
     void register_table_entries() override;
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
 class jit_is_inf_emitter : public jit_emitter {
 public:
-    jit_is_inf_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t hostIsa,
-                       ov::element::Type execPrc = ov::element::f32, bool detect_negative = true, bool detect_positive = true)
-            : jit_emitter(host, hostIsa, execPrc), detect_negative(detect_negative), detect_positive(detect_positive) {
+    jit_is_inf_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                       dnnl::impl::cpu::x64::cpu_isa_t hostIsa,
+                       ov::element::Type execPrc = ov::element::f32,
+                       bool detect_negative = true,
+                       bool detect_positive = true)
+        : jit_emitter(host, hostIsa, execPrc),
+          detect_negative(detect_negative),
+          detect_positive(detect_positive) {
         prepare_table();
     }
-    jit_is_inf_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t hostIsa, const std::shared_ptr<ov::Node>& node,
-                       ov::element::Type execPrc = ov::element::f32): jit_emitter(host, hostIsa, execPrc) {
+    jit_is_inf_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                       dnnl::impl::cpu::x64::cpu_isa_t hostIsa,
+                       const std::shared_ptr<ov::Node>& node,
+                       ov::element::Type execPrc = ov::element::f32)
+        : jit_emitter(host, hostIsa, execPrc) {
         prepare_table();
     }
 
-    size_t get_inputs_num() const override { return 1; };
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr) {
+    size_t get_inputs_num() const override {
+        return 1;
+    };
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr) {
         return {{element::f32}};
     }
 
 protected:
-    size_t aux_gprs_count() const override { return (entry_map_.empty() ? 0 : 1) + 1; }
+    size_t aux_gprs_count() const override {
+        return (entry_map_.empty() ? 0 : 1) + 1;
+    }
     void register_table_entries() override;
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 
     bool detect_negative;
     bool detect_positive;
@@ -654,58 +779,76 @@ class jit_is_inf_emitter : public jit_emitter {
 
 class jit_is_nan_emitter : public jit_emitter {
 public:
-    jit_is_nan_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t hostIsa,
-                       ov::element::Type execPrc = ov::element::f32) : jit_emitter(host, hostIsa, execPrc) {
+    jit_is_nan_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                       dnnl::impl::cpu::x64::cpu_isa_t hostIsa,
+                       ov::element::Type execPrc = ov::element::f32)
+        : jit_emitter(host, hostIsa, execPrc) {
         prepare_table();
     }
-    jit_is_nan_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t hostIsa, const std::shared_ptr<ov::Node>& node,
-                       ov::element::Type execPrc = ov::element::f32) : jit_emitter(host, hostIsa, execPrc) {
+    jit_is_nan_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                       dnnl::impl::cpu::x64::cpu_isa_t hostIsa,
+                       const std::shared_ptr<ov::Node>& node,
+                       ov::element::Type execPrc = ov::element::f32)
+        : jit_emitter(host, hostIsa, execPrc) {
         prepare_table();
     }
 
-    size_t get_inputs_num() const override { return 1; }
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr) {
+    size_t get_inputs_num() const override {
+        return 1;
+    }
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr) {
         return {{element::f32}};
     }
 
 protected:
-    size_t aux_gprs_count() const override { return (entry_map_.empty() ? 0 : 1) + 1; }
+    size_t aux_gprs_count() const override {
+        return (entry_map_.empty() ? 0 : 1) + 1;
+    }
     void register_table_entries() override;
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
 class jit_select_emitter : public jit_emitter {
 public:
-    jit_select_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_select_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                       dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                        ov::element::Type exec_prc = ov::element::f32);
-    jit_select_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
+    jit_select_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                       dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                       const std::shared_ptr<ov::Node>& n,
                        ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
     size_t aux_vecs_count() const override;
 
 private:
-    void emit_impl(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in_vec_idxs, const std::vector<size_t> &out_vec_idxs) const;
+    void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
 class jit_bitwise_and_emitter : public jit_emitter {
 public:
-    jit_bitwise_and_emitter(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-        ov::element::Type exec_prc = ov::element::f32);
-    jit_bitwise_and_emitter(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-        ov::element::Type exec_prc = ov::element::f32);
+    jit_bitwise_and_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                            dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                            ov::element::Type exec_prc = ov::element::f32);
+    jit_bitwise_and_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                            dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                            const std::shared_ptr<ov::Node>& n,
+                            ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
     void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
@@ -716,13 +859,17 @@ class jit_bitwise_and_emitter : public jit_emitter {
 
 class jit_bitwise_not_emitter : public jit_emitter {
 public:
-    jit_bitwise_not_emitter(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-        ov::element::Type exec_prc = ov::element::f32);
-    jit_bitwise_not_emitter(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-        ov::element::Type exec_prc = ov::element::f32);
+    jit_bitwise_not_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                            dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                            ov::element::Type exec_prc = ov::element::f32);
+    jit_bitwise_not_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                            dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                            const std::shared_ptr<ov::Node>& n,
+                            ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
     size_t aux_vecs_count() const override;
 
 private:
@@ -735,13 +882,17 @@ class jit_bitwise_not_emitter : public jit_emitter {
 
 class jit_bitwise_or_emitter : public jit_emitter {
 public:
-    jit_bitwise_or_emitter(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-        ov::element::Type exec_prc = ov::element::f32);
-    jit_bitwise_or_emitter(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-        ov::element::Type exec_prc = ov::element::f32);
+    jit_bitwise_or_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                           dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                           ov::element::Type exec_prc = ov::element::f32);
+    jit_bitwise_or_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                           dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                           const std::shared_ptr<ov::Node>& n,
+                           ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
     void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
@@ -752,13 +903,17 @@ class jit_bitwise_or_emitter : public jit_emitter {
 
 class jit_bitwise_xor_emitter : public jit_emitter {
 public:
-    jit_bitwise_xor_emitter(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-        ov::element::Type exec_prc = ov::element::f32);
-    jit_bitwise_xor_emitter(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& n,
-        ov::element::Type exec_prc = ov::element::f32);
+    jit_bitwise_xor_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                            dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                            ov::element::Type exec_prc = ov::element::f32);
+    jit_bitwise_xor_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                            dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                            const std::shared_ptr<ov::Node>& n,
+                            ov::element::Type exec_prc = ov::element::f32);
 
     size_t get_inputs_num() const override;
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
     void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
@@ -767,5 +922,5 @@ class jit_bitwise_xor_emitter : public jit_emitter {
     void emit_isa(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_emitter.cpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_emitter.cpp
index acbb04ea01af80..7ee4d5184b311a 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_emitter.cpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_emitter.cpp
@@ -3,9 +3,11 @@
 //
 
 #include "jit_emitter.hpp"
+
 #include <vector>
-#include "utils/general_utils.h"
+
 #include "utils.hpp"
+#include "utils/general_utils.h"
 
 using namespace dnnl::impl::cpu;
 using namespace dnnl::impl;
@@ -19,11 +21,12 @@ size_t jit_emitter::get_max_vecs_count() const {
 }
 
 size_t jit_emitter::get_vec_length() const {
-    return one_of(host_isa_, cpu::x64::avx512_core, cpu::x64::avx512_core) ? 64 :
-           one_of(host_isa_, cpu::x64::avx2) ? 32 : 16;
+    return one_of(host_isa_, cpu::x64::avx512_core, cpu::x64::avx512_core) ? 64
+           : one_of(host_isa_, cpu::x64::avx2)                             ? 32
+                                                                           : 16;
 }
 
-void jit_emitter::push_vec(const Xbyak::Address &addr, size_t vec_idx) const {
+void jit_emitter::push_vec(const Xbyak::Address& addr, size_t vec_idx) const {
     if (host_isa_ == cpu::x64::sse41) {
         h->uni_vmovups(addr, Xmm(vec_idx));
     } else if (host_isa_ == cpu::x64::avx2) {
@@ -33,7 +36,7 @@ void jit_emitter::push_vec(const Xbyak::Address &addr, size_t vec_idx) const {
     }
 }
 
-void jit_emitter::pop_vec(size_t vec_idx, const Xbyak::Address &addr) const {
+void jit_emitter::pop_vec(size_t vec_idx, const Xbyak::Address& addr) const {
     if (host_isa_ == cpu::x64::sse41) {
         h->uni_vmovups(Xmm(vec_idx), addr);
     } else if (host_isa_ == cpu::x64::avx2) {
@@ -60,11 +63,15 @@ std::set<std::vector<element::Type>> jit_emitter::get_supported_precisions(const
     return {};
 }
 
-void jit_emitter::emitter_preamble(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs,
-                                   const std::vector<size_t> &pool_vec_idxs, const std::vector<size_t> &pool_gpr_idxs) const {
+void jit_emitter::emitter_preamble(const std::vector<size_t>& in_idxs,
+                                   const std::vector<size_t>& out_idxs,
+                                   const std::vector<size_t>& pool_vec_idxs,
+                                   const std::vector<size_t>& pool_gpr_idxs) const {
     using namespace Xbyak::util;
-    bool is_vec_input = (in_out_type_ == emitter_in_out_map::vec_to_vec) || (in_out_type_ == emitter_in_out_map::vec_to_gpr);
-    bool is_vec_output = (in_out_type_ == emitter_in_out_map::vec_to_vec) || (in_out_type_ == emitter_in_out_map::gpr_to_vec);
+    bool is_vec_input =
+        (in_out_type_ == emitter_in_out_map::vec_to_vec) || (in_out_type_ == emitter_in_out_map::vec_to_gpr);
+    bool is_vec_output =
+        (in_out_type_ == emitter_in_out_map::vec_to_vec) || (in_out_type_ == emitter_in_out_map::gpr_to_vec);
 
     for (auto idx : pool_vec_idxs)
         aux_vec_idxs.push_back(idx);
@@ -73,9 +80,11 @@ void jit_emitter::emitter_preamble(const std::vector<size_t> &in_idxs, const std
     if (host_isa_ == cpu::x64::sse41 && aux_vecs_count() > 0) {
         size_t idx = 0;
         if (is_vec_input)
-            OV_CPU_JIT_EMITTER_ASSERT(std::find(in_idxs.begin(), in_idxs.end(), idx) == in_idxs.end(), "Xmm(0) cannot be input register in SSE41");
+            OV_CPU_JIT_EMITTER_ASSERT(std::find(in_idxs.begin(), in_idxs.end(), idx) == in_idxs.end(),
+                                      "Xmm(0) cannot be input register in SSE41");
         if (is_vec_output)
-            OV_CPU_JIT_EMITTER_ASSERT(std::find(out_idxs.begin(), out_idxs.end(), idx) == out_idxs.end(), "Xmm(0) cannot be output register in SSE41");
+            OV_CPU_JIT_EMITTER_ASSERT(std::find(out_idxs.begin(), out_idxs.end(), idx) == out_idxs.end(),
+                                      "Xmm(0) cannot be output register in SSE41");
         if (std::find(aux_vec_idxs.begin(), aux_vec_idxs.end(), idx) == aux_vec_idxs.end()) {
             aux_vec_idxs.push_back(idx);
             preserved_vec_idxs.push_back(idx);
@@ -93,16 +102,21 @@ void jit_emitter::emitter_preamble(const std::vector<size_t> &in_idxs, const std
     }
 
     for (size_t idx = 0; idx < get_max_vecs_count(); idx++) {
-        if (aux_vec_idxs.size() >= aux_vecs_count()) break;
+        if (aux_vec_idxs.size() >= aux_vecs_count())
+            break;
 
         if (is_vec_input) {
-            if (std::find(in_idxs.begin(), in_idxs.end(), idx) != in_idxs.end()) continue;
+            if (std::find(in_idxs.begin(), in_idxs.end(), idx) != in_idxs.end())
+                continue;
         }
         if (is_vec_output) {
-            if (std::find(out_idxs.begin(), out_idxs.end(), idx) != out_idxs.end()) continue;
+            if (std::find(out_idxs.begin(), out_idxs.end(), idx) != out_idxs.end())
+                continue;
         }
-        if (std::find(aux_vec_idxs.begin(), aux_vec_idxs.end(), idx) != aux_vec_idxs.end()) continue;
-        if (std::find(preserved_vec_idxs.begin(), preserved_vec_idxs.end(), idx) != preserved_vec_idxs.end()) continue;
+        if (std::find(aux_vec_idxs.begin(), aux_vec_idxs.end(), idx) != aux_vec_idxs.end())
+            continue;
+        if (std::find(preserved_vec_idxs.begin(), preserved_vec_idxs.end(), idx) != preserved_vec_idxs.end())
+            continue;
 
         aux_vec_idxs.push_back(idx);
         preserved_vec_idxs.push_back(idx);
@@ -115,18 +129,24 @@ void jit_emitter::emitter_preamble(const std::vector<size_t> &in_idxs, const std
         aux_gpr_idxs.push_back(idx);
 
     for (size_t gpr_idx = 0; gpr_idx <= Operand::R15; ++gpr_idx) {
-        size_t _idx = Operand::R15 - gpr_idx; // we allocate from the end
+        size_t _idx = Operand::R15 - gpr_idx;  // we allocate from the end
 
-        if (aux_gpr_idxs.size() >= aux_gprs_count()) break;
-        if (_idx == Operand::RSP) continue;
+        if (aux_gpr_idxs.size() >= aux_gprs_count())
+            break;
+        if (_idx == Operand::RSP)
+            continue;
         if (!is_vec_input) {
-            if (std::find(in_idxs.begin(), in_idxs.end(), _idx) != in_idxs.end()) continue;
+            if (std::find(in_idxs.begin(), in_idxs.end(), _idx) != in_idxs.end())
+                continue;
         }
         if (!is_vec_output) {
-            if (std::find(out_idxs.begin(), out_idxs.end(), _idx) != out_idxs.end()) continue;
+            if (std::find(out_idxs.begin(), out_idxs.end(), _idx) != out_idxs.end())
+                continue;
         }
-        if (std::find(aux_gpr_idxs.begin(), aux_gpr_idxs.end(), _idx) != aux_gpr_idxs.end()) continue;
-        if (std::find(preserved_gpr_idxs.begin(), preserved_gpr_idxs.end(), _idx) != preserved_gpr_idxs.end()) continue;
+        if (std::find(aux_gpr_idxs.begin(), aux_gpr_idxs.end(), _idx) != aux_gpr_idxs.end())
+            continue;
+        if (std::find(preserved_gpr_idxs.begin(), preserved_gpr_idxs.end(), _idx) != preserved_gpr_idxs.end())
+            continue;
 
         aux_gpr_idxs.push_back(_idx);
         preserved_gpr_idxs.push_back(_idx);
@@ -154,7 +174,6 @@ void jit_emitter::emitter_preamble(const std::vector<size_t> &in_idxs, const std
         load_table_addr();
 }
 
-
 void jit_emitter::emitter_postamble() const {
     using namespace Xbyak::util;
 
@@ -183,7 +202,7 @@ void jit_emitter::emit_data() const {
 
     // Run through the map and insert values stored there
     for (auto it = entry_map_.begin(); it != entry_map_.end(); it++) {
-        const auto &te = (*it).second; // get map entry for a given key
+        const auto& te = (*it).second;  // get map entry for a given key
         const auto len = te.bcast ? get_vec_length() : sizeof(table_entry_val_t);
         for (size_t d = 0; d < len; d += sizeof(table_entry_val_t))
             h->dd(te.val);
@@ -199,14 +218,16 @@ void jit_emitter::prepare_table() {
     // prepare_table.
     size_t off = 0;
     for (auto it = entry_map_.begin(); it != entry_map_.end(); it++) {
-        auto &te = (*it).second;
+        auto& te = (*it).second;
         te.off = off;
         off += te.bcast ? get_vec_length() : sizeof(table_entry_val_t);
     }
 }
 
-void jit_emitter::emit_code(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs,
-                            const std::vector<size_t> &pool_vec_idxs, const std::vector<size_t> &pool_gpr_idxs) const {
+void jit_emitter::emit_code(const std::vector<size_t>& in_idxs,
+                            const std::vector<size_t>& out_idxs,
+                            const std::vector<size_t>& pool_vec_idxs,
+                            const std::vector<size_t>& pool_gpr_idxs) const {
     emitter_preamble(in_idxs, out_idxs, pool_vec_idxs, pool_gpr_idxs);
 
     emit_impl(in_idxs, out_idxs);
@@ -214,5 +235,5 @@ void jit_emitter::emit_code(const std::vector<size_t> &in_idxs, const std::vecto
     emitter_postamble();
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_emitter.hpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_emitter.hpp
index c5729613f1bfe5..04ac2e6ea0684d 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_emitter.hpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_emitter.hpp
@@ -4,17 +4,17 @@
 
 #pragma once
 
-#include "cpu/x64/jit_generator.hpp"
-
-#include "snippets/snippets_isa.hpp"
-#include "snippets/generator.hpp"
-#include "emitters/utils.hpp"
 #include <node.h>
 
 #include <set>
 
+#include "cpu/x64/jit_generator.hpp"
+#include "emitters/utils.hpp"
+#include "snippets/generator.hpp"
+#include "snippets/snippets_isa.hpp"
+
 #ifdef SNIPPETS_DEBUG_CAPS
-#include "emitters/snippets/x64/verbose.hpp"
+#    include "emitters/snippets/x64/verbose.hpp"
 #endif
 
 namespace ov {
@@ -34,14 +34,23 @@ struct emitter_params {
 
 class jit_emitter : public ov::snippets::Emitter {
 public:
-    jit_emitter(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                ov::element::Type exec_prc = ov::element::f32, emitter_in_out_map in_out_type = emitter_in_out_map::vec_to_vec)
-        : Emitter(), h(host), host_isa_(host_isa), exec_prc_(exec_prc), l_table (new Xbyak::Label()), in_out_type_(in_out_type) {
-        k_mask = Xbyak::Opmask(1); // FIXME: in general case we need preserve k_mask state as well
+    jit_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                ov::element::Type exec_prc = ov::element::f32,
+                emitter_in_out_map in_out_type = emitter_in_out_map::vec_to_vec)
+        : Emitter(),
+          h(host),
+          host_isa_(host_isa),
+          exec_prc_(exec_prc),
+          l_table(new Xbyak::Label()),
+          in_out_type_(in_out_type) {
+        k_mask = Xbyak::Opmask(1);  // FIXME: in general case we need preserve k_mask state as well
     }
 
-    void emit_code(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs,
-                   const std::vector<size_t> &pool_vec_idxs = {}, const std::vector<size_t> &pool_gpr_idxs = {}) const override;
+    void emit_code(const std::vector<size_t>& in_idxs,
+                   const std::vector<size_t>& out_idxs,
+                   const std::vector<size_t>& pool_vec_idxs = {},
+                   const std::vector<size_t>& pool_gpr_idxs = {}) const override;
     void emit_data() const override;
 
     virtual size_t get_inputs_num() const = 0;
@@ -53,10 +62,11 @@ class jit_emitter : public ov::snippets::Emitter {
      * Precisions are ordered, the first bigger bitness precision with the same type will be selected.
      * Empty collection means the emitter supports any input precisions.
      */
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 #ifdef SNIPPETS_DEBUG_CAPS
-    const char *info() const {
+    const char* info() const {
         if (!info_.is_initialized())
             info_.init(this);
         return info_.c_str();
@@ -77,12 +87,14 @@ class jit_emitter : public ov::snippets::Emitter {
     virtual void prepare_table();
     virtual void register_table_entries() {}
 
-    void load_table_addr() const { h->mov(p_table, *l_table.get()); }
+    void load_table_addr() const {
+        h->mov(p_table, *l_table.get());
+    }
 
     // we accept only 32bit hexadecimal table values to avoid any rounding
     using table_entry_val_t = uint32_t;
-    using table_entry_offset_t = size_t; // offsets are in bytes wrt p_table
-    using table_entry_bcast_t = bool; // true => bcast value
+    using table_entry_offset_t = size_t;  // offsets are in bytes wrt p_table
+    using table_entry_bcast_t = bool;     // true => bcast value
 
     struct table_entry_t {
         table_entry_val_t val;
@@ -106,10 +118,12 @@ class jit_emitter : public ov::snippets::Emitter {
         _cmp_gt_os = dnnl::impl::cpu::x64::jit_generator::_cmp_nle_us,
     };
 
-    virtual void emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const = 0;
+    virtual void emit_impl(const std::vector<size_t>& in_idxs, const std::vector<size_t>& out_idxs) const = 0;
 
-    virtual void emitter_preamble(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs,
-                          const std::vector<size_t> &pool_vec_idxs, const std::vector<size_t> &pool_gpr_idxs) const;
+    virtual void emitter_preamble(const std::vector<size_t>& in_idxs,
+                                  const std::vector<size_t>& out_idxs,
+                                  const std::vector<size_t>& pool_vec_idxs,
+                                  const std::vector<size_t>& pool_gpr_idxs) const;
     virtual void emitter_postamble() const;
 
     emitter_in_out_map in_out_type_;
@@ -132,14 +146,14 @@ class jit_emitter : public ov::snippets::Emitter {
     mapped_table_t entry_map_;
 
     void push_arg_entry_of(const std::string key, const table_entry_val_t val, const bool broadcast) {
-        mapped_table_entry_t te {0, val, broadcast};
+        mapped_table_entry_t te{0, val, broadcast};
         entry_map_.insert(std::make_pair(key, te));
     }
 
-    void push_entries_of(const table_t &t) {
+    void push_entries_of(const table_t& t) {
         for (auto it = t.begin(); it != t.end(); it++) {
             auto key = (*it).first;
-            auto te = (*it).second; // copy values from table
+            auto te = (*it).second;  // copy values from table
             push_arg_entry_of(key, te.val, te.bcast);
         }
     }
@@ -155,20 +169,20 @@ class jit_emitter : public ov::snippets::Emitter {
     mutable std::vector<size_t> preserved_vec_idxs;
     mutable std::vector<size_t> preserved_gpr_idxs;
 
-    void push_vec(const Xbyak::Address &addr, size_t vec_idx) const;
-    void pop_vec(size_t vec_idx, const Xbyak::Address &addr) const;
+    void push_vec(const Xbyak::Address& addr, size_t vec_idx) const;
+    void pop_vec(size_t vec_idx, const Xbyak::Address& addr) const;
 
     size_t table_off(std::string& key, size_t key_off_val_shift = 0) const {
         // assumption: all table entries sharing the same key also
         // share their broadcast property
         // TODO: enforce through data structure
-        const auto it = entry_map_.find(key); // search an entry for a key
+        const auto it = entry_map_.find(key);  // search an entry for a key
         OV_CPU_JIT_EMITTER_ASSERT(it != entry_map_.end(), "Value has not been found in the table");
-        const auto &te = (*it).second;
+        const auto& te = (*it).second;
         const auto scale = te.bcast ? get_vec_length() : sizeof(table_entry_val_t);
         return te.off + key_off_val_shift * scale;
     }
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.cpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.cpp
index 893c18768a9511..513c1f70d22932 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.cpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "jit_load_store_emitters.hpp"
+
 #include "utils/bfloat16.hpp"
 
 using namespace dnnl::impl;
@@ -16,19 +17,20 @@ using namespace Xbyak::util;
 // An auxiliary vector reg(data_reg_new) is used as destination vector for source pollution instructions,
 // After updated, processed with new vector and no more need to update as source is preserved.
 // e.g. with STORE_KEEP_SOURCE(vextractf128, xmm, Xmm(aux_src_idx), ymm, 1);
-//      if ymm is already updated, h->vextractf128(xmm, ymm, 1) is used, which change ymm values as xmm and ymm have the same index.
-//      if ymm is not updated, h->vextractf128(Xmm(aux_src_idx), ymm, 1) is used, which keep ymm values unchanged as destination is another vector reg.
+//      if ymm is already updated, h->vextractf128(xmm, ymm, 1) is used, which change ymm values as xmm and ymm have the
+//      same index. if ymm is not updated, h->vextractf128(Xmm(aux_src_idx), ymm, 1) is used, which keep ymm values
+//      unchanged as destination is another vector reg.
 #define STORE_KEEP_SOURCE(instruction, data_reg, data_reg_new, ...) \
-    if (data_reg_updated) { \
-        h->instruction(data_reg, __VA_ARGS__); \
-    } else { \
-        h->instruction(data_reg_new, __VA_ARGS__); \
-        data_idx = aux_src_idx; \
-        xmm = Xbyak::Xmm(data_idx); \
-        ymm = Xbyak::Ymm(data_idx); \
-        zmm = Xbyak::Zmm(data_idx); \
-        vmm = Vmm(data_idx); \
-        data_reg_updated = true; \
+    if (data_reg_updated) {                                         \
+        h->instruction(data_reg, __VA_ARGS__);                      \
+    } else {                                                        \
+        h->instruction(data_reg_new, __VA_ARGS__);                  \
+        data_idx = aux_src_idx;                                     \
+        xmm = Xbyak::Xmm(data_idx);                                 \
+        ymm = Xbyak::Ymm(data_idx);                                 \
+        zmm = Xbyak::Zmm(data_idx);                                 \
+        vmm = Vmm(data_idx);                                        \
+        data_reg_updated = true;                                    \
     }
 
 namespace ov {
@@ -39,7 +41,7 @@ namespace {
 constexpr int threshold_for_mask_emu_load = 14;
 // heuristic threshold number by byte between mask store and emulation with several simple partial store
 constexpr int threshold_for_mask_emu_store = 6;
-}   // namespace
+}  // namespace
 
 size_t load_emitter_params::hash() const {
     size_t seed = 0;
@@ -61,46 +63,69 @@ size_t store_emitter_params::hash() const {
     return seed;
 }
 
-static int get_aux_regs_as_temp(const int elem_count, const int data_size, bool is_pure_move, bool is_store_as_real16,
-                                const int avx512_threshold_for_mask = 0, const bool is_fill = false) {
+static int get_aux_regs_as_temp(const int elem_count,
+                                const int data_size,
+                                bool is_pure_move,
+                                bool is_store_as_real16,
+                                const int avx512_threshold_for_mask = 0,
+                                const bool is_fill = false) {
     if (mayiuse(cpu::x64::avx512_core) && is_fill)
         return 1;
     // for pure move, there are direct no-mask instructions to move on full xmm/ymm/zmm, so aux_gpr is not needed.
     // for move+convert:
-    // there are direct no-mask instructions to load i8/u8/i16/u16/bf16/fp16 to full xmm/ymm/zmm as f32/i32, so aux_gpr is not needed.
-    // there are direct no-mask instructions to store i32 on full xmm/ymm/zmm to i8/u8/i16/u16, so aux_gpr is not needed.
-    // store f32 on full xmm/ymm/zmm to bf16/fp16, need convert to bf16/fp16 on vmm, then store vmm to memory, use store_dword_to_word/byte_base condition.
-    // store_num == 16, vector: 16 * f32 -> 16 * bf16 -> ymm(256bit) -> store
-    // store_num == 8,  vector:  8 * f32 ->  8 * bf16 -> xmm(128bit)  -> store
-    // store_num == 4,  vector:  4 * f32 ->  4 * bf16 ->       64bit  -> masked instruction with aux_gpr needed
-    // f32<->i32 is on full vmm, so aux_gpr is not needed.
+    // there are direct no-mask instructions to load i8/u8/i16/u16/bf16/fp16 to full xmm/ymm/zmm as f32/i32, so aux_gpr
+    // is not needed. there are direct no-mask instructions to store i32 on full xmm/ymm/zmm to i8/u8/i16/u16, so
+    // aux_gpr is not needed. store f32 on full xmm/ymm/zmm to bf16/fp16, need convert to bf16/fp16 on vmm, then store
+    // vmm to memory, use store_dword_to_word/byte_base condition. store_num == 16, vector: 16 * f32 -> 16 * bf16 ->
+    // ymm(256bit) -> store store_num == 8,  vector:  8 * f32 ->  8 * bf16 -> xmm(128bit)  -> store store_num == 4,
+    // vector:  4 * f32 ->  4 * bf16 ->       64bit  -> masked instruction with aux_gpr needed f32<->i32 is on full vmm,
+    // so aux_gpr is not needed.
     const int byte_size = elem_count * data_size;
-    if ((is_pure_move && one_of(byte_size, 16, 32, 64)) || (!is_pure_move && one_of(elem_count, 4, 8, 16) && !is_store_as_real16))
+    if ((is_pure_move && one_of(byte_size, 16, 32, 64)) ||
+        (!is_pure_move && one_of(elem_count, 4, 8, 16) && !is_store_as_real16))
         return 0;
-    if ((mayiuse(cpu::x64::avx512_core) && (byte_size > avx512_threshold_for_mask)) || (one_of(byte_size % 16, 1, 2, 3)))
+    if ((mayiuse(cpu::x64::avx512_core) && (byte_size > avx512_threshold_for_mask)) ||
+        (one_of(byte_size % 16, 1, 2, 3)))
         return 1;
     return 0;
 }
 
 /// LOAD ///
-jit_load_emitter::jit_load_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                                   ov::element::Type src_prc, ov::element::Type dst_prc, int load_num, ov::element::Type exec_prc,
-                                   bool is_fill, std::string fill_value, emitter_in_out_map in_out_type)
-: jit_emitter(host, host_isa, exec_prc, in_out_type), name_("unknown"), load_num_(load_num), src_prc_(src_prc),
-    dst_prc_(dst_prc), is_fill_(is_fill), fill_value_(fill_value) {
+jit_load_emitter::jit_load_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                   dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                                   ov::element::Type src_prc,
+                                   ov::element::Type dst_prc,
+                                   int load_num,
+                                   ov::element::Type exec_prc,
+                                   bool is_fill,
+                                   std::string fill_value,
+                                   emitter_in_out_map in_out_type)
+    : jit_emitter(host, host_isa, exec_prc, in_out_type),
+      name_("unknown"),
+      load_num_(load_num),
+      src_prc_(src_prc),
+      dst_prc_(dst_prc),
+      is_fill_(is_fill),
+      fill_value_(fill_value) {
     prepare_table();
     load_size_ = load_num * src_prc.size();
     v_len_elt_ = get_vec_length() / exec_prc.size();
 }
 
-size_t jit_load_emitter::get_inputs_num() const { return 1; }
+size_t jit_load_emitter::get_inputs_num() const {
+    return 1;
+}
 
 size_t jit_load_emitter::aux_gprs_count() const {
     // 0 for temp reg for mask load in avx512 if needed
-    const auto is_pure_load = (src_prc_ == dst_prc_) ||
-                                (one_of(src_prc_, ov::element::f32, ov::element::i32) &&
-                                 one_of(dst_prc_, ov::element::f32, ov::element::i32));
-    int count = get_aux_regs_as_temp(load_num_, static_cast<int>(src_prc_.size()), is_pure_load, false, threshold_for_mask_emu_load, is_fill_);
+    const auto is_pure_load = (src_prc_ == dst_prc_) || (one_of(src_prc_, ov::element::f32, ov::element::i32) &&
+                                                         one_of(dst_prc_, ov::element::f32, ov::element::i32));
+    int count = get_aux_regs_as_temp(load_num_,
+                                     static_cast<int>(src_prc_.size()),
+                                     is_pure_load,
+                                     false,
+                                     threshold_for_mask_emu_load,
+                                     is_fill_);
 
     // 1 for table address
     if (is_fill_)
@@ -109,7 +134,7 @@ size_t jit_load_emitter::aux_gprs_count() const {
     return count;
 }
 
-void jit_load_emitter::emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const {
+void jit_load_emitter::emit_impl(const std::vector<size_t>& in_idxs, const std::vector<size_t>& out_idxs) const {
     // offset in load emitter is the offset of src gpr register, should be parsed from in_idxs.
     const int offset = in_idxs.size() == 2 ? in_idxs[1] : 0;
     if (host_isa_ == cpu::x64::sse41) {
@@ -124,7 +149,7 @@ void jit_load_emitter::emit_impl(const std::vector<size_t> &in_idxs, const std::
 }
 
 template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-void jit_load_emitter::emit_isa(const Xbyak::Reg64 &reg_src, const int out_vec_idx, const int offset) const {
+void jit_load_emitter::emit_isa(const Xbyak::Reg64& reg_src, const int out_vec_idx, const int offset) const {
     bool matched_prc = (dst_prc_ == src_prc_) || (dst_prc_ == ov::element::f32) || (dst_prc_ == ov::element::i32);
     if (!matched_prc) {
         OV_CPU_JIT_EMITTER_THROW("only support output precision of FP32 or I32 or the same precision as input.");
@@ -139,43 +164,43 @@ void jit_load_emitter::emit_isa(const Xbyak::Reg64 &reg_src, const int out_vec_i
     if (src_prc_ == dst_prc_) {
         load_bytes<Vmm>(Vmm(out_vec_idx), reg_src, offset, load_size_);
     } else {
-    // "pure load" + convert. dst_prc must be FP32 or I32.
+        // "pure load" + convert. dst_prc must be FP32 or I32.
         switch (src_prc_) {
-            case ov::element::f32:
-            case ov::element::i32:
-                load_bytes<Vmm>(Vmm(out_vec_idx), reg_src, offset, load_size_);
-                break;
-            case ov::element::i8:
-                load_bytes_to_dword_extension<Vmm>(Vmm(out_vec_idx), reg_src, offset, true, load_size_);
-                break;
-            case ov::element::u8:
-                load_bytes_to_dword_extension<Vmm>(Vmm(out_vec_idx), reg_src, offset, false, load_size_);
-                break;
-            case ov::element::i16:
-            case ov::element::u16:
-            case ov::element::bf16:
-            case ov::element::f16:
-                load_words_to_dword_extension<Vmm>(Vmm(out_vec_idx), reg_src, offset, src_prc_, load_size_);
-                break;
-            default:
-                OV_CPU_JIT_EMITTER_THROW("has unsupported src precision to load.");
+        case ov::element::f32:
+        case ov::element::i32:
+            load_bytes<Vmm>(Vmm(out_vec_idx), reg_src, offset, load_size_);
+            break;
+        case ov::element::i8:
+            load_bytes_to_dword_extension<Vmm>(Vmm(out_vec_idx), reg_src, offset, true, load_size_);
+            break;
+        case ov::element::u8:
+            load_bytes_to_dword_extension<Vmm>(Vmm(out_vec_idx), reg_src, offset, false, load_size_);
+            break;
+        case ov::element::i16:
+        case ov::element::u16:
+        case ov::element::bf16:
+        case ov::element::f16:
+            load_words_to_dword_extension<Vmm>(Vmm(out_vec_idx), reg_src, offset, src_prc_, load_size_);
+            break;
+        default:
+            OV_CPU_JIT_EMITTER_THROW("has unsupported src precision to load.");
         }
     }
 
     // post convert between I32 and FP32
     if (src_prc_ != dst_prc_) {
         switch (dst_prc_) {
-            case ov::element::f32:
-                if (!src_prc_.is_real())
-                    h->uni_vcvtdq2ps(Vmm(out_vec_idx), Vmm(out_vec_idx));
-                break;
-            case ov::element::i32:
-                if (src_prc_.is_real()) {
-                    h->uni_vcvtps2dq(Vmm(out_vec_idx), Vmm(out_vec_idx));
-                }
-                break;
-            default:
-                break;
+        case ov::element::f32:
+            if (!src_prc_.is_real())
+                h->uni_vcvtdq2ps(Vmm(out_vec_idx), Vmm(out_vec_idx));
+            break;
+        case ov::element::i32:
+            if (src_prc_.is_real()) {
+                h->uni_vcvtps2dq(Vmm(out_vec_idx), Vmm(out_vec_idx));
+            }
+            break;
+        default:
+            break;
         }
     }
 
@@ -186,19 +211,19 @@ void jit_load_emitter::emit_isa(const Xbyak::Reg64 &reg_src, const int out_vec_i
 }
 
 /**
-* load_bytes is the utility function to facilitate loading of
-* load_size (0 <= load_size <= 64) many contiguous bytes into the Xmm/Ymm/Zmm
-* register from the memory referenced by ptr[reg + offset] address.
-*
-* Functionally, invocation of load_bytes is equivalent to
-* the following loop:
-*
-* for (int idx = 0; idx < load_size; ++idx)
-*     vpinsrb(vmm, vmm, ptr[reg + offset + idx], idx);
-*
-*/
+ * load_bytes is the utility function to facilitate loading of
+ * load_size (0 <= load_size <= 64) many contiguous bytes into the Xmm/Ymm/Zmm
+ * register from the memory referenced by ptr[reg + offset] address.
+ *
+ * Functionally, invocation of load_bytes is equivalent to
+ * the following loop:
+ *
+ * for (int idx = 0; idx < load_size; ++idx)
+ *     vpinsrb(vmm, vmm, ptr[reg + offset + idx], idx);
+ *
+ */
 template <typename Vmm>
-void jit_load_emitter::load_bytes(const Vmm &vmm, const Xbyak::Reg64 &reg, int offset, int load_size) const {
+void jit_load_emitter::load_bytes(const Vmm& vmm, const Xbyak::Reg64& reg, int offset, int load_size) const {
     constexpr bool is_xmm = std::is_same<Vmm, Xbyak::Xmm>::value;
     constexpr bool is_ymm = std::is_same<Vmm, Xbyak::Ymm>::value;
     constexpr bool is_zmm = std::is_same<Vmm, Xbyak::Zmm>::value;
@@ -249,14 +274,17 @@ void jit_load_emitter::load_bytes(const Vmm &vmm, const Xbyak::Reg64 &reg, int o
         }
 
         // Cornerstone of partial load is combinaion of vpinsrb/w/d.
-        // As vpinsrb/w/d will not only write(insert) values into vmm, but also read values in vmm to copy from to positions that not in imm mask,
-        // this could introduce RAW false dependency(we actually do not care about values not in imm mask).
-        // To eliminate this false dependency,
+        // As vpinsrb/w/d will not only write(insert) values into vmm, but also read values in vmm to copy from to
+        // positions that not in imm mask, this could introduce RAW false dependency(we actually do not care about
+        // values not in imm mask). To eliminate this false dependency,
         // 1. For 1/2/3/4 bytes tails, replace vpinsrb/w/d with mov,shl etc instructions that don't read vmm.
-        //    Besides eliminate RAW, these instructions have smaller latency, which also bring better perf, especially for small loop iteration case.
+        //    Besides eliminate RAW, these instructions have smaller latency, which also bring better perf, especially
+        //    for small loop iteration case.
         // 2. For 8/16 bytes, use vmovq/vmovdqu instructions to load, which also don't read src vmm.
-        // 3. For other size, insert vpxor before vpinsrb/w/d. vpxor and read vmm instructions in previous loop have WAR(write after read) relationship.
-        //    CPU can identify this scenario and assign another physical vector register(register renameing) in next loop to eliminate RAW.
+        // 3. For other size, insert vpxor before vpinsrb/w/d. vpxor and read vmm instructions in previous loop have
+        // WAR(write after read) relationship.
+        //    CPU can identify this scenario and assign another physical vector register(register renameing) in next
+        //    loop to eliminate RAW.
         if (!one_of(bytes_to_load, 0, 1, 2, 3, 4, 8, 16)) {
             h->uni_vpxor(vmm, vmm, vmm);
         }
@@ -266,121 +294,136 @@ void jit_load_emitter::load_bytes(const Vmm &vmm, const Xbyak::Reg64 &reg, int o
             h->uni_vmovdqu(xmm, addr(start_bytes));
 
         switch (bytes_to_load) {
-            case 0: break;
-            case 1:
-                h->movzx(Reg32(aux_gpr_idxs[0]), addr(start_bytes));
-                h->uni_vmovq(xmm, Reg64(aux_gpr_idxs[0]));
-                break;
-            case 2:
-                h->movzx(Reg32(aux_gpr_idxs[0]), word_addr(start_bytes));
-                h->uni_vmovq(xmm, Reg64(aux_gpr_idxs[0]));
-                break;
-            case 3:
-                h->movzx(Reg32(aux_gpr_idxs[0]), addr(start_bytes + 2));
-                h->shl(Reg32(aux_gpr_idxs[0]), 16);
-                h->mov(Reg16(aux_gpr_idxs[0]), word_addr(start_bytes));
-                h->uni_vmovq(xmm, Reg64(aux_gpr_idxs[0]));
-                break;
-            case 4: h->uni_vmovss(xmm, addr(start_bytes)); break;
-            case 5:
-                h->uni_vmovss(xmm, addr(start_bytes));
-                h->uni_vpinsrb(xmm, xmm, addr(start_bytes + 4), 4);
-                break;
-            case 6:
-                h->uni_vmovss(xmm, addr(start_bytes));
-                h->uni_vpinsrw(xmm, xmm, addr(start_bytes + 4), 2);
-                break;
-            case 7:
-                h->uni_vmovss(xmm, addr(start_bytes));
-                h->uni_vpinsrw(xmm, xmm, addr(start_bytes + 4), 2);
-                h->uni_vpinsrb(xmm, xmm, addr(start_bytes + 6), 6);
-                break;
-            case 8: break;
-            case 9: h->uni_vpinsrb(xmm, xmm, addr(start_bytes + 8), 8); break;
-            case 10: h->uni_vpinsrw(xmm, xmm, addr(start_bytes + 8), 4); break;
-            case 11:
-                h->uni_vpinsrw(xmm, xmm, addr(start_bytes + 8), 4);
-                h->uni_vpinsrb(xmm, xmm, addr(start_bytes + 10), 10);
-                break;
-            case 12: h->uni_vpinsrd(xmm, xmm, addr(start_bytes + 8), 2); break;
-            case 13:
-                h->uni_vpinsrd(xmm, xmm, addr(start_bytes + 8), 2);
-                h->uni_vpinsrb(xmm, xmm, addr(start_bytes + 12), 12);
-                break;
-            case 14:
-                h->uni_vpinsrd(xmm, xmm, addr(start_bytes + 8), 2);
-                h->uni_vpinsrw(xmm, xmm, addr(start_bytes + 12), 6);
-                break;
-            case 15:
-                h->uni_vpinsrd(xmm, xmm, addr(start_bytes + 8), 2);
-                h->uni_vpinsrw(xmm, xmm, addr(start_bytes + 12), 6);
-                h->uni_vpinsrb(xmm, xmm, addr(start_bytes + 14), 14);
-                break;
-            case 16: break;
-            default:
-                OV_CPU_JIT_EMITTER_THROW("has unexpected number of values to load in load_byte.");
+        case 0:
+            break;
+        case 1:
+            h->movzx(Reg32(aux_gpr_idxs[0]), addr(start_bytes));
+            h->uni_vmovq(xmm, Reg64(aux_gpr_idxs[0]));
+            break;
+        case 2:
+            h->movzx(Reg32(aux_gpr_idxs[0]), word_addr(start_bytes));
+            h->uni_vmovq(xmm, Reg64(aux_gpr_idxs[0]));
+            break;
+        case 3:
+            h->movzx(Reg32(aux_gpr_idxs[0]), addr(start_bytes + 2));
+            h->shl(Reg32(aux_gpr_idxs[0]), 16);
+            h->mov(Reg16(aux_gpr_idxs[0]), word_addr(start_bytes));
+            h->uni_vmovq(xmm, Reg64(aux_gpr_idxs[0]));
+            break;
+        case 4:
+            h->uni_vmovss(xmm, addr(start_bytes));
+            break;
+        case 5:
+            h->uni_vmovss(xmm, addr(start_bytes));
+            h->uni_vpinsrb(xmm, xmm, addr(start_bytes + 4), 4);
+            break;
+        case 6:
+            h->uni_vmovss(xmm, addr(start_bytes));
+            h->uni_vpinsrw(xmm, xmm, addr(start_bytes + 4), 2);
+            break;
+        case 7:
+            h->uni_vmovss(xmm, addr(start_bytes));
+            h->uni_vpinsrw(xmm, xmm, addr(start_bytes + 4), 2);
+            h->uni_vpinsrb(xmm, xmm, addr(start_bytes + 6), 6);
+            break;
+        case 8:
+            break;
+        case 9:
+            h->uni_vpinsrb(xmm, xmm, addr(start_bytes + 8), 8);
+            break;
+        case 10:
+            h->uni_vpinsrw(xmm, xmm, addr(start_bytes + 8), 4);
+            break;
+        case 11:
+            h->uni_vpinsrw(xmm, xmm, addr(start_bytes + 8), 4);
+            h->uni_vpinsrb(xmm, xmm, addr(start_bytes + 10), 10);
+            break;
+        case 12:
+            h->uni_vpinsrd(xmm, xmm, addr(start_bytes + 8), 2);
+            break;
+        case 13:
+            h->uni_vpinsrd(xmm, xmm, addr(start_bytes + 8), 2);
+            h->uni_vpinsrb(xmm, xmm, addr(start_bytes + 12), 12);
+            break;
+        case 14:
+            h->uni_vpinsrd(xmm, xmm, addr(start_bytes + 8), 2);
+            h->uni_vpinsrw(xmm, xmm, addr(start_bytes + 12), 6);
+            break;
+        case 15:
+            h->uni_vpinsrd(xmm, xmm, addr(start_bytes + 8), 2);
+            h->uni_vpinsrw(xmm, xmm, addr(start_bytes + 12), 6);
+            h->uni_vpinsrb(xmm, xmm, addr(start_bytes + 14), 14);
+            break;
+        case 16:
+            break;
+        default:
+            OV_CPU_JIT_EMITTER_THROW("has unexpected number of values to load in load_byte.");
         }
 
         if (has_xmm_block) {
-            h->vinsertf128(ymm, ymm, xmm, 1); // insert to upper bits of ymm
+            h->vinsertf128(ymm, ymm, xmm, 1);  // insert to upper bits of ymm
             if (has_ymm_block)
-                h->vinsertf128(ymm, ymm, addr(32), 0); // insert to lower bits of ymm
+                h->vinsertf128(ymm, ymm, addr(32), 0);  // insert to lower bits of ymm
             else
-                h->vinsertf128(ymm, ymm, addr(0), 0); // insert to lower bits of ymm
+                h->vinsertf128(ymm, ymm, addr(0), 0);  // insert to lower bits of ymm
         }
 
         if (has_ymm_block) {
-            h->vinsertf64x4(zmm, zmm, ymm, 1); // insert to upper bits of zmm
-            h->vinsertf64x4(zmm, zmm, addr(0), 0); // insert to lower bits of zmm
+            h->vinsertf64x4(zmm, zmm, ymm, 1);      // insert to upper bits of zmm
+            h->vinsertf64x4(zmm, zmm, addr(0), 0);  // insert to lower bits of zmm
         }
     };
 
     switch (load_size) {
-        case 64:
-            h->uni_vmovdqu(zmm, addr(0));
-            break;
-        case 32:
-            h->uni_vmovdqu(ymm, addr(0));
-            break;
-        case 16:
-            h->uni_vmovdqu(xmm, addr(0));
-            break;
-        default: {
-            if (mayiuse(cpu::x64::avx512_core) && load_size > threshold_for_mask_emu_load) {
-                uint64_t mask = 1;
-                mask = (mask << load_size) - mask;
-                h->mov(Reg64(aux_gpr_idxs[0]), mask);
-                h->kmovq(k_mask, Reg64(aux_gpr_idxs[0]));
-                h->vmovdqu8(zmm | k_mask | T_z, addr(0));
-            } else {
-                load_byte_base();
-            }
-            break;
+    case 64:
+        h->uni_vmovdqu(zmm, addr(0));
+        break;
+    case 32:
+        h->uni_vmovdqu(ymm, addr(0));
+        break;
+    case 16:
+        h->uni_vmovdqu(xmm, addr(0));
+        break;
+    default: {
+        if (mayiuse(cpu::x64::avx512_core) && load_size > threshold_for_mask_emu_load) {
+            uint64_t mask = 1;
+            mask = (mask << load_size) - mask;
+            h->mov(Reg64(aux_gpr_idxs[0]), mask);
+            h->kmovq(k_mask, Reg64(aux_gpr_idxs[0]));
+            h->vmovdqu8(zmm | k_mask | T_z, addr(0));
+        } else {
+            load_byte_base();
         }
+        break;
+    }
     }
 }
 
 /**
-* load_bytes_to_dword_extension is the utility function to facilitate
-* loading of load_size (0 <= load_size <= 16) many contiguous bytes in
-* the xmm register from the memory referenced by ptr[reg + offset]
-* address and then do signed/zero extension of those to double words.
-*
-* Functionally, invocation of load_bytes_to_dword_extension is equivalent
-* to the following:
-*
-* for (int idx = 0; idx < load_size; ++idx)
-*     vpinsrb(vmm, vmm, ptr[reg + offset + idx], idx);
-* if (is_signed) vpmovsxbd(vmm, vmm); else vpmovzxbd(vmm, vmm);
-*
-* Valid values for the load_size variable are:
-* [0..4] for XMM version of the function, i.e. 4 bytes -> 4 * 32 bit == 128 bit
-* [0..8] for YMM version of the function. i.e. 8 bytes -> 8 * 32 bit == 256 bit
-* [0..16] for ZMM version of the function. i.e. 16 bytes -> 16 * 32 bit == 512 bit
-*/
+ * load_bytes_to_dword_extension is the utility function to facilitate
+ * loading of load_size (0 <= load_size <= 16) many contiguous bytes in
+ * the xmm register from the memory referenced by ptr[reg + offset]
+ * address and then do signed/zero extension of those to double words.
+ *
+ * Functionally, invocation of load_bytes_to_dword_extension is equivalent
+ * to the following:
+ *
+ * for (int idx = 0; idx < load_size; ++idx)
+ *     vpinsrb(vmm, vmm, ptr[reg + offset + idx], idx);
+ * if (is_signed) vpmovsxbd(vmm, vmm); else vpmovzxbd(vmm, vmm);
+ *
+ * Valid values for the load_size variable are:
+ * [0..4] for XMM version of the function, i.e. 4 bytes -> 4 * 32 bit == 128 bit
+ * [0..8] for YMM version of the function. i.e. 8 bytes -> 8 * 32 bit == 256 bit
+ * [0..16] for ZMM version of the function. i.e. 16 bytes -> 16 * 32 bit == 512 bit
+ */
 
 template <typename Vmm>
-void jit_load_emitter::load_bytes_to_dword_extension(const Vmm &vmm, const Xbyak::Reg64 &reg, int offset, bool is_signed, int load_size) const {
+void jit_load_emitter::load_bytes_to_dword_extension(const Vmm& vmm,
+                                                     const Xbyak::Reg64& reg,
+                                                     int offset,
+                                                     bool is_signed,
+                                                     int load_size) const {
     constexpr bool is_xmm = std::is_same<Vmm, Xbyak::Xmm>::value;
     constexpr bool is_ymm = std::is_same<Vmm, Xbyak::Ymm>::value;
     constexpr bool is_zmm = std::is_same<Vmm, Xbyak::Zmm>::value;
@@ -401,76 +444,80 @@ void jit_load_emitter::load_bytes_to_dword_extension(const Vmm &vmm, const Xbyak
 
     // For load_size == 4/8/16, do load/extension in one go
     switch (load_size) {
-        case 16: {
-            // full size of zmm
-            const auto zmm = Xbyak::Zmm(vmm.getIdx());
-            if (is_signed)
-                h->uni_vpmovsxbd(zmm, ptr[reg + offset]);
-            else
-                h->uni_vpmovzxbd(zmm, ptr[reg + offset]);
-            break;
-        }
-        case 8: {
-            // full size of ymm or ymm_block of zmm
-            const auto ymm = Xbyak::Ymm(vmm.getIdx());
+    case 16: {
+        // full size of zmm
+        const auto zmm = Xbyak::Zmm(vmm.getIdx());
+        if (is_signed)
+            h->uni_vpmovsxbd(zmm, ptr[reg + offset]);
+        else
+            h->uni_vpmovzxbd(zmm, ptr[reg + offset]);
+        break;
+    }
+    case 8: {
+        // full size of ymm or ymm_block of zmm
+        const auto ymm = Xbyak::Ymm(vmm.getIdx());
+        if (is_signed)
+            h->uni_vpmovsxbd(ymm, ptr[reg + offset]);
+        else
+            h->uni_vpmovzxbd(ymm, ptr[reg + offset]);
+        break;
+    }
+    case 4: {
+        // full size of xmm or xmm_block of ymm/zmm
+        const auto xmm = Xbyak::Xmm(vmm.getIdx());
+        if (is_signed)
+            h->uni_vpmovsxbd(xmm, ptr[reg + offset]);
+        else
+            h->uni_vpmovzxbd(xmm, ptr[reg + offset]);
+        break;
+    }
+    default: {
+        if (is_zmm && load_size > threshold_for_mask_emu_load) {
+            unsigned int mask = 1;
+            mask = (mask << load_size) - mask;
+            h->mov(Reg32(aux_gpr_idxs[0]), mask);
+            h->kmovw(k_mask, Reg32(aux_gpr_idxs[0]));
             if (is_signed)
-                h->uni_vpmovsxbd(ymm, ptr[reg + offset]);
+                h->uni_vpmovsxbd(vmm | k_mask | T_z, ptr[reg + offset]);
             else
-                h->uni_vpmovzxbd(ymm, ptr[reg + offset]);
-            break;
-        }
-        case 4: {
-            // full size of xmm or xmm_block of ymm/zmm
+                h->uni_vpmovzxbd(vmm | k_mask | T_z, ptr[reg + offset]);
+        } else {
             const auto xmm = Xbyak::Xmm(vmm.getIdx());
+            load_bytes(xmm, reg, offset, load_size);
             if (is_signed)
-                h->uni_vpmovsxbd(xmm, ptr[reg + offset]);
+                h->uni_vpmovsxbd(vmm, xmm);
             else
-                h->uni_vpmovzxbd(xmm, ptr[reg + offset]);
-            break;
-        }
-        default: {
-            if (is_zmm && load_size > threshold_for_mask_emu_load) {
-                unsigned int mask = 1;
-                mask = (mask << load_size) - mask;
-                h->mov(Reg32(aux_gpr_idxs[0]), mask);
-                h->kmovw(k_mask, Reg32(aux_gpr_idxs[0]));
-                if (is_signed)
-                    h->uni_vpmovsxbd(vmm | k_mask | T_z, ptr[reg + offset]);
-                else
-                    h->uni_vpmovzxbd(vmm | k_mask | T_z, ptr[reg + offset]);
-            } else {
-                const auto xmm = Xbyak::Xmm(vmm.getIdx());
-                load_bytes(xmm, reg, offset, load_size);
-                if (is_signed)
-                    h->uni_vpmovsxbd(vmm, xmm);
-                else
-                    h->uni_vpmovzxbd(vmm, xmm);
-            }
-            break;
+                h->uni_vpmovzxbd(vmm, xmm);
         }
+        break;
+    }
     }
 }
 
 /**
-* load_words_to_dword_extension is the utility function to facilitate
-* loading of load_size (0 <= load_size <= 32) byte many contiguous words(num == load_size / 2)
-* in the Vmm register from the memory referenced by ptr[reg + offset]
-* address and then do signed/zero extension of those to double words.
-*
-* Functionally, invocation of load_words_to_dword_extension is equivalent
-* to the following extended pseudo code:
-*
-* for (int idx = 0; idx < load_size / 2; ++idx)
-*     vpinsrw(vmm, vmm, ptr[reg + offset + 2 * idx], idx);
-* if (is_signed) vpmovsxwd(vmm, vmm); else vpmovzxwd(vmm, vmm);
-*
-* Valid values for the load_size variable are:
-* [0..8] for XMM version of the function.  i.e. 4 words -> 4 * 32 bit == 128 bit
-* [0..16] for YMM version of the function. i.e. 8 words -> 8 * 32 bit == 256 bit
-* [0.. 32] for ZMM version of the function. i.e. 16 words -> 16 * 32 bit == 512 bit
-*/
+ * load_words_to_dword_extension is the utility function to facilitate
+ * loading of load_size (0 <= load_size <= 32) byte many contiguous words(num == load_size / 2)
+ * in the Vmm register from the memory referenced by ptr[reg + offset]
+ * address and then do signed/zero extension of those to double words.
+ *
+ * Functionally, invocation of load_words_to_dword_extension is equivalent
+ * to the following extended pseudo code:
+ *
+ * for (int idx = 0; idx < load_size / 2; ++idx)
+ *     vpinsrw(vmm, vmm, ptr[reg + offset + 2 * idx], idx);
+ * if (is_signed) vpmovsxwd(vmm, vmm); else vpmovzxwd(vmm, vmm);
+ *
+ * Valid values for the load_size variable are:
+ * [0..8] for XMM version of the function.  i.e. 4 words -> 4 * 32 bit == 128 bit
+ * [0..16] for YMM version of the function. i.e. 8 words -> 8 * 32 bit == 256 bit
+ * [0.. 32] for ZMM version of the function. i.e. 16 words -> 16 * 32 bit == 512 bit
+ */
 template <typename Vmm>
-void jit_load_emitter::load_words_to_dword_extension(const Vmm &vmm, const Xbyak::Reg64 &reg, int offset, ov::element::Type prc, int load_size) const {
+void jit_load_emitter::load_words_to_dword_extension(const Vmm& vmm,
+                                                     const Xbyak::Reg64& reg,
+                                                     int offset,
+                                                     ov::element::Type prc,
+                                                     int load_size) const {
     constexpr bool is_xmm = std::is_same<Vmm, Xbyak::Xmm>::value;
     constexpr bool is_ymm = std::is_same<Vmm, Xbyak::Ymm>::value;
     constexpr bool is_zmm = std::is_same<Vmm, Xbyak::Zmm>::value;
@@ -503,87 +550,87 @@ void jit_load_emitter::load_words_to_dword_extension(const Vmm &vmm, const Xbyak
     // For load_size == 32/16/8, do load/extension in one go
     // including xmm/ymm tail block for ymm/zmm, so explicite xmm/ymm/zmm
     switch (load_size) {
-        case 32: {
-            if (is_bf16) {
+    case 32: {
+        if (is_bf16) {
+            h->uni_vpmovzxwd(zmm, ptr[reg + offset]);
+            h->uni_vpslld(zmm, zmm, 16);
+        } else if (is_f16) {
+            h->vcvtph2ps(zmm, ptr[reg + offset]);
+        } else {
+            if (is_signed)
+                h->uni_vpmovsxwd(zmm, ptr[reg + offset]);
+            else
                 h->uni_vpmovzxwd(zmm, ptr[reg + offset]);
-                h->uni_vpslld(zmm, zmm, 16);
-            } else if (is_f16) {
-                h->vcvtph2ps(zmm, ptr[reg + offset]);
-            } else {
-                if (is_signed)
-                    h->uni_vpmovsxwd(zmm, ptr[reg + offset]);
-                else
-                    h->uni_vpmovzxwd(zmm, ptr[reg + offset]);
-            }
-            break;
         }
-        case 16: {
-            if (is_bf16) {
+        break;
+    }
+    case 16: {
+        if (is_bf16) {
+            h->uni_vpmovzxwd(ymm, ptr[reg + offset]);
+            h->uni_vpslld(ymm, ymm, 16);
+        } else if (is_f16) {
+            h->vcvtph2ps(ymm, ptr[reg + offset]);
+        } else {
+            if (is_signed)
+                h->uni_vpmovsxwd(ymm, ptr[reg + offset]);
+            else
                 h->uni_vpmovzxwd(ymm, ptr[reg + offset]);
-                h->uni_vpslld(ymm, ymm, 16);
+        }
+        break;
+    }
+    case 8: {
+        if (is_bf16) {
+            h->uni_vpmovzxwd(xmm, ptr[reg + offset]);
+            h->uni_vpslld(xmm, xmm, 16);
+        } else if (is_f16) {
+            h->vcvtph2ps(xmm, ptr[reg + offset]);
+        } else {
+            if (is_signed)
+                h->uni_vpmovsxwd(xmm, ptr[reg + offset]);
+            else
+                h->uni_vpmovzxwd(xmm, ptr[reg + offset]);
+        }
+        break;
+    }
+    default: {
+        if (is_zmm && load_size > threshold_for_mask_emu_load) {
+            unsigned int mask = 1;
+            mask = (mask << (load_size / 2)) - mask;
+            h->mov(Reg32(aux_gpr_idxs[0]), mask);
+            h->kmovw(k_mask, Reg32(aux_gpr_idxs[0]));
+            if (is_bf16) {
+                h->uni_vpmovzxwd(vmm | k_mask | T_z, ptr[reg + offset]);
+                h->uni_vpslld(vmm, vmm, 16);
             } else if (is_f16) {
-                h->vcvtph2ps(ymm, ptr[reg + offset]);
+                h->vcvtph2ps(vmm | k_mask | T_z, ptr[reg + offset]);
             } else {
                 if (is_signed)
-                    h->uni_vpmovsxwd(ymm, ptr[reg + offset]);
+                    h->uni_vpmovsxwd(vmm | k_mask | T_z, ptr[reg + offset]);
                 else
-                    h->uni_vpmovzxwd(ymm, ptr[reg + offset]);
+                    h->uni_vpmovzxwd(vmm | k_mask | T_z, ptr[reg + offset]);
             }
-            break;
-        }
-        case 8: {
+        } else {
+            // xmm or ymm version
+            load_bytes(xmm, reg, offset, load_size);
             if (is_bf16) {
-                h->uni_vpmovzxwd(xmm, ptr[reg + offset]);
-                h->uni_vpslld(xmm, xmm, 16);
+                h->uni_vpmovzxwd(vmm, xmm);
+                h->uni_vpslld(vmm, vmm, 16);
             } else if (is_f16) {
-                h->vcvtph2ps(xmm, ptr[reg + offset]);
+                h->vcvtph2ps(ymm, xmm);
             } else {
                 if (is_signed)
-                    h->uni_vpmovsxwd(xmm, ptr[reg + offset]);
+                    h->uni_vpmovsxwd(vmm, xmm);
                 else
-                    h->uni_vpmovzxwd(xmm, ptr[reg + offset]);
-            }
-            break;
-        }
-        default: {
-            if (is_zmm && load_size > threshold_for_mask_emu_load) {
-                unsigned int mask = 1;
-                mask = (mask << (load_size / 2)) - mask;
-                h->mov(Reg32(aux_gpr_idxs[0]), mask);
-                h->kmovw(k_mask, Reg32(aux_gpr_idxs[0]));
-                if (is_bf16) {
-                    h->uni_vpmovzxwd(vmm | k_mask | T_z, ptr[reg + offset]);
-                    h->uni_vpslld(vmm, vmm, 16);
-                } else if (is_f16) {
-                    h->vcvtph2ps(vmm | k_mask | T_z, ptr[reg + offset]);
-                } else {
-                    if (is_signed)
-                        h->uni_vpmovsxwd(vmm | k_mask | T_z, ptr[reg + offset]);
-                    else
-                        h->uni_vpmovzxwd(vmm | k_mask | T_z, ptr[reg + offset]);
-                }
-            } else {
-                // xmm or ymm version
-                load_bytes(xmm, reg, offset, load_size);
-                if (is_bf16) {
                     h->uni_vpmovzxwd(vmm, xmm);
-                    h->uni_vpslld(vmm, vmm, 16);
-                } else if (is_f16) {
-                    h->vcvtph2ps(ymm, xmm);
-                } else {
-                    if (is_signed)
-                        h->uni_vpmovsxwd(vmm, xmm);
-                    else
-                        h->uni_vpmovzxwd(vmm, xmm);
-                }
             }
-            break;
         }
+        break;
+    }
     }
 }
 
 template <typename Vmm>
-void jit_load_emitter::fill_with_default(const Vmm &vmm, std::string fill_value, const int &load_num) const {
+void jit_load_emitter::fill_with_default(const Vmm& vmm, std::string fill_value, const int& load_num) const {
     constexpr bool is_xmm = std::is_same<Vmm, Xbyak::Xmm>::value;
     constexpr bool is_ymm = std::is_same<Vmm, Xbyak::Ymm>::value;
     constexpr bool is_zmm = std::is_same<Vmm, Xbyak::Zmm>::value;
@@ -614,10 +661,20 @@ void jit_load_emitter::register_table_entries() {
 }
 
 /// STORE ///
-jit_store_emitter::jit_store_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                                     ov::element::Type src_prc, ov::element::Type dst_prc, int store_num, arithmetic_mode mode, ov::element::Type exec_prc,
+jit_store_emitter::jit_store_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                     dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                                     ov::element::Type src_prc,
+                                     ov::element::Type dst_prc,
+                                     int store_num,
+                                     arithmetic_mode mode,
+                                     ov::element::Type exec_prc,
                                      emitter_in_out_map in_out_type)
-    : jit_emitter(host, host_isa, exec_prc, in_out_type), name_("unknown"), store_num_(store_num), src_prc_(src_prc), dst_prc_(dst_prc), mode_(mode) {
+    : jit_emitter(host, host_isa, exec_prc, in_out_type),
+      name_("unknown"),
+      store_num_(store_num),
+      src_prc_(src_prc),
+      dst_prc_(dst_prc),
+      mode_(mode) {
     prepare_table();
     v_len_elt_ = get_vec_length() / exec_prc.size();
     store_size_ = store_num * dst_prc.size();
@@ -630,17 +687,20 @@ inline bool jit_store_emitter::is_saturation() const {
 
 // case for SSE and AVX2 when we should use AND to truncate values
 inline bool jit_store_emitter::is_truncation_emulation() const {
-    return !mayiuse(cpu::x64::avx512_core) && !is_saturation() &&
-        src_prc_ != dst_prc_ && one_of(dst_prc_, ov::element::u16, ov::element::i16, ov::element::u8, ov::element::i8);
+    return !mayiuse(cpu::x64::avx512_core) && !is_saturation() && src_prc_ != dst_prc_ &&
+           one_of(dst_prc_, ov::element::u16, ov::element::i16, ov::element::u8, ov::element::i8);
 }
 
 size_t jit_store_emitter::aux_gprs_count() const {
     // for temp reg for store(mask version or special number cases)
-    const auto is_pure_store = (src_prc_ == dst_prc_) ||
-                                (one_of(src_prc_, ov::element::f32, ov::element::i32) &&
-                                 one_of(dst_prc_, ov::element::f32, ov::element::i32));
+    const auto is_pure_store = (src_prc_ == dst_prc_) || (one_of(src_prc_, ov::element::f32, ov::element::i32) &&
+                                                          one_of(dst_prc_, ov::element::f32, ov::element::i32));
     const auto is_store_as_real16 = one_of(dst_prc_, ov::element::bf16, ov::element::f16);
-    int count = get_aux_regs_as_temp(store_num_, static_cast<int>(dst_prc_.size()), is_pure_store, is_store_as_real16, threshold_for_mask_emu_store);
+    int count = get_aux_regs_as_temp(store_num_,
+                                     static_cast<int>(dst_prc_.size()),
+                                     is_pure_store,
+                                     is_store_as_real16,
+                                     threshold_for_mask_emu_store);
 
     // for table value in truncation arithmetic mode
     if (is_truncation_emulation())
@@ -661,14 +721,17 @@ size_t jit_store_emitter::aux_vecs_count() const {
     if ((host_isa_ == cpu::x64::sse41) && (src_prc_ == ov::element::f32 && dst_prc_ == ov::element::bf16))
         count++;
 
-    // zero value, zeroed and passed from caller from performance standpoint(zeroed one time and not need preserve and restore status)
+    // zero value, zeroed and passed from caller from performance standpoint(zeroed one time and not need preserve and
+    // restore status)
     if (mayiuse(cpu::x64::avx512_core) && one_of(dst_prc_, ov::element::u8, ov::element::u16))
         count++;
 
     return count;
 }
 
-size_t jit_store_emitter::get_inputs_num() const { return 1; }
+size_t jit_store_emitter::get_inputs_num() const {
+    return 1;
+}
 
 void jit_store_emitter::emit_data() const {
     jit_emitter::emit_data();
@@ -676,7 +739,7 @@ void jit_store_emitter::emit_data() const {
         uni_vcvtneps2bf16_->emit_data();
 }
 
-void jit_store_emitter::emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const {
+void jit_store_emitter::emit_impl(const std::vector<size_t>& in_idxs, const std::vector<size_t>& out_idxs) const {
     // offset in store emitter is the offset of dst gpr register, should be parsed from out_idxs.
     const int offset = out_idxs.size() == 2 ? out_idxs[1] : 0;
     if (host_isa_ == cpu::x64::sse41) {
@@ -691,7 +754,7 @@ void jit_store_emitter::emit_impl(const std::vector<size_t> &in_idxs, const std:
 }
 
 template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-void jit_store_emitter::emit_isa(const int in_vec_idx, const Xbyak::Reg64 &reg_dst, const int offset) const {
+void jit_store_emitter::emit_isa(const int in_vec_idx, const Xbyak::Reg64& reg_dst, const int offset) const {
     bool matched_prc = (src_prc_ == dst_prc_) || (src_prc_ == ov::element::f32) || (src_prc_ == ov::element::i32);
     if (!matched_prc) {
         OV_CPU_JIT_EMITTER_THROW("only support input precision of FP32 or I32 or the same precision as output.");
@@ -707,29 +770,29 @@ void jit_store_emitter::emit_isa(const int in_vec_idx, const Xbyak::Reg64 &reg_d
     data_idx = in_vec_idx;
     data_reg_updated = false;
     if (!aux_vec_idxs.empty())
-        aux_src_idx = aux_vec_idxs.back(); // to avoid src pollution
+        aux_src_idx = aux_vec_idxs.back();  // to avoid src pollution
     if (src_prc_ != dst_prc_) {
         switch (src_prc_) {
-            case ov::element::f32:
-                if (!dst_prc_.is_real()) {
-                    if (is_saturation()) {
-                        h->uni_vcvtps2dq(Vmm(aux_src_idx), Vmm(data_idx));
-                    } else {
-                        h->uni_vcvttps2dq(Vmm(aux_src_idx), Vmm(data_idx));
-                    }
-                    data_idx = aux_src_idx;
-                    data_reg_updated = true;
-                }
-                break;
-            case ov::element::i32:
-                if (dst_prc_.is_real()) {
-                    h->uni_vcvtdq2ps(Vmm(aux_src_idx), Vmm(data_idx));
-                    data_idx = aux_src_idx;
-                    data_reg_updated = true;
+        case ov::element::f32:
+            if (!dst_prc_.is_real()) {
+                if (is_saturation()) {
+                    h->uni_vcvtps2dq(Vmm(aux_src_idx), Vmm(data_idx));
+                } else {
+                    h->uni_vcvttps2dq(Vmm(aux_src_idx), Vmm(data_idx));
                 }
-                break;
-            default:
-                break;
+                data_idx = aux_src_idx;
+                data_reg_updated = true;
+            }
+            break;
+        case ov::element::i32:
+            if (dst_prc_.is_real()) {
+                h->uni_vcvtdq2ps(Vmm(aux_src_idx), Vmm(data_idx));
+                data_idx = aux_src_idx;
+                data_reg_updated = true;
+            }
+            break;
+        default:
+            break;
         }
     }
 
@@ -737,44 +800,44 @@ void jit_store_emitter::emit_isa(const int in_vec_idx, const Xbyak::Reg64 &reg_d
         store_bytes<Vmm>(reg_dst, offset, store_size_);
     } else {
         switch (dst_prc_) {
-            case ov::element::f32:
-            case ov::element::i32:
-                store_bytes<Vmm>(reg_dst, offset, store_size_);
-                break;
-            case ov::element::i8:
-                store_dword_to_byte_extension<Vmm>(reg_dst, offset, true, store_num_);
-                break;
-            case ov::element::u8:
-                store_dword_to_byte_extension<Vmm>(reg_dst, offset, false, store_num_);
-                break;
-            case ov::element::i16:
-            case ov::element::u16:
-            case ov::element::bf16:
-            case ov::element::f16:
-                store_dword_to_word_extension<Vmm>(reg_dst, offset, dst_prc_, store_num_);
-                break;
-            default:
-                OV_CPU_JIT_EMITTER_THROW("has unsupported dst precision to store.");
+        case ov::element::f32:
+        case ov::element::i32:
+            store_bytes<Vmm>(reg_dst, offset, store_size_);
+            break;
+        case ov::element::i8:
+            store_dword_to_byte_extension<Vmm>(reg_dst, offset, true, store_num_);
+            break;
+        case ov::element::u8:
+            store_dword_to_byte_extension<Vmm>(reg_dst, offset, false, store_num_);
+            break;
+        case ov::element::i16:
+        case ov::element::u16:
+        case ov::element::bf16:
+        case ov::element::f16:
+            store_dword_to_word_extension<Vmm>(reg_dst, offset, dst_prc_, store_num_);
+            break;
+        default:
+            OV_CPU_JIT_EMITTER_THROW("has unsupported dst precision to store.");
         }
     }
 }
 /**
-* store_bytes is the utility function to facilitate storing of
-* store_size (0 <= store_size <= 64) many contiguous bytes from the Xmm/Ymm/Zmm
-* register into the memory referenced by ptr[reg + offset] address.
-*
-* Additionally, when store_size > 16, the input Ymm register will not be
-* preserved due to the usage of vextracti128 instruction.
-*
-* Functionally, invocation of store_bytes is equivalent
-* to the following loop:
-*
-* for (int idx = 0; idx < store_size; ++idx)
-*     vpextrb(ptr[reg + offset + idx], vmm, idx);
-*
-*/
+ * store_bytes is the utility function to facilitate storing of
+ * store_size (0 <= store_size <= 64) many contiguous bytes from the Xmm/Ymm/Zmm
+ * register into the memory referenced by ptr[reg + offset] address.
+ *
+ * Additionally, when store_size > 16, the input Ymm register will not be
+ * preserved due to the usage of vextracti128 instruction.
+ *
+ * Functionally, invocation of store_bytes is equivalent
+ * to the following loop:
+ *
+ * for (int idx = 0; idx < store_size; ++idx)
+ *     vpextrb(ptr[reg + offset + idx], vmm, idx);
+ *
+ */
 template <typename Vmm>
-void jit_store_emitter::store_bytes(const Xbyak::Reg64 &reg, int offset, int store_size) const {
+void jit_store_emitter::store_bytes(const Xbyak::Reg64& reg, int offset, int store_size) const {
     constexpr bool is_xmm = std::is_same<Vmm, Xbyak::Xmm>::value;
     constexpr bool is_ymm = std::is_same<Vmm, Xbyak::Ymm>::value;
     constexpr bool is_zmm = std::is_same<Vmm, Xbyak::Zmm>::value;
@@ -805,7 +868,7 @@ void jit_store_emitter::store_bytes(const Xbyak::Reg64 &reg, int offset, int sto
         int bytes_to_store = store_size;
 
         if (store_size > 32) {
-            h->uni_vmovdqu(addr(0), ymm); // store lower bits from zmm
+            h->uni_vmovdqu(addr(0), ymm);  // store lower bits from zmm
             start_bytes += 32;
             bytes_to_store -= 32;
             // load upper bits from zmm into ymm
@@ -813,7 +876,7 @@ void jit_store_emitter::store_bytes(const Xbyak::Reg64 &reg, int offset, int sto
         }
 
         if (bytes_to_store > 16) {
-            h->uni_vmovdqu(addr(start_bytes), xmm); // store lower bits from ymm
+            h->uni_vmovdqu(addr(start_bytes), xmm);  // store lower bits from ymm
             start_bytes += 16;
             bytes_to_store -= 16;
             // load upper bits from ymm into xmm
@@ -834,93 +897,108 @@ void jit_store_emitter::store_bytes(const Xbyak::Reg64 &reg, int offset, int sto
             h->mov(addr(start_bytes + bytes_offset), Reg8(gpr_idx, ext8bit));
         };
         switch (bytes_to_store) {
-            case 0: break;
-            case 1:
-                h->uni_vmovq(Reg64(aux_gpr_idxs[0]), xmm);
-                store_one_byte(0, aux_gpr_idxs[0]);
-                break;
-            case 2:
-                h->uni_vmovq(Reg64(aux_gpr_idxs[0]), xmm);
-                h->mov(addr(start_bytes), Reg16(aux_gpr_idxs[0]));
-                break;
-            case 3:
-                h->uni_vmovq(Reg64(aux_gpr_idxs[0]), xmm);
-                h->mov(addr(start_bytes), Reg16(aux_gpr_idxs[0]));
-                h->shr(Reg64(aux_gpr_idxs[0]), 16);
-                store_one_byte(2, aux_gpr_idxs[0]);
-                break;
-            case 4: h->uni_vmovss(addr(start_bytes), xmm); break;
-            case 5:
-                h->uni_vmovss(addr(start_bytes), xmm);
-                h->uni_vpextrb(addr(start_bytes + 4), xmm, 4);
-                break;
-            case 6:
-                h->uni_vmovss(addr(start_bytes), xmm);
-                h->uni_vpextrw(addr(start_bytes + 4), xmm, 2);
-                break;
-            case 7:
-                h->uni_vmovss(addr(start_bytes), xmm);
-                h->uni_vpextrw(addr(start_bytes + 4), xmm, 2);
-                h->uni_vpextrb(addr(start_bytes + 6), xmm, 6);
-                break;
-            case 8: break;
-            case 9: h->uni_vpextrb(addr(start_bytes + 8), xmm, 8); break;
-            case 10: h->uni_vpextrw(addr(start_bytes + 8), xmm, 4); break;
-            case 11:
-                h->uni_vpextrw(addr(start_bytes + 8), xmm, 4);
-                h->uni_vpextrb(addr(start_bytes + 10), xmm, 10);
-                break;
-            case 12: h->uni_vpextrd(addr(start_bytes + 8), xmm, 2); break;
-            case 13:
-                h->uni_vpextrd(addr(start_bytes + 8), xmm, 2);
-                h->uni_vpextrb(addr(start_bytes + 12), xmm, 12);
-                break;
-            case 14:
-                h->uni_vpextrd(addr(start_bytes + 8), xmm, 2);
-                h->uni_vpextrw(addr(start_bytes + 12), xmm, 6);
-                break;
-            case 15:
-                h->uni_vpextrd(addr(start_bytes + 8), xmm, 2);
-                h->uni_vpextrw(addr(start_bytes + 12), xmm, 6);
-                h->uni_vpextrb(addr(start_bytes + 14), xmm, 14);
-                break;
-            case 16: break;
-            default:
-                OV_CPU_JIT_EMITTER_THROW("has unexpected number of values to store in store_bytes.");
-        }
-    };
-
-    switch (store_size) {
-        case 64:
-            h->uni_vmovdqu(addr(0), zmm);
+        case 0:
+            break;
+        case 1:
+            h->uni_vmovq(Reg64(aux_gpr_idxs[0]), xmm);
+            store_one_byte(0, aux_gpr_idxs[0]);
+            break;
+        case 2:
+            h->uni_vmovq(Reg64(aux_gpr_idxs[0]), xmm);
+            h->mov(addr(start_bytes), Reg16(aux_gpr_idxs[0]));
+            break;
+        case 3:
+            h->uni_vmovq(Reg64(aux_gpr_idxs[0]), xmm);
+            h->mov(addr(start_bytes), Reg16(aux_gpr_idxs[0]));
+            h->shr(Reg64(aux_gpr_idxs[0]), 16);
+            store_one_byte(2, aux_gpr_idxs[0]);
+            break;
+        case 4:
+            h->uni_vmovss(addr(start_bytes), xmm);
+            break;
+        case 5:
+            h->uni_vmovss(addr(start_bytes), xmm);
+            h->uni_vpextrb(addr(start_bytes + 4), xmm, 4);
+            break;
+        case 6:
+            h->uni_vmovss(addr(start_bytes), xmm);
+            h->uni_vpextrw(addr(start_bytes + 4), xmm, 2);
+            break;
+        case 7:
+            h->uni_vmovss(addr(start_bytes), xmm);
+            h->uni_vpextrw(addr(start_bytes + 4), xmm, 2);
+            h->uni_vpextrb(addr(start_bytes + 6), xmm, 6);
+            break;
+        case 8:
             break;
-        case 32:
-            h->uni_vmovdqu(addr(0), ymm);
+        case 9:
+            h->uni_vpextrb(addr(start_bytes + 8), xmm, 8);
+            break;
+        case 10:
+            h->uni_vpextrw(addr(start_bytes + 8), xmm, 4);
+            break;
+        case 11:
+            h->uni_vpextrw(addr(start_bytes + 8), xmm, 4);
+            h->uni_vpextrb(addr(start_bytes + 10), xmm, 10);
+            break;
+        case 12:
+            h->uni_vpextrd(addr(start_bytes + 8), xmm, 2);
+            break;
+        case 13:
+            h->uni_vpextrd(addr(start_bytes + 8), xmm, 2);
+            h->uni_vpextrb(addr(start_bytes + 12), xmm, 12);
+            break;
+        case 14:
+            h->uni_vpextrd(addr(start_bytes + 8), xmm, 2);
+            h->uni_vpextrw(addr(start_bytes + 12), xmm, 6);
+            break;
+        case 15:
+            h->uni_vpextrd(addr(start_bytes + 8), xmm, 2);
+            h->uni_vpextrw(addr(start_bytes + 12), xmm, 6);
+            h->uni_vpextrb(addr(start_bytes + 14), xmm, 14);
             break;
         case 16:
-            h->uni_vmovdqu(addr(0), xmm);
             break;
         default:
-            if (mayiuse(cpu::x64::avx512_core) && store_size > threshold_for_mask_emu_store) {
-                uint64_t mask = 1;
-                mask = (mask << store_size) - mask;
-                h->mov(Reg64(aux_gpr_idxs[0]), mask);
-                h->kmovq(k_mask, Reg64(aux_gpr_idxs[0]));
-                h->vmovdqu8(addr(0), zmm | k_mask);
-            } else {
-                store_byte_base();
-            }
-            break;
+            OV_CPU_JIT_EMITTER_THROW("has unexpected number of values to store in store_bytes.");
+        }
+    };
+
+    switch (store_size) {
+    case 64:
+        h->uni_vmovdqu(addr(0), zmm);
+        break;
+    case 32:
+        h->uni_vmovdqu(addr(0), ymm);
+        break;
+    case 16:
+        h->uni_vmovdqu(addr(0), xmm);
+        break;
+    default:
+        if (mayiuse(cpu::x64::avx512_core) && store_size > threshold_for_mask_emu_store) {
+            uint64_t mask = 1;
+            mask = (mask << store_size) - mask;
+            h->mov(Reg64(aux_gpr_idxs[0]), mask);
+            h->kmovq(k_mask, Reg64(aux_gpr_idxs[0]));
+            h->vmovdqu8(addr(0), zmm | k_mask);
+        } else {
+            store_byte_base();
+        }
+        break;
     }
 }
 
 /**
-* store_dword_to_byte_extension is the utility function to
-* 1. convert store_num (0 <= store_num <= 16) dwords in the Xmm/Ymm/Zmm to store_num bytes, singed or unsinged, truncated or saturated.
-* 2. store the packed byte into the memory referenced by ptr[reg + offset] address.
-*/
+ * store_dword_to_byte_extension is the utility function to
+ * 1. convert store_num (0 <= store_num <= 16) dwords in the Xmm/Ymm/Zmm to store_num bytes, singed or unsinged,
+ * truncated or saturated.
+ * 2. store the packed byte into the memory referenced by ptr[reg + offset] address.
+ */
 template <typename Vmm>
-void jit_store_emitter::store_dword_to_byte_extension(const Xbyak::Reg64 &reg, int offset, bool is_signed, int store_num) const {
+void jit_store_emitter::store_dword_to_byte_extension(const Xbyak::Reg64& reg,
+                                                      int offset,
+                                                      bool is_signed,
+                                                      int store_num) const {
     constexpr bool is_xmm = std::is_same<Vmm, Xbyak::Xmm>::value;
     constexpr bool is_ymm = std::is_same<Vmm, Xbyak::Ymm>::value;
     constexpr bool is_zmm = std::is_same<Vmm, Xbyak::Zmm>::value;
@@ -1032,7 +1110,7 @@ void jit_store_emitter::store_dword_to_byte_extension(const Xbyak::Reg64 &reg, i
         break;
     case 4:
         if (mayiuse(cpu::x64::avx512_core)) {
-            if (is_saturation()) { // xmm block on avx512F + VL
+            if (is_saturation()) {  // xmm block on avx512F + VL
                 if (is_signed) {
                     h->vpmovsdb(addr(0), xmm);
                 } else {
@@ -1074,13 +1152,16 @@ void jit_store_emitter::store_dword_to_byte_extension(const Xbyak::Reg64 &reg, i
 }
 
 /**
-* store_dword_to_word_extension is the utility function to
-* 1. convert store_num (0 <= store_num <= 16) dwords in the Xmm/Ymm/Zmm to store_num words with singed or unsinged saturation.
-* 2. store the packed words into the memory referenced by ptr[reg + offset] address.
-*/
+ * store_dword_to_word_extension is the utility function to
+ * 1. convert store_num (0 <= store_num <= 16) dwords in the Xmm/Ymm/Zmm to store_num words with singed or unsinged
+ * saturation.
+ * 2. store the packed words into the memory referenced by ptr[reg + offset] address.
+ */
 template <typename Vmm>
-void jit_store_emitter::store_dword_to_word_extension(const Xbyak::Reg64 &reg,
-    int offset, ov::element::Type precision, int store_num) const {
+void jit_store_emitter::store_dword_to_word_extension(const Xbyak::Reg64& reg,
+                                                      int offset,
+                                                      ov::element::Type precision,
+                                                      int store_num) const {
     const bool is_bf16 = (precision == ov::element::bf16);
     const bool is_f16 = (precision == ov::element::f16);
     const bool is_signed = precision.is_signed();
@@ -1151,7 +1232,8 @@ void jit_store_emitter::store_dword_to_word_extension(const Xbyak::Reg64 &reg,
 
     if (is_bf16) {
         if (mayiuse(cpu::x64::avx512_core)) {
-            // to avoid src vmm pollution, this check means no precision convert happens, so data_idx is still original_data_idx.
+            // to avoid src vmm pollution, this check means no precision convert happens, so data_idx is still
+            // original_data_idx.
             if (src_prc_ == ov::element::f32) {
                 ymm = Ymm(aux_vec_idxs[0]);
             }
@@ -1171,7 +1253,8 @@ void jit_store_emitter::store_dword_to_word_extension(const Xbyak::Reg64 &reg,
             if (host_isa_ == cpu::x64::sse41 && src_prc_ == ov::element::f32) {
                 auto xmm_aux1 = Xmm(aux_vec_idxs[1]);
                 h->uni_vmovups(xmm_aux1, vmm);
-                uni_vcvtneps2bf16_->emit_code({static_cast<size_t>(vmm.getIdx())}, {static_cast<size_t>(vmm.getIdx())},
+                uni_vcvtneps2bf16_->emit_code({static_cast<size_t>(vmm.getIdx())},
+                                              {static_cast<size_t>(vmm.getIdx())},
                                               {static_cast<size_t>(xmm.getIdx())});
                 h->uni_vmovups(xmm, vmm);
                 h->uni_vmovups(vmm, xmm_aux1);  // return original data to src vmm
@@ -1222,7 +1305,7 @@ void jit_store_emitter::store_dword_to_word_extension(const Xbyak::Reg64 &reg,
                     Vmm zero(aux_vec_idxs[0]);
                     h->uni_vpxor(zero, zero, zero);
                     STORE_KEEP_SOURCE(uni_vpmaxsd, vmm, Vmm(aux_src_idx), vmm, zero);
-                    h->vpmovusdw(ptr[reg + offset], vmm); // unsinged int32 saturate to unsigned int16.
+                    h->vpmovusdw(ptr[reg + offset], vmm);  // unsinged int32 saturate to unsigned int16.
                 }
             } else {
                 h->vpmovdw(ptr[reg + offset], vmm);
@@ -1261,7 +1344,7 @@ void jit_store_emitter::store_dword_to_word_extension(const Xbyak::Reg64 &reg,
                     h->vpmovdw(ptr[reg + offset], xmm);
                 }
             } else {
-               store_dword_to_word_base();
+                store_dword_to_word_base();
             }
             break;
         default:
@@ -1297,5 +1380,5 @@ void jit_store_emitter::register_table_entries() {
     }
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.hpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.hpp
index 9570a836aa64ee..2c4e15ccaeb28b 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.hpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/jit_load_store_emitters.hpp
@@ -4,16 +4,23 @@
 
 #pragma once
 
-#include "jit_emitter.hpp"
 #include "jit_bf16_emitters.hpp"
+#include "jit_emitter.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
 struct load_emitter_params : public emitter_params {
-    load_emitter_params(ov::element::Type src_prc, ov::element::Type dst_prc,
-                        int load_num, bool is_fill = false, std::string fill_value = "zero"):
-        src_prc_(src_prc), dst_prc_(dst_prc), load_num_(load_num), is_fill_(is_fill), fill_value_(fill_value) {}
+    load_emitter_params(ov::element::Type src_prc,
+                        ov::element::Type dst_prc,
+                        int load_num,
+                        bool is_fill = false,
+                        std::string fill_value = "zero")
+        : src_prc_(src_prc),
+          dst_prc_(dst_prc),
+          load_num_(load_num),
+          is_fill_(is_fill),
+          fill_value_(fill_value) {}
 
     size_t hash() const override;
 
@@ -25,8 +32,10 @@ struct load_emitter_params : public emitter_params {
 };
 
 struct store_emitter_params : public emitter_params {
-    store_emitter_params(ov::element::Type src_prc, ov::element::Type dst_prc, int store_num):
-        src_prc_(src_prc), dst_prc_(dst_prc), store_num_(store_num) {}
+    store_emitter_params(ov::element::Type src_prc, ov::element::Type dst_prc, int store_num)
+        : src_prc_(src_prc),
+          dst_prc_(dst_prc),
+          store_num_(store_num) {}
 
     size_t hash() const override;
 
@@ -36,57 +45,61 @@ struct store_emitter_params : public emitter_params {
 };
 
 // Arithmetic modes for data type conversion in store_emitter
-enum arithmetic_mode {
-    saturation,
-    truncation
-};
+enum arithmetic_mode { saturation, truncation };
 
 class jit_load_emitter : public jit_emitter {
 public:
-    jit_load_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                     ov::element::Type src_prc, ov::element::Type dst_prc, int load_num,
+    jit_load_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                     dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                     ov::element::Type src_prc,
+                     ov::element::Type dst_prc,
+                     int load_num,
                      ov::element::Type exec_prc = ov::element::f32,
-                     bool is_fill = false, std::string fill_value = "zero",
+                     bool is_fill = false,
+                     std::string fill_value = "zero",
                      emitter_in_out_map in_out_type = emitter_in_out_map::gpr_to_vec);
     /**
-    * load_num values with src_prc precision are loaded from ptr[Reg64(in_idxs[0]) + offset_byte] address to Vmm[out_idxs[0]] as dst_prc, where offset_byte is in_idxs[1]
-    * is_fill: when load_num can not fully fit in vector register, whether fill_value should be filled as default values.
-    * fill_value: when load_num can not fully fit in vector register, what values should be filled as default values.
-    *   currently support "zero", "int_one", "float_one", "int32_min", "float_min", "int32_max" and "float_max".
-    * supported src_prc and dst_prc pairs are as below(x indicate for support):
-    *       FP32  I32   I16   U16   I8    U8    BF16  --> src_prc
-    * FP32   x     x     x     x     x    x     x
-    * I32    x     x     x     x     x    x     x
-    * I16                x
-    * U16                      x
-    * I8                             x
-    * U8                                  x
-    * BF16                                      x
-    *  |
-    * \|/
-    * dst_prc
-    */
+     * load_num values with src_prc precision are loaded from ptr[Reg64(in_idxs[0]) + offset_byte] address to
+     * Vmm[out_idxs[0]] as dst_prc, where offset_byte is in_idxs[1] is_fill: when load_num can not fully fit in vector
+     * register, whether fill_value should be filled as default values. fill_value: when load_num can not fully fit in
+     * vector register, what values should be filled as default values. currently support "zero", "int_one",
+     * "float_one", "int32_min", "float_min", "int32_max" and "float_max". supported src_prc and dst_prc pairs are as
+     * below(x indicate for support): FP32  I32   I16   U16   I8    U8    BF16  --> src_prc FP32   x     x     x     x
+     * x    x     x I32    x     x     x     x     x    x     x I16                x U16                      x I8 x U8
+     * x BF16                                      x
+     *  |
+     * \|/
+     * dst_prc
+     */
 
     // offset in load emitter is the offset of src gpr register, should be parsed from in_idxs.
-    void emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_idxs, const std::vector<size_t>& out_idxs) const override;
 
     size_t get_inputs_num() const override;
 
 private:
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const Xbyak::Reg64 &reg_src,  const int out_vec_idx, const int offset) const;
+    void emit_isa(const Xbyak::Reg64& reg_src, const int out_vec_idx, const int offset) const;
 
     template <typename Vmm>
-    void load_bytes(const Vmm &vmm, const Xbyak::Reg64 &reg, int offset, int load_size) const;
+    void load_bytes(const Vmm& vmm, const Xbyak::Reg64& reg, int offset, int load_size) const;
 
     template <typename Vmm>
-    void load_bytes_to_dword_extension(const Vmm &vmm, const Xbyak::Reg64 &reg, int offset, bool is_signed, int load_size) const;
+    void load_bytes_to_dword_extension(const Vmm& vmm,
+                                       const Xbyak::Reg64& reg,
+                                       int offset,
+                                       bool is_signed,
+                                       int load_size) const;
 
     template <typename Vmm>
-    void load_words_to_dword_extension(const Vmm &vmm, const Xbyak::Reg64 &reg, int offset, ov::element::Type prc, int load_size) const;
+    void load_words_to_dword_extension(const Vmm& vmm,
+                                       const Xbyak::Reg64& reg,
+                                       int offset,
+                                       ov::element::Type prc,
+                                       int load_size) const;
 
     template <typename Vmm>
-    void fill_with_default(const Vmm &vmm, std::string fill_value, const int &load_num) const;
+    void fill_with_default(const Vmm& vmm, std::string fill_value, const int& load_num) const;
 
     void register_table_entries() override;
 
@@ -104,30 +117,27 @@ class jit_load_emitter : public jit_emitter {
 
 class jit_store_emitter : public jit_emitter {
 public:
-    jit_store_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                      ov::element::Type src_prc, ov::element::Type dst_prc, int store_num,
+    jit_store_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                      dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                      ov::element::Type src_prc,
+                      ov::element::Type dst_prc,
+                      int store_num,
                       arithmetic_mode mode = arithmetic_mode::saturation,
                       ov::element::Type exec_prc = ov::element::f32,
                       emitter_in_out_map in_out_type = emitter_in_out_map::vec_to_gpr);
 
     /**
-    * store_num values with src_prc in Vmm[in_vec_idx] is stored to ptr[reg_dst + offset_byte] address as dst_prc data, where offset_byte is in_idxs[1]
-    * supported src_prc and dst_prc pairs are as below(x indicate for support):
-    *       FP32  I32   I16   U16   I8    U8    BF16  --> src_prc
-    * FP32   x     x
-    * I32    x     x
-    * I16    x     x     x
-    * U16    x     x           x
-    * I8     x     x                 x
-    * U8     x     x                       x
-    * BF16   x*    x*                             x
-    * \|/
-    * dst_prc
-    * note: FP32/I32-->BF16(x*) is supported only on at least avx512-core plateform
-    */
+     * store_num values with src_prc in Vmm[in_vec_idx] is stored to ptr[reg_dst + offset_byte] address as dst_prc data,
+     * where offset_byte is in_idxs[1] supported src_prc and dst_prc pairs are as below(x indicate for support): FP32
+     * I32   I16   U16   I8    U8    BF16  --> src_prc FP32   x     x I32    x     x I16    x     x     x U16    x     x
+     * x I8     x     x                 x U8     x     x                       x BF16   x*    x* x
+     * \|/
+     * dst_prc
+     * note: FP32/I32-->BF16(x*) is supported only on at least avx512-core plateform
+     */
 
     // offset in store emitter is the offset of dst gpr register, should be parsed from out_idxs.
-    void emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_idxs, const std::vector<size_t>& out_idxs) const override;
 
     size_t get_inputs_num() const override;
 
@@ -139,16 +149,19 @@ class jit_store_emitter : public jit_emitter {
 
 private:
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const int in_vec_idx,  const Xbyak::Reg64 &reg_dst, const int offset) const;
+    void emit_isa(const int in_vec_idx, const Xbyak::Reg64& reg_dst, const int offset) const;
 
     template <typename Vmm>
-    void store_bytes(const Xbyak::Reg64 &reg, int offset, int store_size) const;
+    void store_bytes(const Xbyak::Reg64& reg, int offset, int store_size) const;
 
     template <typename Vmm>
-    void store_dword_to_byte_extension(const Xbyak::Reg64 &reg, int offset, bool is_signed, int store_size) const;
+    void store_dword_to_byte_extension(const Xbyak::Reg64& reg, int offset, bool is_signed, int store_size) const;
 
     template <typename Vmm>
-    void store_dword_to_word_extension(const Xbyak::Reg64 &reg, int offset, ov::element::Type precision, int store_size) const;
+    void store_dword_to_word_extension(const Xbyak::Reg64& reg,
+                                       int offset,
+                                       ov::element::Type precision,
+                                       int store_size) const;
 
     void register_table_entries() override;
 
@@ -176,5 +189,5 @@ class jit_store_emitter : public jit_emitter {
     mutable int aux_src_idx = 0;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/utils.cpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/utils.cpp
index ea16122f2f9793..420e9691ebc73c 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/utils.cpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/utils.cpp
@@ -21,8 +21,21 @@ EmitABIRegSpills::~EmitABIRegSpills() {
 
 void EmitABIRegSpills::preamble() {
     // gprs
-    Xbyak::Operand gprs_to_save[] = {h->r8, h->r9, h->r10, h->r11, h->r12, h->r13, h->r14, h->r15,
-                                     h->rax, h->rbx, h->rcx, h->rdx, h->rdi, h->rsi, h->rbp};
+    Xbyak::Operand gprs_to_save[] = {h->r8,
+                                     h->r9,
+                                     h->r10,
+                                     h->r11,
+                                     h->r12,
+                                     h->r13,
+                                     h->r14,
+                                     h->r15,
+                                     h->rax,
+                                     h->rbx,
+                                     h->rcx,
+                                     h->rdx,
+                                     h->rdi,
+                                     h->rsi,
+                                     h->rbp};
     size_t n_gprs_to_save = sizeof(gprs_to_save) / sizeof(gprs_to_save[0]);
 
     h->sub(h->rsp, n_gprs_to_save * gpr_size);
@@ -75,8 +88,21 @@ void EmitABIRegSpills::postamble() {
     }
 
     // restore gpr registers
-    Xbyak::Operand gprs_to_save[] = {h->r8, h->r9, h->r10, h->r11, h->r12, h->r13, h->r14, h->r15,
-                                     h->rax, h->rbx, h->rcx, h->rdx, h->rdi, h->rsi, h->rbp};
+    Xbyak::Operand gprs_to_save[] = {h->r8,
+                                     h->r9,
+                                     h->r10,
+                                     h->r11,
+                                     h->r12,
+                                     h->r13,
+                                     h->r14,
+                                     h->r15,
+                                     h->rax,
+                                     h->rbx,
+                                     h->rcx,
+                                     h->rdx,
+                                     h->rdi,
+                                     h->rsi,
+                                     h->rbp};
     size_t n_gprs_to_save = sizeof(gprs_to_save) / sizeof(gprs_to_save[0]);
     for (int i = n_gprs_to_save - 1; i >= 0; --i)
         h->mov(gprs_to_save[i], h->ptr[h->rsp + i * gpr_size]);
@@ -113,13 +139,17 @@ void EmitABIRegSpills::rsp_restore() {
 cpu_isa_t EmitABIRegSpills::get_isa() {
     // need preserve based on cpu capability, instead of host isa.
     // in case there are possibilty that different isa emitters exist in one kernel from perf standpoint in the future.
-    // e.g. other emitters isa is avx512, while this emitter isa is avx2, and internal call is used. Internal call may use avx512 and spoil k-reg, ZMM.
-    // do not care about platform w/ avx512_common but w/o avx512_core(knight landing), which is obsoleted.
-    if (mayiuse(avx512_core)) return avx512_core;
-    if (mayiuse(avx2)) return avx2;
-    if (mayiuse(sse41)) return sse41;
+    // e.g. other emitters isa is avx512, while this emitter isa is avx2, and internal call is used. Internal call may
+    // use avx512 and spoil k-reg, ZMM. do not care about platform w/ avx512_common but w/o avx512_core(knight landing),
+    // which is obsoleted.
+    if (mayiuse(avx512_core))
+        return avx512_core;
+    if (mayiuse(avx2))
+        return avx2;
+    if (mayiuse(sse41))
+        return sse41;
     OV_CPU_JIT_EMITTER_THROW("unsupported isa");
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/plugin/x64/utils.hpp b/src/plugins/intel_cpu/src/emitters/plugin/x64/utils.hpp
index 16a66beba7a536..ba956f3375f054 100644
--- a/src/plugins/intel_cpu/src/emitters/plugin/x64/utils.hpp
+++ b/src/plugins/intel_cpu/src/emitters/plugin/x64/utils.hpp
@@ -30,11 +30,15 @@ class EmitABIRegSpills {
 
     static dnnl::impl::cpu::x64::cpu_isa_t get_isa();
 
-    inline size_t get_max_vecs_count() const { return dnnl::impl::cpu::x64::isa_num_vregs(isa); }
-    inline size_t get_vec_length() const { return dnnl::impl::cpu::x64::isa_max_vlen(isa); }
+    inline size_t get_max_vecs_count() const {
+        return dnnl::impl::cpu::x64::isa_num_vregs(isa);
+    }
+    inline size_t get_vec_length() const {
+        return dnnl::impl::cpu::x64::isa_max_vlen(isa);
+    }
 
-    dnnl::impl::cpu::x64::jit_generator* h {nullptr};
-    const dnnl::impl::cpu::x64::cpu_isa_t isa {dnnl::impl::cpu::x64::cpu_isa_t::isa_undef};
+    dnnl::impl::cpu::x64::jit_generator* h{nullptr};
+    const dnnl::impl::cpu::x64::cpu_isa_t isa{dnnl::impl::cpu::x64::cpu_isa_t::isa_undef};
 
     static constexpr int k_mask_size = 8;
     static constexpr int k_mask_num = 8;
@@ -44,5 +48,5 @@ class EmitABIRegSpills {
     bool rsp_status = true;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/cpu_kernel_executor_table.hpp b/src/plugins/intel_cpu/src/emitters/snippets/cpu_kernel_executor_table.hpp
index 79e8dcafb218f6..cfe03d21eac19e 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/cpu_kernel_executor_table.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/cpu_kernel_executor_table.hpp
@@ -4,34 +4,38 @@
 
 #pragma once
 
-#include "snippets/kernel_executor_table.hpp"
 #include "cache/multi_cache.h"
+#include "snippets/kernel_executor_table.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
-template<typename Conf, typename KernelType>
+template <typename Conf, typename KernelType>
 class CPUKernelExecutor : public snippets::KernelExecutor<Conf, KernelType> {
 public:
-     CPUKernelExecutor(ov::intel_cpu::MultiCacheWeakPtr kernel_cache, Conf c) :
-                       snippets::KernelExecutor<Conf, KernelType>(std::move(c)), m_kernel_cache(std::move(kernel_cache)) {}
+    CPUKernelExecutor(ov::intel_cpu::MultiCacheWeakPtr kernel_cache, Conf c)
+        : snippets::KernelExecutor<Conf, KernelType>(std::move(c)),
+          m_kernel_cache(std::move(kernel_cache)) {}
 
-    void update_kernel(const Conf& config, std::shared_ptr<KernelType>& kernel) const override final { // NOLINT
+    void update_kernel(const Conf& config, std::shared_ptr<KernelType>& kernel) const override final {  // NOLINT
         const auto& cache = m_kernel_cache.lock();
         OPENVINO_ASSERT(cache, "Invalid kernel cache pointer in CPUKernelExecutor::update_kernel()");
-        const auto& lookup_result = cache->getOrCreate(Key(config),
-                                                       [this](const Key& k) {
-                                                            return compile_kernel(k.config);
-                                                       });
+        const auto& lookup_result = cache->getOrCreate(Key(config), [this](const Key& k) {
+            return compile_kernel(k.config);
+        });
         kernel = lookup_result.first;
     }
 
 protected:
     struct Key {
         explicit Key(Conf c) : config{std::move(c)} {}
-        const  Conf config;
-        size_t hash() const { return config.hash(); }
-        bool operator==(const Key& rhs) const { return config == rhs.config; }
+        const Conf config;
+        size_t hash() const {
+            return config.hash();
+        }
+        bool operator==(const Key& rhs) const {
+            return config == rhs.config;
+        }
     };
     /** Compile kernel managed by KernelExecutor instance. Will be called only if Kernel is not found in the cache */
     virtual std::shared_ptr<KernelType> compile_kernel(const Conf& c) const = 0;
@@ -39,5 +43,5 @@ class CPUKernelExecutor : public snippets::KernelExecutor<Conf, KernelType> {
     ov::intel_cpu::MultiCacheWeakPtr m_kernel_cache;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.cpp b/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.cpp
index b2758735b2d27a..65741d7031d289 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.cpp
@@ -8,8 +8,8 @@
 #include "snippets/utils/utils.hpp"
 
 #ifndef OPENVINO_ARCH_ARM64
-#include "transformations/snippets/x64/pass/lowered/brgemm_copy_b_loop_ports_adjuster.hpp"
-#include "transformations/snippets/x64/pass/lowered/external_repacking_adjuster.hpp"
+#    include "transformations/snippets/x64/pass/lowered/brgemm_copy_b_loop_ports_adjuster.hpp"
+#    include "transformations/snippets/x64/pass/lowered/external_repacking_adjuster.hpp"
 #endif
 namespace ov {
 namespace intel_cpu {
@@ -21,7 +21,8 @@ const size_t CPURuntimeConfigurator::rank6D = 6;
 std::string CPURuntimeConfig::to_string() const {
     std::stringstream out;
     out << RuntimeConfig::to_string();
-    out << "Loop Parameters:" << "\n";
+    out << "Loop Parameters:"
+        << "\n";
     for (size_t i = 0; i < loop_args.size(); ++i) {
         const auto& loop = loop_args[i];
         out << "\t[" << i << "] WA: " << loop.m_work_amount << "\n";
@@ -38,8 +39,8 @@ std::string CPURuntimeConfig::to_string() const {
 }
 #endif
 
-CPURuntimeConfigurator::CPURuntimeConfigurator() : ov::snippets::RuntimeConfigurator(std::make_shared<CPURuntimeConfig>()) {
-}
+CPURuntimeConfigurator::CPURuntimeConfigurator()
+    : ov::snippets::RuntimeConfigurator(std::make_shared<CPURuntimeConfig>()) {}
 
 void CPURuntimeConfigurator::initialization(const ov::snippets::lowered::LinearIRCPtr& linear_ir) {
     RuntimeConfigurator::initialization(linear_ir);
@@ -78,12 +79,14 @@ void CPURuntimeConfigurator::update_loop_args(const ov::snippets::lowered::Linea
         const auto& data_sizes = loop_info->get_data_sizes();
 
         auto& loop_arg = cpu_config->loop_args[idx];
-        loop_arg = jit_snippets_call_args::loop_args_t(loop_info->get_work_amount(), loop_info->get_ptr_increments(), loop_info->get_finalization_offsets());
+        loop_arg = jit_snippets_call_args::loop_args_t(loop_info->get_work_amount(),
+                                                       loop_info->get_ptr_increments(),
+                                                       loop_info->get_finalization_offsets());
         for (int64_t i = 0; i < loop_arg.m_num_data_ptrs; ++i) {
             loop_arg.m_ptr_increments[i] *= (increment * data_sizes[i]);
             loop_arg.m_finalization_offsets[i] *= data_sizes[i];
         }
     }
 }
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.hpp b/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.hpp
index 42ce35a3c66c2b..1706670ce870d1 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/cpu_runtime_configurator.hpp
@@ -34,6 +34,7 @@ class CPURuntimeConfigurator : public ov::snippets::RuntimeConfigurator {
      * @param linear_ir LinearIR
      */
     void update_loop_args(const ov::snippets::lowered::LinearIRCPtr& linear_ir) const;
+
 protected:
     void update(const ov::snippets::lowered::LinearIRCPtr& linear_ir) override;
     void update_tensor_rank(const ov::snippets::VectorDims& master_shape) const override;
@@ -43,5 +44,5 @@ class CPURuntimeConfigurator : public ov::snippets::RuntimeConfigurator {
     static const size_t rank6D;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/jit_container_emitter.cpp b/src/plugins/intel_cpu/src/emitters/snippets/jit_container_emitter.cpp
index 6f78c43fd54797..ceee57f3c0cd28 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/jit_container_emitter.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/jit_container_emitter.cpp
@@ -3,15 +3,18 @@
 //
 
 #include "jit_container_emitter.hpp"
+
 #include "emitters/utils.hpp"
 #include "utils/general_utils.h"
 
 namespace ov {
 namespace intel_cpu {
 
-void jit_container_emitter::map_abstract_registers(mapping_info& gpr_map_pool, mapping_info& vec_map_pool,
+void jit_container_emitter::map_abstract_registers(mapping_info& gpr_map_pool,
+                                                   mapping_info& vec_map_pool,
                                                    snippets::lowered::LinearIR::container& expressions) const {
-    OV_CPU_JIT_EMITTER_ASSERT(!expressions.empty(), "Cannot map registers when there is no allocated_emitters provided");
+    OV_CPU_JIT_EMITTER_ASSERT(!expressions.empty(),
+                              "Cannot map registers when there is no allocated_emitters provided");
 
     auto map_regs = [&](const std::vector<snippets::Reg>& abstract_regs) {
         std::vector<snippets::Reg> physical_regs = abstract_regs;
@@ -19,13 +22,16 @@ void jit_container_emitter::map_abstract_registers(mapping_info& gpr_map_pool, m
             const auto& abstract_reg = abstract_regs[i];
             const auto& type = abstract_reg.type;
             const auto& abstract = abstract_reg.idx;
-            OV_CPU_JIT_EMITTER_ASSERT(one_of(type, snippets::RegType::gpr, snippets::RegType::vec), "Incorrect reg type detected!");
+            OV_CPU_JIT_EMITTER_ASSERT(one_of(type, snippets::RegType::gpr, snippets::RegType::vec),
+                                      "Incorrect reg type detected!");
             auto& mapping = type == snippets::RegType::gpr ? gpr_map_pool : vec_map_pool;
             auto& abstract_to_physical = mapping.first;
             auto& regs_pool = mapping.second;
             auto& physical = physical_regs[i];
             if (abstract_to_physical.count(abstract) == 0) {
-                OV_CPU_JIT_EMITTER_ASSERT(!regs_pool.empty(), "Cannot map registers for jit_container_emitter: not enough regs in the pool");
+                OV_CPU_JIT_EMITTER_ASSERT(
+                    !regs_pool.empty(),
+                    "Cannot map registers for jit_container_emitter: not enough regs in the pool");
                 physical.idx = regs_pool.back();
                 regs_pool.pop_back();
                 abstract_to_physical[abstract] = physical.idx;
@@ -48,5 +54,5 @@ void jit_container_emitter::map_abstract_registers(mapping_info& gpr_map_pool, m
     }
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/jit_container_emitter.hpp b/src/plugins/intel_cpu/src/emitters/snippets/jit_container_emitter.hpp
index 2325c6ef1a2eb3..7737e7e1150926 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/jit_container_emitter.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/jit_container_emitter.hpp
@@ -20,8 +20,10 @@ class jit_container_emitter {
 
 protected:
     // maps gpr and vec abstract registers to physical ones.
-    void map_abstract_registers(mapping_info& gpr_map_pool, mapping_info& vec_map_pool, snippets::lowered::LinearIR::container& expressions) const;
+    void map_abstract_registers(mapping_info& gpr_map_pool,
+                                mapping_info& vec_map_pool,
+                                snippets::lowered::LinearIR::container& expressions) const;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/jit_snippets_call_args.cpp b/src/plugins/intel_cpu/src/emitters/snippets/jit_snippets_call_args.cpp
index 48f98c2ffb2450..20e19bcba7e4f4 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/jit_snippets_call_args.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/jit_snippets_call_args.cpp
@@ -3,10 +3,11 @@
 //
 
 #include "jit_snippets_call_args.hpp"
-#include "emitters/utils.hpp"
 
 #include <cstring>
 
+#include "emitters/utils.hpp"
+
 namespace ov {
 namespace intel_cpu {
 
@@ -21,16 +22,19 @@ void jit_snippets_call_args::register_loops(const std::vector<loop_args_t>& loop
     std::copy(loops.begin(), loops.end(), loop_args);
 }
 
-jit_snippets_call_args::loop_args_t::loop_args_t(int64_t work_amount, const std::vector<int64_t>& ptr_increments,
+jit_snippets_call_args::loop_args_t::loop_args_t(int64_t work_amount,
+                                                 const std::vector<int64_t>& ptr_increments,
                                                  const std::vector<int64_t>& finalization_offsets)
     : m_work_amount(work_amount) {
-    OV_CPU_JIT_EMITTER_ASSERT(ptr_increments.size() == finalization_offsets.size(), "Inconsistent sizes of ptr_increments and finalization_offsets");
+    OV_CPU_JIT_EMITTER_ASSERT(ptr_increments.size() == finalization_offsets.size(),
+                              "Inconsistent sizes of ptr_increments and finalization_offsets");
     m_num_data_ptrs = static_cast<int64_t>(ptr_increments.size());
     init_pointers_and_copy_data(m_num_data_ptrs, ptr_increments.data(), finalization_offsets.data());
 }
 
 jit_snippets_call_args::loop_args_t::loop_args_t(const loop_args_t& other)
-    : m_work_amount(other.m_work_amount), m_num_data_ptrs(other.m_num_data_ptrs) {
+    : m_work_amount(other.m_work_amount),
+      m_num_data_ptrs(other.m_num_data_ptrs) {
     init_pointers_and_copy_data(m_num_data_ptrs, other.m_ptr_increments, other.m_finalization_offsets);
 }
 
@@ -44,7 +48,8 @@ jit_snippets_call_args::loop_args_t& jit_snippets_call_args::loop_args_t::operat
     return *this;
 }
 
-void jit_snippets_call_args::loop_args_t::init_pointers_and_copy_data(const int64_t num_elements, const int64_t* ptr_increments,
+void jit_snippets_call_args::loop_args_t::init_pointers_and_copy_data(const int64_t num_elements,
+                                                                      const int64_t* ptr_increments,
                                                                       const int64_t* finalization_offsets) {
     const size_t chunk_size = num_elements * sizeof(int64_t);
     m_ptr_increments = new int64_t[num_elements];
@@ -60,5 +65,5 @@ void swap(jit_snippets_call_args::loop_args_t& first, jit_snippets_call_args::lo
     std::swap(first.m_finalization_offsets, second.m_finalization_offsets);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/jit_snippets_call_args.hpp b/src/plugins/intel_cpu/src/emitters/snippets/jit_snippets_call_args.hpp
index 027655d493784d..eb74190dd71676 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/jit_snippets_call_args.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/jit_snippets_call_args.hpp
@@ -4,9 +4,9 @@
 
 #pragma once
 
-#include <vector>
-#include <cstdint>
 #include <cstddef>
+#include <cstdint>
+#include <vector>
 
 #include "dnnl_types.h"
 #include "openvino/core/visibility.hpp"
@@ -15,12 +15,12 @@ namespace ov {
 namespace intel_cpu {
 
 #if defined(OPENVINO_ARCH_ARM64)
-#define SNIPPETS_MAX_DATA_PTR_COUNT 23
+#    define SNIPPETS_MAX_DATA_PTR_COUNT 23
 #else
-#define SNIPPETS_MAX_DATA_PTR_COUNT 11
+#    define SNIPPETS_MAX_DATA_PTR_COUNT 11
 #endif
 
-#define GET_OFF(field) offsetof(jit_snippets_call_args, field)
+#define GET_OFF(field)           offsetof(jit_snippets_call_args, field)
 #define GET_OFF_LOOP_ARGS(field) offsetof(jit_snippets_call_args::loop_args_t, field)
 
 struct amx_tile_config_t {
@@ -37,9 +37,9 @@ struct jit_snippets_call_args {
 
     void register_loops(const std::vector<loop_args_t>& loops);
 
-    const void *src_ptrs[SNIPPETS_MAX_DATA_PTR_COUNT] = {};
-    void *dst_ptrs[SNIPPETS_MAX_DATA_PTR_COUNT] = {};
-    void *buffer_scratchpad_ptr = nullptr;
+    const void* src_ptrs[SNIPPETS_MAX_DATA_PTR_COUNT] = {};
+    void* dst_ptrs[SNIPPETS_MAX_DATA_PTR_COUNT] = {};
+    void* buffer_scratchpad_ptr = nullptr;
 
     // Note: Ideally loop_args must be private, since we manage this pointer manually.
     // However, standard-layout class definition (to use offset_of) requires the same access specifier
@@ -51,14 +51,18 @@ struct jit_snippets_call_args {
 
 struct jit_snippets_call_args::loop_args_t {
     loop_args_t() = default;
-    loop_args_t(int64_t work_amount, const std::vector<int64_t>& ptr_increments, const std::vector<int64_t>& finalization_offsets);
+    loop_args_t(int64_t work_amount,
+                const std::vector<int64_t>& ptr_increments,
+                const std::vector<int64_t>& finalization_offsets);
     loop_args_t(const loop_args_t& other);
     ~loop_args_t();
 
     loop_args_t& operator=(loop_args_t other);
     friend void swap(loop_args_t& first, loop_args_t& second);
 
-    void init_pointers_and_copy_data(const int64_t num_elements, const int64_t* ptr_increments, const int64_t* finalization_offsets);
+    void init_pointers_and_copy_data(const int64_t num_elements,
+                                     const int64_t* ptr_increments,
+                                     const int64_t* finalization_offsets);
 
     int64_t m_work_amount = 0;
     int64_t m_num_data_ptrs = 0;
@@ -71,5 +75,5 @@ struct jit_snippets_compile_args {
     std::vector<size_t> exec_domain = {};
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/utils/debug_caps_config.cpp b/src/plugins/intel_cpu/src/emitters/snippets/utils/debug_caps_config.cpp
index b7c51539861ff8..e4c3c40e1d8120 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/utils/debug_caps_config.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/utils/debug_caps_config.cpp
@@ -3,7 +3,7 @@
 //
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#include "debug_caps_config.hpp"
+#    include "debug_caps_config.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -20,7 +20,7 @@ void SnippetsDebugCapsConfig::readProperties() {
     enable_segfault_detector = readEnv("OV_CPU_SNIPPETS_SEGFAULT_DETECTOR") ? true : false;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
-#endif // SNIPPETS_DEBUG_CAPS
+#endif  // SNIPPETS_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/utils/debug_caps_config.hpp b/src/plugins/intel_cpu/src/emitters/snippets/utils/debug_caps_config.hpp
index 14dcae0ddf0c69..8f01e85063f5e9 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/utils/debug_caps_config.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/utils/debug_caps_config.hpp
@@ -3,10 +3,10 @@
 //
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#pragma once
+#    pragma once
 
-#include <string>
-#include <cstdlib>
+#    include <cstdlib>
+#    include <string>
 
 namespace ov {
 namespace intel_cpu {
@@ -23,7 +23,7 @@ class SnippetsDebugCapsConfig {
     void readProperties();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
-#endif // SNIPPETS_DEBUG_CAPS
+#endif  // SNIPPETS_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/cpu_generator.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/cpu_generator.cpp
index c210782db8f91c..39e384837856a1 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/cpu_generator.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/cpu_generator.cpp
@@ -4,63 +4,61 @@
 
 #include "cpu_generator.hpp"
 
-#include "snippets/snippets_isa.hpp"
-#include "emitters/snippets/cpu_runtime_configurator.hpp"
+#include <openvino/opsets/opset5.hpp>
 
+#include "emitters/plugin/x64/jit_conversion_emitters.hpp"
+#include "emitters/plugin/x64/jit_dnnl_emitters.hpp"
+#include "emitters/plugin/x64/jit_dnnl_ext_emitters.hpp"
+#include "emitters/plugin/x64/jit_eltwise_emitters.hpp"
+#include "emitters/snippets/cpu_kernel_executor_table.hpp"
+#include "emitters/snippets/cpu_runtime_configurator.hpp"
 #include "emitters/snippets/x64/jit_brgemm_copy_b_emitter.hpp"
 #include "emitters/snippets/x64/jit_brgemm_emitter.hpp"
-#include "emitters/snippets/x64/jit_memory_emitters.hpp"
+#include "emitters/snippets/x64/jit_fill_emitter.hpp"
+#include "emitters/snippets/x64/jit_horizon_emitter.hpp"
 #include "emitters/snippets/x64/jit_kernel_emitter.hpp"
 #include "emitters/snippets/x64/jit_loop_emitters.hpp"
+#include "emitters/snippets/x64/jit_memory_emitters.hpp"
 #include "emitters/snippets/x64/jit_snippets_emitters.hpp"
-#include "emitters/snippets/x64/jit_fill_emitter.hpp"
-#include "emitters/snippets/x64/jit_horizon_emitter.hpp"
-#include "emitters/plugin/x64/jit_eltwise_emitters.hpp"
-#include "emitters/plugin/x64/jit_dnnl_emitters.hpp"
-#include "emitters/plugin/x64/jit_dnnl_ext_emitters.hpp"
-#include "emitters/plugin/x64/jit_conversion_emitters.hpp"
-
-#include "transformations/snippets/x64/op/load_convert.hpp"
-#include "transformations/snippets/x64/op/store_convert.hpp"
+#include "snippets/snippets_isa.hpp"
+#include "transformations/cpu_opset/common/op/swish_cpu.hpp"
 #include "transformations/snippets/common/op/fused_mul_add.hpp"
 #include "transformations/snippets/x64/op/brgemm_copy_b.hpp"
 #include "transformations/snippets/x64/op/brgemm_cpu.hpp"
+#include "transformations/snippets/x64/op/load_convert.hpp"
 #include "transformations/snippets/x64/op/perf_count_rdtsc.hpp"
-#include "transformations/cpu_opset/common/op/swish_cpu.hpp"
+#include "transformations/snippets/x64/op/store_convert.hpp"
 #include "transformations/snippets/x64/pass/lowered/fuse_load_store_and_convert.hpp"
 
-#include <openvino/opsets/opset5.hpp>
-#include "emitters/snippets/cpu_kernel_executor_table.hpp"
-
 #ifdef SNIPPETS_DEBUG_CAPS
-#include "emitters/snippets/x64/jit_perf_count_chrono_emitters.hpp"
-#include "emitters/snippets/x64/jit_perf_count_rdtsc_emitters.hpp"
-#include "transformations/snippets/x64/op/perf_count_rdtsc.hpp"
-#include "emitters/snippets/x64/jit_debug_emitter.hpp"
-#include "emitters/snippets/x64/jit_segfault_detector_emitter.hpp"
-#include "emitters/snippets/x64/verbose.hpp"
+#    include "emitters/snippets/x64/jit_debug_emitter.hpp"
+#    include "emitters/snippets/x64/jit_perf_count_chrono_emitters.hpp"
+#    include "emitters/snippets/x64/jit_perf_count_rdtsc_emitters.hpp"
+#    include "emitters/snippets/x64/jit_segfault_detector_emitter.hpp"
+#    include "emitters/snippets/x64/verbose.hpp"
+#    include "transformations/snippets/x64/op/perf_count_rdtsc.hpp"
 #endif
 
 #ifdef SNIPPETS_LIBXSMM_TPP
-#include "transformations/tpp/x64/op/brgemm.hpp"
-#include "transformations/tpp/x64/op/eltwise.hpp"
-#include "transformations/tpp/x64/op/reduce.hpp"
-#include "transformations/tpp/x64/op/modifiers.hpp"
-#include "transformations/tpp/x64/op/scalar.hpp"
-#include "transformations/tpp/x64/op/equation.hpp"
-#include "emitters/tpp/x64/jit_eltwise_emitters.hpp"
-#include "emitters/tpp/x64/jit_brgemm_emitter.hpp"
-#include "emitters/tpp/x64/jit_scalar_emitter.hpp"
-#include "emitters/tpp/x64/jit_equation_emitter.hpp"
-#include "emitters/tpp/x64/jit_debug_emitter.hpp"
+#    include "emitters/tpp/x64/jit_brgemm_emitter.hpp"
+#    include "emitters/tpp/x64/jit_debug_emitter.hpp"
+#    include "emitters/tpp/x64/jit_eltwise_emitters.hpp"
+#    include "emitters/tpp/x64/jit_equation_emitter.hpp"
+#    include "emitters/tpp/x64/jit_scalar_emitter.hpp"
+#    include "transformations/tpp/x64/op/brgemm.hpp"
+#    include "transformations/tpp/x64/op/eltwise.hpp"
+#    include "transformations/tpp/x64/op/equation.hpp"
+#    include "transformations/tpp/x64/op/modifiers.hpp"
+#    include "transformations/tpp/x64/op/reduce.hpp"
+#    include "transformations/tpp/x64/op/scalar.hpp"
 // Note: for reference implementations
-#include <cmath>
+#    include <cmath>
 #endif
 
 namespace ov {
 
 #ifdef SNIPPETS_DEBUG_CAPS
-static bool is_load_emitter(const intel_cpu::jit_emitter *emitter) {
+static bool is_load_emitter(const intel_cpu::jit_emitter* emitter) {
     bool ret = false;
     if (dynamic_cast<const intel_cpu::jit_load_memory_emitter*>(emitter) ||
         dynamic_cast<const intel_cpu::jit_load_broadcast_emitter*>(emitter)) {
@@ -69,7 +67,7 @@ static bool is_load_emitter(const intel_cpu::jit_emitter *emitter) {
     return ret;
 }
 
-static bool is_store_emitter(const intel_cpu::jit_emitter *emitter) {
+static bool is_store_emitter(const intel_cpu::jit_emitter* emitter) {
     bool ret = false;
     if (dynamic_cast<const intel_cpu::jit_store_memory_emitter*>(emitter)) {
         return true;
@@ -77,72 +75,82 @@ static bool is_store_emitter(const intel_cpu::jit_emitter *emitter) {
     return ret;
 }
 
-static bool is_segfault_detector_emitter(const intel_cpu::jit_emitter *emitter) {
+static bool is_segfault_detector_emitter(const intel_cpu::jit_emitter* emitter) {
     // default active for typical tensor memory access emitters
     bool ret = false;
-    ret = is_load_emitter(emitter) ||
-        is_store_emitter(emitter) ||
-        dynamic_cast<const intel_cpu::jit_brgemm_emitter*>(emitter) ||
-        dynamic_cast<const intel_cpu::jit_brgemm_copy_b_emitter*>(emitter) ||
-        dynamic_cast<const intel_cpu::jit_kernel_emitter*>(emitter);
+    ret = is_load_emitter(emitter) || is_store_emitter(emitter) ||
+          dynamic_cast<const intel_cpu::jit_brgemm_emitter*>(emitter) ||
+          dynamic_cast<const intel_cpu::jit_brgemm_copy_b_emitter*>(emitter) ||
+          dynamic_cast<const intel_cpu::jit_kernel_emitter*>(emitter);
     return ret;
     // use below code to active all emitters for extend usage
     // return !dynamic_cast<const jit_nop_emitter*>(emitter);
 }
 
-#define CREATE_SNIPPETS_EMITTER(e_type, ...) { \
-    [this](const snippets::lowered::ExpressionPtr& expr) -> std::shared_ptr<snippets::Emitter> { \
-        auto emitter = std::make_shared<e_type>(h.get(), isa, expr, ##__VA_ARGS__); \
-        if (debug_config.enable_segfault_detector && is_segfault_detector_emitter(emitter.get())) { \
-            auto segfault_emitter = std::make_shared<jit_uni_segfault_detector_emitter>(h.get(), isa, emitter.get(), \
-                is_load_emitter(emitter.get()), is_store_emitter(emitter.get()), expr->get_node()->get_friendly_name()); \
-            return std::make_shared<jit_debug_emitter>(emitter, segfault_emitter, jit_debug_emitter::EmissionLocation::preamble); \
-        } else { \
-            return emitter; \
-        } \
-    }, \
-    [](const std::shared_ptr<ov::Node>& n) -> std::set<std::vector<element::Type>> { \
-        return e_type::get_supported_precisions(n); \
-    } \
-}
+#    define CREATE_SNIPPETS_EMITTER(e_type, ...)                                                                    \
+        {                                                                                                           \
+            [this](const snippets::lowered::ExpressionPtr& expr) -> std::shared_ptr<snippets::Emitter> {            \
+                auto emitter = std::make_shared<e_type>(h.get(), isa, expr, ##__VA_ARGS__);                         \
+                if (debug_config.enable_segfault_detector && is_segfault_detector_emitter(emitter.get())) {         \
+                    auto segfault_emitter =                                                                         \
+                        std::make_shared<jit_uni_segfault_detector_emitter>(h.get(),                                \
+                                                                            isa,                                    \
+                                                                            emitter.get(),                          \
+                                                                            is_load_emitter(emitter.get()),         \
+                                                                            is_store_emitter(emitter.get()),        \
+                                                                            expr->get_node()->get_friendly_name()); \
+                    return std::make_shared<jit_debug_emitter>(emitter,                                             \
+                                                               segfault_emitter,                                    \
+                                                               jit_debug_emitter::EmissionLocation::preamble);      \
+                } else {                                                                                            \
+                    return emitter;                                                                                 \
+                }                                                                                                   \
+            },                                                                                                      \
+                [](const std::shared_ptr<ov::Node>& n) -> std::set<std::vector<element::Type>> {                    \
+                    return e_type::get_supported_precisions(n);                                                     \
+                }                                                                                                   \
+        }
 #else
-#define CREATE_SNIPPETS_EMITTER(e_type, ...) { \
-    [this](const snippets::lowered::ExpressionPtr& expr) -> std::shared_ptr<snippets::Emitter> { \
-        return std::make_shared<e_type>(h.get(), isa, expr, ##__VA_ARGS__); \
-    }, \
-    [](const std::shared_ptr<ov::Node>& n) -> std::set<std::vector<element::Type>> { \
-        return e_type::get_supported_precisions(n); \
-    } \
-}
+#    define CREATE_SNIPPETS_EMITTER(e_type, ...)                                                         \
+        {                                                                                                \
+            [this](const snippets::lowered::ExpressionPtr& expr) -> std::shared_ptr<snippets::Emitter> { \
+                return std::make_shared<e_type>(h.get(), isa, expr, ##__VA_ARGS__);                      \
+            },                                                                                           \
+                [](const std::shared_ptr<ov::Node>& n) -> std::set<std::vector<element::Type>> {         \
+                    return e_type::get_supported_precisions(n);                                          \
+                }                                                                                        \
+        }
 #endif
 
-#define CREATE_DEBUG_TPP_EMITTER(e_type) { \
-    [this](const snippets::lowered::ExpressionPtr& expr) -> std::shared_ptr<snippets::Emitter> { \
-        return std::make_shared<DebugTppEmitter>(expr, std::make_shared<e_type>(h.get(), isa, expr)); \
-    }, \
-    [](const std::shared_ptr<ov::Node>& n) -> std::set<std::vector<element::Type>> { \
-        return e_type::get_supported_precisions(n); \
-    } \
-}
-
+#define CREATE_DEBUG_TPP_EMITTER(e_type)                                                                  \
+    {                                                                                                     \
+        [this](const snippets::lowered::ExpressionPtr& expr) -> std::shared_ptr<snippets::Emitter> {      \
+            return std::make_shared<DebugTppEmitter>(expr, std::make_shared<e_type>(h.get(), isa, expr)); \
+        },                                                                                                \
+            [](const std::shared_ptr<ov::Node>& n) -> std::set<std::vector<element::Type>> {              \
+                return e_type::get_supported_precisions(n);                                               \
+            }                                                                                             \
+    }
 
-#define CREATE_CPU_EMITTER(e_type) { \
-    [this](const snippets::lowered::ExpressionPtr& expr) -> std::shared_ptr<snippets::Emitter> { \
-        return std::make_shared<e_type>(h.get(), isa, expr->get_node()); \
-    }, \
-    [](const std::shared_ptr<ov::Node>& n) -> std::set<std::vector<element::Type>> { \
-        return e_type::get_supported_precisions(n); \
-    } \
-}
+#define CREATE_CPU_EMITTER(e_type)                                                                   \
+    {                                                                                                \
+        [this](const snippets::lowered::ExpressionPtr& expr) -> std::shared_ptr<snippets::Emitter> { \
+            return std::make_shared<e_type>(h.get(), isa, expr->get_node());                         \
+        },                                                                                           \
+            [](const std::shared_ptr<ov::Node>& n) -> std::set<std::vector<element::Type>> {         \
+                return e_type::get_supported_precisions(n);                                          \
+            }                                                                                        \
+    }
 
-#define CREATE_UNDEFINED_EMITTER(supported_precisions) { \
-    [](const snippets::lowered::ExpressionPtr& expr) -> std::shared_ptr<snippets::Emitter> { \
-        return nullptr; \
-    }, \
-    [](const std::shared_ptr<ov::Node>& n) -> std::set<std::vector<element::Type>> { \
-        return supported_precisions; \
-    } \
-}
+#define CREATE_UNDEFINED_EMITTER(supported_precisions)                                           \
+    {                                                                                            \
+        [](const snippets::lowered::ExpressionPtr& expr) -> std::shared_ptr<snippets::Emitter> { \
+            return nullptr;                                                                      \
+        },                                                                                       \
+            [](const std::shared_ptr<ov::Node>& n) -> std::set<std::vector<element::Type>> {     \
+                return supported_precisions;                                                     \
+            }                                                                                    \
+    }
 
 class jit_snippet : public dnnl::impl::cpu::x64::jit_generator {
 public:
@@ -157,30 +165,43 @@ class jit_snippet : public dnnl::impl::cpu::x64::jit_generator {
 
 intel_cpu::CPUTargetMachine::CPUTargetMachine(dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                                               ov::intel_cpu::MultiCacheWeakPtr cache)
-   : TargetMachine(std::make_shared<CPURuntimeConfigurator>()), h(new jit_snippet()), isa(host_isa), compiled_kernel_cache(std::move(cache)) {
+    : TargetMachine(std::make_shared<CPURuntimeConfigurator>()),
+      h(new jit_snippet()),
+      isa(host_isa),
+      compiled_kernel_cache(std::move(cache)) {
     // data movement
     jitters[op::v0::Parameter::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_nop_emitter);
     jitters[op::v0::Result::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_nop_emitter);
     jitters[snippets::op::Buffer::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_nop_emitter);
     jitters[snippets::op::VectorBuffer::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_nop_emitter);
-    jitters[snippets::op::RankNormalization::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_nop_emitter);
+    jitters[snippets::op::RankNormalization::get_type_info_static()] =
+        CREATE_SNIPPETS_EMITTER(intel_cpu::jit_nop_emitter);
     jitters[snippets::op::Reshape::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_nop_emitter);
 
     jitters[snippets::op::Load::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_load_memory_emitter);
-    jitters[snippets::op::LoadReshape::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_load_memory_emitter);
-    jitters[snippets::op::BroadcastLoad::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_load_broadcast_emitter);
-    jitters[intel_cpu::LoadConvertSaturation::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_load_memory_emitter);
-    jitters[intel_cpu::LoadConvertTruncation::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_load_memory_emitter);
+    jitters[snippets::op::LoadReshape::get_type_info_static()] =
+        CREATE_SNIPPETS_EMITTER(intel_cpu::jit_load_memory_emitter);
+    jitters[snippets::op::BroadcastLoad::get_type_info_static()] =
+        CREATE_SNIPPETS_EMITTER(intel_cpu::jit_load_broadcast_emitter);
+    jitters[intel_cpu::LoadConvertSaturation::get_type_info_static()] =
+        CREATE_SNIPPETS_EMITTER(intel_cpu::jit_load_memory_emitter);
+    jitters[intel_cpu::LoadConvertTruncation::get_type_info_static()] =
+        CREATE_SNIPPETS_EMITTER(intel_cpu::jit_load_memory_emitter);
 
     jitters[snippets::op::Store::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_store_memory_emitter);
-    jitters[intel_cpu::StoreConvertSaturation::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_store_memory_emitter);
-    jitters[intel_cpu::StoreConvertTruncation::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_store_memory_emitter);
+    jitters[intel_cpu::StoreConvertSaturation::get_type_info_static()] =
+        CREATE_SNIPPETS_EMITTER(intel_cpu::jit_store_memory_emitter);
+    jitters[intel_cpu::StoreConvertTruncation::get_type_info_static()] =
+        CREATE_SNIPPETS_EMITTER(intel_cpu::jit_store_memory_emitter);
 
     jitters[snippets::op::Scalar::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_scalar_emitter);
-    jitters[snippets::op::BroadcastMove::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_broadcast_move_emitter);
+    jitters[snippets::op::BroadcastMove::get_type_info_static()] =
+        CREATE_SNIPPETS_EMITTER(intel_cpu::jit_broadcast_move_emitter);
 
-    jitters[snippets::op::ConvertTruncation::get_type_info_static()] = CREATE_CPU_EMITTER(intel_cpu::jit_convert_truncation_emitter);
-    jitters[snippets::op::ConvertSaturation::get_type_info_static()] = CREATE_CPU_EMITTER(intel_cpu::jit_convert_saturation_emitter);
+    jitters[snippets::op::ConvertTruncation::get_type_info_static()] =
+        CREATE_CPU_EMITTER(intel_cpu::jit_convert_truncation_emitter);
+    jitters[snippets::op::ConvertSaturation::get_type_info_static()] =
+        CREATE_CPU_EMITTER(intel_cpu::jit_convert_saturation_emitter);
 
     // ternary
     jitters[op::v1::Select::get_type_info_static()] = CREATE_CPU_EMITTER(intel_cpu::jit_select_emitter);
@@ -203,10 +224,12 @@ intel_cpu::CPUTargetMachine::CPUTargetMachine(dnnl::impl::cpu::x64::cpu_isa_t ho
     jitters[op::v1::Mod::get_type_info_static()] = CREATE_CPU_EMITTER(intel_cpu::jit_mod_emitter);
     jitters[op::v1::Multiply::get_type_info_static()] = CREATE_CPU_EMITTER(intel_cpu::jit_multiply_emitter);
     jitters[op::v1::NotEqual::get_type_info_static()] = CREATE_CPU_EMITTER(intel_cpu::jit_not_equal_emitter);
-    jitters[snippets::op::PowerStatic::get_type_info_static()] = CREATE_CPU_EMITTER(intel_cpu::jit_power_static_emitter);
+    jitters[snippets::op::PowerStatic::get_type_info_static()] =
+        CREATE_CPU_EMITTER(intel_cpu::jit_power_static_emitter);
     jitters[op::v1::Power::get_type_info_static()] = CREATE_CPU_EMITTER(intel_cpu::jit_power_dynamic_emitter);
     jitters[op::v0::PRelu::get_type_info_static()] = CREATE_CPU_EMITTER(intel_cpu::jit_prelu_emitter);
-    jitters[op::v0::SquaredDifference::get_type_info_static()] = CREATE_CPU_EMITTER(intel_cpu::jit_squared_difference_emitter);
+    jitters[op::v0::SquaredDifference::get_type_info_static()] =
+        CREATE_CPU_EMITTER(intel_cpu::jit_squared_difference_emitter);
     jitters[op::v1::Subtract::get_type_info_static()] = CREATE_CPU_EMITTER(intel_cpu::jit_subtract_emitter);
     jitters[op::v0::Xor::get_type_info_static()] = CREATE_CPU_EMITTER(intel_cpu::jit_logical_xor_emitter);
 
@@ -235,25 +258,35 @@ intel_cpu::CPUTargetMachine::CPUTargetMachine(dnnl::impl::cpu::x64::cpu_isa_t ho
     jitters[snippets::op::HorizonMax::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_horizon_emitter);
     jitters[snippets::op::HorizonSum::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_horizon_emitter);
 
-    jitters[snippets::op::KernelStatic::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_kernel_static_emitter);
-    jitters[snippets::op::KernelDynamic::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_kernel_dynamic_emitter);
-    jitters[snippets::op::LoopBegin::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_loop_begin_emitter);
+    jitters[snippets::op::KernelStatic::get_type_info_static()] =
+        CREATE_SNIPPETS_EMITTER(intel_cpu::jit_kernel_static_emitter);
+    jitters[snippets::op::KernelDynamic::get_type_info_static()] =
+        CREATE_SNIPPETS_EMITTER(intel_cpu::jit_kernel_dynamic_emitter);
+    jitters[snippets::op::LoopBegin::get_type_info_static()] =
+        CREATE_SNIPPETS_EMITTER(intel_cpu::jit_loop_begin_emitter);
     jitters[snippets::op::LoopEnd::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_loop_end_emitter);
-    // Note: jit_brgemm_emitter and jit_brgemm_copy_b_emitter support runtime recompilation, so their constructor takes additional arguments
-    jitters[intel_cpu::BrgemmCPU::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_brgemm_emitter,
-                                                                                    configurator->get_kernel_executor_table(),
-                                                                                    compiled_kernel_cache);
-    jitters[intel_cpu::BrgemmCopyB::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(intel_cpu::jit_brgemm_copy_b_emitter,
-                                                                                      configurator->get_kernel_executor_table(),
-                                                                                      compiled_kernel_cache);
+    // Note: jit_brgemm_emitter and jit_brgemm_copy_b_emitter support runtime recompilation, so their constructor takes
+    // additional arguments
+    jitters[intel_cpu::BrgemmCPU::get_type_info_static()] =
+        CREATE_SNIPPETS_EMITTER(intel_cpu::jit_brgemm_emitter,
+                                configurator->get_kernel_executor_table(),
+                                compiled_kernel_cache);
+    jitters[intel_cpu::BrgemmCopyB::get_type_info_static()] =
+        CREATE_SNIPPETS_EMITTER(intel_cpu::jit_brgemm_copy_b_emitter,
+                                configurator->get_kernel_executor_table(),
+                                compiled_kernel_cache);
     jitters[snippets::op::ReduceMax::get_type_info_static()] = CREATE_UNDEFINED_EMITTER({{ov::element::f32}});
     jitters[snippets::op::ReduceSum::get_type_info_static()] = CREATE_UNDEFINED_EMITTER({{ov::element::f32}});
 
 #ifdef SNIPPETS_DEBUG_CAPS
-    jitters[snippets::op::PerfCountBegin::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_perf_count_chrono_start_emitter);
-    jitters[snippets::op::PerfCountEnd::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_perf_count_chrono_end_emitter);
-    jitters[ov::intel_cpu::PerfCountRdtscBegin::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_perf_count_rdtsc_start_emitter);
-    jitters[ov::intel_cpu::PerfCountRdtscEnd::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_perf_count_rdtsc_end_emitter);
+    jitters[snippets::op::PerfCountBegin::get_type_info_static()] =
+        CREATE_CPU_EMITTER(ov::intel_cpu::jit_perf_count_chrono_start_emitter);
+    jitters[snippets::op::PerfCountEnd::get_type_info_static()] =
+        CREATE_CPU_EMITTER(ov::intel_cpu::jit_perf_count_chrono_end_emitter);
+    jitters[ov::intel_cpu::PerfCountRdtscBegin::get_type_info_static()] =
+        CREATE_CPU_EMITTER(ov::intel_cpu::jit_perf_count_rdtsc_start_emitter);
+    jitters[ov::intel_cpu::PerfCountRdtscEnd::get_type_info_static()] =
+        CREATE_CPU_EMITTER(ov::intel_cpu::jit_perf_count_rdtsc_end_emitter);
 #endif
 
 #ifdef SNIPPETS_LIBXSMM_TPP
@@ -267,8 +300,8 @@ intel_cpu::CPUTargetMachine::CPUTargetMachine(dnnl::impl::cpu::x64::cpu_isa_t ho
     // Note: you can register Debug emitter for Unary/Binary operations as shown below:
     // jitters[intel_cpu::tpp::op::Add::get_type_info_static()] = CREATE_DEBUG_TPP_EMITTER(UnaryEltwiseTppEmitter);
     //
-    // Note: you can register Reference emitter for Unary operations using std::function or lambda function as shown below:
-    // jitters[intel_cpu::tpp::op::Exp::get_type_info_static()] =
+    // Note: you can register Reference emitter for Unary operations using std::function or lambda function as shown
+    // below: jitters[intel_cpu::tpp::op::Exp::get_type_info_static()] =
     //        CREATE_SNIPPETS_EMITTER(ReferenceUnaryEltwiseTppEmitter, static_cast<float(*)(float)>(std::exp));
     // jitters[intel_cpu::tpp::op::Reciprocal::get_type_info_static()] =
     //         CREATE_SNIPPETS_EMITTER(ReferenceUnaryEltwiseTppEmitter, [](float x){ return 1.f/x; });
@@ -292,10 +325,14 @@ std::shared_ptr<snippets::TargetMachine> intel_cpu::CPUTargetMachine::clone() co
 
 size_t intel_cpu::CPUTargetMachine::get_lanes() const {
     switch (isa) {
-        case dnnl::impl::cpu::x64::avx2 : return dnnl::impl::cpu::x64::cpu_isa_traits<dnnl::impl::cpu::x64::avx2>::vlen / sizeof(float);
-        case dnnl::impl::cpu::x64::sse41 : return dnnl::impl::cpu::x64::cpu_isa_traits<dnnl::impl::cpu::x64::sse41>::vlen / sizeof(float);
-        case dnnl::impl::cpu::x64::avx512_core : return dnnl::impl::cpu::x64::cpu_isa_traits<dnnl::impl::cpu::x64::avx512_core>::vlen / sizeof(float);
-        default : OPENVINO_THROW("unknown isa ", isa);
+    case dnnl::impl::cpu::x64::avx2:
+        return dnnl::impl::cpu::x64::cpu_isa_traits<dnnl::impl::cpu::x64::avx2>::vlen / sizeof(float);
+    case dnnl::impl::cpu::x64::sse41:
+        return dnnl::impl::cpu::x64::cpu_isa_traits<dnnl::impl::cpu::x64::sse41>::vlen / sizeof(float);
+    case dnnl::impl::cpu::x64::avx512_core:
+        return dnnl::impl::cpu::x64::cpu_isa_traits<dnnl::impl::cpu::x64::avx512_core>::vlen / sizeof(float);
+    default:
+        OPENVINO_THROW("unknown isa ", isa);
     }
 }
 
@@ -315,13 +352,15 @@ snippets::CompiledSnippetPtr intel_cpu::CPUTargetMachine::get_snippet() {
     if (h->create_kernel() != dnnl::impl::status::success) {
         OPENVINO_THROW("Failed to create jit_kernel in get_snippet()");
     }
-    const auto& result = std::make_shared<CompiledSnippetCPU>(std::unique_ptr<dnnl::impl::cpu::x64::jit_generator>(h.release()));
+    const auto& result =
+        std::make_shared<CompiledSnippetCPU>(std::unique_ptr<dnnl::impl::cpu::x64::jit_generator>(h.release()));
     // Note that we reset all the generated code, since it was copied into CompiledSnippetCPU
     h.reset(new jit_snippet());
     return result;
 }
 
-intel_cpu::CompiledSnippetCPU::CompiledSnippetCPU(std::unique_ptr<dnnl::impl::cpu::x64::jit_generator> h) : h_compiled(std::move(h)) {
+intel_cpu::CompiledSnippetCPU::CompiledSnippetCPU(std::unique_ptr<dnnl::impl::cpu::x64::jit_generator> h)
+    : h_compiled(std::move(h)) {
     OPENVINO_ASSERT(h_compiled && h_compiled->jit_ker(), "Got invalid jit generator or kernel was nopt compiled");
 }
 
@@ -337,15 +376,14 @@ bool intel_cpu::CompiledSnippetCPU::empty() const {
     return get_code_size() == 0;
 }
 
-intel_cpu::CPUGenerator::CPUGenerator(dnnl::impl::cpu::x64::cpu_isa_t isa_,  ov::intel_cpu::MultiCacheWeakPtr cache) :
-    Generator(std::make_shared<CPUTargetMachine>(isa_, std::move(cache))) {
-}
-intel_cpu::CPUGenerator::CPUGenerator(const std::shared_ptr<CPUTargetMachine>& target) : Generator(target) {
-}
+intel_cpu::CPUGenerator::CPUGenerator(dnnl::impl::cpu::x64::cpu_isa_t isa_, ov::intel_cpu::MultiCacheWeakPtr cache)
+    : Generator(std::make_shared<CPUTargetMachine>(isa_, std::move(cache))) {}
+intel_cpu::CPUGenerator::CPUGenerator(const std::shared_ptr<CPUTargetMachine>& target) : Generator(target) {}
 
 std::shared_ptr<snippets::Generator> intel_cpu::CPUGenerator::clone() const {
     const auto& cpu_target_machine = std::dynamic_pointer_cast<CPUTargetMachine>(target->clone());
-    OPENVINO_ASSERT(cpu_target_machine, "Failed to clone CPUGenerator: the instance contains incompatible TargetMachine type");
+    OPENVINO_ASSERT(cpu_target_machine,
+                    "Failed to clone CPUGenerator: the instance contains incompatible TargetMachine type");
     return std::make_shared<CPUGenerator>(cpu_target_machine);
 }
 
@@ -358,12 +396,11 @@ ov::snippets::RegType intel_cpu::CPUGenerator::get_specific_op_out_reg_type(cons
 #endif
         std::dynamic_pointer_cast<intel_cpu::BrgemmCopyB>(op))
         return ov::snippets::RegType::gpr;
-    else if (
-        std::dynamic_pointer_cast<intel_cpu::FusedMulAdd>(op) ||
-        std::dynamic_pointer_cast<intel_cpu::SwishNode>(op))
+    else if (std::dynamic_pointer_cast<intel_cpu::FusedMulAdd>(op) ||
+             std::dynamic_pointer_cast<intel_cpu::SwishNode>(op))
         return ov::snippets::RegType::vec;
     else
-       return ov::snippets::RegType::undefined;
+        return ov::snippets::RegType::undefined;
 }
 
 bool intel_cpu::CPUGenerator::uses_precompiled_kernel(const std::shared_ptr<snippets::Emitter>& e) const {
@@ -383,4 +420,4 @@ bool intel_cpu::CPUGenerator::uses_precompiled_kernel(const std::shared_ptr<snip
 #endif
     return need;
 }
-} // namespace ov
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/cpu_generator.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/cpu_generator.hpp
index 57cd931ab62063..a86f3050580ed4 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/cpu_generator.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/cpu_generator.hpp
@@ -4,17 +4,15 @@
 
 #pragma once
 
+#include "cache/multi_cache.h"
 #include "cpu/x64/jit_generator.hpp"
-
-#include "snippets/target_machine.hpp"
+#include "emitters/snippets/jit_snippets_call_args.hpp"
 #include "snippets/generator.hpp"
-#include "cache/multi_cache.h"
 #include "snippets/runtime_configurator.hpp"
-
-#include "emitters/snippets/jit_snippets_call_args.hpp"
+#include "snippets/target_machine.hpp"
 
 #ifdef SNIPPETS_DEBUG_CAPS
-#include "emitters/snippets/utils/debug_caps_config.hpp"
+#    include "emitters/snippets/utils/debug_caps_config.hpp"
 #endif
 
 namespace ov {
@@ -22,6 +20,7 @@ namespace intel_cpu {
 
 class CompiledSnippetCPU : public snippets::CompiledSnippet {
     const std::unique_ptr<const dnnl::impl::cpu::x64::jit_generator> h_compiled;
+
 public:
     const uint8_t* get_code() const override;
     size_t get_code_size() const override;
@@ -31,8 +30,7 @@ class CompiledSnippetCPU : public snippets::CompiledSnippet {
 
 class CPUTargetMachine : public snippets::TargetMachine {
 public:
-    explicit CPUTargetMachine(dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                              ov::intel_cpu::MultiCacheWeakPtr);
+    explicit CPUTargetMachine(dnnl::impl::cpu::x64::cpu_isa_t host_isa, ov::intel_cpu::MultiCacheWeakPtr);
     std::shared_ptr<snippets::TargetMachine> clone() const override;
     bool is_supported() const override;
     snippets::CompiledSnippetPtr get_snippet() override;
@@ -60,5 +58,5 @@ class CPUGenerator : public snippets::Generator {
     bool uses_precompiled_kernel(const std::shared_ptr<snippets::Emitter>& emitter) const override;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_copy_b_emitter.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_copy_b_emitter.cpp
index 53d8fea05a8adf..6df658d8d72d0c 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_copy_b_emitter.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_copy_b_emitter.cpp
@@ -4,18 +4,15 @@
 
 #include "jit_brgemm_copy_b_emitter.hpp"
 
+#include <cpu/x64/brgemm/brgemm.hpp>
+#include <cpu/x64/matmul/brgemm_matmul_utils.hpp>
+
 #include "emitters/plugin/x64/utils.hpp"
 #include "emitters/snippets/x64/utils.hpp"
-
-#include "snippets/utils/utils.hpp"
 #include "snippets/lowered/expression.hpp"
-
+#include "snippets/utils/utils.hpp"
 #include "transformations/snippets/x64/op/brgemm_cpu.hpp"
 
-#include <cpu/x64/brgemm/brgemm.hpp>
-#include <cpu/x64/matmul/brgemm_matmul_utils.hpp>
-
-
 using namespace Xbyak;
 using namespace dnnl::impl;
 using namespace dnnl::impl::cpu::x64;
@@ -34,7 +31,9 @@ bool get_is_transposed(const ov::snippets::lowered::ExpressionPtr& expr) {
 }
 }  // namespace
 
-jit_brgemm_copy_b_emitter::jit_brgemm_copy_b_emitter(jit_generator* h, cpu_isa_t isa, const ov::snippets::lowered::ExpressionPtr& expr,
+jit_brgemm_copy_b_emitter::jit_brgemm_copy_b_emitter(jit_generator* h,
+                                                     cpu_isa_t isa,
+                                                     const ov::snippets::lowered::ExpressionPtr& expr,
                                                      const snippets::KernelExecutorTablePtr& kernel_table,
                                                      const ov::intel_cpu::MultiCacheWeakPtr& compiled_kernel_cache)
     : jit_emitter(h, isa) {
@@ -57,17 +56,20 @@ jit_brgemm_copy_b_emitter::jit_brgemm_copy_b_emitter(jit_generator* h, cpu_isa_t
     m_with_comp = with_compensations(brgemm_type);
 
     BrgemmCopyBKernelConfig kernel_config(src_prc, wei_prc, primitive_isa, m_with_comp, is_transposed, wei_N_blk);
-    m_kernel_executor = kernel_table->register_kernel<BrgemmCopyBKernelExecutor>(expr, compiled_kernel_cache, kernel_config);
+    m_kernel_executor =
+        kernel_table->register_kernel<BrgemmCopyBKernelExecutor>(expr, compiled_kernel_cache, kernel_config);
 
     m_memory_offsets = {brgemm_repack->get_offset_in(), brgemm_repack->get_offset_out()};
-    m_buffer_ids = {utils::get_buffer_cluster_id(expr->get_input_port(0)), utils::get_buffer_cluster_id(expr->get_output_port(0))};
+    m_buffer_ids = {utils::get_buffer_cluster_id(expr->get_input_port(0)),
+                    utils::get_buffer_cluster_id(expr->get_output_port(0))};
     if (m_with_comp) {
         m_memory_offsets.push_back(brgemm_repack->get_offset_compensations());
         m_buffer_ids.push_back(utils::get_buffer_cluster_id(expr->get_output_port(1)));
     }
 }
 
-void jit_brgemm_copy_b_emitter::validate_arguments(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
+void jit_brgemm_copy_b_emitter::validate_arguments(const std::vector<size_t>& in,
+                                                   const std::vector<size_t>& out) const {
     OV_CPU_JIT_EMITTER_ASSERT(in.size() == 1, "expects 1 input");
     OV_CPU_JIT_EMITTER_ASSERT((m_with_comp && out.size() == 2) || (!m_with_comp && out.size() == 1),
                               "expects 2 outputs if there are compensations");
@@ -87,14 +89,20 @@ void jit_brgemm_copy_b_emitter::emit_impl(const std::vector<size_t>& in, const s
     // Reserve memory on the stack
     h->sub(h->rsp, reserved_stack_size);
 
-    const bool is_dynamic_case = std::any_of(m_memory_offsets.cbegin(), m_memory_offsets.cend(), ov::snippets::utils::is_dynamic_value<size_t>);
+    const bool is_dynamic_case =
+        std::any_of(m_memory_offsets.cbegin(), m_memory_offsets.cend(), ov::snippets::utils::is_dynamic_value<size_t>);
     Xbyak::Reg64 aux_reg = is_dynamic_case ? ov::intel_cpu::utils::get_aux_gpr(mem_ptrs_idxs) : Xbyak::Reg64();
 
-    const std::vector<size_t> args_offsets {GET_OFF_BRGEMM_COPY_B_ARGS(src), GET_OFF_BRGEMM_COPY_B_ARGS(tr_src), GET_OFF_BRGEMM_COPY_B_ARGS(compensation_ptr)};
+    const std::vector<size_t> args_offsets{GET_OFF_BRGEMM_COPY_B_ARGS(src),
+                                           GET_OFF_BRGEMM_COPY_B_ARGS(tr_src),
+                                           GET_OFF_BRGEMM_COPY_B_ARGS(compensation_ptr)};
     const auto& mem_ptrs = ov::intel_cpu::utils::transform_idxs_to_regs(mem_ptrs_idxs);
     for (size_t i = 0; i < mem_ptrs.size(); i++) {
         if (ov::snippets::utils::is_dynamic_value(m_memory_offsets[i]))
-            utils::push_ptr_with_runtime_offset_on_stack(h, args_offsets[i], mem_ptrs[i], aux_reg,
+            utils::push_ptr_with_runtime_offset_on_stack(h,
+                                                         args_offsets[i],
+                                                         mem_ptrs[i],
+                                                         aux_reg,
                                                          GET_OFF(buffer_offsets) + m_buffer_ids[i] * sizeof(size_t));
         else
             utils::push_ptr_with_static_offset_on_stack(h, args_offsets[i], mem_ptrs[i], m_memory_offsets[i]);
@@ -116,5 +124,5 @@ void jit_brgemm_copy_b_emitter::emit_impl(const std::vector<size_t>& in, const s
     spill.postamble();
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_copy_b_emitter.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_copy_b_emitter.hpp
index ef53efe6081217..96a80153bba4b6 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_copy_b_emitter.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_copy_b_emitter.hpp
@@ -5,38 +5,40 @@
 #pragma once
 
 #include "emitters/plugin/x64/jit_emitter.hpp"
-
 #include "kernel_executors/brgemm_copy_b.hpp"
 
-
 namespace ov {
 namespace intel_cpu {
 
 class jit_brgemm_copy_b_emitter : public jit_emitter {
 public:
-    jit_brgemm_copy_b_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+    jit_brgemm_copy_b_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                              dnnl::impl::cpu::x64::cpu_isa_t isa,
                               const ov::snippets::lowered::ExpressionPtr& expr,
                               const snippets::KernelExecutorTablePtr& kernel_table,
                               const ov::intel_cpu::MultiCacheWeakPtr& compiled_kernel_cache);
 
-    size_t get_inputs_num() const override {return 1;}
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr) {
+    size_t get_inputs_num() const override {
+        return 1;
+    }
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr) {
         return {{element::i8}, {element::bf16}, {element::f32}};
     }
 
 private:
-    void validate_arguments(const std::vector<size_t> &in, const std::vector<size_t> &out) const override;
+    void validate_arguments(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
 
     std::vector<size_t> m_memory_offsets{};
     std::vector<size_t> m_buffer_ids{};
-    std::shared_ptr<BrgemmCopyBKernelExecutor> m_kernel_executor {nullptr};
-    bool m_with_comp {false};
+    std::shared_ptr<BrgemmCopyBKernelExecutor> m_kernel_executor{nullptr};
+    bool m_with_comp{false};
 
 #ifdef SNIPPETS_DEBUG_CAPS
-    friend std::string init_info_jit_brgemm_copy_b_emitter(const jit_brgemm_copy_b_emitter *emitter);
+    friend std::string init_info_jit_brgemm_copy_b_emitter(const jit_brgemm_copy_b_emitter* emitter);
 #endif
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_emitter.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_emitter.cpp
index 6e70cbf2e8fe81..172a1cc0b98284 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_emitter.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_emitter.cpp
@@ -4,13 +4,12 @@
 
 #include "jit_brgemm_emitter.hpp"
 
-#include "transformations/snippets/x64/op/brgemm_cpu.hpp"
-#include "transformations/snippets/x64/op/brgemm_utils.hpp"
+#include "emitters/plugin/x64/utils.hpp"
 #include "emitters/snippets/x64/kernel_executors/brgemm.hpp"
 #include "emitters/snippets/x64/kernel_executors/brgemm_amx.hpp"
-#include "emitters/plugin/x64/utils.hpp"
-
 #include "snippets/utils/utils.hpp"
+#include "transformations/snippets/x64/op/brgemm_cpu.hpp"
+#include "transformations/snippets/x64/op/brgemm_utils.hpp"
 #include "utils.hpp"
 
 using namespace Xbyak;
@@ -20,11 +19,12 @@ using namespace dnnl::impl::cpu::x64;
 namespace ov {
 namespace intel_cpu {
 
-jit_brgemm_emitter::jit_brgemm_emitter(jit_generator* h, cpu_isa_t isa,
+jit_brgemm_emitter::jit_brgemm_emitter(jit_generator* h,
+                                       cpu_isa_t isa,
                                        const ov::snippets::lowered::ExpressionPtr& expr,
                                        const snippets::KernelExecutorTablePtr& kernel_table,
-                                       const ov::intel_cpu::MultiCacheWeakPtr& compiled_kernel_cache) :
-                                       jit_emitter(h, isa) {
+                                       const ov::intel_cpu::MultiCacheWeakPtr& compiled_kernel_cache)
+    : jit_emitter(h, isa) {
     in_out_type_ = emitter_in_out_map::gpr_to_gpr;
     const auto& brgemm_node = as_type_ptr<ov::intel_cpu::BrgemmCPU>(expr->get_node());
     const auto& brg0Prc = brgemm_node->get_input_element_type(0);
@@ -33,20 +33,26 @@ jit_brgemm_emitter::jit_brgemm_emitter(jit_generator* h, cpu_isa_t isa,
     m_is_with_amx = brgemm_utils::with_amx(brgemm_type);
     if (m_is_with_amx) {
         BrgemmAMXKernelConfig kernel_config(brg0Prc, brg1Prc, brgemm_utils::get_primitive_isa(brg0Prc, true));
-        m_kernel_executor = kernel_table->register_kernel<BrgemmAMXKernelExecutor>(expr, compiled_kernel_cache, kernel_config);
+        m_kernel_executor =
+            kernel_table->register_kernel<BrgemmAMXKernelExecutor>(expr, compiled_kernel_cache, kernel_config);
     } else {
-        BrgemmKernelConfig kernel_config(brg0Prc, brg1Prc, with_compensations(brgemm_type), brgemm_utils::get_primitive_isa(brg0Prc, false));
-        m_kernel_executor = kernel_table->register_kernel<BrgemmKernelExecutor>(expr, compiled_kernel_cache, kernel_config);
+        BrgemmKernelConfig kernel_config(brg0Prc,
+                                         brg1Prc,
+                                         with_compensations(brgemm_type),
+                                         brgemm_utils::get_primitive_isa(brg0Prc, false));
+        m_kernel_executor =
+            kernel_table->register_kernel<BrgemmKernelExecutor>(expr, compiled_kernel_cache, kernel_config);
     }
     // Note: even if the Brgemm node is dynamic, the first shapeInfer and RuntimeConfigurator::update()
     // are performed before the BrgemmKernelExecutor registration. So we have to trigger update() manually
     // for both static and the 1st dynamic shapes.
     OV_CPU_JIT_EMITTER_ASSERT(!snippets::utils::is_dynamic_vdims(expr->get_input_port_descriptor(0)->get_shape()) &&
-                              !snippets::utils::is_dynamic_vdims(expr->get_input_port_descriptor(1)->get_shape()),
+                                  !snippets::utils::is_dynamic_vdims(expr->get_input_port_descriptor(1)->get_shape()),
                               "Jit emitter is called when the shapes are unknown");
 
     m_memory_offsets = {brgemm_node->get_offset_a(), brgemm_node->get_offset_b(), brgemm_node->get_offset_c()};
-    m_buffer_ids = {utils::get_buffer_cluster_id(expr->get_input_port(0)), utils::get_buffer_cluster_id(expr->get_input_port(1)),
+    m_buffer_ids = {utils::get_buffer_cluster_id(expr->get_input_port(0)),
+                    utils::get_buffer_cluster_id(expr->get_input_port(1)),
                     utils::get_buffer_cluster_id(expr->get_output_port(0))};
     if (with_scratchpad(brgemm_type)) {
         m_memory_offsets.push_back(brgemm_node->get_offset_scratch());
@@ -54,7 +60,8 @@ jit_brgemm_emitter::jit_brgemm_emitter(jit_generator* h, cpu_isa_t isa,
     }
 }
 
-std::set<std::vector<element::Type>> jit_brgemm_emitter::get_supported_precisions(const std::shared_ptr<ov::Node>& node) {
+std::set<std::vector<element::Type>> jit_brgemm_emitter::get_supported_precisions(
+    const std::shared_ptr<ov::Node>& node) {
     const auto brgemm = as_type_ptr<ov::intel_cpu::BrgemmCPU>(node);
     OV_CPU_JIT_EMITTER_ASSERT(brgemm, "get_supported_precisions() expects BrgemmCPU node");
     using brgemm_utils::BRGEMM_TYPE;
@@ -77,7 +84,7 @@ std::set<std::vector<element::Type>> jit_brgemm_emitter::get_supported_precision
     OV_CPU_JIT_EMITTER_THROW("got BrgemmCPU node with unsupported type");
 }
 
-void jit_brgemm_emitter::validate_arguments(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
+void jit_brgemm_emitter::validate_arguments(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
     OV_CPU_JIT_EMITTER_ASSERT(m_memory_offsets.size() == in.size() + 1 && (out.size() == 1),
                               "expects 3 inputs if there are compensations/wsp");
 }
@@ -96,8 +103,7 @@ void jit_brgemm_emitter::emit_impl(const std::vector<size_t>& in, const std::vec
         OV_CPU_JIT_EMITTER_THROW("uknown execuor type");
 }
 
-template<typename T,
-         typename std::enable_if<std::is_base_of<BrgemmBaseKernelExecutor, T>::value, bool>::type>
+template <typename T, typename std::enable_if<std::is_base_of<BrgemmBaseKernelExecutor, T>::value, bool>::type>
 void jit_brgemm_emitter::emit_call(const std::vector<size_t>& mem_ptrs_idxs) const {
     EmitABIRegSpills spill(h);
     spill.preamble();
@@ -107,17 +113,24 @@ void jit_brgemm_emitter::emit_call(const std::vector<size_t>& mem_ptrs_idxs) con
     // Reserve memory on the stack
     h->sub(h->rsp, reserved_stack_size);
 
-    const bool is_dynamic_case = std::any_of(m_memory_offsets.cbegin(), m_memory_offsets.cend(), ov::snippets::utils::is_dynamic_value<size_t>);
+    const bool is_dynamic_case =
+        std::any_of(m_memory_offsets.cbegin(), m_memory_offsets.cend(), ov::snippets::utils::is_dynamic_value<size_t>);
     Xbyak::Reg64 aux_reg = is_dynamic_case ? ov::intel_cpu::utils::get_aux_gpr(mem_ptrs_idxs) : Xbyak::Reg64();
 
 #define GET_OFF_CALL_ARGS(field) offsetof(typename T::call_args, field)
-    const std::vector<size_t> brgemm_args_offsets = { GET_OFF_CALL_ARGS(A), GET_OFF_CALL_ARGS(B), GET_OFF_CALL_ARGS(C), GET_OFF_CALL_ARGS(scratch) };
+    const std::vector<size_t> brgemm_args_offsets = {GET_OFF_CALL_ARGS(A),
+                                                     GET_OFF_CALL_ARGS(B),
+                                                     GET_OFF_CALL_ARGS(C),
+                                                     GET_OFF_CALL_ARGS(scratch)};
 #undef GET_OFF_CALL_ARGS
 
     const auto& mem_ptrs = utils::transform_idxs_to_regs(mem_ptrs_idxs);
     for (size_t i = 0; i < mem_ptrs.size(); i++) {
         if (ov::snippets::utils::is_dynamic_value(m_memory_offsets[i]))
-            utils::push_ptr_with_runtime_offset_on_stack(h, brgemm_args_offsets[i], mem_ptrs[i], aux_reg,
+            utils::push_ptr_with_runtime_offset_on_stack(h,
+                                                         brgemm_args_offsets[i],
+                                                         mem_ptrs[i],
+                                                         aux_reg,
                                                          GET_OFF(buffer_offsets) + m_buffer_ids[i] * sizeof(size_t));
         else
             utils::push_ptr_with_static_offset_on_stack(h, brgemm_args_offsets[i], mem_ptrs[i], m_memory_offsets[i]);
@@ -145,5 +158,5 @@ void jit_brgemm_emitter::emit_call(const std::vector<size_t>& mem_ptrs_idxs) con
     spill.postamble();
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_emitter.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_emitter.hpp
index ccec1b68b18b20..9d072065c0fe52 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_emitter.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_brgemm_emitter.hpp
@@ -12,34 +12,39 @@ namespace intel_cpu {
 
 class jit_brgemm_emitter : public jit_emitter {
 public:
-    jit_brgemm_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+    jit_brgemm_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                       dnnl::impl::cpu::x64::cpu_isa_t isa,
                        const ov::snippets::lowered::ExpressionPtr& expr,
                        const snippets::KernelExecutorTablePtr& kernel_table,
                        const ov::intel_cpu::MultiCacheWeakPtr& compiled_kernel_cache);
 
-    size_t get_inputs_num() const override { return m_memory_offsets.size() - 1; }
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr);
+    size_t get_inputs_num() const override {
+        return m_memory_offsets.size() - 1;
+    }
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr);
 
 private:
-    void validate_arguments(const std::vector<size_t> &in, const std::vector<size_t> &out) const override;
+    void validate_arguments(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
 
     template <typename T,
               typename std::enable_if<std::is_base_of<BrgemmBaseKernelExecutor, T>::value, bool>::type = true>
     void emit_call(const std::vector<size_t>& mem_ptrs_idxs) const;
 
-    // Note: offsets order: A, B, C (+ scratchpad, if needed). Values can be dynamic_value if offset is calculated in runtime
+    // Note: offsets order: A, B, C (+ scratchpad, if needed). Values can be dynamic_value if offset is calculated in
+    // runtime
     std::vector<size_t> m_memory_offsets{};
     // Note: cluster ids order: A, B, C (+ scratchpad, if needed). Values can be dynamic_value if there is no buffer
     std::vector<size_t> m_buffer_ids{};
     std::shared_ptr<BrgemmBaseKernelExecutor> m_kernel_executor = nullptr;
 
 #ifdef SNIPPETS_DEBUG_CAPS
-    friend std::string init_info_jit_brgemm_emitter(const jit_brgemm_emitter *emitter);
+    friend std::string init_info_jit_brgemm_emitter(const jit_brgemm_emitter* emitter);
 #endif
 
-    bool m_is_with_amx {false};
+    bool m_is_with_amx{false};
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_debug_emitter.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_debug_emitter.cpp
index 05b9d15786157b..45ebfc83899dba 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_debug_emitter.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_debug_emitter.cpp
@@ -4,9 +4,11 @@
 
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#include "jit_debug_emitter.hpp"
-#include <vector>
-#include "utils/general_utils.h"
+#    include "jit_debug_emitter.hpp"
+
+#    include <vector>
+
+#    include "utils/general_utils.h"
 
 using namespace dnnl::impl::cpu;
 using namespace dnnl::impl;
@@ -27,8 +29,10 @@ size_t jit_debug_emitter::aux_gprs_count() const {
     return m_target_emitter->aux_gprs_count();
 }
 
-void jit_debug_emitter::emitter_preamble(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs,
-                                   const std::vector<size_t> &pool_vec_idxs, const std::vector<size_t> &pool_gpr_idxs) const {
+void jit_debug_emitter::emitter_preamble(const std::vector<size_t>& in_idxs,
+                                         const std::vector<size_t>& out_idxs,
+                                         const std::vector<size_t>& pool_vec_idxs,
+                                         const std::vector<size_t>& pool_gpr_idxs) const {
     m_target_emitter->emitter_preamble(in_idxs, out_idxs, pool_vec_idxs, pool_gpr_idxs);
 }
 
@@ -52,12 +56,14 @@ void jit_debug_emitter::register_table_entries() {
     m_target_emitter->register_table_entries();
 }
 
-void jit_debug_emitter::emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const {
+void jit_debug_emitter::emit_impl(const std::vector<size_t>& in_idxs, const std::vector<size_t>& out_idxs) const {
     m_target_emitter->emit_impl(in_idxs, out_idxs);
 }
 
-void jit_debug_emitter::emit_code(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs,
-                            const std::vector<size_t> &pool_vec_idxs, const std::vector<size_t> &pool_gpr_idxs) const {
+void jit_debug_emitter::emit_code(const std::vector<size_t>& in_idxs,
+                                  const std::vector<size_t>& out_idxs,
+                                  const std::vector<size_t>& pool_vec_idxs,
+                                  const std::vector<size_t>& pool_gpr_idxs) const {
     if (m_decorator_emit_loc == EmissionLocation::preamble || m_decorator_emit_loc == EmissionLocation::both)
         m_decorator_emitter->emit_code(in_idxs, out_idxs, pool_vec_idxs, pool_gpr_idxs);
 
@@ -67,7 +73,7 @@ void jit_debug_emitter::emit_code(const std::vector<size_t> &in_idxs, const std:
         m_decorator_emitter->emit_code(in_idxs, out_idxs, pool_vec_idxs, pool_gpr_idxs);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
 #endif
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_debug_emitter.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_debug_emitter.hpp
index fe7cc527418587..2591af119cc3b5 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_debug_emitter.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_debug_emitter.hpp
@@ -4,29 +4,33 @@
 
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#pragma once
-
-#include "emitters/plugin/x64/jit_emitter.hpp"
+#    pragma once
 
+#    include "emitters/plugin/x64/jit_emitter.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
 class jit_debug_emitter : public jit_emitter {
 public:
-    enum class EmissionLocation {
-        preamble,
-        postamble,
-        both
-    };
-    jit_debug_emitter(const std::shared_ptr<jit_emitter>& target_emitter, const std::shared_ptr<jit_emitter>& decorator_emitter, const EmissionLocation& loc)
-        : jit_emitter(target_emitter->h, target_emitter->host_isa_, target_emitter->exec_prc_, target_emitter->in_out_type_),
-        m_target_emitter(target_emitter), m_decorator_emitter(decorator_emitter), m_decorator_emit_loc(loc) {
-            prepare_table();
-        }
-
-    void emit_code(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs,
-                   const std::vector<size_t> &pool_vec_idxs = {}, const std::vector<size_t> &pool_gpr_idxs = {}) const override;
+    enum class EmissionLocation { preamble, postamble, both };
+    jit_debug_emitter(const std::shared_ptr<jit_emitter>& target_emitter,
+                      const std::shared_ptr<jit_emitter>& decorator_emitter,
+                      const EmissionLocation& loc)
+        : jit_emitter(target_emitter->h,
+                      target_emitter->host_isa_,
+                      target_emitter->exec_prc_,
+                      target_emitter->in_out_type_),
+          m_target_emitter(target_emitter),
+          m_decorator_emitter(decorator_emitter),
+          m_decorator_emit_loc(loc) {
+        prepare_table();
+    }
+
+    void emit_code(const std::vector<size_t>& in_idxs,
+                   const std::vector<size_t>& out_idxs,
+                   const std::vector<size_t>& pool_vec_idxs = {},
+                   const std::vector<size_t>& pool_gpr_idxs = {}) const override;
     void emit_data() const override;
 
     size_t get_inputs_num() const override;
@@ -38,10 +42,12 @@ class jit_debug_emitter : public jit_emitter {
     void prepare_table() override;
     void register_table_entries() override;
 
-    void emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_idxs, const std::vector<size_t>& out_idxs) const override;
 
-    void emitter_preamble(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs,
-                          const std::vector<size_t> &pool_vec_idxs, const std::vector<size_t> &pool_gpr_idxs) const override;
+    void emitter_preamble(const std::vector<size_t>& in_idxs,
+                          const std::vector<size_t>& out_idxs,
+                          const std::vector<size_t>& pool_vec_idxs,
+                          const std::vector<size_t>& pool_gpr_idxs) const override;
     void emitter_postamble() const override;
 
 private:
@@ -54,7 +60,7 @@ class jit_debug_emitter : public jit_emitter {
     EmissionLocation m_decorator_emit_loc;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
 #endif
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_fill_emitter.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_fill_emitter.cpp
index 1c05100317ae5f..687917acbabc5a 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_fill_emitter.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_fill_emitter.cpp
@@ -4,16 +4,15 @@
 
 #include "jit_fill_emitter.hpp"
 
-
 using namespace Xbyak;
 using namespace dnnl::impl;
 using namespace dnnl::impl::cpu::x64;
 
-
 namespace ov {
 namespace intel_cpu {
 
-jit_fill_emitter::jit_fill_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+jit_fill_emitter::jit_fill_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                                   dnnl::impl::cpu::x64::cpu_isa_t isa,
                                    const ov::snippets::lowered::ExpressionPtr& expr)
     : jit_emitter(h, isa, ov::element::f32, emitter_in_out_map::vec_to_vec) {
     const auto fill = ov::as_type_ptr<snippets::op::Fill>(expr->get_node());
@@ -52,9 +51,9 @@ void jit_fill_emitter::emit_impl(const std::vector<size_t>& in, const std::vecto
 }
 
 template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-void jit_fill_emitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
-    using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,
-            Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
+void jit_fill_emitter::emit_isa(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
+    using Vmm = typename dnnl::impl::utils::
+        conditional3<isa == dnnl::impl::cpu::x64::sse41, Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
 
     Vmm src_vmm = Vmm(in[0]);
     Vmm dst_vmm = Vmm(out[0]);
@@ -62,7 +61,8 @@ void jit_fill_emitter::emit_isa(const std::vector<size_t> &in, const std::vector
     const size_t supported_et_size = 4;
     const auto register_capacity = (src_vmm.getBit() / 8) / supported_et_size;
     if (offset == register_capacity) {
-        // WA: since AssignRegisters doesn't support inplace logic, Fill ops with offset = register_capacity can't be removed from the LIR
+        // WA: since AssignRegisters doesn't support inplace logic, Fill ops with offset = register_capacity can't be
+        // removed from the LIR
         // TODO: when inplace is supported, remove such Fill ops from the LIR and remove this logic.
         // Ticket: 126270
         if (src_vmm.getIdx() != dst_vmm.getIdx())
@@ -105,5 +105,5 @@ void jit_fill_emitter::fill_tail(const Vmm& src_vmm, const Vmm& dst_vmm) const {
     }
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_fill_emitter.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_fill_emitter.hpp
index 79e9a0e4027a5d..23b929cc161ca7 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_fill_emitter.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_fill_emitter.hpp
@@ -6,15 +6,18 @@
 
 #include "emitters/plugin/x64/jit_emitter.hpp"
 
-
 namespace ov {
 namespace intel_cpu {
 
 class jit_fill_emitter : public jit_emitter {
 public:
-    jit_fill_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const ov::snippets::lowered::ExpressionPtr& expr);
+    jit_fill_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                     dnnl::impl::cpu::x64::cpu_isa_t isa,
+                     const ov::snippets::lowered::ExpressionPtr& expr);
 
-    size_t get_inputs_num() const override {return 1;}
+    size_t get_inputs_num() const override {
+        return 1;
+    }
 
 protected:
     size_t aux_gprs_count() const override;
@@ -23,18 +26,22 @@ class jit_fill_emitter : public jit_emitter {
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const;
+    void emit_isa(const std::vector<size_t>& in, const std::vector<size_t>& out) const;
     template <typename Vmm>
     void fill_full(const Vmm& vmm_dst) const;
     template <typename Vmm>
     void fill_tail(const Vmm& vmm_src, const Vmm& vmm_dst) const;
 
-    bool is_full_reg() const { return offset == 0; }
-    bool is_optimized() const { return is_full_reg() && fill_value == uint32_t(0x0); }
+    bool is_full_reg() const {
+        return offset == 0;
+    }
+    bool is_optimized() const {
+        return is_full_reg() && fill_value == uint32_t(0x0);
+    }
 
     size_t offset = 0;
     uint32_t fill_value = 0x0;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_horizon_emitter.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_horizon_emitter.cpp
index a4f5cbe16d7e1f..34e9c2f71fd148 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_horizon_emitter.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_horizon_emitter.cpp
@@ -4,7 +4,6 @@
 
 #include "jit_horizon_emitter.hpp"
 
-
 using namespace Xbyak;
 using namespace dnnl::impl;
 using namespace dnnl::impl::cpu::x64;
@@ -12,7 +11,8 @@ using namespace dnnl::impl::cpu::x64;
 namespace ov {
 namespace intel_cpu {
 
-jit_horizon_emitter::jit_horizon_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+jit_horizon_emitter::jit_horizon_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                                         dnnl::impl::cpu::x64::cpu_isa_t isa,
                                          const ov::snippets::lowered::ExpressionPtr& expr)
     : jit_emitter(h, isa, ov::element::f32, emitter_in_out_map::vec_to_vec) {
     if (ov::is_type<const snippets::op::HorizonMax>(expr->get_node())) {
@@ -24,8 +24,7 @@ jit_horizon_emitter::jit_horizon_emitter(dnnl::impl::cpu::x64::jit_generator* h,
     }
 }
 
-void jit_horizon_emitter::emit_impl(const std::vector<size_t>& in,
-                                    const std::vector<size_t>& out) const {
+void jit_horizon_emitter::emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
     if (host_isa_ == dnnl::impl::cpu::x64::sse41) {
         emit_isa<dnnl::impl::cpu::x64::sse41>(in, out);
     } else if (host_isa_ == dnnl::impl::cpu::x64::avx2) {
@@ -38,9 +37,12 @@ void jit_horizon_emitter::emit_impl(const std::vector<size_t>& in,
 }
 
 template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-void jit_horizon_emitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
+void jit_horizon_emitter::emit_isa(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
     using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,
-            Xbyak::Xmm, isa == dnnl::impl::cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
+                                                         Xbyak::Xmm,
+                                                         isa == dnnl::impl::cpu::x64::avx2,
+                                                         Xbyak::Ymm,
+                                                         Xbyak::Zmm>::type;
 
     Vmm src_vmm = Vmm(in[0]);
     Vmm dst_vmm = Vmm(out[0]);
@@ -67,19 +69,19 @@ void jit_horizon_emitter::emit_isa(const std::vector<size_t> &in, const std::vec
     perform_op<Xbyak::Xmm>(dst_vmm, dst_vmm, aux_vmm);
 }
 
-template<typename Vmm>
-void jit_horizon_emitter::perform_op(const Vmm &vmm1, const Vmm &vmm2, const Vmm &vmm3) const {
+template <typename Vmm>
+void jit_horizon_emitter::perform_op(const Vmm& vmm1, const Vmm& vmm2, const Vmm& vmm3) const {
     switch (m_op_type) {
-        case OpType::max:
-            h->uni_vmaxps(vmm1, vmm2, vmm3);
-            break;
-        case OpType::sum:
-            h->uni_vaddps(vmm1, vmm2, vmm3);
-            break;
-        default:
-            OV_CPU_JIT_EMITTER_THROW("Unsupported horizontal operation.");
+    case OpType::max:
+        h->uni_vmaxps(vmm1, vmm2, vmm3);
+        break;
+    case OpType::sum:
+        h->uni_vaddps(vmm1, vmm2, vmm3);
+        break;
+    default:
+        OV_CPU_JIT_EMITTER_THROW("Unsupported horizontal operation.");
     }
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_horizon_emitter.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_horizon_emitter.hpp
index 1b222cb2a86776..df74b2ad9783a4 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_horizon_emitter.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_horizon_emitter.hpp
@@ -6,34 +6,40 @@
 
 #include "emitters/plugin/x64/jit_emitter.hpp"
 
-
 namespace ov {
 namespace intel_cpu {
 
 class jit_horizon_emitter : public jit_emitter {
 public:
-    jit_horizon_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const ov::snippets::lowered::ExpressionPtr& expr);
+    jit_horizon_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                        dnnl::impl::cpu::x64::cpu_isa_t isa,
+                        const ov::snippets::lowered::ExpressionPtr& expr);
 
-    size_t get_inputs_num() const override {return 1;}
-    static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ov::Node>& node = nullptr) {
+    size_t get_inputs_num() const override {
+        return 1;
+    }
+    static std::set<std::vector<element::Type>> get_supported_precisions(
+        const std::shared_ptr<ov::Node>& node = nullptr) {
         return {{element::f32}};
     }
 
 protected:
-    size_t aux_vecs_count() const override {return 1;}
+    size_t aux_vecs_count() const override {
+        return 1;
+    }
 
 private:
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const;
+    void emit_isa(const std::vector<size_t>& in, const std::vector<size_t>& out) const;
 
-    template<typename Vmm>
-    void perform_op(const Vmm &vmm1, const Vmm &vmm2, const Vmm &vmm3) const;
+    template <typename Vmm>
+    void perform_op(const Vmm& vmm1, const Vmm& vmm2, const Vmm& vmm3) const;
 
     enum class OpType { max, sum };
     OpType m_op_type = OpType::max;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_kernel_emitter.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_kernel_emitter.cpp
index 476123355abe70..bd5a3227e1e125 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_kernel_emitter.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_kernel_emitter.cpp
@@ -14,8 +14,11 @@ using namespace dnnl::impl::cpu::x64;
 namespace ov {
 namespace intel_cpu {
 
-jit_kernel_emitter::jit_kernel_emitter(jit_generator* h, cpu_isa_t isa, const ov::snippets::lowered::ExpressionPtr& expr)
-    : jit_emitter(h, isa), reg_runtime_params_idx(abi_param1.getIdx()) {
+jit_kernel_emitter::jit_kernel_emitter(jit_generator* h,
+                                       cpu_isa_t isa,
+                                       const ov::snippets::lowered::ExpressionPtr& expr)
+    : jit_emitter(h, isa),
+      reg_runtime_params_idx(abi_param1.getIdx()) {
     const auto kernel = ov::as_type_ptr<snippets::op::Kernel>(expr->get_node());
     OV_CPU_JIT_EMITTER_ASSERT(kernel != nullptr, "invoked with invalid op argument");
     OV_CPU_JIT_EMITTER_ASSERT(!kernel->region->empty(), "invoked with empty body");
@@ -59,8 +62,12 @@ void jit_kernel_emitter::init_reg_pools(const std::set<size_t>& gpr_blacklist, c
         gp_regs_pool[i] = vec_regs_pool[i] = 15 - i;
     auto remove_regs_from_pool = [](std::vector<size_t>& pool, const std::set<size_t>& to_remove) {
         // It's important to keep the order of other elements
-        pool.erase(std::remove_if(pool.begin(), pool.end(),
-                                  [&](size_t x) {return to_remove.count(x) != 0;}), pool.end());
+        pool.erase(std::remove_if(pool.begin(),
+                                  pool.end(),
+                                  [&](size_t x) {
+                                      return to_remove.count(x) != 0;
+                                  }),
+                   pool.end());
     };
     // Reserve stack base and pointer for push(...) and pop(...) operations
     std::set<size_t> gprs_blacklist_extended{Xbyak::Operand::RSP, Xbyak::Operand::RBP};
@@ -70,25 +77,31 @@ void jit_kernel_emitter::init_reg_pools(const std::set<size_t>& gpr_blacklist, c
     remove_regs_from_pool(vec_regs_pool, vec_blacklist);
 }
 
-void jit_kernel_emitter::emit_code(const std::vector<size_t> &in, const std::vector<size_t> &out,
-                                   const std::vector<size_t> &pool_vec_idxs, const std::vector<size_t> &pool_gpr_idxs) const {
+void jit_kernel_emitter::emit_code(const std::vector<size_t>& in,
+                                   const std::vector<size_t>& out,
+                                   const std::vector<size_t>& pool_vec_idxs,
+                                   const std::vector<size_t>& pool_gpr_idxs) const {
     validate_arguments(in, out);
     emit_impl(in, out);
 }
 
-void jit_kernel_emitter::validate_arguments(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
+void jit_kernel_emitter::validate_arguments(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
     OV_CPU_JIT_EMITTER_ASSERT(in.empty() && out.empty(), ": expects 0 registers on input and output");
     const auto num_params = num_inputs + num_outputs + num_unique_buffers;
     // The number of used gpr may be >= num_params since LoopBegin+LoopEnd could also use gpr to store work_amount
     OV_CPU_JIT_EMITTER_ASSERT(data_ptr_regs_idx.size() == num_params,
-                              "number of inputs and outputs is inconsistent with the number of allocated registers ", num_params,
-                              " data_ptr_regs_idx.size() = ", data_ptr_regs_idx.size());
+                              "number of inputs and outputs is inconsistent with the number of allocated registers ",
+                              num_params,
+                              " data_ptr_regs_idx.size() = ",
+                              data_ptr_regs_idx.size());
 }
 
 void jit_kernel_emitter::init_body_regs(const std::set<size_t>& kernel_regs,
-                                        const std::vector<size_t> &pool_vec_idxs, const std::vector<size_t> &pool_gpr_idxs) {
+                                        const std::vector<size_t>& pool_vec_idxs,
+                                        const std::vector<size_t>& pool_gpr_idxs) {
     // Initialize pools of gp and vec registers
-    // Reserve kernel regs (abi_param1 and, if there is, abi_param2), since they'll be used to pass runtime call args to kernel
+    // Reserve kernel regs (abi_param1 and, if there is, abi_param2), since they'll be used to pass runtime call args to
+    // kernel
     init_reg_pools(kernel_regs, {});
 
     mapping_info gpr_map_pool({}, gp_regs_pool);
@@ -122,9 +135,11 @@ void jit_kernel_emitter::emit_impl(const std::vector<size_t>& in, const std::vec
     h->postamble();
 }
 
-jit_kernel_static_emitter::jit_kernel_static_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+jit_kernel_static_emitter::jit_kernel_static_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                                                     dnnl::impl::cpu::x64::cpu_isa_t isa,
                                                      const ov::snippets::lowered::ExpressionPtr& expr)
-    : jit_kernel_emitter(h, isa, expr), reg_indexes_idx(abi_param2.getIdx()) {
+    : jit_kernel_emitter(h, isa, expr),
+      reg_indexes_idx(abi_param2.getIdx()) {
     const auto kernel = ov::as_type_ptr<snippets::op::KernelStatic>(expr->get_node());
     OV_CPU_JIT_EMITTER_ASSERT(kernel != nullptr, "expectes KernelStatic expression");
     jcp = *reinterpret_cast<const jit_snippets_compile_args*>(kernel->compile_params);
@@ -158,12 +173,12 @@ void jit_kernel_static_emitter::init_data_pointers(const std::vector<Xbyak::Reg6
             }
         }
     };
-    const auto spare_corruptable_gpr = std::find_if(gp_regs_pool.begin(), gp_regs_pool.end(),
-                                                   [this](size_t reg) {
-                                                        return reg != reg_indexes_idx && reg != reg_runtime_params_idx;
-                                                   });
+    const auto spare_corruptable_gpr = std::find_if(gp_regs_pool.begin(), gp_regs_pool.end(), [this](size_t reg) {
+        return reg != reg_indexes_idx && reg != reg_runtime_params_idx;
+    });
     const bool last_iter_explicitly = spare_corruptable_gpr == gp_regs_pool.end();
-    Reg64 reg_tmp = last_iter_explicitly ? data_ptr_regs[num_params - 1] : Reg64(static_cast<int>(*spare_corruptable_gpr));
+    Reg64 reg_tmp =
+        last_iter_explicitly ? data_ptr_regs[num_params - 1] : Reg64(static_cast<int>(*spare_corruptable_gpr));
     // Vector "data_ptr_regs" is sorted by abstract regs.
     // It means that the vector contains the physical registers in order [src, .., src, dst, .., dst, buffer]
     // So we can initialize buffer register firstly as last value of vector "data_ptr_regs"
@@ -193,13 +208,15 @@ void jit_kernel_static_emitter::init_data_pointers(const std::vector<Xbyak::Reg6
     }
 }
 
-jit_kernel_dynamic_emitter::jit_kernel_dynamic_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+jit_kernel_dynamic_emitter::jit_kernel_dynamic_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                                                       dnnl::impl::cpu::x64::cpu_isa_t isa,
                                                        const ov::snippets::lowered::ExpressionPtr& expr)
     : jit_kernel_emitter(h, isa, expr) {
     const auto kernel = ov::as_type_ptr<snippets::op::KernelDynamic>(expr->get_node());
     OV_CPU_JIT_EMITTER_ASSERT(kernel, "expectes KernelDynamic expression");
 
-    // - Reserve abi_param1, since it wll be used to pass runtime call args to all dynamic emitters that needs runtime args
+    // - Reserve abi_param1, since it wll be used to pass runtime call args to all dynamic emitters that needs runtime
+    // args
     // - We cannot assign this register to the body emitters since runtime params MUST be valid during whole execution
     //   for all dynamic emitters
     init_body_regs({reg_runtime_params_idx});
@@ -220,5 +237,5 @@ void jit_kernel_dynamic_emitter::init_data_pointers(const std::vector<Xbyak::Reg
     }
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_kernel_emitter.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_kernel_emitter.hpp
index b297b033566f9f..68ea6684cbcd17 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_kernel_emitter.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_kernel_emitter.hpp
@@ -5,10 +5,8 @@
 #pragma once
 
 #include "emitters/plugin/x64/jit_emitter.hpp"
-
-#include "emitters/snippets/jit_snippets_call_args.hpp"
 #include "emitters/snippets/jit_container_emitter.hpp"
-
+#include "emitters/snippets/jit_snippets_call_args.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -16,8 +14,9 @@ namespace intel_cpu {
 ///
 /// \brief    Kernel is the only entry point to Codogen Jit compilation. Kernel perform abstract-to-physical register
 /// mapping and creates a pools of available gpr and vec registers. Kernel usually contains (at least one)
-/// jit_loop_begin_emitter and jit_loop_end_emitter pair. In general the enclosed emitters should be organized in the following way:
-/// jit_kernel_emitter {                 /* entry point, maps registers, creates pools of available registers */
+/// jit_loop_begin_emitter and jit_loop_end_emitter pair. In general the enclosed emitters should be organized in the
+/// following way: jit_kernel_emitter {                 /* entry point, maps registers, creates pools of available
+/// registers */
 ///     1.S jit_loop_begin_emitter        /* Scalar Loop over the outer dimension [START] */
 ///         2.S jit_loop_begin_emitter    /* inner vector loop [START] */
 ///             ...                 /* All the necessary Load/Strore/elementwise emitters */
@@ -32,21 +31,29 @@ namespace intel_cpu {
 
 class jit_kernel_emitter : public jit_emitter, public jit_container_emitter {
 public:
-    jit_kernel_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const ov::snippets::lowered::ExpressionPtr& expr);
-
-    size_t get_inputs_num() const override {return 0;}
-    void emit_code(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs,
-                   const std::vector<size_t> &pool_vec_idxs = {}, const std::vector<size_t> &pool_gpr_idxs = {}) const override;
+    jit_kernel_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                       dnnl::impl::cpu::x64::cpu_isa_t isa,
+                       const ov::snippets::lowered::ExpressionPtr& expr);
+
+    size_t get_inputs_num() const override {
+        return 0;
+    }
+    void emit_code(const std::vector<size_t>& in_idxs,
+                   const std::vector<size_t>& out_idxs,
+                   const std::vector<size_t>& pool_vec_idxs = {},
+                   const std::vector<size_t>& pool_gpr_idxs = {}) const override;
 
 protected:
     void validate_arguments(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
-    void init_body_regs(const std::set<size_t>& kernel_regs, const std::vector<size_t> &pool_vec_idxs = {}, const std::vector<size_t> &pool_gpr_idxs = {});
+    void init_body_regs(const std::set<size_t>& kernel_regs,
+                        const std::vector<size_t>& pool_vec_idxs = {},
+                        const std::vector<size_t>& pool_gpr_idxs = {});
     /**
-    * @brief populates physical registers pools for x86 (both vec and gp).
+     * @brief populates physical registers pools for x86 (both vec and gp).
      * Skips stack-related gprs and extra gprs passed as arguments.
      * @arg gpr_blacklist - set of gp registers that should not be added to register pool
      * @arg vec_blacklist - set of vec registers should not be added to register pool
-    */
+     */
     void init_reg_pools(const std::set<size_t>& gpr_blacklist, const std::set<size_t>& vec_blacklist);
 
     virtual void init_data_pointers(const std::vector<Xbyak::Reg64>& data_ptr_regs) const = 0;
@@ -70,13 +77,15 @@ class jit_kernel_emitter : public jit_emitter, public jit_container_emitter {
     std::shared_ptr<snippets::lowered::LinearIR> body;
 
 #ifdef SNIPPETS_DEBUG_CAPS
-    friend std::string init_info_jit_kernel_emitter(const jit_kernel_emitter *emitter);
+    friend std::string init_info_jit_kernel_emitter(const jit_kernel_emitter* emitter);
 #endif
 };
 
 class jit_kernel_static_emitter : public jit_kernel_emitter {
 public:
-    jit_kernel_static_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const ov::snippets::lowered::ExpressionPtr& expr);
+    jit_kernel_static_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                              dnnl::impl::cpu::x64::cpu_isa_t isa,
+                              const ov::snippets::lowered::ExpressionPtr& expr);
 
 private:
     void init_data_pointers(const std::vector<Xbyak::Reg64>& data_ptr_regs) const override;
@@ -86,21 +95,23 @@ class jit_kernel_static_emitter : public jit_kernel_emitter {
     std::vector<std::vector<size_t>> data_offsets;
 
 #ifdef SNIPPETS_DEBUG_CAPS
-    friend std::string init_info_jit_kernel_static_emitter(const jit_kernel_static_emitter *emitter);
+    friend std::string init_info_jit_kernel_static_emitter(const jit_kernel_static_emitter* emitter);
 #endif
 };
 
 class jit_kernel_dynamic_emitter : public jit_kernel_emitter {
 public:
-    jit_kernel_dynamic_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const ov::snippets::lowered::ExpressionPtr& expr);
+    jit_kernel_dynamic_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                               dnnl::impl::cpu::x64::cpu_isa_t isa,
+                               const ov::snippets::lowered::ExpressionPtr& expr);
 
 private:
     void init_data_pointers(const std::vector<Xbyak::Reg64>& data_ptr_regs) const override;
 
 #ifdef SNIPPETS_DEBUG_CAPS
-    friend std::string init_info_jit_kernel_dynamic_emitter(const jit_kernel_dynamic_emitter *emitter);
+    friend std::string init_info_jit_kernel_dynamic_emitter(const jit_kernel_dynamic_emitter* emitter);
 #endif
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.cpp
index f3151d0df4ccb1..86421678a29011 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.cpp
@@ -18,8 +18,11 @@ namespace intel_cpu {
 namespace {
 class jit_aux_gpr_holder {
 public:
-    jit_aux_gpr_holder(dnnl::impl::cpu::x64::jit_generator* host, std::vector<size_t>& pool_gpr_idxs, const std::vector<size_t>& used_gpr_idxs)
-        : m_h(host), m_pool_gpr_idxs(pool_gpr_idxs) {
+    jit_aux_gpr_holder(dnnl::impl::cpu::x64::jit_generator* host,
+                       std::vector<size_t>& pool_gpr_idxs,
+                       const std::vector<size_t>& used_gpr_idxs)
+        : m_h(host),
+          m_pool_gpr_idxs(pool_gpr_idxs) {
         // If the pool is empty, let's manualy allocate the gpr and push original vlaue on stack
         if (m_pool_gpr_idxs.empty()) {
             m_aux_gpr_idx = ov::intel_cpu::utils::get_aux_gpr(used_gpr_idxs);
@@ -39,21 +42,26 @@ class jit_aux_gpr_holder {
         }
     }
 
-    const Reg64& get_reg() const { return m_aux_gpr_idx; }
+    const Reg64& get_reg() const {
+        return m_aux_gpr_idx;
+    }
 
 private:
     dnnl::impl::cpu::x64::jit_generator* m_h;
     std::vector<size_t>& m_pool_gpr_idxs;
-    Reg64 m_aux_gpr_idx {};
+    Reg64 m_aux_gpr_idx{};
     bool m_is_preserved = false;
 };
 }  // namespace
 
 /* ================== jit_loop_begin_emitter ====================== */
 
-jit_loop_begin_emitter::jit_loop_begin_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+jit_loop_begin_emitter::jit_loop_begin_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                                               dnnl::impl::cpu::x64::cpu_isa_t isa,
                                                const ov::snippets::lowered::ExpressionPtr& expr)
-    : jit_emitter(h, isa), loop_begin_label{new Xbyak::Label()}, loop_end_label(nullptr) {
+    : jit_emitter(h, isa),
+      loop_begin_label{new Xbyak::Label()},
+      loop_end_label(nullptr) {
     const auto loop_begin = ov::as_type_ptr<snippets::op::LoopBegin>(expr->get_node());
     OV_CPU_JIT_EMITTER_ASSERT(loop_begin, "expects LoopBegin expression");
     const auto loop_end = loop_begin->get_loop_end();
@@ -65,7 +73,7 @@ jit_loop_begin_emitter::jit_loop_begin_emitter(dnnl::impl::cpu::x64::jit_generat
     in_out_type_ = emitter_in_out_map::gpr_to_gpr;
 }
 
-void jit_loop_begin_emitter::validate_arguments(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
+void jit_loop_begin_emitter::validate_arguments(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
     OV_CPU_JIT_EMITTER_ASSERT(in.empty(), "Invalid inputs size: expected 0 got " + std::to_string(in.size()));
     // Note: the only expected output is work amount register (communicated to jit_loop_end_emitter)
     OV_CPU_JIT_EMITTER_ASSERT(out.size() == 1, "Invalid outputs size: expected 1 got " + std::to_string(out.size()));
@@ -74,21 +82,24 @@ void jit_loop_begin_emitter::validate_arguments(const std::vector<size_t> &in, c
                               "loop increment might be dynamic only if loop evaluates once!");
 }
 
-void jit_loop_begin_emitter::emit_code(const std::vector<size_t> &in, const std::vector<size_t> &out,
-                                       const std::vector<size_t> &pool_vec_idxs, const std::vector<size_t> &pool_gpr_idxs) const {
+void jit_loop_begin_emitter::emit_code(const std::vector<size_t>& in,
+                                       const std::vector<size_t>& out,
+                                       const std::vector<size_t>& pool_vec_idxs,
+                                       const std::vector<size_t>& pool_gpr_idxs) const {
     validate_arguments(in, out);
     jit_emitter::emit_code(in, out, pool_vec_idxs, pool_gpr_idxs);
 }
 
 void jit_loop_begin_emitter::emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
     // If the loop evaulate once, we can skip loop begin code emission
-    // If work_amount is dynamic, we should get runtime `work_amount` - it might be `zero` and we should skip loop evaluation
+    // If work_amount is dynamic, we should get runtime `work_amount` - it might be `zero` and we should skip loop
+    // evaluation
     if (evaluate_once && !is_work_amount_dynamic)
         return;
 
     Reg64 reg_work_amount = Reg64(static_cast<int>(out.back()));
     if (is_work_amount_dynamic) {
-        jit_aux_gpr_holder gpr_holder(h, aux_gpr_idxs, out); // loop_begin has only output registers
+        jit_aux_gpr_holder gpr_holder(h, aux_gpr_idxs, out);  // loop_begin has only output registers
         Reg64 reg_loop_args_ptr = gpr_holder.get_reg();
         const auto id_offset = loop_id * sizeof(jit_snippets_call_args::loop_args_t);
         h->mov(reg_loop_args_ptr, h->ptr[abi_param1 + GET_OFF(loop_args)]);
@@ -113,9 +124,12 @@ void jit_loop_begin_emitter::emit_impl(const std::vector<size_t>& in, const std:
 
 /* ================== jit_loop_end_emitter ====================== */
 
-jit_loop_end_emitter::jit_loop_end_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+jit_loop_end_emitter::jit_loop_end_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                                           dnnl::impl::cpu::x64::cpu_isa_t isa,
                                            const ov::snippets::lowered::ExpressionPtr& expr)
-    : jit_emitter(h, isa), loop_begin_label{nullptr}, loop_end_label{new Xbyak::Label()} {
+    : jit_emitter(h, isa),
+      loop_begin_label{nullptr},
+      loop_end_label{new Xbyak::Label()} {
     in_out_type_ = emitter_in_out_map::gpr_to_gpr;
     const auto loop_end = ov::as_type_ptr<snippets::op::LoopEnd>(expr->get_node());
     OV_CPU_JIT_EMITTER_ASSERT(loop_end != nullptr, "expected LoopEnd expr");
@@ -132,8 +146,9 @@ jit_loop_end_emitter::jit_loop_end_emitter(dnnl::impl::cpu::x64::jit_generator*
 
     are_ptr_increments_dynamic =
         std::any_of(ptr_increments.cbegin(), ptr_increments.cend(), ov::snippets::utils::is_dynamic_value<int64_t>);
-    are_final_offsets_dynamic =
-        std::any_of(finalization_offsets.cbegin(), finalization_offsets.cend(), ov::snippets::utils::is_dynamic_value<int64_t>);
+    are_final_offsets_dynamic = std::any_of(finalization_offsets.cbegin(),
+                                            finalization_offsets.cend(),
+                                            ov::snippets::utils::is_dynamic_value<int64_t>);
     are_ptr_shifts_dynamic = are_ptr_increments_dynamic || are_final_offsets_dynamic;
 
     const auto begin_expr = get_loop_begin_expr(expr);
@@ -143,29 +158,51 @@ jit_loop_end_emitter::jit_loop_end_emitter(dnnl::impl::cpu::x64::jit_generator*
     loop_begin_label = loop_begin_emitter->get_begin_label();
 }
 
-ov::snippets::lowered::ExpressionPtr jit_loop_end_emitter::get_loop_begin_expr(const ov::snippets::lowered::ExpressionPtr& expr) {
+ov::snippets::lowered::ExpressionPtr jit_loop_end_emitter::get_loop_begin_expr(
+    const ov::snippets::lowered::ExpressionPtr& expr) {
     const auto begin_expr = expr->get_input_port_connectors().back()->get_source().get_expr();
     OV_CPU_JIT_EMITTER_ASSERT(ov::is_type<snippets::op::LoopBegin>(begin_expr->get_node()),
                               "LoopEnd expression must have th last port connector to LoopBegin");
     return begin_expr;
 }
 
-void jit_loop_end_emitter::validate_arguments(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
+void jit_loop_end_emitter::validate_arguments(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
     const auto io_size = num_inputs + num_outputs;
     OV_CPU_JIT_EMITTER_ASSERT(out.size() == 0, "Invalid number of out arguments: expected ", 0, " got ", out.size());
-    OV_CPU_JIT_EMITTER_ASSERT(in.size() == io_size + 1, "Invalid number of in arguments: expected ", io_size + 1, " got ", in.size());
-    OV_CPU_JIT_EMITTER_ASSERT(is_incremented.size() == io_size, "Invalid is_incremented size: expected ", io_size, " got ", is_incremented.size());
-    OV_CPU_JIT_EMITTER_ASSERT(ptr_increments.size() == io_size, "Invalid ptr_increments size: expected ", io_size, " got ", ptr_increments.size());
+    OV_CPU_JIT_EMITTER_ASSERT(in.size() == io_size + 1,
+                              "Invalid number of in arguments: expected ",
+                              io_size + 1,
+                              " got ",
+                              in.size());
+    OV_CPU_JIT_EMITTER_ASSERT(is_incremented.size() == io_size,
+                              "Invalid is_incremented size: expected ",
+                              io_size,
+                              " got ",
+                              is_incremented.size());
+    OV_CPU_JIT_EMITTER_ASSERT(ptr_increments.size() == io_size,
+                              "Invalid ptr_increments size: expected ",
+                              io_size,
+                              " got ",
+                              ptr_increments.size());
     OV_CPU_JIT_EMITTER_ASSERT(finalization_offsets.size() == io_size,
-                              "Invalid finalization_offsets size: expected: ", io_size, " got ", finalization_offsets.size());
-    OV_CPU_JIT_EMITTER_ASSERT(data_sizes.size() == io_size, "Invalid data_sizes size: expected: ", io_size, " got ", data_sizes.size());
+                              "Invalid finalization_offsets size: expected: ",
+                              io_size,
+                              " got ",
+                              finalization_offsets.size());
+    OV_CPU_JIT_EMITTER_ASSERT(data_sizes.size() == io_size,
+                              "Invalid data_sizes size: expected: ",
+                              io_size,
+                              " got ",
+                              data_sizes.size());
     OV_CPU_JIT_EMITTER_ASSERT(loop_end_label != nullptr && loop_begin_label != nullptr, "has not inited labels!");
     OV_CPU_JIT_EMITTER_ASSERT(!snippets::utils::is_dynamic_value(wa_increment) || evaluate_once,
                               "loop increment might be dynamic only if loop evaluates once!");
 }
 
-void jit_loop_end_emitter::emit_code(const std::vector<size_t> &in, const std::vector<size_t> &out,
-                                     const std::vector<size_t> &pool_vec_idxs, const std::vector<size_t> &pool_gpr_idxs) const {
+void jit_loop_end_emitter::emit_code(const std::vector<size_t>& in,
+                                     const std::vector<size_t>& out,
+                                     const std::vector<size_t>& pool_vec_idxs,
+                                     const std::vector<size_t>& pool_gpr_idxs) const {
     validate_arguments(in, out);
     jit_emitter::emit_code(in, out, pool_vec_idxs, pool_gpr_idxs);
 }
@@ -176,34 +213,38 @@ void jit_loop_end_emitter::emit_impl(const std::vector<size_t>& in, const std::v
     data_ptr_reg_idxs.reserve(num_inputs + num_outputs);
     std::copy(in.begin(), in.end() - 1, std::back_inserter(data_ptr_reg_idxs));
 
-    auto apply_increments = [&](bool use_runtime_args, size_t field_offset, const std::vector<int64_t>& increments, size_t scale) {
-        Reg64 reg_increments;
-        auto add_increments = [&]() {
-            for (size_t idx = 0; idx < data_ptr_reg_idxs.size(); idx++) {
-                const auto& increment = increments[idx];
-                if (is_incremented[idx] && increment != 0) {
-                    if (ov::snippets::utils::is_dynamic_value(increment)) {
-                        OV_CPU_JIT_EMITTER_ASSERT(use_runtime_args, "Loop argument structure cannot be pushed to aux GPR");
-                        h->add(Reg64(static_cast<int>(data_ptr_reg_idxs[idx])), h->ptr[reg_increments + idx * sizeof(int64_t)]);
-                    } else {
-                        h->add(Reg64(static_cast<int>(data_ptr_reg_idxs[idx])), increment * scale * data_sizes[idx]);
+    auto apply_increments =
+        [&](bool use_runtime_args, size_t field_offset, const std::vector<int64_t>& increments, size_t scale) {
+            Reg64 reg_increments;
+            auto add_increments = [&]() {
+                for (size_t idx = 0; idx < data_ptr_reg_idxs.size(); idx++) {
+                    const auto& increment = increments[idx];
+                    if (is_incremented[idx] && increment != 0) {
+                        if (ov::snippets::utils::is_dynamic_value(increment)) {
+                            OV_CPU_JIT_EMITTER_ASSERT(use_runtime_args,
+                                                      "Loop argument structure cannot be pushed to aux GPR");
+                            h->add(Reg64(static_cast<int>(data_ptr_reg_idxs[idx])),
+                                   h->ptr[reg_increments + idx * sizeof(int64_t)]);
+                        } else {
+                            h->add(Reg64(static_cast<int>(data_ptr_reg_idxs[idx])),
+                                   increment * scale * data_sizes[idx]);
+                        }
                     }
                 }
+            };
+
+            const auto id_offset = loop_id * sizeof(jit_snippets_call_args::loop_args_t);
+            if (use_runtime_args) {
+                jit_aux_gpr_holder gpr_holder(h, aux_gpr_idxs, in);  // loop_end has only input registers
+                reg_increments = gpr_holder.get_reg();
+                h->mov(reg_increments, h->ptr[abi_param1 + GET_OFF(loop_args)]);
+                h->mov(reg_increments, h->ptr[reg_increments + id_offset + field_offset]);
+                add_increments();
+            } else {
+                add_increments();
             }
         };
 
-        const auto id_offset = loop_id * sizeof(jit_snippets_call_args::loop_args_t);
-        if (use_runtime_args) {
-            jit_aux_gpr_holder gpr_holder(h, aux_gpr_idxs, in); // loop_end has only input registers
-            reg_increments = gpr_holder.get_reg();
-            h->mov(reg_increments, h->ptr[abi_param1 + GET_OFF(loop_args)]);
-            h->mov(reg_increments, h->ptr[reg_increments + id_offset + field_offset]);
-            add_increments();
-        } else {
-            add_increments();
-        }
-    };
-
     if (!evaluate_once) {
         apply_increments(are_ptr_increments_dynamic, GET_OFF_LOOP_ARGS(m_ptr_increments), ptr_increments, wa_increment);
 
@@ -220,5 +261,5 @@ void jit_loop_end_emitter::emit_impl(const std::vector<size_t>& in, const std::v
 
 /* ============================================================== */
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.hpp
index 262bba39b7d74c..c0a2b53b100c62 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_emitters.hpp
@@ -5,7 +5,6 @@
 #pragma once
 
 #include "emitters/plugin/x64/jit_emitter.hpp"
-
 #include "snippets/op/loop.hpp"
 #include "snippets/utils/utils.hpp"
 
@@ -14,25 +13,36 @@ namespace intel_cpu {
 
 /* ================== jit_loop_begin_emitter ====================== */
 
-class jit_loop_begin_emitter: public jit_emitter {
+class jit_loop_begin_emitter : public jit_emitter {
 public:
-    jit_loop_begin_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+    jit_loop_begin_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                           dnnl::impl::cpu::x64::cpu_isa_t isa,
                            const ov::snippets::lowered::ExpressionPtr& expr);
 
-    size_t get_inputs_num() const override { return 0; }
+    size_t get_inputs_num() const override {
+        return 0;
+    }
 
-    void emit_code(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs,
-                  const std::vector<size_t> &pool_vec_idxs = {}, const std::vector<size_t> &pool_gpr_idxs = {}) const override;
+    void emit_code(const std::vector<size_t>& in_idxs,
+                   const std::vector<size_t>& out_idxs,
+                   const std::vector<size_t>& pool_vec_idxs = {},
+                   const std::vector<size_t>& pool_gpr_idxs = {}) const override;
 
-    void set_loop_end_label(const std::shared_ptr<const Xbyak::Label>& label) { loop_end_label = label; }
-    std::shared_ptr<const Xbyak::Label> get_begin_label() { return loop_begin_label; }
+    void set_loop_end_label(const std::shared_ptr<const Xbyak::Label>& label) {
+        loop_end_label = label;
+    }
+    std::shared_ptr<const Xbyak::Label> get_begin_label() {
+        return loop_begin_label;
+    }
 
 protected:
-    void validate_arguments(const std::vector<size_t> &in, const std::vector<size_t> &out) const override;
+    void validate_arguments(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
 
     // `jit_loop_begin_emitter` handles manually aux_gpr allocation using `jit_aux_gpr_holder`
-    size_t aux_gprs_count() const override { return 0; }
+    size_t aux_gprs_count() const override {
+        return 0;
+    }
 
     std::shared_ptr<Xbyak::Label> loop_begin_label = nullptr;
     std::shared_ptr<const Xbyak::Label> loop_end_label = nullptr;
@@ -43,27 +53,33 @@ class jit_loop_begin_emitter: public jit_emitter {
     bool is_work_amount_dynamic = false;
 };
 
-
 /* ============================================================== */
 
 /* ================== jit_loop_end_emitter ====================== */
 
-class jit_loop_end_emitter: public jit_emitter {
+class jit_loop_end_emitter : public jit_emitter {
 public:
-    jit_loop_end_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
-                           const ov::snippets::lowered::ExpressionPtr& expr);
+    jit_loop_end_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                         dnnl::impl::cpu::x64::cpu_isa_t isa,
+                         const ov::snippets::lowered::ExpressionPtr& expr);
 
-    size_t get_inputs_num() const override { return 0; }
+    size_t get_inputs_num() const override {
+        return 0;
+    }
 
-    void emit_code(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs,
-                   const std::vector<size_t> &pool_vec_idxs = {}, const std::vector<size_t> &pool_gpr_idxs = {}) const override;
+    void emit_code(const std::vector<size_t>& in_idxs,
+                   const std::vector<size_t>& out_idxs,
+                   const std::vector<size_t>& pool_vec_idxs = {},
+                   const std::vector<size_t>& pool_gpr_idxs = {}) const override;
 
 protected:
-    void validate_arguments(const std::vector<size_t> &in, const std::vector<size_t> &out) const override;
+    void validate_arguments(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
 
     // `jit_loop_end_emitter` handles manually aux_gpr allocation using `jit_aux_gpr_holder`
-    size_t aux_gprs_count() const override { return 0; }
+    size_t aux_gprs_count() const override {
+        return 0;
+    }
 
     static ov::snippets::lowered::ExpressionPtr get_loop_begin_expr(const ov::snippets::lowered::ExpressionPtr& expr);
 
@@ -86,5 +102,5 @@ class jit_loop_end_emitter: public jit_emitter {
 
 /* ============================================================== */
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_memory_emitters.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_memory_emitters.cpp
index b7a5fc2e993398..307ef63a8e6a2e 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_memory_emitters.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_memory_emitters.cpp
@@ -5,10 +5,9 @@
 #include "jit_memory_emitters.hpp"
 
 #include "emitters/snippets/jit_snippets_call_args.hpp"
+#include "snippets/op/buffer.hpp"
 #include "transformations/snippets/x64/op/load_convert.hpp"
 #include "transformations/snippets/x64/op/store_convert.hpp"
-#include "snippets/op/buffer.hpp"
-
 
 using namespace Xbyak;
 using namespace dnnl::impl;
@@ -21,7 +20,10 @@ using jit_generator = dnnl::impl::cpu::x64::jit_generator;
 using cpu_isa_t = dnnl::impl::cpu::x64::cpu_isa_t;
 using ExpressionPtr = ov::snippets::lowered::ExpressionPtr;
 
-jit_memory_emitter::jit_memory_emitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr, emitter_in_out_map in_out_type)
+jit_memory_emitter::jit_memory_emitter(jit_generator* h,
+                                       cpu_isa_t isa,
+                                       const ExpressionPtr& expr,
+                                       emitter_in_out_map in_out_type)
     : jit_emitter(h, isa) {
     in_out_type_ = in_out_type;
 
@@ -36,7 +38,8 @@ jit_memory_emitter::jit_memory_emitter(jit_generator* h, cpu_isa_t isa, const Ex
         compiled_byte_offset = memory_access->get_input_offset();
         buffer_cluster_id = get_parent_buffer_cluster_id(expr);
     } else if (in_out_type_ == emitter_in_out_map::vec_to_gpr) {
-        OV_CPU_JIT_EMITTER_ASSERT(memory_access->is_memory_access_output_port(0), "must be output port - memory access");
+        OV_CPU_JIT_EMITTER_ASSERT(memory_access->is_memory_access_output_port(0),
+                                  "must be output port - memory access");
         count = memory_access->get_output_count();
         compiled_byte_offset = memory_access->get_output_offset();
         buffer_cluster_id = get_consumer_buffer_cluster_id(expr);
@@ -46,7 +49,8 @@ jit_memory_emitter::jit_memory_emitter(jit_generator* h, cpu_isa_t isa, const Ex
 
     if (ov::snippets::utils::is_dynamic_value(compiled_byte_offset)) {
         is_offset_runtime = true;
-        // Compiled byte offset is zero to manually `add` runtime offset before operation and `sub` after to reset pointer in the register
+        // Compiled byte offset is zero to manually `add` runtime offset before operation and `sub` after to reset
+        // pointer in the register
         compiled_byte_offset = 0;
         OV_CPU_JIT_EMITTER_ASSERT(buffer_cluster_id != SIZE_MAX, "Incorrect buffer offset in call_args");
     }
@@ -84,8 +88,10 @@ std::vector<size_t> jit_memory_emitter::get_available_aux_gprs() const {
     return available_aux_gprs;
 }
 
-void jit_memory_emitter::emit_code(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs,
-                                   const std::vector<size_t> &pool_vec_idxs, const std::vector<size_t> &pool_gpr_idxs) const {
+void jit_memory_emitter::emit_code(const std::vector<size_t>& in_idxs,
+                                   const std::vector<size_t>& out_idxs,
+                                   const std::vector<size_t>& pool_vec_idxs,
+                                   const std::vector<size_t>& pool_gpr_idxs) const {
     emitter_preamble(in_idxs, out_idxs, pool_vec_idxs, pool_gpr_idxs);
 
     Reg64 reg_runtime_params = abi_param1;  // defined by jit_kernel_emitter
@@ -152,19 +158,26 @@ void jit_load_broadcast_emitter::emit_impl(const std::vector<size_t>& in, const
 }
 
 template <cpu_isa_t isa>
-void jit_load_broadcast_emitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
-    using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,
-            Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
+void jit_load_broadcast_emitter::emit_isa(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
+    using Vmm = typename dnnl::impl::utils::
+        conditional3<isa == dnnl::impl::cpu::x64::sse41, Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
     Reg64 in_reg(in[0]);
     Vmm vmm_dst = Vmm(out[0]);
 
-    // It doesn't really matter if we broadcast or `movss` for vector tails so keep only one version for `BroadcastLoad`,
-    // key point here is not to add post-increment, it might be fixed by some other approach in future
+    // It doesn't really matter if we broadcast or `movss` for vector tails so keep only one version for
+    // `BroadcastLoad`, key point here is not to add post-increment, it might be fixed by some other approach in future
     switch (src_prc.size()) {
-        case 4: h->uni_vbroadcastss(vmm_dst, h->ptr[in_reg + compiled_byte_offset]); break;
-        case 2: h->vpbroadcastw(vmm_dst, h->ptr[in_reg + compiled_byte_offset]); break;
-        case 1: h->vpbroadcastb(vmm_dst, h->ptr[in_reg + compiled_byte_offset]); break;
-        default: OV_CPU_JIT_EMITTER_THROW("Unsupported data type");
+    case 4:
+        h->uni_vbroadcastss(vmm_dst, h->ptr[in_reg + compiled_byte_offset]);
+        break;
+    case 2:
+        h->vpbroadcastw(vmm_dst, h->ptr[in_reg + compiled_byte_offset]);
+        break;
+    case 1:
+        h->vpbroadcastb(vmm_dst, h->ptr[in_reg + compiled_byte_offset]);
+        break;
+    default:
+        OV_CPU_JIT_EMITTER_THROW("Unsupported data type");
     }
 }
 
@@ -190,5 +203,5 @@ void jit_store_memory_emitter::emit_data() const {
     store_emitter->emit_data();
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_memory_emitters.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_memory_emitters.hpp
index 55a41c977dd67c..d21e85d53e7193 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_memory_emitters.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_memory_emitters.hpp
@@ -7,17 +7,20 @@
 #include "emitters/plugin/x64/jit_emitter.hpp"
 #include "emitters/plugin/x64/jit_load_store_emitters.hpp"
 
-
 namespace ov {
 namespace intel_cpu {
 
-class jit_memory_emitter : public jit_emitter  {
+class jit_memory_emitter : public jit_emitter {
 public:
-    jit_memory_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
-                       const ov::snippets::lowered::ExpressionPtr& expr, emitter_in_out_map in_out_type);
+    jit_memory_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                       dnnl::impl::cpu::x64::cpu_isa_t isa,
+                       const ov::snippets::lowered::ExpressionPtr& expr,
+                       emitter_in_out_map in_out_type);
 
-    void emit_code(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs,
-                   const std::vector<size_t> &pool_vec_idxs = {}, const std::vector<size_t> &pool_gpr_idxs = {}) const override;
+    void emit_code(const std::vector<size_t>& in_idxs,
+                   const std::vector<size_t>& out_idxs,
+                   const std::vector<size_t>& pool_vec_idxs = {},
+                   const std::vector<size_t>& pool_gpr_idxs = {}) const override;
 
 protected:
     static size_t get_parent_buffer_cluster_id(const ov::snippets::lowered::ExpressionPtr& expr);
@@ -36,16 +39,19 @@ class jit_memory_emitter : public jit_emitter  {
     bool is_offset_runtime = false;
 
 #ifdef SNIPPETS_DEBUG_CAPS
-    friend std::string init_info_jit_memory_emitter(const jit_memory_emitter *emitter);
+    friend std::string init_info_jit_memory_emitter(const jit_memory_emitter* emitter);
 #endif
 };
 
 class jit_load_memory_emitter : public jit_memory_emitter {
 public:
-    jit_load_memory_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+    jit_load_memory_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                            dnnl::impl::cpu::x64::cpu_isa_t isa,
                             const ov::snippets::lowered::ExpressionPtr& expr);
 
-    size_t get_inputs_num() const override {return 0;}
+    size_t get_inputs_num() const override {
+        return 0;
+    }
 
 private:
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
@@ -58,24 +64,30 @@ class jit_load_memory_emitter : public jit_memory_emitter {
 
 class jit_load_broadcast_emitter : public jit_memory_emitter {
 public:
-    jit_load_broadcast_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+    jit_load_broadcast_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                               dnnl::impl::cpu::x64::cpu_isa_t isa,
                                const ov::snippets::lowered::ExpressionPtr& expr);
 
-    size_t get_inputs_num() const override {return 0;}
+    size_t get_inputs_num() const override {
+        return 0;
+    }
 
 private:
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const;
+    void emit_isa(const std::vector<size_t>& in, const std::vector<size_t>& out) const;
 };
 
-class jit_store_memory_emitter : public jit_memory_emitter  {
+class jit_store_memory_emitter : public jit_memory_emitter {
 public:
-    jit_store_memory_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+    jit_store_memory_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                             dnnl::impl::cpu::x64::cpu_isa_t isa,
                              const ov::snippets::lowered::ExpressionPtr& expr);
 
-    size_t get_inputs_num() const override {return 1;}
+    size_t get_inputs_num() const override {
+        return 1;
+    }
 
 private:
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
@@ -86,5 +98,5 @@ class jit_store_memory_emitter : public jit_memory_emitter  {
     std::unique_ptr<jit_store_emitter> store_emitter = nullptr;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_chrono_emitters.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_chrono_emitters.cpp
index f89e906ce57593..ccb4da742e38d6 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_chrono_emitters.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_chrono_emitters.cpp
@@ -3,9 +3,9 @@
 //
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#include "jit_perf_count_chrono_emitters.hpp"
+#    include "jit_perf_count_chrono_emitters.hpp"
 
-#include "emitters/plugin/x64/utils.hpp"
+#    include "emitters/plugin/x64/utils.hpp"
 
 using namespace dnnl::impl;
 using namespace dnnl::impl::utils;
@@ -17,8 +17,10 @@ using namespace Xbyak::util;
 namespace ov {
 namespace intel_cpu {
 
-jit_perf_count_chrono_start_emitter::jit_perf_count_chrono_start_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                                            const std::shared_ptr<ov::Node>& n) : jit_emitter(host, host_isa) {
+jit_perf_count_chrono_start_emitter::jit_perf_count_chrono_start_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                                                         dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                                                                         const std::shared_ptr<ov::Node>& n)
+    : jit_emitter(host, host_isa) {
     m_start_node = ov::as_type_ptr<snippets::op::PerfCountBegin>(n);
 }
 
@@ -30,11 +32,12 @@ void jit_perf_count_chrono_start_emitter::set_start_time(snippets::op::PerfCount
     start_node->set_start_time();
 }
 
-void jit_perf_count_chrono_start_emitter::emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const {
+void jit_perf_count_chrono_start_emitter::emit_impl(const std::vector<size_t>& in_idxs,
+                                                    const std::vector<size_t>& out_idxs) const {
     EmitABIRegSpills spill(h);
     spill.preamble();
 
-    const auto &set_start_time_overload = static_cast<void (*)(snippets::op::PerfCountBegin*)>(set_start_time);
+    const auto& set_start_time_overload = static_cast<void (*)(snippets::op::PerfCountBegin*)>(set_start_time);
     h->mov(h->rax, reinterpret_cast<size_t>(set_start_time_overload));
     h->mov(abi_param1, reinterpret_cast<size_t>(m_start_node.get()));
 
@@ -46,8 +49,10 @@ void jit_perf_count_chrono_start_emitter::emit_impl(const std::vector<size_t> &i
 }
 
 ///////////////////jit_perf_count_chrono_end_emitter////////////////////////////////////
-jit_perf_count_chrono_end_emitter::jit_perf_count_chrono_end_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-    const std::shared_ptr<ov::Node>& n) : jit_emitter(host, host_isa) {
+jit_perf_count_chrono_end_emitter::jit_perf_count_chrono_end_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                                                     dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                                                                     const std::shared_ptr<ov::Node>& n)
+    : jit_emitter(host, host_isa) {
     m_end_node = ov::as_type_ptr<snippets::op::PerfCountEnd>(n);
 }
 
@@ -59,11 +64,13 @@ void jit_perf_count_chrono_end_emitter::set_accumulated_time(snippets::op::PerfC
     end_node->set_accumulated_time();
 }
 
-void jit_perf_count_chrono_end_emitter::emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const {
+void jit_perf_count_chrono_end_emitter::emit_impl(const std::vector<size_t>& in_idxs,
+                                                  const std::vector<size_t>& out_idxs) const {
     EmitABIRegSpills spill(h);
     spill.preamble();
 
-    const auto &set_accumulated_time_overload = static_cast<void (*)(snippets::op::PerfCountEnd*)>(set_accumulated_time);
+    const auto& set_accumulated_time_overload =
+        static_cast<void (*)(snippets::op::PerfCountEnd*)>(set_accumulated_time);
     h->mov(h->rax, reinterpret_cast<size_t>(set_accumulated_time_overload));
     h->mov(abi_param1, reinterpret_cast<size_t>(m_end_node.get()));
 
@@ -74,6 +81,6 @@ void jit_perf_count_chrono_end_emitter::emit_impl(const std::vector<size_t> &in_
     spill.postamble();
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
-#endif // SNIPPETS_DEBUG_CAPS
+}  // namespace intel_cpu
+}  // namespace ov
+#endif  // SNIPPETS_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_chrono_emitters.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_chrono_emitters.hpp
index e8608afc7f1428..817c0583609778 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_chrono_emitters.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_chrono_emitters.hpp
@@ -3,24 +3,23 @@
 //
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#pragma once
-
-#include "emitters/plugin/x64/jit_emitter.hpp"
-
-#include "snippets/op/perf_count.hpp"
+#    pragma once
 
+#    include "emitters/plugin/x64/jit_emitter.hpp"
+#    include "snippets/op/perf_count.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
 class jit_perf_count_chrono_start_emitter : public jit_emitter {
 public:
-    jit_perf_count_chrono_start_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_perf_count_chrono_start_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                        dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                                         const std::shared_ptr<ov::Node>& n);
     size_t get_inputs_num() const override;
 
 private:
-    void emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_idxs, const std::vector<size_t>& out_idxs) const override;
     static void set_start_time(snippets::op::PerfCountBegin* start_node);
 
     std::shared_ptr<snippets::op::PerfCountBegin> m_start_node = nullptr;
@@ -28,17 +27,18 @@ class jit_perf_count_chrono_start_emitter : public jit_emitter {
 
 class jit_perf_count_chrono_end_emitter : public jit_emitter {
 public:
-    jit_perf_count_chrono_end_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+    jit_perf_count_chrono_end_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                      dnnl::impl::cpu::x64::cpu_isa_t host_isa,
                                       const std::shared_ptr<ov::Node>& n);
     size_t get_inputs_num() const override;
 
 private:
-    void emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_idxs, const std::vector<size_t>& out_idxs) const override;
     static void set_accumulated_time(snippets::op::PerfCountEnd* end_node);
 
     std::shared_ptr<snippets::op::PerfCountEnd> m_end_node = nullptr;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
-#endif // SNIPPETS_DEBUG_CAPS
+}  // namespace intel_cpu
+}  // namespace ov
+#endif  // SNIPPETS_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_rdtsc_emitters.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_rdtsc_emitters.cpp
index c469c052ce3ef6..e951f8042ad762 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_rdtsc_emitters.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_rdtsc_emitters.cpp
@@ -3,7 +3,7 @@
 //
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#include "jit_perf_count_rdtsc_emitters.hpp"
+#    include "jit_perf_count_rdtsc_emitters.hpp"
 
 using namespace dnnl::impl;
 using namespace dnnl::impl::utils;
@@ -15,8 +15,10 @@ using namespace Xbyak::util;
 namespace ov {
 namespace intel_cpu {
 
-jit_perf_count_rdtsc_start_emitter::jit_perf_count_rdtsc_start_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                                            const std::shared_ptr<ov::Node>& n) : jit_emitter(host, host_isa) {
+jit_perf_count_rdtsc_start_emitter::jit_perf_count_rdtsc_start_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                                                       dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                                                                       const std::shared_ptr<ov::Node>& n)
+    : jit_emitter(host, host_isa) {
     m_start_node = ov::as_type_ptr<ov::intel_cpu::PerfCountRdtscBegin>(n);
 }
 
@@ -24,16 +26,18 @@ size_t jit_perf_count_rdtsc_start_emitter::get_inputs_num() const {
     return 0;
 }
 
-void jit_perf_count_rdtsc_start_emitter::emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const {
+void jit_perf_count_rdtsc_start_emitter::emit_impl(const std::vector<size_t>& in_idxs,
+                                                   const std::vector<size_t>& out_idxs) const {
     h->push(h->rax);
     h->push(h->rdx);
 
-    // The EDX register is loaded with the high-order 32 bits of the MSR and the EAX register is loaded with the low-order 32 bits.
+    // The EDX register is loaded with the high-order 32 bits of the MSR and the EAX register is loaded with the
+    // low-order 32 bits.
     h->lfence();
     h->rdtsc();
     h->lfence();
-    h->shl(h->rdx, 0x20);     // shift to higher half of rdx 0x20(32)
-    h->or_(h->rdx, h->rax);   // rdx has current tsc
+    h->shl(h->rdx, 0x20);    // shift to higher half of rdx 0x20(32)
+    h->or_(h->rdx, h->rax);  // rdx has current tsc
 
     h->mov(h->rax, reinterpret_cast<size_t>(&m_start_node->start_count));
     h->mov(qword[h->rax], h->rdx);
@@ -43,16 +47,19 @@ void jit_perf_count_rdtsc_start_emitter::emit_impl(const std::vector<size_t> &in
 }
 
 ///////////////////jit_perf_count_rdtsc_end_emitter////////////////////////////////////
-jit_perf_count_rdtsc_end_emitter::jit_perf_count_rdtsc_end_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-    const std::shared_ptr<ov::Node>& n) : jit_emitter(host, host_isa) {
-        m_end_node = ov::as_type_ptr<ov::intel_cpu::PerfCountRdtscEnd>(n);
+jit_perf_count_rdtsc_end_emitter::jit_perf_count_rdtsc_end_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                                                   dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                                                                   const std::shared_ptr<ov::Node>& n)
+    : jit_emitter(host, host_isa) {
+    m_end_node = ov::as_type_ptr<ov::intel_cpu::PerfCountRdtscEnd>(n);
 }
 
 size_t jit_perf_count_rdtsc_end_emitter::get_inputs_num() const {
     return 0;
 }
 
-void jit_perf_count_rdtsc_end_emitter::emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const {
+void jit_perf_count_rdtsc_end_emitter::emit_impl(const std::vector<size_t>& in_idxs,
+                                                 const std::vector<size_t>& out_idxs) const {
     h->push(h->rax);
     h->push(h->rdx);
 
@@ -79,6 +86,6 @@ void jit_perf_count_rdtsc_end_emitter::emit_impl(const std::vector<size_t> &in_i
     h->pop(h->rax);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
-#endif // SNIPPETS_DEBUG_CAPS
+}  // namespace intel_cpu
+}  // namespace ov
+#endif  // SNIPPETS_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_rdtsc_emitters.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_rdtsc_emitters.hpp
index c3ae1aac01ab9d..343807bdfcd076 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_rdtsc_emitters.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_perf_count_rdtsc_emitters.hpp
@@ -3,40 +3,40 @@
 //
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#pragma once
-
-#include "emitters/plugin/x64/jit_emitter.hpp"
-
-#include "transformations/snippets/x64/op/perf_count_rdtsc.hpp"
+#    pragma once
 
+#    include "emitters/plugin/x64/jit_emitter.hpp"
+#    include "transformations/snippets/x64/op/perf_count_rdtsc.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
 class jit_perf_count_rdtsc_start_emitter : public jit_emitter {
 public:
-    jit_perf_count_rdtsc_start_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                            const std::shared_ptr<ov::Node>& n);
+    jit_perf_count_rdtsc_start_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                       dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                                       const std::shared_ptr<ov::Node>& n);
     size_t get_inputs_num() const override;
 
 private:
-    void emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_idxs, const std::vector<size_t>& out_idxs) const override;
 
     std::shared_ptr<ov::intel_cpu::PerfCountRdtscBegin> m_start_node = nullptr;
 };
 
 class jit_perf_count_rdtsc_end_emitter : public jit_emitter {
 public:
-    jit_perf_count_rdtsc_end_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-                            const std::shared_ptr<ov::Node>& n);
+    jit_perf_count_rdtsc_end_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                     dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                                     const std::shared_ptr<ov::Node>& n);
     size_t get_inputs_num() const override;
 
 private:
-    void emit_impl(const std::vector<size_t> &in_idxs, const std::vector<size_t> &out_idxs) const override;
+    void emit_impl(const std::vector<size_t>& in_idxs, const std::vector<size_t>& out_idxs) const override;
 
     std::shared_ptr<ov::intel_cpu::PerfCountRdtscEnd> m_end_node = nullptr;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
-#endif // SNIPPETS_DEBUG_CAPS
+}  // namespace intel_cpu
+}  // namespace ov
+#endif  // SNIPPETS_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_segfault_detector_emitter.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_segfault_detector_emitter.cpp
index f88c345ff055b5..c513e969144d1c 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_segfault_detector_emitter.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_segfault_detector_emitter.cpp
@@ -4,8 +4,9 @@
 
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#include "jit_segfault_detector_emitter.hpp"
-#include "emitters/plugin/x64/utils.hpp"
+#    include "jit_segfault_detector_emitter.hpp"
+
+#    include "emitters/plugin/x64/utils.hpp"
 
 using namespace dnnl::impl::utils;
 using namespace dnnl::impl;
@@ -18,22 +19,28 @@ namespace intel_cpu {
 std::shared_ptr<ThreadLocal<jit_uni_segfault_detector_emitter*>> g_custom_segfault_handler =
     std::make_shared<ThreadLocal<jit_uni_segfault_detector_emitter*>>();
 
-jit_uni_segfault_detector_emitter::jit_uni_segfault_detector_emitter(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-    jit_emitter* target_emitter, bool is_load, bool is_store, std::string target_node_name) :
-    jit_emitter(host, host_isa),
-    m_target_emitter(target_emitter),
-    is_target_use_load_emitter(is_load),
-    is_target_use_store_emitter(is_store),
-    m_target_node_name(target_node_name) {
+jit_uni_segfault_detector_emitter::jit_uni_segfault_detector_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                                                     dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                                                                     jit_emitter* target_emitter,
+                                                                     bool is_load,
+                                                                     bool is_store,
+                                                                     std::string target_node_name)
+    : jit_emitter(host, host_isa),
+      m_target_emitter(target_emitter),
+      is_target_use_load_emitter(is_load),
+      is_target_use_store_emitter(is_store),
+      m_target_node_name(target_node_name) {}
+
+size_t jit_uni_segfault_detector_emitter::get_inputs_num() const {
+    return 1;
 }
 
-size_t jit_uni_segfault_detector_emitter::get_inputs_num() const { return 1; }
-
 const jit_emitter* jit_uni_segfault_detector_emitter::get_target_emitter() const {
     return m_target_emitter;
 }
 
-void jit_uni_segfault_detector_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const {
+void jit_uni_segfault_detector_emitter::emit_impl(const std::vector<size_t>& in_vec_idxs,
+                                                  const std::vector<size_t>& out_vec_idxs) const {
     save_target_emitter();
     if (is_target_use_load_emitter) {
         memory_track(in_vec_idxs[0]);
@@ -47,7 +54,8 @@ void jit_uni_segfault_detector_emitter::save_target_emitter() const {
     EmitABIRegSpills spill(h);
     spill.preamble();
 
-    const auto &set_local_handler_overload = static_cast<void (*)(jit_uni_segfault_detector_emitter*)>(set_local_handler);
+    const auto& set_local_handler_overload =
+        static_cast<void (*)(jit_uni_segfault_detector_emitter*)>(set_local_handler);
     h->mov(h->rax, reinterpret_cast<size_t>(set_local_handler_overload));
     h->mov(abi_param1, reinterpret_cast<uint64_t>(this));
 
@@ -85,7 +93,7 @@ void jit_uni_segfault_detector_emitter::memory_track(size_t gpr_idx_for_mem_addr
     h->pop(h->r15);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
 #endif
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_segfault_detector_emitter.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_segfault_detector_emitter.hpp
index 21ffaa84cf3db8..86191ae865fe38 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_segfault_detector_emitter.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_segfault_detector_emitter.hpp
@@ -4,11 +4,12 @@
 
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#pragma once
+#    pragma once
 
-#include <string.h>
-#include "emitters/plugin/x64/jit_emitter.hpp"
-#include "openvino/runtime/threading/thread_local.hpp"
+#    include <string.h>
+
+#    include "emitters/plugin/x64/jit_emitter.hpp"
+#    include "openvino/runtime/threading/thread_local.hpp"
 
 using namespace ov::threading;
 
@@ -20,18 +21,22 @@ extern std::shared_ptr<ThreadLocal<jit_uni_segfault_detector_emitter*>> g_custom
 
 class jit_uni_segfault_detector_emitter : public jit_emitter {
 public:
-    jit_uni_segfault_detector_emitter(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
-        jit_emitter* target_emitter, bool is_load, bool is_store, std::string target_node_name);
+    jit_uni_segfault_detector_emitter(dnnl::impl::cpu::x64::jit_generator* host,
+                                      dnnl::impl::cpu::x64::cpu_isa_t host_isa,
+                                      jit_emitter* target_emitter,
+                                      bool is_load,
+                                      bool is_store,
+                                      std::string target_node_name);
 
     size_t get_inputs_num() const override;
 
     const jit_emitter* get_target_emitter() const;
 
 private:
-    // emit code is to save "this" pointer(jit_uni_segfault_detector_emitter) to global handler, then print info w/ it's target_emitter.
-    // and to save tracked memory address, iteration, etc to print
+    // emit code is to save "this" pointer(jit_uni_segfault_detector_emitter) to global handler, then print info w/ it's
+    // target_emitter. and to save tracked memory address, iteration, etc to print
     void emit_impl(const std::vector<size_t>& in_vec_idxs, const std::vector<size_t>& out_vec_idxs) const override;
-    jit_emitter *m_target_emitter = nullptr;
+    jit_emitter* m_target_emitter = nullptr;
     bool is_target_use_load_emitter = false;
     bool is_target_use_store_emitter = false;
     std::string m_target_node_name = "";
@@ -44,10 +49,10 @@ class jit_uni_segfault_detector_emitter : public jit_emitter {
     mutable size_t current_address = 0;
     mutable size_t iteration = 0;
 
-    friend std::string init_info_jit_uni_segfault_detector_emitter(const jit_uni_segfault_detector_emitter *emitter);
+    friend std::string init_info_jit_uni_segfault_detector_emitter(const jit_uni_segfault_detector_emitter* emitter);
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
 #endif
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_snippets_emitters.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_snippets_emitters.cpp
index d8066f9a126543..ba4012de86d83d 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_snippets_emitters.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_snippets_emitters.cpp
@@ -15,7 +15,10 @@ using jit_generator = dnnl::impl::cpu::x64::jit_generator;
 using cpu_isa_t = dnnl::impl::cpu::x64::cpu_isa_t;
 using ExpressionPtr = ov::snippets::lowered::ExpressionPtr;
 
-jit_nop_emitter::jit_nop_emitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr, emitter_in_out_map emitter_type)
+jit_nop_emitter::jit_nop_emitter(jit_generator* h,
+                                 cpu_isa_t isa,
+                                 const ExpressionPtr& expr,
+                                 emitter_in_out_map emitter_type)
     : jit_emitter(h, isa) {
     in_out_type_ = emitter_type;
 }
@@ -25,7 +28,8 @@ jit_parameter_emitter::jit_parameter_emitter(jit_generator* h, cpu_isa_t isa, co
     in_out_type_ = emitter_in_out_map::gpr_to_gpr;
 }
 
-jit_result_emitter::jit_result_emitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr) : jit_nop_emitter(h, isa, expr) {
+jit_result_emitter::jit_result_emitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr)
+    : jit_nop_emitter(h, isa, expr) {
     in_out_type_ = emitter_in_out_map::gpr_to_gpr;
 }
 
@@ -34,14 +38,13 @@ jit_broadcast_move_emitter::jit_broadcast_move_emitter(jit_generator* h, cpu_isa
     const auto n = expr->get_node();
     if (n->get_input_element_type(0) != n->get_output_element_type(0))
         OV_CPU_JIT_EMITTER_THROW("supports only equal input and output types but gets: ",
-                              n->get_input_element_type(0),
-                              " and ",
-                              n->get_output_element_type(0));
+                                 n->get_input_element_type(0),
+                                 " and ",
+                                 n->get_output_element_type(0));
     byte_size = n->get_input_element_type(0).size();
 }
 
-void jit_broadcast_move_emitter::emit_impl(const std::vector<size_t>& in,
-          const std::vector<size_t>& out) const {
+void jit_broadcast_move_emitter::emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
     if (host_isa_ == dnnl::impl::cpu::x64::sse41) {
         emit_isa<dnnl::impl::cpu::x64::sse41>(in, out);
     } else if (host_isa_ == dnnl::impl::cpu::x64::avx2) {
@@ -54,17 +57,24 @@ void jit_broadcast_move_emitter::emit_impl(const std::vector<size_t>& in,
 }
 
 template <cpu_isa_t isa>
-void jit_broadcast_move_emitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
-    using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,
-            Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
+void jit_broadcast_move_emitter::emit_isa(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
+    using Vmm = typename dnnl::impl::utils::
+        conditional3<isa == dnnl::impl::cpu::x64::sse41, Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
     Xmm xmm_src0 = Xmm(in[0]);
-    Vmm vmm_dst  = Vmm(out[0]);
+    Vmm vmm_dst = Vmm(out[0]);
 
     switch (byte_size) {
-        case 4: h->uni_vbroadcastss(vmm_dst, xmm_src0); break;
-        case 2: h->vpbroadcastw(vmm_dst, xmm_src0); break;
-        case 1: h->vpbroadcastb(vmm_dst, xmm_src0); break;
-        default: OV_CPU_JIT_EMITTER_THROW("unsupported data type");
+    case 4:
+        h->uni_vbroadcastss(vmm_dst, xmm_src0);
+        break;
+    case 2:
+        h->vpbroadcastw(vmm_dst, xmm_src0);
+        break;
+    case 1:
+        h->vpbroadcastb(vmm_dst, xmm_src0);
+        break;
+    default:
+        OV_CPU_JIT_EMITTER_THROW("unsupported data type");
     }
 }
 
@@ -74,14 +84,20 @@ int32_t jit_scalar_emitter::read_value(const ov::snippets::lowered::ExpressionPt
     const auto& precision = n->get_output_element_type(0);
     int32_t res = INT_MIN;
     switch (precision) {
-        case element::i32: res = n->cast_vector<int32_t>(1)[0]; break;
-        case element::f32: res = dnnl::impl::cpu::x64::float2int(n->cast_vector<float>(1)[0]); break;
-        default: OV_CPU_JIT_EMITTER_THROW("doesn't support ", precision);
+    case element::i32:
+        res = n->cast_vector<int32_t>(1)[0];
+        break;
+    case element::f32:
+        res = dnnl::impl::cpu::x64::float2int(n->cast_vector<float>(1)[0]);
+        break;
+    default:
+        OV_CPU_JIT_EMITTER_THROW("doesn't support ", precision);
     }
     return res;
 }
 
-jit_scalar_emitter::jit_scalar_emitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr) : jit_emitter(h, isa) {
+jit_scalar_emitter::jit_scalar_emitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr)
+    : jit_emitter(h, isa) {
     push_arg_entry_of("scalar", read_value(expr), true);
     prepare_table();
 }
@@ -89,21 +105,27 @@ jit_scalar_emitter::jit_scalar_emitter(jit_generator* h, cpu_isa_t isa, const Ex
 void jit_scalar_emitter::emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
     using isa = cpu_isa_t;
     switch (host_isa_) {
-        case isa::sse41: emit_isa<isa::sse41>(in, out); break;
-        case isa::avx2: emit_isa<isa::avx2>(in, out); break;
-        case isa::avx512_core: emit_isa<isa::avx512_core>(in, out); break;
-        default: OV_CPU_JIT_EMITTER_THROW("Unsupported isa ", host_isa_);
+    case isa::sse41:
+        emit_isa<isa::sse41>(in, out);
+        break;
+    case isa::avx2:
+        emit_isa<isa::avx2>(in, out);
+        break;
+    case isa::avx512_core:
+        emit_isa<isa::avx512_core>(in, out);
+        break;
+    default:
+        OV_CPU_JIT_EMITTER_THROW("Unsupported isa ", host_isa_);
     }
 }
 
 template <cpu_isa_t isa>
-void jit_scalar_emitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
-    using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,
-            Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
-    Vmm vmm_dst  = Vmm(out[0]);
+void jit_scalar_emitter::emit_isa(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
+    using Vmm = typename dnnl::impl::utils::
+        conditional3<isa == dnnl::impl::cpu::x64::sse41, Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
+    Vmm vmm_dst = Vmm(out[0]);
     h->uni_vbroadcastss(vmm_dst, table_val("scalar"));
 }
 
-
 }  // namespace intel_cpu
 }  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_snippets_emitters.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_snippets_emitters.hpp
index c75f071c4ec7e0..6a91e3b7c47d3d 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_snippets_emitters.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/jit_snippets_emitters.hpp
@@ -6,16 +6,19 @@
 
 #include "emitters/plugin/x64/jit_emitter.hpp"
 
-
 namespace ov {
 namespace intel_cpu {
 
 class jit_nop_emitter : public jit_emitter {
 public:
-    jit_nop_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
-                    const ov::snippets::lowered::ExpressionPtr& expr, emitter_in_out_map emitter_type = gpr_to_gpr);
+    jit_nop_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                    dnnl::impl::cpu::x64::cpu_isa_t isa,
+                    const ov::snippets::lowered::ExpressionPtr& expr,
+                    emitter_in_out_map emitter_type = gpr_to_gpr);
 
-    size_t get_inputs_num() const override {return 0;}
+    size_t get_inputs_num() const override {
+        return 0;
+    }
 
 private:
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override {}
@@ -23,31 +26,40 @@ class jit_nop_emitter : public jit_emitter {
 
 class jit_parameter_emitter : public jit_nop_emitter {
 public:
-    jit_parameter_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+    jit_parameter_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                          dnnl::impl::cpu::x64::cpu_isa_t isa,
                           const ov::snippets::lowered::ExpressionPtr& expr);
 
-    size_t get_inputs_num() const override { return 0; }
+    size_t get_inputs_num() const override {
+        return 0;
+    }
 };
 
 class jit_result_emitter : public jit_nop_emitter {
 public:
-    jit_result_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+    jit_result_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                       dnnl::impl::cpu::x64::cpu_isa_t isa,
                        const ov::snippets::lowered::ExpressionPtr& expr);
-    size_t get_inputs_num() const override {return 1;}
+    size_t get_inputs_num() const override {
+        return 1;
+    }
 };
 
 class jit_broadcast_move_emitter : public jit_emitter {
 public:
-    jit_broadcast_move_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+    jit_broadcast_move_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                               dnnl::impl::cpu::x64::cpu_isa_t isa,
                                const ov::snippets::lowered::ExpressionPtr& expr);
 
-    size_t get_inputs_num() const override {return 1;}
+    size_t get_inputs_num() const override {
+        return 1;
+    }
 
 private:
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
 
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const;
+    void emit_isa(const std::vector<size_t>& in, const std::vector<size_t>& out) const;
 
 private:
     size_t byte_size = 0lu;
@@ -55,18 +67,23 @@ class jit_broadcast_move_emitter : public jit_emitter {
 
 class jit_scalar_emitter : public jit_emitter {
 public:
-    jit_scalar_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
+    jit_scalar_emitter(dnnl::impl::cpu::x64::jit_generator* h,
+                       dnnl::impl::cpu::x64::cpu_isa_t isa,
                        const ov::snippets::lowered::ExpressionPtr& expr);
 
-    size_t get_inputs_num() const override {return 0;}
-    size_t aux_gprs_count() const override {return 1;}
+    size_t get_inputs_num() const override {
+        return 0;
+    }
+    size_t aux_gprs_count() const override {
+        return 1;
+    }
     static int32_t read_value(const ov::snippets::lowered::ExpressionPtr& expr);
 
 private:
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
     template <dnnl::impl::cpu::x64::cpu_isa_t isa>
-    void emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const;
+    void emit_isa(const std::vector<size_t>& in, const std::vector<size_t>& out) const;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm.cpp
index c57824526d6e20..58a31a1804782a 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm.cpp
@@ -6,13 +6,10 @@
 
 #include "common/utils.hpp"
 #include "dnnl_extension_utils.h"
-
 #include "snippets/lowered/pass/insert_specific_iterations.hpp"
-
 #include "transformations/snippets/x64/op/brgemm_cpu.hpp"
 #include "transformations/snippets/x64/op/brgemm_utils.hpp"
 
-
 using namespace Xbyak;
 using namespace dnnl::impl;
 using namespace dnnl::impl::cpu::x64;
@@ -20,15 +17,21 @@ using namespace dnnl::impl::cpu::x64;
 namespace ov {
 namespace intel_cpu {
 
-BrgemmKernelConfig::BrgemmKernelConfig(const element::Type& in0_dtype, const element::Type& in1_dtype,
-                                       bool is_with_comp, dnnl::impl::cpu::x64::cpu_isa_t primitive_isa)
-    : BrgemmBaseKernelConfig(), m_static_params(std::make_shared<StaticParams>(in0_dtype, in1_dtype, is_with_comp, primitive_isa)) {
+BrgemmKernelConfig::BrgemmKernelConfig(const element::Type& in0_dtype,
+                                       const element::Type& in1_dtype,
+                                       bool is_with_comp,
+                                       dnnl::impl::cpu::x64::cpu_isa_t primitive_isa)
+    : BrgemmBaseKernelConfig(),
+      m_static_params(std::make_shared<StaticParams>(in0_dtype, in1_dtype, is_with_comp, primitive_isa)) {
     m_hash = compute_hash();
 }
 
-BrgemmKernelConfig::StaticParams::StaticParams(const element::Type& in0_dtype, const element::Type& in1_dtype,
-                                               bool is_with_comp, dnnl::impl::cpu::x64::cpu_isa_t primitive_isa)
-    : StaticBaseParams(in0_dtype, in1_dtype, primitive_isa, compute_hash(is_with_comp)), is_with_comp(is_with_comp) {}
+BrgemmKernelConfig::StaticParams::StaticParams(const element::Type& in0_dtype,
+                                               const element::Type& in1_dtype,
+                                               bool is_with_comp,
+                                               dnnl::impl::cpu::x64::cpu_isa_t primitive_isa)
+    : StaticBaseParams(in0_dtype, in1_dtype, primitive_isa, compute_hash(is_with_comp)),
+      is_with_comp(is_with_comp) {}
 
 bool BrgemmKernelConfig::StaticParams::operator==(const StaticParams& rhs) const {
     return StaticBaseParams::operator==(rhs) && is_with_comp == rhs.is_with_comp;
@@ -47,8 +50,8 @@ std::string BrgemmKernelConfig::StaticParams::to_string() const {
 }
 #endif
 
-BrgemmKernelExecutor::BrgemmKernelExecutor(ov::intel_cpu::MultiCacheWeakPtr kernel_cache, BrgemmKernelConfig config) :
-        CPUKernelExecutor<BrgemmKernelConfig, BrgemmCompiledKernel>(std::move(kernel_cache), std::move(config)) { }
+BrgemmKernelExecutor::BrgemmKernelExecutor(ov::intel_cpu::MultiCacheWeakPtr kernel_cache, BrgemmKernelConfig config)
+    : CPUKernelExecutor<BrgemmKernelConfig, BrgemmCompiledKernel>(std::move(kernel_cache), std::move(config)) {}
 
 std::shared_ptr<BrgemmCompiledKernel> BrgemmKernelExecutor::compile_kernel(const BrgemmKernelConfig& config) const {
     std::shared_ptr<BrgemmCompiledKernel> compiled_kernel = std::make_shared<BrgemmCompiledKernel>();
@@ -57,8 +60,17 @@ std::shared_ptr<BrgemmCompiledKernel> BrgemmKernelExecutor::compile_kernel(const
     if (config.is_empty())
         return compiled_kernel;
 
-    create_brgemm_kernel(compiled_kernel->brgemm_kernel, config.get_dt_in0(), config.get_dt_in1(), config.get_isa(),
-                         config.get_M(), config.get_N(), config.get_K(), config.get_LDA(), config.get_LDB(), config.get_LDC(), config.get_beta());
+    create_brgemm_kernel(compiled_kernel->brgemm_kernel,
+                         config.get_dt_in0(),
+                         config.get_dt_in1(),
+                         config.get_isa(),
+                         config.get_M(),
+                         config.get_N(),
+                         config.get_K(),
+                         config.get_LDA(),
+                         config.get_LDB(),
+                         config.get_LDC(),
+                         config.get_beta());
 
     return compiled_kernel;
 }
@@ -81,8 +93,9 @@ void BrgemmKernelExecutor::execute(const BrgemmKernelExecutor* executor, call_ar
 }
 
 #ifdef SNIPPETS_DEBUG_CAPS
-BrgemmKernelReferenceExecutor::BrgemmKernelReferenceExecutor(ov::intel_cpu::MultiCacheWeakPtr kernel_cache, BrgemmKernelConfig config) :
-        BrgemmKernelExecutor(std::move(kernel_cache), std::move(config)) {}
+BrgemmKernelReferenceExecutor::BrgemmKernelReferenceExecutor(ov::intel_cpu::MultiCacheWeakPtr kernel_cache,
+                                                             BrgemmKernelConfig config)
+    : BrgemmKernelExecutor(std::move(kernel_cache), std::move(config)) {}
 
 std::shared_ptr<BrgemmCompiledKernel> BrgemmKernelReferenceExecutor::compile_kernel(const BrgemmKernelConfig& c) const {
     const auto& res = std::make_shared<BrgemmCompiledKernel>();
@@ -91,11 +104,10 @@ std::shared_ptr<BrgemmCompiledKernel> BrgemmKernelReferenceExecutor::compile_ker
 }
 
 brgemm_ref_kernel::brgemm_ref_kernel(BrgemmKernelConfig c) : m_config(std::move(c)) {
-    OV_CPU_JIT_EMITTER_ASSERT(!m_config.is_with_comp(),
-                              "brgemm_ref_kernel doesn't currently support compensations");
-    OV_CPU_JIT_EMITTER_ASSERT(m_config.get_dt_in0() == m_config.get_dt_in1() &&
-                              m_config.get_dt_in0() == dnnl_data_type_t::dnnl_f32,
-                              "brgemm_ref_kernel currently supports only fp32 inputs");
+    OV_CPU_JIT_EMITTER_ASSERT(!m_config.is_with_comp(), "brgemm_ref_kernel doesn't currently support compensations");
+    OV_CPU_JIT_EMITTER_ASSERT(
+        m_config.get_dt_in0() == m_config.get_dt_in1() && m_config.get_dt_in0() == dnnl_data_type_t::dnnl_f32,
+        "brgemm_ref_kernel currently supports only fp32 inputs");
 }
 
 void brgemm_ref_kernel::operator()(dnnl::impl::cpu::x64::brgemm_kernel_params_t* args) const {
@@ -115,5 +127,5 @@ void brgemm_ref_kernel::operator()(dnnl::impl::cpu::x64::brgemm_kernel_params_t*
 }
 #endif
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm.hpp
index 1c3d1e18872aea..9cc17049c4d3ae 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm.hpp
@@ -11,24 +11,33 @@ namespace intel_cpu {
 
 struct BrgemmKernelConfig : public BrgemmBaseKernelConfig {
 public:
-    BrgemmKernelConfig(const element::Type& in0_dtype, const element::Type& in1_dtype,
-                       bool is_with_comp, dnnl::impl::cpu::x64::cpu_isa_t primitive_isa);
+    BrgemmKernelConfig(const element::Type& in0_dtype,
+                       const element::Type& in1_dtype,
+                       bool is_with_comp,
+                       dnnl::impl::cpu::x64::cpu_isa_t primitive_isa);
     BrgemmKernelConfig() = delete;
 
     std::unique_ptr<snippets::KernelExecutorBase::GenericConfig> get_clone_ptr() const override {
         return std::unique_ptr<BrgemmKernelConfig>(new BrgemmKernelConfig(*this));
     }
 
-    bool is_with_comp() const { return m_static_params->is_with_comp; }
+    bool is_with_comp() const {
+        return m_static_params->is_with_comp;
+    }
 
 private:
     struct StaticParams : StaticBaseParams {
-        StaticParams(const element::Type& in0_dtype, const element::Type& in1_dtype, bool is_with_comp, dnnl::impl::cpu::x64::cpu_isa_t primitive_isa);
+        StaticParams(const element::Type& in0_dtype,
+                     const element::Type& in1_dtype,
+                     bool is_with_comp,
+                     dnnl::impl::cpu::x64::cpu_isa_t primitive_isa);
 
-        const bool is_with_comp {false};
+        const bool is_with_comp{false};
 
         bool operator==(const StaticParams& rhs) const;
-        bool operator!=(const StaticParams& rhs) const { return !(*this == rhs); }
+        bool operator!=(const StaticParams& rhs) const {
+            return !(*this == rhs);
+        }
 #ifdef SNIPPETS_DEBUG_CAPS
         std::string to_string() const;
 #endif
@@ -36,9 +45,11 @@ struct BrgemmKernelConfig : public BrgemmBaseKernelConfig {
         static size_t compute_hash(bool is_with_comp);
     };
 
-    std::shared_ptr<StaticBaseParams> get_static_params() const override { return m_static_params; }
+    std::shared_ptr<StaticBaseParams> get_static_params() const override {
+        return m_static_params;
+    }
 
-    std::shared_ptr<StaticParams> m_static_params {nullptr};
+    std::shared_ptr<StaticParams> m_static_params{nullptr};
 };
 
 // The `update_kernel` method verifies that a compiled kernel is not nullptr.
@@ -76,21 +87,25 @@ class BrgemmKernelReferenceExecutor : public BrgemmKernelExecutor {
 public:
     BrgemmKernelReferenceExecutor(ov::intel_cpu::MultiCacheWeakPtr kernel_cache, BrgemmKernelConfig config);
     using BrgemmKernelExecutor::execute;
+
 protected:
     std::shared_ptr<BrgemmCompiledKernel> compile_kernel(const BrgemmKernelConfig& c) const override;
 };
 
 struct brgemm_ref_kernel : public dnnl::impl::cpu::x64::brgemm_kernel_t {
     brgemm_ref_kernel(BrgemmKernelConfig c);
-    void operator()(dnnl::impl::cpu::x64::brgemm_kernel_params_t *) const override;
-    dnnl_status_t create_kernel() override { return dnnl_status_t::dnnl_success; }
-    const dnnl::impl::cpu::x64::jit_generator *get_jit_generator() const override {
+    void operator()(dnnl::impl::cpu::x64::brgemm_kernel_params_t*) const override;
+    dnnl_status_t create_kernel() override {
+        return dnnl_status_t::dnnl_success;
+    }
+    const dnnl::impl::cpu::x64::jit_generator* get_jit_generator() const override {
         OV_CPU_JIT_EMITTER_THROW("get_jit_generator should not be called for reference kernel");
         return nullptr;
     }
+
 private:
     BrgemmKernelConfig m_config;
 };
 #endif
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_amx.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_amx.cpp
index 62c7236735f70e..12c52d43b2c4b8 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_amx.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_amx.cpp
@@ -4,35 +4,40 @@
 
 #include "brgemm_amx.hpp"
 
-#include "transformations/snippets/x64/op/brgemm_utils.hpp"
-#include "transformations/snippets/x64/op/brgemm_cpu.hpp"
-
 #include <cpu/x64/amx_tile_configure.hpp>
 
+#include "transformations/snippets/x64/op/brgemm_cpu.hpp"
+#include "transformations/snippets/x64/op/brgemm_utils.hpp"
 
 #define INNER_K_BLK(dtype) static_cast<dnnl_dim_t>((brgemm_utils::repacking::compute_inner_k_block(in0_dtype)))
 #define VNNI_FACTOR(dtype) static_cast<dnnl_dim_t>((brgemm_utils::compute_vnni_factor(in0_dtype)))
-#define EQ(X) X == rhs.X
-#define HASH(X) seed = hash_combine(seed, X)
-
+#define EQ(X)              X == rhs.X
+#define HASH(X)            seed = hash_combine(seed, X)
 
 using namespace Xbyak;
 using namespace dnnl::impl;
 using namespace dnnl::impl::cpu::x64;
 
-
 namespace ov {
 namespace intel_cpu {
 
-BrgemmAMXKernelConfig::BrgemmAMXKernelConfig(const element::Type& in0_dtype, const element::Type& in1_dtype, dnnl::impl::cpu::x64::cpu_isa_t primitive_isa)
-    : BrgemmBaseKernelConfig(), m_static_params(std::make_shared<StaticParams>(in0_dtype, in1_dtype, primitive_isa)) {
+BrgemmAMXKernelConfig::BrgemmAMXKernelConfig(const element::Type& in0_dtype,
+                                             const element::Type& in1_dtype,
+                                             dnnl::impl::cpu::x64::cpu_isa_t primitive_isa)
+    : BrgemmBaseKernelConfig(),
+      m_static_params(std::make_shared<StaticParams>(in0_dtype, in1_dtype, primitive_isa)) {
     m_hash = compute_hash();
 }
 
-BrgemmAMXKernelConfig::StaticParams::StaticParams(const element::Type& in0_dtype, const element::Type& in1_dtype,
+BrgemmAMXKernelConfig::StaticParams::StaticParams(const element::Type& in0_dtype,
+                                                  const element::Type& in1_dtype,
                                                   dnnl::impl::cpu::x64::cpu_isa_t primitive_isa)
-    : StaticBaseParams(in0_dtype, in1_dtype, primitive_isa, compute_hash(INNER_K_BLK(in0_dtype), VNNI_FACTOR(in0_dtype))),
-      inner_k_blk(INNER_K_BLK(in0_dtype)), vnni_factor(VNNI_FACTOR(in0_dtype)) {}
+    : StaticBaseParams(in0_dtype,
+                       in1_dtype,
+                       primitive_isa,
+                       compute_hash(INNER_K_BLK(in0_dtype), VNNI_FACTOR(in0_dtype))),
+      inner_k_blk(INNER_K_BLK(in0_dtype)),
+      vnni_factor(VNNI_FACTOR(in0_dtype)) {}
 
 bool BrgemmAMXKernelConfig::StaticParams::operator==(const StaticParams& rhs) const {
     return StaticBaseParams::operator==(rhs) && EQ(inner_k_blk) && EQ(vnni_factor);
@@ -40,7 +45,8 @@ bool BrgemmAMXKernelConfig::StaticParams::operator==(const StaticParams& rhs) co
 
 size_t BrgemmAMXKernelConfig::StaticParams::compute_hash(dnnl_dim_t inner_k_blk, dnnl_dim_t vnni_factor) {
     size_t seed = 0;
-    HASH(inner_k_blk); HASH(vnni_factor);
+    HASH(inner_k_blk);
+    HASH(vnni_factor);
     return seed;
 }
 
@@ -58,30 +64,50 @@ std::string BrgemmAMXKernelConfig::StaticParams::to_string() const {
 }
 #endif
 
-BrgemmAMXKernelExecutor::BrgemmAMXKernelExecutor(ov::intel_cpu::MultiCacheWeakPtr kernel_cache, BrgemmAMXKernelConfig config) :
-        CPUKernelExecutor<BrgemmAMXKernelConfig, BrgemmAMXCompiledKernel>(std::move(kernel_cache), std::move(config)) {}
+BrgemmAMXKernelExecutor::BrgemmAMXKernelExecutor(ov::intel_cpu::MultiCacheWeakPtr kernel_cache,
+                                                 BrgemmAMXKernelConfig config)
+    : CPUKernelExecutor<BrgemmAMXKernelConfig, BrgemmAMXCompiledKernel>(std::move(kernel_cache), std::move(config)) {}
 
 namespace {
 struct BrgemmCopyAKey {
-    BrgemmCopyAKey(cpu_isa_t isa, dnnl_data_type_t dt, dnnl_dim_t K, dnnl_dim_t K_blk, dnnl_dim_t K_tail, dnnl_dim_t src_stride, dnnl_dim_t LDA)
-        : isa(isa), dt(dt), K{K}, K_blk{K_blk}, K_tail{K_tail}, src_stride{src_stride}, LDA{LDA} {}
+    BrgemmCopyAKey(cpu_isa_t isa,
+                   dnnl_data_type_t dt,
+                   dnnl_dim_t K,
+                   dnnl_dim_t K_blk,
+                   dnnl_dim_t K_tail,
+                   dnnl_dim_t src_stride,
+                   dnnl_dim_t LDA)
+        : isa(isa),
+          dt(dt),
+          K{K},
+          K_blk{K_blk},
+          K_tail{K_tail},
+          src_stride{src_stride},
+          LDA{LDA} {}
 
     size_t hash() const {
         size_t seed = 0;
-        HASH(isa); HASH(dt); HASH(K); HASH(K_blk); HASH(K_tail); HASH(src_stride); HASH(LDA);
+        HASH(isa);
+        HASH(dt);
+        HASH(K);
+        HASH(K_blk);
+        HASH(K_tail);
+        HASH(src_stride);
+        HASH(LDA);
         return seed;
     }
     bool operator==(const BrgemmCopyAKey& rhs) const {
         return EQ(isa) && EQ(dt) && EQ(K) && EQ(K_blk) && EQ(K_tail) && EQ(src_stride) && EQ(LDA);
     }
 
-    cpu_isa_t isa {cpu_isa_t::isa_undef};
-    dnnl_data_type_t dt {dnnl_data_type_t::dnnl_data_type_undef};
-    dnnl_dim_t K {0}, K_blk {0}, K_tail {0}, src_stride {0}, LDA {0};
+    cpu_isa_t isa{cpu_isa_t::isa_undef};
+    dnnl_data_type_t dt{dnnl_data_type_t::dnnl_data_type_undef};
+    dnnl_dim_t K{0}, K_blk{0}, K_tail{0}, src_stride{0}, LDA{0};
 };
-} // namespace
+}  // namespace
 
-std::shared_ptr<BrgemmAMXCompiledKernel> BrgemmAMXKernelExecutor::compile_kernel(const BrgemmAMXKernelConfig& config) const {
+std::shared_ptr<BrgemmAMXCompiledKernel> BrgemmAMXKernelExecutor::compile_kernel(
+    const BrgemmAMXKernelConfig& config) const {
     std::shared_ptr<BrgemmAMXCompiledKernel> compiled_kernel = std::make_shared<BrgemmAMXCompiledKernel>();
 
     // Brgemm is not executable - nothing to compile
@@ -98,14 +124,26 @@ std::shared_ptr<BrgemmAMXCompiledKernel> BrgemmAMXKernelExecutor::compile_kernel
     };
 
     auto brgemm_builder = [](const BrgemmAMXKernelConfig& k) {
-        std::shared_ptr<BrgemmAMXCompiledKernel::BrgemmKernel> ker = std::make_shared<BrgemmAMXCompiledKernel::BrgemmKernel>();
-        create_brgemm_kernel(ker->brgemm_kernel, k.get_dt_in0(), k.get_dt_in1(), k.get_isa(), k.get_M(), k.get_N(), k.get_K(),
-                             k.get_LDA(), k.get_LDB(), k.get_LDC(), k.get_beta(), true, ker->palette);
+        std::shared_ptr<BrgemmAMXCompiledKernel::BrgemmKernel> ker =
+            std::make_shared<BrgemmAMXCompiledKernel::BrgemmKernel>();
+        create_brgemm_kernel(ker->brgemm_kernel,
+                             k.get_dt_in0(),
+                             k.get_dt_in1(),
+                             k.get_isa(),
+                             k.get_M(),
+                             k.get_N(),
+                             k.get_K(),
+                             k.get_LDA(),
+                             k.get_LDB(),
+                             k.get_LDC(),
+                             k.get_beta(),
+                             true,
+                             ker->palette);
         return ker;
     };
 
     auto brgemm_copy_a_builder = [](const BrgemmCopyAKey& k) {
-        std::shared_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_a_t> ker {nullptr};
+        std::shared_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_a_t> ker{nullptr};
         create_brgemm_copy_a_kernel(ker, k.isa, k.dt, k.K, k.K_blk, k.K_tail, k.src_stride, k.LDA);
         return ker;
     };
@@ -130,7 +168,13 @@ std::shared_ptr<BrgemmAMXCompiledKernel> BrgemmAMXKernelExecutor::compile_kernel
             K_tail = ov::snippets::utils::rnd_up(K_tail, config.get_vnni_factor());
             LDA = K_tail;
 
-            const auto key = BrgemmCopyAKey(config.get_isa(), config.get_dt_in0(), config.get_K(), config.get_inner_K_blk(), K_tail, copy_A_src_stride, LDA);
+            const auto key = BrgemmCopyAKey(config.get_isa(),
+                                            config.get_dt_in0(),
+                                            config.get_K(),
+                                            config.get_inner_K_blk(),
+                                            K_tail,
+                                            copy_A_src_stride,
+                                            LDA);
             const auto result = cache->getOrCreate(key, brgemm_copy_a_builder);
             compiled_kernel->brgemm_copy_a_kernel = result.first;
         }
@@ -142,11 +186,17 @@ std::shared_ptr<BrgemmAMXCompiledKernel> BrgemmAMXKernelExecutor::compile_kernel
     return compiled_kernel;
 }
 
-void BrgemmAMXKernelExecutor::create_brgemm_copy_a_kernel(std::shared_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_a_t>& kernel,
-                                                          dnnl::impl::cpu::x64::cpu_isa_t isa, dnnl_data_type_t dt,
-                                                          dnnl_dim_t K, dnnl_dim_t K_blk, dnnl_dim_t K_tail, dnnl_dim_t src_stride, dnnl_dim_t LDA) {
+void BrgemmAMXKernelExecutor::create_brgemm_copy_a_kernel(
+    std::shared_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_a_t>& kernel,
+    dnnl::impl::cpu::x64::cpu_isa_t isa,
+    dnnl_data_type_t dt,
+    dnnl_dim_t K,
+    dnnl_dim_t K_blk,
+    dnnl_dim_t K_tail,
+    dnnl_dim_t src_stride,
+    dnnl_dim_t LDA) {
     matmul::brgemm_matmul_conf_t conf_;
-    conf_.src_tag = dnnl_abcd; // unused
+    conf_.src_tag = dnnl_abcd;  // unused
     conf_.K = K;
     conf_.K_tail = K_tail;
     conf_.K_blk = K_blk;
@@ -176,18 +226,28 @@ void BrgemmAMXKernelExecutor::update_config(const ov::snippets::lowered::Express
     return BrgemmBaseKernelExecutor::update_config(expr, linear_ir, config);
 }
 
-void BrgemmAMXKernelExecutor::configure_tiles_if_needed(amx_tile_config_t* config, const char* palette, dnnl_dim_t M, dnnl_dim_t N, dnnl_dim_t K) {
+void BrgemmAMXKernelExecutor::configure_tiles_if_needed(amx_tile_config_t* config,
+                                                        const char* palette,
+                                                        dnnl_dim_t M,
+                                                        dnnl_dim_t N,
+                                                        dnnl_dim_t K) {
     auto compatible = [&](amx_tile_config_t* rhs) {
         return rhs && rhs->M == M && rhs->N == N && rhs->K == K;
     };
     if (config && !compatible(config)) {
-        config->M = M; config->N = N; config->K = K;
+        config->M = M;
+        config->N = N;
+        config->K = K;
         cpu::x64::amx_tile_configure(palette);
     }
 }
 
-void BrgemmAMXKernelExecutor::execute_brgemm_copy_a_kernel(const std::shared_ptr<matmul::jit_brgemm_matmul_copy_a_t>& kernel,
-                                                           const void* src, const void* tr_src, dnnl_dim_t M, dnnl_dim_t K) {
+void BrgemmAMXKernelExecutor::execute_brgemm_copy_a_kernel(
+    const std::shared_ptr<matmul::jit_brgemm_matmul_copy_a_t>& kernel,
+    const void* src,
+    const void* tr_src,
+    dnnl_dim_t M,
+    dnnl_dim_t K) {
     auto ctx = matmul::jit_brgemm_matmul_copy_a_t::ctx_t();
 
     ctx.current_M_blk = M;
@@ -219,7 +279,11 @@ void BrgemmAMXKernelExecutor::execute(const BrgemmAMXKernelExecutor* executor, c
 
     if (K_body != 0) {
         const auto& K_body_kernel = kernel->K_body_kernel;
-        configure_tiles_if_needed(args->amx_tile_config, K_body_kernel->palette, config.get_M(), config.get_N(), K_body);
+        configure_tiles_if_needed(args->amx_tile_config,
+                                  K_body_kernel->palette,
+                                  config.get_M(),
+                                  config.get_N(),
+                                  K_body);
         execute_brgemm_kernel(K_body_kernel->brgemm_kernel, src_ptr, wei_ptr, args->C, scratch, false);
 
         src_ptr = src_ptr + K_body * dnnl_data_type_size(config.get_dt_in0());
@@ -235,7 +299,11 @@ void BrgemmAMXKernelExecutor::execute(const BrgemmAMXKernelExecutor* executor, c
         }
 
         const auto& K_tail_kernel = kernel->K_tail_kernel;
-        configure_tiles_if_needed(args->amx_tile_config, K_tail_kernel->palette, config.get_M(), config.get_N(), K_tail);
+        configure_tiles_if_needed(args->amx_tile_config,
+                                  K_tail_kernel->palette,
+                                  config.get_M(),
+                                  config.get_N(),
+                                  K_tail);
         execute_brgemm_kernel(K_tail_kernel->brgemm_kernel, src_ptr, wei_ptr, args->C, scratch, false);
     }
 }
@@ -245,5 +313,5 @@ void BrgemmAMXKernelExecutor::execute(const BrgemmAMXKernelExecutor* executor, c
 #undef EQ
 #undef HASH
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_amx.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_amx.hpp
index a8544e5343b0ce..733295ec995583 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_amx.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_amx.hpp
@@ -4,42 +4,50 @@
 
 #pragma once
 
-#include "brgemm_base.hpp"
-
-#include "emitters/plugin/x64/jit_emitter.hpp"
-#include "emitters/snippets/jit_snippets_call_args.hpp"
-#include "emitters/snippets/cpu_kernel_executor_table.hpp"
-
 #include <cpu/x64/brgemm/brgemm.hpp>
 #include <cpu/x64/matmul/brgemm_matmul_copy_utils.hpp>
 
+#include "brgemm_base.hpp"
+#include "emitters/plugin/x64/jit_emitter.hpp"
+#include "emitters/snippets/cpu_kernel_executor_table.hpp"
+#include "emitters/snippets/jit_snippets_call_args.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
 struct BrgemmAMXKernelConfig : public BrgemmBaseKernelConfig {
 public:
-    BrgemmAMXKernelConfig(const element::Type& in0_dtype, const element::Type& in1_dtype, dnnl::impl::cpu::x64::cpu_isa_t primitive_isa);
+    BrgemmAMXKernelConfig(const element::Type& in0_dtype,
+                          const element::Type& in1_dtype,
+                          dnnl::impl::cpu::x64::cpu_isa_t primitive_isa);
     BrgemmAMXKernelConfig() = delete;
 
     std::unique_ptr<GenericConfig> get_clone_ptr() const override {
         return std::unique_ptr<BrgemmAMXKernelConfig>(new BrgemmAMXKernelConfig(*this));
     }
 
-    dnnl_dim_t get_inner_K_blk() const { return m_static_params->inner_k_blk; }
-    dnnl_dim_t get_vnni_factor() const { return m_static_params->vnni_factor; }
+    dnnl_dim_t get_inner_K_blk() const {
+        return m_static_params->inner_k_blk;
+    }
+    dnnl_dim_t get_vnni_factor() const {
+        return m_static_params->vnni_factor;
+    }
 
     bool need_copy_a(dnnl_dim_t K) const;
 
 private:
     struct StaticParams : StaticBaseParams {
-        StaticParams(const element::Type& in0_dtype, const element::Type& in1_dtype, dnnl::impl::cpu::x64::cpu_isa_t primitive_isa);
+        StaticParams(const element::Type& in0_dtype,
+                     const element::Type& in1_dtype,
+                     dnnl::impl::cpu::x64::cpu_isa_t primitive_isa);
 
-        const dnnl_dim_t inner_k_blk {0};
-        const dnnl_dim_t vnni_factor {0};
+        const dnnl_dim_t inner_k_blk{0};
+        const dnnl_dim_t vnni_factor{0};
 
         bool operator==(const StaticParams& rhs) const;
-        bool operator!=(const StaticParams& rhs) const { return !(*this == rhs); }
+        bool operator!=(const StaticParams& rhs) const {
+            return !(*this == rhs);
+        }
 #ifdef SNIPPETS_DEBUG_CAPS
         std::string to_string() const;
 #endif
@@ -47,22 +55,24 @@ struct BrgemmAMXKernelConfig : public BrgemmBaseKernelConfig {
         static size_t compute_hash(dnnl_dim_t inner_k_blk, dnnl_dim_t vnni_factor);
     };
 
-    std::shared_ptr<StaticBaseParams> get_static_params() const override { return m_static_params; }
+    std::shared_ptr<StaticBaseParams> get_static_params() const override {
+        return m_static_params;
+    }
 
-    std::shared_ptr<StaticParams> m_static_params {nullptr};
+    std::shared_ptr<StaticParams> m_static_params{nullptr};
 };
 
 struct BrgemmAMXCompiledKernel {
     struct BrgemmKernel {
-        std::shared_ptr<dnnl::impl::cpu::x64::brgemm_kernel_t> brgemm_kernel {nullptr};
+        std::shared_ptr<dnnl::impl::cpu::x64::brgemm_kernel_t> brgemm_kernel{nullptr};
         // Note: Palette is treated as a part of a kernel because it is initialized during the kernel compilation stage.
         //       Each kernel need to store the pallet it was compiled with.
         char palette[64] = {};
     };
 
-    std::shared_ptr<BrgemmKernel> K_body_kernel {nullptr};
-    std::shared_ptr<BrgemmKernel> K_tail_kernel {nullptr};
-    std::shared_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_a_t> brgemm_copy_a_kernel {nullptr};
+    std::shared_ptr<BrgemmKernel> K_body_kernel{nullptr};
+    std::shared_ptr<BrgemmKernel> K_tail_kernel{nullptr};
+    std::shared_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_a_t> brgemm_copy_a_kernel{nullptr};
 };
 
 class BrgemmAMXKernelExecutor : public BrgemmBaseKernelExecutor,
@@ -87,16 +97,30 @@ class BrgemmAMXKernelExecutor : public BrgemmBaseKernelExecutor,
                        const ov::snippets::lowered::LinearIRCPtr& linear_ir,
                        BrgemmAMXKernelConfig& config) const override;
 
-    static void configure_tiles_if_needed(amx_tile_config_t* config, const char* palette, dnnl_dim_t M, dnnl_dim_t N, dnnl_dim_t K);
-
-    static void create_brgemm_copy_a_kernel(std::shared_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_a_t>& kernel,
-                                            dnnl::impl::cpu::x64::cpu_isa_t isa, dnnl_data_type_t dt,
-                                            dnnl_dim_t K, dnnl_dim_t K_blk, dnnl_dim_t K_tail, dnnl_dim_t src_stride, dnnl_dim_t LDA);
-
-    static void execute_brgemm_copy_a_kernel(const std::shared_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_a_t>& kernel,
-                                             const void* src, const void* tr_src, dnnl_dim_t M, dnnl_dim_t K);
+    static void configure_tiles_if_needed(amx_tile_config_t* config,
+                                          const char* palette,
+                                          dnnl_dim_t M,
+                                          dnnl_dim_t N,
+                                          dnnl_dim_t K);
+
+    static void create_brgemm_copy_a_kernel(
+        std::shared_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_a_t>& kernel,
+        dnnl::impl::cpu::x64::cpu_isa_t isa,
+        dnnl_data_type_t dt,
+        dnnl_dim_t K,
+        dnnl_dim_t K_blk,
+        dnnl_dim_t K_tail,
+        dnnl_dim_t src_stride,
+        dnnl_dim_t LDA);
+
+    static void execute_brgemm_copy_a_kernel(
+        const std::shared_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_a_t>& kernel,
+        const void* src,
+        const void* tr_src,
+        dnnl_dim_t M,
+        dnnl_dim_t K);
 };
 #define GET_OFF_BRGEMM_AMX_ARGS(field) offsetof(BrgemmAMXKernelExecutor::call_args, field)
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_base.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_base.cpp
index 17b1f0e053b577..008237780de3f6 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_base.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_base.cpp
@@ -9,11 +9,11 @@
 #include "transformations/snippets/x64/op/brgemm_cpu.hpp"
 #include "transformations/snippets/x64/op/brgemm_utils.hpp"
 
-#define DIM_CAST(X) static_cast<dnnl_dim_t>(X)
+#define DIM_CAST(X)   static_cast<dnnl_dim_t>(X)
 #define DTYPE_CAST(X) static_cast<dnnl_data_type_t>(DnnlExtensionUtils::ElementTypeToDataType(X))
-#define PRINT(X) ss << #X  << " = " << X << "\n"
-#define EQ(X) X == rhs.X
-#define HASH(X) seed = hash_combine(seed, X)
+#define PRINT(X)      ss << #X << " = " << X << "\n"
+#define EQ(X)         X == rhs.X
+#define HASH(X)       seed = hash_combine(seed, X)
 
 using namespace Xbyak;
 using namespace dnnl::impl;
@@ -31,22 +31,34 @@ bool BrgemmBaseKernelConfig::is_empty() const {
 }
 
 bool BrgemmBaseKernelConfig::operator==(const BrgemmBaseKernelConfig& rhs) const {
-    return EQ(m_hash) && EQ(m_beta) &&
-           EQ(m_M) && EQ(m_N) && EQ(m_K) &&
-           EQ(m_LDA) && EQ(m_LDB) && EQ(m_LDC) &&
+    return EQ(m_hash) && EQ(m_beta) && EQ(m_M) && EQ(m_N) && EQ(m_K) && EQ(m_LDA) && EQ(m_LDB) && EQ(m_LDC) &&
            (EQ(get_static_params()) || *get_static_params() == *(rhs.get_static_params()));
 }
 
-void BrgemmBaseKernelConfig::update(dnnl_dim_t M, dnnl_dim_t N, dnnl_dim_t K, dnnl_dim_t LDA, dnnl_dim_t LDB, dnnl_dim_t LDC, float beta) {
+void BrgemmBaseKernelConfig::update(dnnl_dim_t M,
+                                    dnnl_dim_t N,
+                                    dnnl_dim_t K,
+                                    dnnl_dim_t LDA,
+                                    dnnl_dim_t LDB,
+                                    dnnl_dim_t LDC,
+                                    float beta) {
     // If M is zero, it means that Brgemm won't be executed (in Loop with work_amount = 0, for example)
     // To process this case, we have to make this Config as empty (nullify runtime parameters)
     if (utils::one_of(0, M, N, K)) {
-        m_M = 0; m_N = 0; m_K = 0;
-        m_LDA = 0; m_LDB = 0; m_LDC = 0;
+        m_M = 0;
+        m_N = 0;
+        m_K = 0;
+        m_LDA = 0;
+        m_LDB = 0;
+        m_LDC = 0;
         m_beta = 0;
     } else {
-        m_M = M; m_N = N; m_K = K;
-        m_LDA = LDA; m_LDB = LDB; m_LDC = LDC;
+        m_M = M;
+        m_N = N;
+        m_K = K;
+        m_LDA = LDA;
+        m_LDB = LDB;
+        m_LDC = LDC;
         m_beta = beta;
     }
     m_hash = compute_hash();
@@ -54,30 +66,45 @@ void BrgemmBaseKernelConfig::update(dnnl_dim_t M, dnnl_dim_t N, dnnl_dim_t K, dn
 
 size_t BrgemmBaseKernelConfig::compute_hash() const {
     size_t seed = get_static_params()->hash();
-    HASH(m_M); HASH(m_N); HASH(m_K);
-    HASH(m_LDA); HASH(m_LDB); HASH(m_LDC);
+    HASH(m_M);
+    HASH(m_N);
+    HASH(m_K);
+    HASH(m_LDA);
+    HASH(m_LDB);
+    HASH(m_LDC);
     HASH(m_beta);
     return seed;
 }
 
-BrgemmBaseKernelConfig::StaticBaseParams::StaticBaseParams(const element::Type& in0_dtype, const element::Type& in1_dtype,
-                                                           cpu_isa_t primitive_isa, size_t hash_seed)
-    : dt_in0(DTYPE_CAST(in0_dtype)), dt_in1(DTYPE_CAST(in1_dtype)), isa(primitive_isa), m_hash(compute_hash(hash_seed, dt_in0, dt_in1, isa)) {}
+BrgemmBaseKernelConfig::StaticBaseParams::StaticBaseParams(const element::Type& in0_dtype,
+                                                           const element::Type& in1_dtype,
+                                                           cpu_isa_t primitive_isa,
+                                                           size_t hash_seed)
+    : dt_in0(DTYPE_CAST(in0_dtype)),
+      dt_in1(DTYPE_CAST(in1_dtype)),
+      isa(primitive_isa),
+      m_hash(compute_hash(hash_seed, dt_in0, dt_in1, isa)) {}
 
 bool BrgemmBaseKernelConfig::StaticBaseParams::operator==(const StaticBaseParams& rhs) const {
     return EQ(hash()) && EQ(dt_in0) && EQ(dt_in1) && EQ(isa);
 }
 
-size_t BrgemmBaseKernelConfig::StaticBaseParams::compute_hash(size_t hash_seed, dnnl_data_type_t dt_in0, dnnl_data_type_t dt_in1, cpu_isa_t isa) {
+size_t BrgemmBaseKernelConfig::StaticBaseParams::compute_hash(size_t hash_seed,
+                                                              dnnl_data_type_t dt_in0,
+                                                              dnnl_data_type_t dt_in1,
+                                                              cpu_isa_t isa) {
     size_t seed = hash_seed;
-    HASH(dt_in0); HASH(dt_in1); HASH(isa);
+    HASH(dt_in0);
+    HASH(dt_in1);
+    HASH(isa);
     return seed;
 }
 
 #ifdef SNIPPETS_DEBUG_CAPS
 std::string BrgemmBaseKernelConfig::StaticBaseParams::to_string() const {
     std::stringstream ss;
-    PRINT(dt_in0); PRINT(dt_in1);
+    PRINT(dt_in0);
+    PRINT(dt_in1);
     PRINT(isa);
     return ss.str();
 }
@@ -85,26 +112,33 @@ std::string BrgemmBaseKernelConfig::StaticBaseParams::to_string() const {
 std::string BrgemmBaseKernelConfig::to_string() const {
     std::stringstream ss;
     ss << get_static_params()->to_string() << "\n";
-    PRINT(m_M); PRINT(m_N); PRINT(m_K);
-    PRINT(m_LDA); PRINT(m_LDB); PRINT(m_LDC);
+    PRINT(m_M);
+    PRINT(m_N);
+    PRINT(m_K);
+    PRINT(m_LDA);
+    PRINT(m_LDB);
+    PRINT(m_LDC);
     PRINT(m_beta);
     return ss.str();
 }
 #endif
 
-float BrgemmBaseKernelExecutor::get_beta(const ov::snippets::lowered::LoopManagerPtr& loop_manager, int loop_id,
+float BrgemmBaseKernelExecutor::get_beta(const ov::snippets::lowered::LoopManagerPtr& loop_manager,
+                                         int loop_id,
                                          const ov::snippets::lowered::ExpandedLoopInfoPtr& current_expanded_loop_info) {
     // Find all Expanded loops with the same Unified loop information -> they were decomposed from this Unified Loop.
     // Note that LoopInfo are normalized and sorted (due to NormalizedLoopIDs pass).
     // It means that previous executed Loops have Loop ID less the current Loop ID.
-    // - If there is executed Loop (work_amount > 0) and evaluated before the current -> the current Brgemm should have `beta = 1`.
+    // - If there is executed Loop (work_amount > 0) and evaluated before the current -> the current Brgemm should have
+    // `beta = 1`.
     // - If there is not this Loop -> the current executed Brgemm should have `beta = 0`.
     if (loop_id > 0) {
         const auto& current_unified_loop_info = current_expanded_loop_info->get_unified_loop_info();
         // Check the previous Loops
         --loop_id;
         while (loop_id >= 0) {
-            const auto& expanded_loop_info = loop_manager->get_loop_info<ov::snippets::lowered::ExpandedLoopInfo>(loop_id);
+            const auto& expanded_loop_info =
+                loop_manager->get_loop_info<ov::snippets::lowered::ExpandedLoopInfo>(loop_id);
             if (expanded_loop_info->get_unified_loop_info() != current_unified_loop_info)
                 return 0;
             if (expanded_loop_info->get_work_amount() > 0) {
@@ -143,7 +177,7 @@ void BrgemmBaseKernelExecutor::update_config(const ov::snippets::lowered::Expres
     size_t loop_idx = 0;
     const auto& loop_ids = expr->get_loop_ids();
     const auto& loop_manager = linear_ir->get_loop_manager();
-    auto get_loop_info = [&](){
+    auto get_loop_info = [&]() {
         OPENVINO_ASSERT(loop_idx < loop_ids.size(), "Loop is missed");
         return loop_manager->get_loop_info<ov::snippets::lowered::ExpandedLoopInfo>(loop_ids[loop_idx++]);
     };
@@ -160,9 +194,11 @@ void BrgemmBaseKernelExecutor::update_config(const ov::snippets::lowered::Expres
         // to avoid extra checks, we validate only first input port
         // Note: We check `is_incremented` attribute only for not incremented ports because
         //       this `is_incremented = true` can be changed by `CleanRepeatedDataPointerShifts` optimization
-        auto check_port = [&](const ov::snippets::lowered::LoopPort& p) { return p.dim_idx == 1; };
+        auto check_port = [&](const ov::snippets::lowered::LoopPort& p) {
+            return p.dim_idx == 1;
+        };
         OPENVINO_ASSERT(in_ports.size() > 1 && std::all_of(in_ports.cbegin(), in_ports.cend(), check_port) &&
-                        out_ports.size() == 1 && check_port(out_ports.back()),
+                            out_ports.size() == 1 && check_port(out_ports.back()),
                         "Incorrect Loop by Brgemm dimension M");
         M = current_expanded_loop_info->get_work_amount() > 0 ? current_expanded_loop_info->get_increment() : 0;
         input_pds[0]->set_subtensor_dim(1, M);
@@ -179,9 +215,12 @@ void BrgemmBaseKernelExecutor::update_config(const ov::snippets::lowered::Expres
         // Quick validation check: Should we check that port is really Brgemm port?
         // Note: We check `is_incremented` attribute only for not incremented ports because
         //       this `is_incremented = true` can be changed by `CleanRepeatedDataPointerShifts` optimization
-        auto check_port = [&](const ov::snippets::lowered::LoopPort& p) { return p.dim_idx == 0; };
-        OPENVINO_ASSERT(in_ports.size() >= 2 && !in_ports.front().is_incremented && std::all_of(in_ports.cbegin(), in_ports.cend(), check_port) &&
-                        out_ports.size() == 1 && check_port(out_ports.back()),
+        auto check_port = [&](const ov::snippets::lowered::LoopPort& p) {
+            return p.dim_idx == 0;
+        };
+        OPENVINO_ASSERT(in_ports.size() >= 2 && !in_ports.front().is_incremented &&
+                            std::all_of(in_ports.cbegin(), in_ports.cend(), check_port) && out_ports.size() == 1 &&
+                            check_port(out_ports.back()),
                         "Incorrect Loop by Brgemm dimension N");
         N = current_expanded_loop_info->get_work_amount() > 0 ? current_expanded_loop_info->get_increment() : 0;
         input_pds[1]->set_subtensor_dim(0, N);
@@ -204,7 +243,7 @@ void BrgemmBaseKernelExecutor::update_config(const ov::snippets::lowered::Expres
         // Note: We check `is_incremented` attribute only for not incremented ports because
         //       this `is_incremented = true` can be changed by `CleanRepeatedDataPointerShifts` optimization
         OPENVINO_ASSERT(in_ports.size() >= 2 && in_ports.front().dim_idx == 0 && in_ports.back().dim_idx == 1 &&
-                        out_ports.size() == 1 && !out_ports.front().is_incremented,
+                            out_ports.size() == 1 && !out_ports.front().is_incremented,
                         "Incorrect Loop by Brgemm dimension K");
         K = current_expanded_loop_info->get_work_amount() > 0 ? current_expanded_loop_info->get_increment() : 0;
         input_pds[0]->set_subtensor_dim(0, K);
@@ -226,13 +265,37 @@ void BrgemmBaseKernelExecutor::update_config(const ov::snippets::lowered::Expres
     config.update(DIM_CAST(M), DIM_CAST(N), DIM_CAST(K), LDA, LDB, LDC, beta);
 }
 
-void BrgemmBaseKernelExecutor::create_brgemm_kernel(std::shared_ptr<brgemm_kernel_t>& kernel, dnnl_data_type_t dt0, dnnl_data_type_t dt1,
-                                                    cpu_isa_t isa, dnnl_dim_t M, dnnl_dim_t N, dnnl_dim_t K,
-                                                    dnnl_dim_t LDA, dnnl_dim_t LDB, dnnl_dim_t LDC, float beta, bool with_amx, char* palette) {
+void BrgemmBaseKernelExecutor::create_brgemm_kernel(std::shared_ptr<brgemm_kernel_t>& kernel,
+                                                    dnnl_data_type_t dt0,
+                                                    dnnl_data_type_t dt1,
+                                                    cpu_isa_t isa,
+                                                    dnnl_dim_t M,
+                                                    dnnl_dim_t N,
+                                                    dnnl_dim_t K,
+                                                    dnnl_dim_t LDA,
+                                                    dnnl_dim_t LDB,
+                                                    dnnl_dim_t LDC,
+                                                    float beta,
+                                                    bool with_amx,
+                                                    char* palette) {
     cpu::x64::brgemm_desc_t desc;
-    OV_CPU_JIT_EMITTER_ASSERT(brgemm_desc_init(&desc, isa, cpu::x64::brgemm_strd, dt0, dt1,
-                                               false, false, cpu::x64::brgemm_row_major, 1.f,
-                                               beta, LDA, LDB, LDC, M, N, K, nullptr) == dnnl_success,
+    OV_CPU_JIT_EMITTER_ASSERT(brgemm_desc_init(&desc,
+                                               isa,
+                                               cpu::x64::brgemm_strd,
+                                               dt0,
+                                               dt1,
+                                               false,
+                                               false,
+                                               cpu::x64::brgemm_row_major,
+                                               1.f,
+                                               beta,
+                                               LDA,
+                                               LDB,
+                                               LDC,
+                                               M,
+                                               N,
+                                               K,
+                                               nullptr) == dnnl_success,
                               "Cannot initialize brgemm descriptor due to invalid params");
 
     if (with_amx) {
@@ -241,12 +304,18 @@ void BrgemmBaseKernelExecutor::create_brgemm_kernel(std::shared_ptr<brgemm_kerne
     }
 
     cpu::x64::brgemm_kernel_t* kernel_ = nullptr;
-    OV_CPU_JIT_EMITTER_ASSERT(brgemm_kernel_create(&kernel_, desc) == dnnl_success, "Cannot create brgemm kernel due to invalid params");
+    OV_CPU_JIT_EMITTER_ASSERT(brgemm_kernel_create(&kernel_, desc) == dnnl_success,
+                              "Cannot create brgemm kernel due to invalid params");
     kernel = std::unique_ptr<brgemm_kernel_t>(kernel_);
 }
 
-void BrgemmBaseKernelExecutor::execute_brgemm_kernel(const std::shared_ptr<dnnl::impl::cpu::x64::brgemm_kernel_t>& kernel,
-                                                     const void* src, const void* wei, void* dst, void* scratch, bool with_comp) {
+void BrgemmBaseKernelExecutor::execute_brgemm_kernel(
+    const std::shared_ptr<dnnl::impl::cpu::x64::brgemm_kernel_t>& kernel,
+    const void* src,
+    const void* wei,
+    void* dst,
+    void* scratch,
+    bool with_comp) {
     cpu::x64::brgemm_kernel_params_t brgemm_p;
     brgemm_p.batch = nullptr;  // default value
     brgemm_p.ptr_A = src;
@@ -269,5 +338,5 @@ void BrgemmBaseKernelExecutor::execute_brgemm_kernel(const std::shared_ptr<dnnl:
 #undef EQ
 #undef HASH
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_base.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_base.hpp
index 74a5c2b76daf65..674ea42522230b 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_base.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_base.hpp
@@ -4,17 +4,15 @@
 
 #pragma once
 
-#include "openvino/core/type/element_type.hpp"
+#include <cpu/x64/brgemm/brgemm.hpp>
 
 #include "cpu/x64/cpu_isa_traits.hpp"
-
 #include "emitters/plugin/x64/jit_emitter.hpp"
-#include "emitters/snippets/jit_snippets_call_args.hpp"
 #include "emitters/snippets/cpu_kernel_executor_table.hpp"
-#include <cpu/x64/brgemm/brgemm.hpp>
-
-#include "snippets/lowered/loop_manager.hpp"
+#include "emitters/snippets/jit_snippets_call_args.hpp"
+#include "openvino/core/type/element_type.hpp"
 #include "snippets/lowered/loop_info.hpp"
+#include "snippets/lowered/loop_manager.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -24,27 +22,51 @@ struct BrgemmBaseKernelConfig : public snippets::KernelExecutorBase::GenericConf
     BrgemmBaseKernelConfig() = default;
 
     bool is_completed() const override;
-    size_t hash() const override { return m_hash; }
+    size_t hash() const override {
+        return m_hash;
+    }
 
     bool is_empty() const;
     void update(dnnl_dim_t M, dnnl_dim_t N, dnnl_dim_t K, dnnl_dim_t LDA, dnnl_dim_t LDB, dnnl_dim_t LDC, float beta);
 
     bool operator==(const BrgemmBaseKernelConfig& rhs) const;
-    bool operator!=(const BrgemmBaseKernelConfig& rhs) const {return !(*this == rhs);}
-
-    dnnl_data_type_t get_dt_in0() const { return get_static_params()->dt_in0; }
-    dnnl_data_type_t get_dt_in1() const { return get_static_params()->dt_in1; }
-
-    dnnl::impl::cpu::x64::cpu_isa_t get_isa() const { return get_static_params()->isa; }
-    float get_beta() const { return m_beta; }
-
-    dnnl_dim_t get_M() const { return m_M; }
-    dnnl_dim_t get_N() const { return m_N; }
-    dnnl_dim_t get_K() const { return m_K; }
-
-    dnnl_dim_t get_LDA() const { return m_LDA; }
-    dnnl_dim_t get_LDB() const { return m_LDB; }
-    dnnl_dim_t get_LDC() const { return m_LDC; }
+    bool operator!=(const BrgemmBaseKernelConfig& rhs) const {
+        return !(*this == rhs);
+    }
+
+    dnnl_data_type_t get_dt_in0() const {
+        return get_static_params()->dt_in0;
+    }
+    dnnl_data_type_t get_dt_in1() const {
+        return get_static_params()->dt_in1;
+    }
+
+    dnnl::impl::cpu::x64::cpu_isa_t get_isa() const {
+        return get_static_params()->isa;
+    }
+    float get_beta() const {
+        return m_beta;
+    }
+
+    dnnl_dim_t get_M() const {
+        return m_M;
+    }
+    dnnl_dim_t get_N() const {
+        return m_N;
+    }
+    dnnl_dim_t get_K() const {
+        return m_K;
+    }
+
+    dnnl_dim_t get_LDA() const {
+        return m_LDA;
+    }
+    dnnl_dim_t get_LDB() const {
+        return m_LDB;
+    }
+    dnnl_dim_t get_LDC() const {
+        return m_LDC;
+    }
 
 #ifdef SNIPPETS_DEBUG_CAPS
     std::string to_string() const override;
@@ -52,51 +74,77 @@ struct BrgemmBaseKernelConfig : public snippets::KernelExecutorBase::GenericConf
 
 protected:
     struct StaticBaseParams {
-        StaticBaseParams(const element::Type& in0_dtype, const element::Type& in1_dtype, dnnl::impl::cpu::x64::cpu_isa_t primitive_isa, size_t hash_seed);
+        StaticBaseParams(const element::Type& in0_dtype,
+                         const element::Type& in1_dtype,
+                         dnnl::impl::cpu::x64::cpu_isa_t primitive_isa,
+                         size_t hash_seed);
         virtual ~StaticBaseParams() = default;
 
-        const dnnl_data_type_t dt_in0 {dnnl_f32}, dt_in1 {dnnl_f32};
-        const dnnl::impl::cpu::x64::cpu_isa_t isa {dnnl::impl::cpu::x64::isa_undef};
+        const dnnl_data_type_t dt_in0{dnnl_f32}, dt_in1{dnnl_f32};
+        const dnnl::impl::cpu::x64::cpu_isa_t isa{dnnl::impl::cpu::x64::isa_undef};
 
-        size_t hash() const { return m_hash; }
+        size_t hash() const {
+            return m_hash;
+        }
 
         bool operator==(const StaticBaseParams& rhs) const;
-        bool operator!=(const StaticBaseParams& rhs) const { return !(*this == rhs); }
+        bool operator!=(const StaticBaseParams& rhs) const {
+            return !(*this == rhs);
+        }
 #ifdef SNIPPETS_DEBUG_CAPS
         std::string to_string() const;
 #endif
     protected:
-        static size_t compute_hash(size_t hash_seed, dnnl_data_type_t dt_in0, dnnl_data_type_t dt_in1, dnnl::impl::cpu::x64::cpu_isa_t isa);
+        static size_t compute_hash(size_t hash_seed,
+                                   dnnl_data_type_t dt_in0,
+                                   dnnl_data_type_t dt_in1,
+                                   dnnl::impl::cpu::x64::cpu_isa_t isa);
 
-        const size_t m_hash {0};
+        const size_t m_hash{0};
     };
 
     virtual std::shared_ptr<StaticBaseParams> get_static_params() const = 0;
     size_t compute_hash() const;
 
-    dnnl_dim_t m_M {0}, m_N {0}, m_K {0}, m_LDA {0}, m_LDB {0}, m_LDC {0};
-    float m_beta {0};
-    size_t m_hash {SIZE_MAX};
+    dnnl_dim_t m_M{0}, m_N{0}, m_K{0}, m_LDA{0}, m_LDB{0}, m_LDC{0};
+    float m_beta{0};
+    size_t m_hash{SIZE_MAX};
 };
 
 class BrgemmBaseKernelExecutor {
 public:
     virtual ~BrgemmBaseKernelExecutor() = default;
+
 protected:
-    static float get_beta(const ov::snippets::lowered::LoopManagerPtr& loop_manager, int loop_id,
+    static float get_beta(const ov::snippets::lowered::LoopManagerPtr& loop_manager,
+                          int loop_id,
                           const ov::snippets::lowered::ExpandedLoopInfoPtr& current_expanded_loop_info);
 
     static void update_config(const ov::snippets::lowered::ExpressionPtr& expr,
                               const ov::snippets::lowered::LinearIRCPtr& linear_ir,
                               BrgemmBaseKernelConfig& config);
 
-    static void create_brgemm_kernel(std::shared_ptr<dnnl::impl::cpu::x64::brgemm_kernel_t>& kernel, dnnl_data_type_t dt0, dnnl_data_type_t dt1,
-                                     dnnl::impl::cpu::x64::cpu_isa_t isa, dnnl_dim_t M, dnnl_dim_t N, dnnl_dim_t K,
-                                     dnnl_dim_t LDA, dnnl_dim_t LDB, dnnl_dim_t LDC, float beta, bool with_amx = false, char* palette = nullptr);
-
-    static void execute_brgemm_kernel(const std::shared_ptr<dnnl::impl::cpu::x64::brgemm_kernel_t>& kernel, const void* src, const void* wei,
-                                      void* dst, void* scratch, bool with_comp);
+    static void create_brgemm_kernel(std::shared_ptr<dnnl::impl::cpu::x64::brgemm_kernel_t>& kernel,
+                                     dnnl_data_type_t dt0,
+                                     dnnl_data_type_t dt1,
+                                     dnnl::impl::cpu::x64::cpu_isa_t isa,
+                                     dnnl_dim_t M,
+                                     dnnl_dim_t N,
+                                     dnnl_dim_t K,
+                                     dnnl_dim_t LDA,
+                                     dnnl_dim_t LDB,
+                                     dnnl_dim_t LDC,
+                                     float beta,
+                                     bool with_amx = false,
+                                     char* palette = nullptr);
+
+    static void execute_brgemm_kernel(const std::shared_ptr<dnnl::impl::cpu::x64::brgemm_kernel_t>& kernel,
+                                      const void* src,
+                                      const void* wei,
+                                      void* dst,
+                                      void* scratch,
+                                      bool with_comp);
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_copy_b.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_copy_b.cpp
index cc79458c7c4c64..dd216517ace12e 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_copy_b.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_copy_b.cpp
@@ -4,8 +4,8 @@
 
 #include "brgemm_copy_b.hpp"
 
-#include "snippets/lowered/loop_manager.hpp"
 #include "emitters/plugin/x64/utils.hpp"
+#include "snippets/lowered/loop_manager.hpp"
 #include "transformations/snippets/x64/op/brgemm_utils.hpp"
 
 #define DTYPE_CAST(X) static_cast<dnnl_data_type_t>(DnnlExtensionUtils::ElementTypeToDataType(X))
@@ -16,8 +16,12 @@ using namespace dnnl::impl::cpu::x64;
 namespace ov {
 namespace intel_cpu {
 
-BrgemmCopyBKernelConfig::BrgemmCopyBKernelConfig(const element::Type& src_dt, const element::Type& wei_dt, cpu_isa_t isa,
-                                                 bool is_with_comp, bool is_transposed_B, dnnl_dim_t wei_N_blk)
+BrgemmCopyBKernelConfig::BrgemmCopyBKernelConfig(const element::Type& src_dt,
+                                                 const element::Type& wei_dt,
+                                                 cpu_isa_t isa,
+                                                 bool is_with_comp,
+                                                 bool is_transposed_B,
+                                                 dnnl_dim_t wei_N_blk)
     : m_static_params(std::make_shared<StaticParams>(src_dt, wei_dt, isa, is_with_comp, is_transposed_B, wei_N_blk)) {
     m_hash = compute_hash();
 }
@@ -37,17 +41,28 @@ bool BrgemmCopyBKernelConfig::operator==(const BrgemmCopyBKernelConfig& rhs) con
 #undef EQ
 }
 
-void BrgemmCopyBKernelConfig::update(dnnl_dim_t N, dnnl_dim_t N_blk, dnnl_dim_t K, dnnl_dim_t K_blk, dnnl_dim_t copy_B_wei_stride, dnnl_dim_t LDB) {
-    // If one of the dims is zero, it means that BrgemmCopyB won't be executed (in Loop with work_amount = 0, for example)
-    // To process this case, we have to make this Config as empty (nullify runtime parameters)
+void BrgemmCopyBKernelConfig::update(dnnl_dim_t N,
+                                     dnnl_dim_t N_blk,
+                                     dnnl_dim_t K,
+                                     dnnl_dim_t K_blk,
+                                     dnnl_dim_t copy_B_wei_stride,
+                                     dnnl_dim_t LDB) {
+    // If one of the dims is zero, it means that BrgemmCopyB won't be executed (in Loop with work_amount = 0, for
+    // example) To process this case, we have to make this Config as empty (nullify runtime parameters)
     if (utils::one_of(0, N, K)) {
-        m_N = 0; m_N_blk = 0;
-        m_K = 0; m_K_blk = 0;
-        m_copy_B_wei_stride = 0; m_LDB = 0;
+        m_N = 0;
+        m_N_blk = 0;
+        m_K = 0;
+        m_K_blk = 0;
+        m_copy_B_wei_stride = 0;
+        m_LDB = 0;
     } else {
-        m_N = N; m_N_blk = N_blk;
-        m_K = K; m_K_blk = K_blk;
-        m_copy_B_wei_stride = copy_B_wei_stride; m_LDB = LDB;
+        m_N = N;
+        m_N_blk = N_blk;
+        m_K = K;
+        m_K_blk = K_blk;
+        m_copy_B_wei_stride = copy_B_wei_stride;
+        m_LDB = LDB;
     }
     m_hash = compute_hash();
 }
@@ -55,59 +70,94 @@ void BrgemmCopyBKernelConfig::update(dnnl_dim_t N, dnnl_dim_t N_blk, dnnl_dim_t
 size_t BrgemmCopyBKernelConfig::compute_hash() const {
     size_t seed = m_static_params->hash;
 #define HASH(X) seed = hash_combine(seed, X)
-    HASH(m_N); HASH(m_N_blk);
-    HASH(m_K); HASH(m_K_blk);
-    HASH(m_copy_B_wei_stride); HASH(m_LDB);
+    HASH(m_N);
+    HASH(m_N_blk);
+    HASH(m_K);
+    HASH(m_K_blk);
+    HASH(m_copy_B_wei_stride);
+    HASH(m_LDB);
 #undef HASH
     return seed;
 }
 
-BrgemmCopyBKernelConfig::StaticParams::StaticParams(const element::Type& src_type, const element::Type& wei_type, cpu_isa_t isa,
-                                                    bool is_with_comp, bool is_transposed_B, dnnl_dim_t wei_n_blk)
-    : src_dt(DTYPE_CAST(src_type)), wei_dt(DTYPE_CAST(wei_type)), isa(isa),
-      is_with_comp(is_with_comp), is_transposed_B(is_transposed_B), wei_N_blk(wei_n_blk),
+BrgemmCopyBKernelConfig::StaticParams::StaticParams(const element::Type& src_type,
+                                                    const element::Type& wei_type,
+                                                    cpu_isa_t isa,
+                                                    bool is_with_comp,
+                                                    bool is_transposed_B,
+                                                    dnnl_dim_t wei_n_blk)
+    : src_dt(DTYPE_CAST(src_type)),
+      wei_dt(DTYPE_CAST(wei_type)),
+      isa(isa),
+      is_with_comp(is_with_comp),
+      is_transposed_B(is_transposed_B),
+      wei_N_blk(wei_n_blk),
       hash(init_hash(src_dt, wei_dt, isa, is_with_comp, is_transposed_B, wei_N_blk)) {}
 
 bool BrgemmCopyBKernelConfig::StaticParams::operator==(const StaticParams& rhs) const {
 #define EQ(X) X == rhs.X
-    return EQ(hash) && EQ(src_dt) && EQ(wei_dt)&& EQ(isa) && EQ(is_with_comp) && EQ(is_transposed_B) && EQ(wei_N_blk);
+    return EQ(hash) && EQ(src_dt) && EQ(wei_dt) && EQ(isa) && EQ(is_with_comp) && EQ(is_transposed_B) && EQ(wei_N_blk);
 #undef EQ
 }
 
-size_t BrgemmCopyBKernelConfig::StaticParams::init_hash(const dnnl_data_type_t& src_dt, const dnnl_data_type_t& wei_dt, cpu_isa_t isa,
-                                                        bool is_with_comp, bool is_transposed_B, dnnl_dim_t wei_N_blk) {
+size_t BrgemmCopyBKernelConfig::StaticParams::init_hash(const dnnl_data_type_t& src_dt,
+                                                        const dnnl_data_type_t& wei_dt,
+                                                        cpu_isa_t isa,
+                                                        bool is_with_comp,
+                                                        bool is_transposed_B,
+                                                        dnnl_dim_t wei_N_blk) {
     size_t seed = 0;
 #define HASH(X) seed = hash_combine(seed, X)
-    HASH(src_dt); HASH(wei_dt); HASH(isa);
-    HASH(is_with_comp); HASH(is_transposed_B); HASH(wei_N_blk);
+    HASH(src_dt);
+    HASH(wei_dt);
+    HASH(isa);
+    HASH(is_with_comp);
+    HASH(is_transposed_B);
+    HASH(wei_N_blk);
 #undef HASH
     return seed;
 }
 
 #ifdef SNIPPETS_DEBUG_CAPS
-#define PRINT(X) ss << #X  << " = " << X << "\n"
+#    define PRINT(X) ss << #X << " = " << X << "\n"
 std::string BrgemmCopyBKernelConfig::to_string() const {
     std::stringstream ss;
     ss << m_static_params->to_string() << "\n";
-    PRINT(m_hash); PRINT(m_N); PRINT(m_N_blk);
-    PRINT(m_K); PRINT(m_K_blk); PRINT(m_LDB); PRINT(m_copy_B_wei_stride);
+    PRINT(m_hash);
+    PRINT(m_N);
+    PRINT(m_N_blk);
+    PRINT(m_K);
+    PRINT(m_K_blk);
+    PRINT(m_LDB);
+    PRINT(m_copy_B_wei_stride);
     return ss.str();
 }
 std::string BrgemmCopyBKernelConfig::StaticParams::to_string() const {
     std::stringstream ss;
-    PRINT(src_dt); PRINT(wei_dt); PRINT(isa);
-    PRINT(is_with_comp); PRINT(is_transposed_B); PRINT(wei_N_blk);
+    PRINT(src_dt);
+    PRINT(wei_dt);
+    PRINT(isa);
+    PRINT(is_with_comp);
+    PRINT(is_transposed_B);
+    PRINT(wei_N_blk);
     return ss.str();
 }
-#undef PRINT
+#    undef PRINT
 #endif
 
 BrgemmCopyBKernel::BrgemmCopyBKernel() : jit_generator(jit_name()), ker_(nullptr) {}
 
 BrgemmCopyBKernel::BrgemmCopyBKernel(const BrgemmCopyBKernelConfig& conf)
-    : jit_generator(jit_name()), is_with_comp(conf.is_with_comp()), is_transpose(conf.is_transposed_B()),
-      wei_data_size(dnnl_data_type_size(conf.get_wei_dt())), vnni_factor(data_type_vnni_granularity(conf.get_wei_dt())),
-      K(conf.get_K()), N_blk(conf.get_N_blk()), wei_N_blk(conf.get_wei_N_blk()), wei_N_tail(conf.get_wei_N_tail()), ker_(nullptr) {
+    : jit_generator(jit_name()),
+      is_with_comp(conf.is_with_comp()),
+      is_transpose(conf.is_transposed_B()),
+      wei_data_size(dnnl_data_type_size(conf.get_wei_dt())),
+      vnni_factor(data_type_vnni_granularity(conf.get_wei_dt())),
+      K(conf.get_K()),
+      N_blk(conf.get_N_blk()),
+      wei_N_blk(conf.get_wei_N_blk()),
+      wei_N_tail(conf.get_wei_N_tail()),
+      ker_(nullptr) {
     init_brgemm_copy_b_kernel(dnnl_brgemm_copy_b_kernel, conf);
     OV_CPU_JIT_EMITTER_ASSERT(dnnl_brgemm_copy_b_kernel, "Kernel is missed!");
 }
@@ -124,8 +174,9 @@ void BrgemmCopyBKernel::operator()(const call_args* args) const {
     ker_(args);
 }
 
-void BrgemmCopyBKernel::init_brgemm_copy_b_kernel(std::unique_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_b_t>& kernel,
-                                                  const BrgemmCopyBKernelConfig& conf) const {
+void BrgemmCopyBKernel::init_brgemm_copy_b_kernel(
+    std::unique_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_b_t>& kernel,
+    const BrgemmCopyBKernelConfig& conf) const {
     matmul::brgemm_matmul_conf_t brgCopyKernelConf;
     brgCopyKernelConf.src_dt = conf.get_src_dt();
     brgCopyKernelConf.wei_dt = conf.get_wei_dt();
@@ -143,8 +194,10 @@ void BrgemmCopyBKernel::init_brgemm_copy_b_kernel(std::unique_ptr<dnnl::impl::cp
     brgCopyKernelConf.K = conf.get_K_blk();
     brgCopyKernelConf.K_blk = conf.get_K_blk();
     brgCopyKernelConf.N_chunk_elems = brgCopyKernelConf.N_blk;
-    brgCopyKernelConf.b_dt_sz = DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(brgCopyKernelConf.wei_dt));
-    brgCopyKernelConf.tr_b_dt_sz = DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(brgCopyKernelConf.wei_dt));
+    brgCopyKernelConf.b_dt_sz =
+        DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(brgCopyKernelConf.wei_dt));
+    brgCopyKernelConf.tr_b_dt_sz =
+        DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(brgCopyKernelConf.wei_dt));
 
     brgCopyKernelConf.req_wei_vnni_downconvert = false;
 
@@ -191,28 +244,35 @@ void BrgemmCopyBKernel::generate() {
     postamble();
 }
 
-void BrgemmCopyBKernel::emit_brgemm_copy_b_kernel_call(size_t N, size_t K, size_t offset_in, size_t offset_out, size_t offset_comp) {
+void BrgemmCopyBKernel::emit_brgemm_copy_b_kernel_call(size_t N,
+                                                       size_t K,
+                                                       size_t offset_in,
+                                                       size_t offset_out,
+                                                       size_t offset_comp) {
     EmitABIRegSpills spill(this);
     spill.preamble();
 
     const auto add_offset = [&](Xbyak::Reg64 reg, size_t bytes_offset) {
-        if (bytes_offset) add(reg, bytes_offset);
+        if (bytes_offset)
+            add(reg, bytes_offset);
     };
 
     // save function address in gpr to pass in call instruction
-    const auto& kernel_overload = static_cast<void (*)(matmul::jit_brgemm_matmul_copy_b_t*, const void*, const void*, const void*, size_t, size_t)>(execute);
+    const auto& kernel_overload = static_cast<
+        void (*)(matmul::jit_brgemm_matmul_copy_b_t*, const void*, const void*, const void*, size_t, size_t)>(execute);
     mov(rbp, reinterpret_cast<uintptr_t>(kernel_overload));
     mov(abi_param1, reinterpret_cast<uintptr_t>(dnnl_brgemm_copy_b_kernel.get()));
 
-    add_offset(src_reg, offset_in); // abi_param2
-    add_offset(tr_src_reg, offset_out); // abi_param3
-    if (is_with_comp)  // abi_param4
+    add_offset(src_reg, offset_in);      // abi_param2
+    add_offset(tr_src_reg, offset_out);  // abi_param3
+    if (is_with_comp)                    // abi_param4
         add_offset(comp_reg, offset_comp);
     else
         mov(comp_reg, reinterpret_cast<uintptr_t>(nullptr));
 
 #ifdef _WIN32
-    // Note: ABI requires that the remaining parameters (except the first for) are pushed to the stack in right-to-left order
+    // Note: ABI requires that the remaining parameters (except the first for) are pushed to the stack in right-to-left
+    // order
     //  Shadow space will be allocated inside internal_call_rsp_align()
     push(K);
     push(N);
@@ -233,7 +293,12 @@ void BrgemmCopyBKernel::emit_brgemm_copy_b_kernel_call(size_t N, size_t K, size_
     spill.postamble();
 }
 
-void BrgemmCopyBKernel::execute(matmul::jit_brgemm_matmul_copy_b_t* kernel, const void* src, const void* dst, const void* comp, size_t N, size_t K) {
+void BrgemmCopyBKernel::execute(matmul::jit_brgemm_matmul_copy_b_t* kernel,
+                                const void* src,
+                                const void* dst,
+                                const void* comp,
+                                size_t N,
+                                size_t K) {
     auto ctx = matmul::jit_brgemm_matmul_copy_b_t::ctx_t();
     ctx.current_N_blk = N;
     ctx.src = src;
@@ -248,10 +313,12 @@ void BrgemmCopyBKernel::execute(matmul::jit_brgemm_matmul_copy_b_t* kernel, cons
     (*kernel)(&ctx);
 }
 
-BrgemmCopyBKernelExecutor::BrgemmCopyBKernelExecutor(ov::intel_cpu::MultiCacheWeakPtr kernel_cache, BrgemmCopyBKernelConfig config)
-    : CPUKernelExecutor<BrgemmCopyBKernelConfig, BrgemmCopyBKernel>(std::move(kernel_cache), std::move(config)) { }
+BrgemmCopyBKernelExecutor::BrgemmCopyBKernelExecutor(ov::intel_cpu::MultiCacheWeakPtr kernel_cache,
+                                                     BrgemmCopyBKernelConfig config)
+    : CPUKernelExecutor<BrgemmCopyBKernelConfig, BrgemmCopyBKernel>(std::move(kernel_cache), std::move(config)) {}
 
-std::shared_ptr<BrgemmCopyBKernel> BrgemmCopyBKernelExecutor::compile_kernel(const BrgemmCopyBKernelConfig& config) const {
+std::shared_ptr<BrgemmCopyBKernel> BrgemmCopyBKernelExecutor::compile_kernel(
+    const BrgemmCopyBKernelConfig& config) const {
     std::shared_ptr<BrgemmCopyBKernel> compiled_kernel = std::make_shared<BrgemmCopyBKernel>();
     // BrgemmCopyB is not executable - nothing to compile
     if (!config.is_empty()) {
@@ -283,14 +350,16 @@ void BrgemmCopyBKernelExecutor::update_config(const ov::snippets::lowered::Expre
     const auto& loop_manager = linear_ir->get_loop_manager();
 
     auto init = [&](size_t& dim, size_t& blk, size_t idx) {
-        OPENVINO_ASSERT(idx < planar_shape.size() && idx < in_subtensor.size(), "Index must be less than shape/subtensor rank!");
+        OPENVINO_ASSERT(idx < planar_shape.size() && idx < in_subtensor.size(),
+                        "Index must be less than shape/subtensor rank!");
         dim = *(planar_shape.rbegin() + idx);
         blk = *(in_subtensor.rbegin() + idx);
         if (ov::snippets::utils::is_full_dim_value(blk)) {
             blk = dim;
         } else {
             OPENVINO_ASSERT(loop_idx < loop_ids.size(), "Loop is missed");
-            const auto& current_expanded_loop_info = loop_manager->get_loop_info<ov::snippets::lowered::ExpandedLoopInfo>(loop_ids[loop_idx++]);
+            const auto& current_expanded_loop_info =
+                loop_manager->get_loop_info<ov::snippets::lowered::ExpandedLoopInfo>(loop_ids[loop_idx++]);
             blk = current_expanded_loop_info->get_increment();
             input_desc->set_subtensor_dim(idx, blk);
             output_desc->set_subtensor_dim(idx, blk);
@@ -306,7 +375,9 @@ void BrgemmCopyBKernelExecutor::update_config(const ov::snippets::lowered::Expre
 
     const auto& brg_weight_etype = expr->get_node()->get_input_element_type(0);
     const auto LDB = brgemm_utils::repacking::compute_LDB(N_dim, brg_weight_etype);
-    const auto copy_B_wei_stride = ov::snippets::utils::get_dim_stride(expr->get_input_port(0), config.is_transposed_B() ? 0 : 1) * brg_weight_etype.size();
+    const auto copy_B_wei_stride =
+        ov::snippets::utils::get_dim_stride(expr->get_input_port(0), config.is_transposed_B() ? 0 : 1) *
+        brg_weight_etype.size();
 
     config.update(N_dim, N_blk, K_dim, K_blk, copy_B_wei_stride, LDB);
 }
@@ -318,5 +389,5 @@ void BrgemmCopyBKernelExecutor::execute(const BrgemmCopyBKernelExecutor* executo
     (*kernel)(args);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_copy_b.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_copy_b.hpp
index c4e3f3622ad88f..b3b107cd676705 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_copy_b.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/kernel_executors/brgemm_copy_b.hpp
@@ -4,13 +4,12 @@
 
 #pragma once
 
-#include "emitters/plugin/x64/jit_emitter.hpp"
-#include "emitters/snippets/jit_snippets_call_args.hpp"
-#include "emitters/snippets/cpu_kernel_executor_table.hpp"
-
 #include <cpu/x64/brgemm/brgemm.hpp>
 #include <cpu/x64/matmul/brgemm_matmul_copy_utils.hpp>
 
+#include "emitters/plugin/x64/jit_emitter.hpp"
+#include "emitters/snippets/cpu_kernel_executor_table.hpp"
+#include "emitters/snippets/jit_snippets_call_args.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -18,11 +17,17 @@ namespace intel_cpu {
 struct BrgemmCopyBKernelConfig : public snippets::KernelExecutorBase::GenericConfig {
 public:
     BrgemmCopyBKernelConfig() = default;
-    BrgemmCopyBKernelConfig(const element::Type& src_dt, const element::Type& wei_dt, dnnl::impl::cpu::x64::cpu_isa_t isa,
-                            bool is_with_comp, bool is_transposed_B, dnnl_dim_t wei_N_blk);
+    BrgemmCopyBKernelConfig(const element::Type& src_dt,
+                            const element::Type& wei_dt,
+                            dnnl::impl::cpu::x64::cpu_isa_t isa,
+                            bool is_with_comp,
+                            bool is_transposed_B,
+                            dnnl_dim_t wei_N_blk);
 
     bool operator==(const BrgemmCopyBKernelConfig& rhs) const;
-    bool operator!=(const BrgemmCopyBKernelConfig& rhs) const {return !(*this == rhs);}
+    bool operator!=(const BrgemmCopyBKernelConfig& rhs) const {
+        return !(*this == rhs);
+    }
 
     std::unique_ptr<GenericConfig> get_clone_ptr() const override {
         return std::unique_ptr<BrgemmCopyBKernelConfig>(new BrgemmCopyBKernelConfig(*this));
@@ -31,26 +36,61 @@ struct BrgemmCopyBKernelConfig : public snippets::KernelExecutorBase::GenericCon
     bool is_empty() const;
     bool is_completed() const override;
 
-    void update(dnnl_dim_t N, dnnl_dim_t N_blk, dnnl_dim_t K, dnnl_dim_t K_blk, dnnl_dim_t copy_B_wei_stride, dnnl_dim_t LDB);
+    void update(dnnl_dim_t N,
+                dnnl_dim_t N_blk,
+                dnnl_dim_t K,
+                dnnl_dim_t K_blk,
+                dnnl_dim_t copy_B_wei_stride,
+                dnnl_dim_t LDB);
 
-    size_t hash() const override { return m_hash; }
+    size_t hash() const override {
+        return m_hash;
+    }
 
-    dnnl_data_type_t get_src_dt() const { return m_static_params->src_dt; }
-    dnnl_data_type_t get_wei_dt() const { return m_static_params->wei_dt; }
+    dnnl_data_type_t get_src_dt() const {
+        return m_static_params->src_dt;
+    }
+    dnnl_data_type_t get_wei_dt() const {
+        return m_static_params->wei_dt;
+    }
 
-    dnnl::impl::cpu::x64::cpu_isa_t get_isa() const { return m_static_params->isa; }
-    bool is_with_comp() const { return m_static_params->is_with_comp; }
-    bool is_transposed_B() const { return m_static_params->is_transposed_B; }
+    dnnl::impl::cpu::x64::cpu_isa_t get_isa() const {
+        return m_static_params->isa;
+    }
+    bool is_with_comp() const {
+        return m_static_params->is_with_comp;
+    }
+    bool is_transposed_B() const {
+        return m_static_params->is_transposed_B;
+    }
 
-    dnnl_dim_t get_N() const { return m_N; }
-    dnnl_dim_t get_N_blk() const { return m_N_blk; }
-    dnnl_dim_t get_N_tail() const { return m_N % m_N_blk; }
-    dnnl_dim_t get_wei_N_blk() const { return m_static_params->wei_N_blk; }
-    dnnl_dim_t get_wei_N_tail() const { return m_N_blk % m_static_params->wei_N_blk; }
-    dnnl_dim_t get_K() const { return m_K; }
-    dnnl_dim_t get_K_blk() const { return m_K_blk; }
-    dnnl_dim_t get_copy_B_wei_stride() const { return m_copy_B_wei_stride; }
-    dnnl_dim_t get_LDB() const { return m_LDB; }
+    dnnl_dim_t get_N() const {
+        return m_N;
+    }
+    dnnl_dim_t get_N_blk() const {
+        return m_N_blk;
+    }
+    dnnl_dim_t get_N_tail() const {
+        return m_N % m_N_blk;
+    }
+    dnnl_dim_t get_wei_N_blk() const {
+        return m_static_params->wei_N_blk;
+    }
+    dnnl_dim_t get_wei_N_tail() const {
+        return m_N_blk % m_static_params->wei_N_blk;
+    }
+    dnnl_dim_t get_K() const {
+        return m_K;
+    }
+    dnnl_dim_t get_K_blk() const {
+        return m_K_blk;
+    }
+    dnnl_dim_t get_copy_B_wei_stride() const {
+        return m_copy_B_wei_stride;
+    }
+    dnnl_dim_t get_LDB() const {
+        return m_LDB;
+    }
 
 #ifdef SNIPPETS_DEBUG_CAPS
     std::string to_string() const override;
@@ -58,35 +98,45 @@ struct BrgemmCopyBKernelConfig : public snippets::KernelExecutorBase::GenericCon
 
 private:
     struct StaticParams {
-        StaticParams(const element::Type& src_dt, const element::Type& wei_dt, dnnl::impl::cpu::x64::cpu_isa_t isa,
-                     bool is_with_comp, bool is_transposed_B, dnnl_dim_t wei_N_blk);
-
-        const dnnl_data_type_t src_dt {dnnl_data_type_undef}, wei_dt {dnnl_data_type_undef};
-        const dnnl::impl::cpu::x64::cpu_isa_t isa {dnnl::impl::cpu::x64::isa_undef};
-        const bool is_with_comp {false};
-        const bool is_transposed_B {false};
-        const dnnl_dim_t wei_N_blk {0};
-        const size_t hash {0};
+        StaticParams(const element::Type& src_dt,
+                     const element::Type& wei_dt,
+                     dnnl::impl::cpu::x64::cpu_isa_t isa,
+                     bool is_with_comp,
+                     bool is_transposed_B,
+                     dnnl_dim_t wei_N_blk);
+
+        const dnnl_data_type_t src_dt{dnnl_data_type_undef}, wei_dt{dnnl_data_type_undef};
+        const dnnl::impl::cpu::x64::cpu_isa_t isa{dnnl::impl::cpu::x64::isa_undef};
+        const bool is_with_comp{false};
+        const bool is_transposed_B{false};
+        const dnnl_dim_t wei_N_blk{0};
+        const size_t hash{0};
 
         bool operator==(const StaticParams& rhs) const;
-        bool operator!=(const StaticParams& rhs) const { return !(*this == rhs); }
+        bool operator!=(const StaticParams& rhs) const {
+            return !(*this == rhs);
+        }
 
 #ifdef SNIPPETS_DEBUG_CAPS
         std::string to_string() const;
 #endif
 
     private:
-        static size_t init_hash(const dnnl_data_type_t& src_dt, const dnnl_data_type_t& wei_dt, dnnl::impl::cpu::x64::cpu_isa_t primitive_isa,
-                                bool is_with_comp, bool is_transposed_B, dnnl_dim_t wei_N_blk);
+        static size_t init_hash(const dnnl_data_type_t& src_dt,
+                                const dnnl_data_type_t& wei_dt,
+                                dnnl::impl::cpu::x64::cpu_isa_t primitive_isa,
+                                bool is_with_comp,
+                                bool is_transposed_B,
+                                dnnl_dim_t wei_N_blk);
     };
 
     size_t compute_hash() const;
 
     std::shared_ptr<StaticParams> m_static_params;
-    dnnl_dim_t m_N {0}, m_N_blk {0};
-    dnnl_dim_t m_K {0}, m_K_blk {0};
-    dnnl_dim_t m_copy_B_wei_stride {0}, m_LDB {0};
-    size_t m_hash {SIZE_MAX};
+    dnnl_dim_t m_N{0}, m_N_blk{0};
+    dnnl_dim_t m_K{0}, m_K_blk{0};
+    dnnl_dim_t m_copy_B_wei_stride{0}, m_LDB{0};
+    size_t m_hash{SIZE_MAX};
 };
 
 struct BrgemmCopyBKernel : public dnnl::impl::cpu::x64::jit_generator {
@@ -109,8 +159,12 @@ struct BrgemmCopyBKernel : public dnnl::impl::cpu::x64::jit_generator {
 
     void emit_brgemm_copy_b_kernel_call(size_t N, size_t K, size_t offset_in, size_t offset_out, size_t offset_comp);
 
-    static void execute(dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_b_t* kernel, const void* src, const void* dst, const void* comp,
-                        size_t N, size_t K);
+    static void execute(dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_b_t* kernel,
+                        const void* src,
+                        const void* dst,
+                        const void* comp,
+                        size_t N,
+                        size_t K);
 
     void init_brgemm_copy_b_kernel(std::unique_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_b_t>& kernel,
                                    const BrgemmCopyBKernelConfig& conf) const;
@@ -151,5 +205,5 @@ class BrgemmCopyBKernelExecutor : public CPUKernelExecutor<BrgemmCopyBKernelConf
 };
 #define GET_OFF_BRGEMM_COPY_B_ARGS(field) offsetof(BrgemmCopyBKernel::call_args, field)
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/utils.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/utils.cpp
index 687a397addc208..0604792fc22573 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/utils.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/utils.cpp
@@ -4,11 +4,10 @@
 
 #include "utils.hpp"
 
+#include "emitters/utils.hpp"
 #include "snippets/lowered/expressions/buffer_expression.hpp"
-#include "snippets/op/memory_access.hpp"
 #include "snippets/op/loop.hpp"
-
-#include "emitters/utils.hpp"
+#include "snippets/op/memory_access.hpp"
 
 using namespace dnnl::impl::cpu::x64;
 
@@ -26,18 +25,18 @@ size_t get_buffer_cluster_id(const ov::snippets::lowered::ExpressionPort& port)
     size_t offset = ov::snippets::utils::get_dynamic_value<size_t>();
     size_t id = SIZE_MAX;
     switch (port.get_type()) {
-        case ov::snippets::lowered::ExpressionPort::Type::Input:
-            offset = ma_op->get_input_offset(port.get_index());
-            id = get_cluster_id(port.get_port_connector_ptr()->get_source());
-            break;
-        case ov::snippets::lowered::ExpressionPort::Type::Output:
-            offset = ma_op->get_output_offset(port.get_index());
-            for (const auto& child : port.get_connected_ports())
-                if (!ov::is_type<snippets::op::LoopEnd>(child.get_expr()->get_node()))
-                    id = get_cluster_id(child);
-            break;
-        default:
-            OV_CPU_JIT_EMITTER_THROW("Uknown type of expression port!");
+    case ov::snippets::lowered::ExpressionPort::Type::Input:
+        offset = ma_op->get_input_offset(port.get_index());
+        id = get_cluster_id(port.get_port_connector_ptr()->get_source());
+        break;
+    case ov::snippets::lowered::ExpressionPort::Type::Output:
+        offset = ma_op->get_output_offset(port.get_index());
+        for (const auto& child : port.get_connected_ports())
+            if (!ov::is_type<snippets::op::LoopEnd>(child.get_expr()->get_node()))
+                id = get_cluster_id(child);
+        break;
+    default:
+        OV_CPU_JIT_EMITTER_THROW("Uknown type of expression port!");
     }
     OV_CPU_JIT_EMITTER_ASSERT(IMPLICATION(ov::snippets::utils::is_dynamic_value(offset), id != SIZE_MAX),
                               "In dynamic case Buffer Cluster ID must be known!");
@@ -46,31 +45,41 @@ size_t get_buffer_cluster_id(const ov::snippets::lowered::ExpressionPort& port)
 
 Xbyak::Reg64 get_aux_gpr(const std::vector<size_t>& used_gpr_idxs) {
     // RSP, RBP - stack-related registers, abi_param1 - runtime parameter register in the kernel
-    static std::unordered_set<size_t> blacklist_gpr_idxs = { Xbyak::Operand::RSP, Xbyak::Operand::RBP, static_cast<size_t>(abi_param1.getIdx()) };
+    static std::unordered_set<size_t> blacklist_gpr_idxs = {Xbyak::Operand::RSP,
+                                                            Xbyak::Operand::RBP,
+                                                            static_cast<size_t>(abi_param1.getIdx())};
     for (size_t gpr_idx = 0; gpr_idx <= Xbyak::Operand::R15; ++gpr_idx) {
-        size_t _idx = Xbyak::Operand::R15 - gpr_idx; // we allocate from the end
-        if (std::find(used_gpr_idxs.cbegin(), used_gpr_idxs.cend(), _idx) != used_gpr_idxs.cend()) continue;
-        if (blacklist_gpr_idxs.count(_idx) > 0) continue;
+        size_t _idx = Xbyak::Operand::R15 - gpr_idx;  // we allocate from the end
+        if (std::find(used_gpr_idxs.cbegin(), used_gpr_idxs.cend(), _idx) != used_gpr_idxs.cend())
+            continue;
+        if (blacklist_gpr_idxs.count(_idx) > 0)
+            continue;
         return Xbyak::Reg64(_idx);
     }
     OV_CPU_JIT_EMITTER_THROW("Failed to allocate aux GPR");
 }
 
-void push_ptr_with_runtime_offset_on_stack(dnnl::impl::cpu::x64::jit_generator* h, size_t stack_offset,
-                                           Xbyak::Reg64 ptr_reg, Xbyak::Reg64 aux_reg, size_t runtime_offset) {
+void push_ptr_with_runtime_offset_on_stack(dnnl::impl::cpu::x64::jit_generator* h,
+                                           size_t stack_offset,
+                                           Xbyak::Reg64 ptr_reg,
+                                           Xbyak::Reg64 aux_reg,
+                                           size_t runtime_offset) {
     const auto stack_frame = h->qword[h->rsp + stack_offset];
     h->mov(aux_reg, ptr_reg);
     h->add(aux_reg, h->ptr[abi_param1 + runtime_offset]);
     h->mov(stack_frame, aux_reg);
 }
 
-void push_ptr_with_static_offset_on_stack(dnnl::impl::cpu::x64::jit_generator* h, size_t stack_offset,
-                                          Xbyak::Reg64 ptr_reg, size_t ptr_offset) {
+void push_ptr_with_static_offset_on_stack(dnnl::impl::cpu::x64::jit_generator* h,
+                                          size_t stack_offset,
+                                          Xbyak::Reg64 ptr_reg,
+                                          size_t ptr_offset) {
     const auto stack_frame = h->qword[h->rsp + stack_offset];
     h->mov(stack_frame, ptr_reg);
-    if (ptr_offset != 0) h->add(stack_frame, ptr_offset);
+    if (ptr_offset != 0)
+        h->add(stack_frame, ptr_offset);
 }
 
-}   // namespace utils
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace utils
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/utils.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/utils.hpp
index 97ea86f404fd67..3d8026ea33c750 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/utils.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/utils.hpp
@@ -13,13 +13,17 @@ namespace utils {
 
 inline static std::vector<Xbyak::Reg64> transform_idxs_to_regs(const std::vector<size_t>& idxs) {
     std::vector<Xbyak::Reg64> regs(idxs.size());
-    std::transform(idxs.begin(), idxs.end(), regs.begin(), [](size_t idx){return Xbyak::Reg64(static_cast<int>(idx));});
+    std::transform(idxs.begin(), idxs.end(), regs.begin(), [](size_t idx) {
+        return Xbyak::Reg64(static_cast<int>(idx));
+    });
     return regs;
 }
 
 inline static std::vector<size_t> transform_snippets_regs_to_idxs(const std::vector<snippets::Reg>& regs) {
     std::vector<size_t> idxs(regs.size());
-    std::transform(regs.cbegin(), regs.cend(), idxs.begin(), [](const snippets::Reg& reg) { return reg.idx; });
+    std::transform(regs.cbegin(), regs.cend(), idxs.begin(), [](const snippets::Reg& reg) {
+        return reg.idx;
+    });
     return idxs;
 }
 
@@ -46,8 +50,11 @@ Xbyak::Reg64 get_aux_gpr(const std::vector<size_t>& used_gpr_idxs);
  * @param aux_reg aux register
  * @param runtime_offset offset in runtime params `abi_param1`
  */
-void push_ptr_with_runtime_offset_on_stack(dnnl::impl::cpu::x64::jit_generator* h, size_t stack_offset,
-                                           Xbyak::Reg64 ptr_reg, Xbyak::Reg64 aux_reg, size_t runtime_offset);
+void push_ptr_with_runtime_offset_on_stack(dnnl::impl::cpu::x64::jit_generator* h,
+                                           size_t stack_offset,
+                                           Xbyak::Reg64 ptr_reg,
+                                           Xbyak::Reg64 aux_reg,
+                                           size_t runtime_offset);
 
 /**
  * @brief Push data pointer on stack adding static offset `ptr_offset`
@@ -56,9 +63,11 @@ void push_ptr_with_runtime_offset_on_stack(dnnl::impl::cpu::x64::jit_generator*
  * @param ptr_reg register contains data pointer
  * @param ptr_offset offset which will be added to data pointer
  */
-void push_ptr_with_static_offset_on_stack(dnnl::impl::cpu::x64::jit_generator* h, size_t stack_offset,
-                                          Xbyak::Reg64 ptr_reg, size_t ptr_offset);
+void push_ptr_with_static_offset_on_stack(dnnl::impl::cpu::x64::jit_generator* h,
+                                          size_t stack_offset,
+                                          Xbyak::Reg64 ptr_reg,
+                                          size_t ptr_offset);
 
-}   // namespace utils
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace utils
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/verbose.cpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/verbose.cpp
index 269212edf1ab9b..9ac7f0d5cd0ffc 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/verbose.cpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/verbose.cpp
@@ -4,20 +4,20 @@
 
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#include "verbose.hpp"
-#include "jit_segfault_detector_emitter.hpp"
-#include "jit_memory_emitters.hpp"
-#include "jit_brgemm_emitter.hpp"
-#include "jit_brgemm_copy_b_emitter.hpp"
-#include "jit_kernel_emitter.hpp"
-#include "jit_snippets_emitters.hpp"
-#include "kernel_executors/brgemm.hpp"
-#include "kernel_executors/brgemm_amx.hpp"
+#    include "verbose.hpp"
 
+#    include "jit_brgemm_copy_b_emitter.hpp"
+#    include "jit_brgemm_emitter.hpp"
+#    include "jit_kernel_emitter.hpp"
+#    include "jit_memory_emitters.hpp"
+#    include "jit_segfault_detector_emitter.hpp"
+#    include "jit_snippets_emitters.hpp"
+#    include "kernel_executors/brgemm.hpp"
+#    include "kernel_executors/brgemm_amx.hpp"
 
-#ifndef _WIN32
-#include <cxxabi.h>
-#endif
+#    ifndef _WIN32
+#        include <cxxabi.h>
+#    endif
 
 namespace ov {
 namespace intel_cpu {
@@ -44,50 +44,44 @@ std::string vector_to_string(const T& v) {
 
 std::string get_emitter_type_name(const jit_emitter* emitter) {
     std::string name = typeid(*emitter).name();
-#ifndef _WIN32
+#    ifndef _WIN32
     int status;
-    std::unique_ptr<char, void (*)(void*)> demangled_name(
-            abi::__cxa_demangle(name.c_str(), nullptr, nullptr, &status),
-            std::free);
+    std::unique_ptr<char, void (*)(void*)> demangled_name(abi::__cxa_demangle(name.c_str(), nullptr, nullptr, &status),
+                                                          std::free);
     name = demangled_name.get();
-#endif
+#    endif
     return name;
 }
 
-std::string init_info_jit_memory_emitter(const jit_memory_emitter *emitter) {
+std::string init_info_jit_memory_emitter(const jit_memory_emitter* emitter) {
     std::stringstream ss;
-    ss << " src_precision:" << emitter->src_prc
-       << " dst_precision:" << emitter->dst_prc
-       << " load/store_element_number:" << emitter->count
-       << " byte_offset:" << emitter->compiled_byte_offset;
+    ss << " src_precision:" << emitter->src_prc << " dst_precision:" << emitter->dst_prc
+       << " load/store_element_number:" << emitter->count << " byte_offset:" << emitter->compiled_byte_offset;
     return ss.str();
 }
 
-static std::string init_info_jit_load_memory_emitter(const jit_load_memory_emitter *emitter) {
+static std::string init_info_jit_load_memory_emitter(const jit_load_memory_emitter* emitter) {
     std::stringstream ss;
     std::string memory_emitter_info = init_info_jit_memory_emitter(emitter);
-    ss << "Emitter_type_name:jit_load_memory_emitter"
-       << memory_emitter_info;
+    ss << "Emitter_type_name:jit_load_memory_emitter" << memory_emitter_info;
     return ss.str();
 }
 
-static std::string init_info_jit_load_broadcast_emitter(const jit_load_broadcast_emitter *emitter) {
+static std::string init_info_jit_load_broadcast_emitter(const jit_load_broadcast_emitter* emitter) {
     std::stringstream ss;
     std::string memory_emitter_info = init_info_jit_memory_emitter(emitter);
-    ss << "Emitter_type_name:jit_load_broadcast_emitter"
-       << memory_emitter_info;
+    ss << "Emitter_type_name:jit_load_broadcast_emitter" << memory_emitter_info;
     return ss.str();
 }
 
-static std::string init_info_jit_store_memory_emitter(const jit_store_memory_emitter *emitter) {
+static std::string init_info_jit_store_memory_emitter(const jit_store_memory_emitter* emitter) {
     std::stringstream ss;
     std::string memory_emitter_info = init_info_jit_memory_emitter(emitter);
-    ss << "Emitter_type_name:jit_store_memory_emitter"
-       << memory_emitter_info;
+    ss << "Emitter_type_name:jit_store_memory_emitter" << memory_emitter_info;
     return ss.str();
 }
 
-std::string init_info_jit_brgemm_emitter(const jit_brgemm_emitter *emitter) {
+std::string init_info_jit_brgemm_emitter(const jit_brgemm_emitter* emitter) {
     std::stringstream ss;
     ss << "Emitter_type_name:jit_brgemm_emitter";
     if (const auto& common = std::dynamic_pointer_cast<BrgemmKernelExecutor>(emitter->m_kernel_executor))
@@ -100,10 +94,9 @@ std::string init_info_jit_brgemm_emitter(const jit_brgemm_emitter *emitter) {
     return ss.str();
 }
 
-std::string init_info_jit_brgemm_copy_b_emitter(const jit_brgemm_copy_b_emitter *emitter) {
+std::string init_info_jit_brgemm_copy_b_emitter(const jit_brgemm_copy_b_emitter* emitter) {
     std::stringstream ss;
-    ss << "Emitter_type_name:jit_brgemm_copy_b_emitter"
-       <<  emitter->m_kernel_executor->to_string()
+    ss << "Emitter_type_name:jit_brgemm_copy_b_emitter" << emitter->m_kernel_executor->to_string()
        << " m_memory_offset:" << vector_to_string(emitter->m_memory_offsets)
        << " m_buffer_ids:" << vector_to_string(emitter->m_buffer_ids);
 
@@ -114,11 +107,9 @@ std::string init_info_jit_kernel_static_emitter(const jit_kernel_static_emitter*
     std::stringstream ss;
     ss << "Emitter_type_name:jit_kernel_static_emitter"
        << " jcp.exec_domain:" << vector_to_string(emitter->jcp.exec_domain)
-       << " gp_regs_pool:"<< vector_to_string(emitter->gp_regs_pool)
-       << " master_shape:" << vector_to_string(emitter->master_shape)
-       << " num_inputs:" << emitter->num_inputs
-       << " num_outputs:" << emitter->num_outputs
-       << " num_unique_buffers:" << emitter->num_unique_buffers
+       << " gp_regs_pool:" << vector_to_string(emitter->gp_regs_pool)
+       << " master_shape:" << vector_to_string(emitter->master_shape) << " num_inputs:" << emitter->num_inputs
+       << " num_outputs:" << emitter->num_outputs << " num_unique_buffers:" << emitter->num_unique_buffers
        << " data_ptr_regs_idx:" << vector_to_string(emitter->data_ptr_regs_idx)
        << " vec_regs_pool:" << vector_to_string(emitter->vec_regs_pool)
        << " reg_indexes_idx:" << emitter->reg_indexes_idx
@@ -131,24 +122,20 @@ std::string init_info_jit_kernel_static_emitter(const jit_kernel_static_emitter*
 std::string init_info_jit_kernel_dynamic_emitter(const jit_kernel_dynamic_emitter* emitter) {
     std::stringstream ss;
     ss << "Emitter_type_name:jit_kernel_dynamic_emitter"
-       << " gp_regs_pool:"<< vector_to_string(emitter->gp_regs_pool)
-       << " num_inputs:" << emitter->num_inputs
-       << " num_outputs:" << emitter->num_outputs
-       << " num_unique_buffers:" << emitter->num_unique_buffers
+       << " gp_regs_pool:" << vector_to_string(emitter->gp_regs_pool) << " num_inputs:" << emitter->num_inputs
+       << " num_outputs:" << emitter->num_outputs << " num_unique_buffers:" << emitter->num_unique_buffers
        << " data_ptr_regs_idx:" << vector_to_string(emitter->data_ptr_regs_idx)
        << " vec_regs_pool:" << vector_to_string(emitter->vec_regs_pool)
        << " reg_runtime_params_idx:" << emitter->reg_runtime_params_idx;
     return ss.str();
 }
 
-std::string init_info_jit_uni_segfault_detector_emitter(const jit_uni_segfault_detector_emitter *emitter) {
+std::string init_info_jit_uni_segfault_detector_emitter(const jit_uni_segfault_detector_emitter* emitter) {
     std::stringstream ss;
-    ss << "Node_name:" << emitter->m_target_node_name
-       << " use_load_emitter:"<< emitter->is_target_use_load_emitter
-       << " use_store_emitter:"<< emitter->is_target_use_store_emitter;
+    ss << "Node_name:" << emitter->m_target_node_name << " use_load_emitter:" << emitter->is_target_use_load_emitter
+       << " use_store_emitter:" << emitter->is_target_use_store_emitter;
     if (emitter->is_target_use_load_emitter || emitter->is_target_use_store_emitter) {
-        ss << " start_address:" << emitter->start_address
-           << " current_address:" << emitter->current_address
+        ss << " start_address:" << emitter->start_address << " current_address:" << emitter->current_address
            << " iteration:" << emitter->iteration << " ";
     }
     // traget emitter info
@@ -158,14 +145,15 @@ std::string init_info_jit_uni_segfault_detector_emitter(const jit_uni_segfault_d
     return ss.str();
 }
 
-static std::string init_info_jit_emitter_general(const jit_emitter *emitter) {
+static std::string init_info_jit_emitter_general(const jit_emitter* emitter) {
     std::stringstream ss;
     ss << "Emitter_type_name:" << get_emitter_type_name(emitter);
     return ss.str();
 }
 
-void jit_emitter_info_t::init(const jit_emitter *emitter) {
-    if (is_initialized_) return;
+void jit_emitter_info_t::init(const jit_emitter* emitter) {
+    if (is_initialized_)
+        return;
     if (auto e_type = dynamic_cast<const jit_load_memory_emitter*>(emitter)) {
         str_ = init_info_jit_load_memory_emitter(e_type);
     } else if (auto e_type = dynamic_cast<const jit_load_broadcast_emitter*>(emitter)) {
@@ -188,7 +176,7 @@ void jit_emitter_info_t::init(const jit_emitter *emitter) {
     is_initialized_ = true;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
 #endif
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/emitters/snippets/x64/verbose.hpp b/src/plugins/intel_cpu/src/emitters/snippets/x64/verbose.hpp
index a81364039b98a7..ffbe210f75d2ff 100644
--- a/src/plugins/intel_cpu/src/emitters/snippets/x64/verbose.hpp
+++ b/src/plugins/intel_cpu/src/emitters/snippets/x64/verbose.hpp
@@ -4,27 +4,30 @@
 
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#pragma once
+#    pragma once
 
-#include <sstream>
+#    include <sstream>
 
 namespace ov {
 namespace intel_cpu {
 class jit_emitter;
 struct jit_emitter_info_t {
     jit_emitter_info_t() = default;
-    jit_emitter_info_t(const jit_emitter_info_t &rhs)
-        : str_(rhs.str_), is_initialized_(rhs.is_initialized_) {}
-    jit_emitter_info_t &operator=(const jit_emitter_info_t &rhs) {
+    jit_emitter_info_t(const jit_emitter_info_t& rhs) : str_(rhs.str_), is_initialized_(rhs.is_initialized_) {}
+    jit_emitter_info_t& operator=(const jit_emitter_info_t& rhs) {
         is_initialized_ = rhs.is_initialized_;
         str_ = rhs.str_;
         return *this;
     }
 
-    const char *c_str() const { return str_.c_str(); }
-    bool is_initialized() const { return is_initialized_; }
+    const char* c_str() const {
+        return str_.c_str();
+    }
+    bool is_initialized() const {
+        return is_initialized_;
+    }
 
-    void init(const jit_emitter *emitter);
+    void init(const jit_emitter* emitter);
 
 private:
     std::string str_;
@@ -33,7 +36,7 @@ struct jit_emitter_info_t {
 
 std::string get_emitter_type_name(const jit_emitter* emitter);
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
 #endif
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/emitters/utils.cpp b/src/plugins/intel_cpu/src/emitters/utils.cpp
index b92277ae643218..43172e1b600843 100644
--- a/src/plugins/intel_cpu/src/emitters/utils.cpp
+++ b/src/plugins/intel_cpu/src/emitters/utils.cpp
@@ -7,28 +7,29 @@
 namespace ov {
 namespace intel_cpu {
 
-std::string jit_emitter_pretty_name(const std::string &pretty_func) {
-#define SAFE_SYMBOL_FINDING(idx, find) \
-    auto idx = (find); \
+std::string jit_emitter_pretty_name(const std::string& pretty_func) {
+#define SAFE_SYMBOL_FINDING(idx, find)        \
+    auto idx = (find);                        \
     if (idx == std::string::npos || idx == 0) \
         return pretty_func;
     // Example:
-    //      pretty_func := void ov::intel_cpu::jit_load_memory_emitter::emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const
-    //      begin := -----------|
-    //      end := ---------------------------------------------------|
-    //      result := ov::intel_cpu::jit_load_memory_emitter
+    //      pretty_func := void ov::intel_cpu::jit_load_memory_emitter::emit_impl(const std::vector<size_t>& in, const
+    //      std::vector<size_t>& out) const begin := -----------| end :=
+    //      ---------------------------------------------------| result := ov::intel_cpu::jit_load_memory_emitter
     // Signatures:
     //      GCC:   void foo() [with T = {type}]
     //      clang: void foo() [T = {type}]
     //      MSVC:  void __cdecl foo<{type}>(void)
     SAFE_SYMBOL_FINDING(parenthesis, pretty_func.find("("))
-    if (pretty_func[parenthesis - 1] == '>') { // To cover template on MSVC
+    if (pretty_func[parenthesis - 1] == '>') {  // To cover template on MSVC
         parenthesis--;
         size_t counter = 1;
         while (counter != 0 && parenthesis > 0) {
             parenthesis--;
-            if (pretty_func[parenthesis] == '>') counter++;
-            if (pretty_func[parenthesis] == '<') counter--;
+            if (pretty_func[parenthesis] == '>')
+                counter++;
+            if (pretty_func[parenthesis] == '<')
+                counter--;
         }
     }
     SAFE_SYMBOL_FINDING(end, pretty_func.substr(0, parenthesis).rfind("::"))
@@ -38,5 +39,5 @@ std::string jit_emitter_pretty_name(const std::string &pretty_func) {
     return end > begin ? pretty_func.substr(begin, end - begin) : pretty_func;
 }
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/emitters/utils.hpp b/src/plugins/intel_cpu/src/emitters/utils.hpp
index 4c3210579d7fd2..7c89b720159dde 100644
--- a/src/plugins/intel_cpu/src/emitters/utils.hpp
+++ b/src/plugins/intel_cpu/src/emitters/utils.hpp
@@ -5,21 +5,22 @@
 #pragma once
 
 #include <string>
+
 #include "openvino/core/except.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
-std::string jit_emitter_pretty_name(const std::string &pretty_func);
+std::string jit_emitter_pretty_name(const std::string& pretty_func);
 
 #ifdef __GNUC__
-#define OV_CPU_JIT_EMITTER_NAME jit_emitter_pretty_name(__PRETTY_FUNCTION__)
+#    define OV_CPU_JIT_EMITTER_NAME jit_emitter_pretty_name(__PRETTY_FUNCTION__)
 #else /* __GNUC__ */
-#define OV_CPU_JIT_EMITTER_NAME jit_emitter_pretty_name(__FUNCSIG__)
+#    define OV_CPU_JIT_EMITTER_NAME jit_emitter_pretty_name(__FUNCSIG__)
 #endif /* __GNUC__ */
 
-#define OV_CPU_JIT_EMITTER_THROW(...) OPENVINO_THROW(OV_CPU_JIT_EMITTER_NAME, ": ", __VA_ARGS__)
+#define OV_CPU_JIT_EMITTER_THROW(...)        OPENVINO_THROW(OV_CPU_JIT_EMITTER_NAME, ": ", __VA_ARGS__)
 #define OV_CPU_JIT_EMITTER_ASSERT(cond, ...) OPENVINO_ASSERT((cond), OV_CPU_JIT_EMITTER_NAME, ": ", __VA_ARGS__)
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/extension.cpp b/src/plugins/intel_cpu/src/extension.cpp
index e6dbc04b0ca6a4..bdb5211009a22a 100644
--- a/src/plugins/intel_cpu/src/extension.cpp
+++ b/src/plugins/intel_cpu/src/extension.cpp
@@ -9,8 +9,8 @@
 #include "ov_ops/augru_sequence.hpp"
 #include "ov_ops/fully_connected.hpp"
 #include "ov_ops/fully_connected_compressed.hpp"
-#include "ov_ops/fully_connected_quantized_legacy.hpp"
 #include "ov_ops/fully_connected_quantized.hpp"
+#include "ov_ops/fully_connected_quantized_legacy.hpp"
 #include "ov_ops/gather_compressed.hpp"
 #include "ov_ops/multiclass_nms_ie_internal.hpp"
 #include "ov_ops/nms_ie_internal.hpp"
@@ -26,8 +26,8 @@
 #include "transformations/cpu_opset/common/op/sdpa.hpp"
 #include "transformations/cpu_opset/common/op/swish_cpu.hpp"
 #include "transformations/cpu_opset/x64/op/interaction.hpp"
-#include "transformations/cpu_opset/x64/op/mha.hpp"
 #include "transformations/cpu_opset/x64/op/llm_mlp.hpp"
+#include "transformations/cpu_opset/x64/op/mha.hpp"
 #include "transformations/cpu_opset/x64/op/qkv_proj.hpp"
 #include "transformations/snippets/x64/op/brgemm_copy_b.hpp"
 #include "transformations/snippets/x64/op/brgemm_cpu.hpp"
@@ -40,8 +40,7 @@ namespace {
 template <typename Op>
 class TypeRelaxedExtension : public ov::OpExtension<ov::op::TypeRelaxed<Op>> {
 public:
-    TypeRelaxedExtension()
-        : m_ext_type(Op::get_type_info_static().name, "type_relaxed_opset") {}
+    TypeRelaxedExtension() : m_ext_type(Op::get_type_info_static().name, "type_relaxed_opset") {}
     ~TypeRelaxedExtension() override = default;
 
     const ov::DiscreteTypeInfo& get_type_info() const override {
@@ -159,31 +158,31 @@ class TypeRelaxedExtension : public ov::OpExtension<ov::op::TypeRelaxed<Op>> {
 #    define SNIPPETS_DEBUG_CAPS_EXTENSIONS
 #endif
 
-#define SNIPPETS_EXTENSIONS                                  \
-    OP_EXTENSION(ov::snippets::op::Brgemm)                   \
-    OP_EXTENSION(ov::snippets::op::BroadcastLoad)            \
-    OP_EXTENSION(ov::snippets::op::BroadcastMove)            \
-    OP_EXTENSION(ov::snippets::op::ConvertSaturation)        \
-    OP_EXTENSION(ov::snippets::op::ConvertTruncation)        \
-    OP_EXTENSION(ov::snippets::op::Fill)                     \
-    OP_EXTENSION(ov::snippets::op::HorizonMax)               \
-    OP_EXTENSION(ov::snippets::op::HorizonSum)               \
-    OP_EXTENSION(ov::snippets::op::KernelStatic)             \
-    OP_EXTENSION(ov::snippets::op::KernelDynamic)            \
-    OP_EXTENSION(ov::snippets::op::Load)                     \
-    OP_EXTENSION(ov::snippets::op::LoadReshape)              \
-    OP_EXTENSION(ov::snippets::op::LoopBegin)                \
-    OP_EXTENSION(ov::snippets::op::LoopEnd)                  \
-    OP_EXTENSION(ov::snippets::op::Buffer)                   \
-    OP_EXTENSION(ov::snippets::op::Nop)                      \
-    OP_EXTENSION(ov::snippets::op::PowerStatic)              \
-    OP_EXTENSION(ov::snippets::op::Scalar)                   \
-    OP_EXTENSION(ov::snippets::op::Store)                    \
-    OP_EXTENSION(ov::snippets::op::Subgraph)                 \
-    OP_EXTENSION(ov::snippets::op::VectorBuffer)             \
-    OP_EXTENSION(ov::snippets::op::RankNormalization)        \
-    OP_EXTENSION(ov::snippets::op::ReduceMax)                \
-    OP_EXTENSION(ov::snippets::op::ReduceSum)                \
+#define SNIPPETS_EXTENSIONS                           \
+    OP_EXTENSION(ov::snippets::op::Brgemm)            \
+    OP_EXTENSION(ov::snippets::op::BroadcastLoad)     \
+    OP_EXTENSION(ov::snippets::op::BroadcastMove)     \
+    OP_EXTENSION(ov::snippets::op::ConvertSaturation) \
+    OP_EXTENSION(ov::snippets::op::ConvertTruncation) \
+    OP_EXTENSION(ov::snippets::op::Fill)              \
+    OP_EXTENSION(ov::snippets::op::HorizonMax)        \
+    OP_EXTENSION(ov::snippets::op::HorizonSum)        \
+    OP_EXTENSION(ov::snippets::op::KernelStatic)      \
+    OP_EXTENSION(ov::snippets::op::KernelDynamic)     \
+    OP_EXTENSION(ov::snippets::op::Load)              \
+    OP_EXTENSION(ov::snippets::op::LoadReshape)       \
+    OP_EXTENSION(ov::snippets::op::LoopBegin)         \
+    OP_EXTENSION(ov::snippets::op::LoopEnd)           \
+    OP_EXTENSION(ov::snippets::op::Buffer)            \
+    OP_EXTENSION(ov::snippets::op::Nop)               \
+    OP_EXTENSION(ov::snippets::op::PowerStatic)       \
+    OP_EXTENSION(ov::snippets::op::Scalar)            \
+    OP_EXTENSION(ov::snippets::op::Store)             \
+    OP_EXTENSION(ov::snippets::op::Subgraph)          \
+    OP_EXTENSION(ov::snippets::op::VectorBuffer)      \
+    OP_EXTENSION(ov::snippets::op::RankNormalization) \
+    OP_EXTENSION(ov::snippets::op::ReduceMax)         \
+    OP_EXTENSION(ov::snippets::op::ReduceSum)         \
     OP_EXTENSION(ov::snippets::op::Reshape)
 
 OPENVINO_CREATE_EXTENSIONS(std::vector<ov::Extension::Ptr>(
diff --git a/src/plugins/intel_cpu/src/graph.cpp b/src/plugins/intel_cpu/src/graph.cpp
index 6aa4644f902bc9..7fb5f512227cf9 100644
--- a/src/plugins/intel_cpu/src/graph.cpp
+++ b/src/plugins/intel_cpu/src/graph.cpp
@@ -9,6 +9,7 @@
 #include <limits>
 #include <map>
 #include <memory>
+#include <oneapi/dnnl/dnnl.hpp>
 #include <string>
 #include <tuple>
 #include <unordered_map>
@@ -16,6 +17,7 @@
 #include <utility>
 #include <vector>
 
+#include "common/primitive_desc_iface.hpp"
 #include "edge.h"
 #include "graph_dumper.h"
 #include "graph_optimizer.h"
@@ -28,25 +30,21 @@
 #include "nodes/common/cpu_memcpy.h"
 #include "nodes/convert.h"
 #include "nodes/input.h"
-#include "nodes/reorder.h"
 #include "nodes/memory.hpp"
+#include "nodes/reorder.h"
 #include "openvino/core/except.hpp"
 #include "openvino/core/model.hpp"
 #include "openvino/core/node.hpp"
+#include "openvino/core/parallel.hpp"
 #include "openvino/core/type/element_type.hpp"
+#include "openvino/runtime/exception.hpp"
+#include "openvino/runtime/threading/cpu_streams_executor.hpp"
 #include "utils/debug_capabilities.h"
 #include "utils/general_utils.h"
 #include "utils/ngraph_utils.hpp"
 #include "utils/node_dumper.h"
-#include "utils/verbose.h"
 #include "utils/precision_support.h"
-
-#include <oneapi/dnnl/dnnl.hpp>
-#include "common/primitive_desc_iface.hpp"
-
-#include "openvino/runtime/exception.hpp"
-#include "openvino/runtime/threading/cpu_streams_executor.hpp"
-#include "openvino/core/parallel.hpp"
+#include "utils/verbose.h"
 
 #if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO)
 #    include <tbb/task.h>
@@ -61,8 +59,8 @@ Graph::~Graph() {
     CPU_DEBUG_CAP_ENABLE(average_counters(*this));
 }
 
-template<typename NET>
-void Graph::CreateGraph(NET &model, const GraphContext::CPtr context) {
+template <typename NET>
+void Graph::CreateGraph(NET& model, const GraphContext::CPtr context) {
     OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, "CreateGraph");
 
     Init(model, context);
@@ -104,7 +102,7 @@ void Graph::CreateGraph(const std::vector<NodePtr>& graphNodes,
 
 template void Graph::CreateGraph(const std::shared_ptr<const ov::Model>&, const GraphContext::CPtr);
 
-void Graph::Replicate(const std::shared_ptr<const ov::Model> &model,
+void Graph::Replicate(const std::shared_ptr<const ov::Model>& model,
                       const std::vector<node::Input::InputConfig>& inputConfigs,
                       const std::vector<node::Input::OutputConfig>& outputConfigs) {
     OV_ITT_SCOPE_CHAIN(FIRST_INFERENCE, taskChain, itt::domains::intel_cpu_LT, "Graph::Replicate", "ov::Model");
@@ -135,7 +133,9 @@ void Graph::Replicate(const std::shared_ptr<const ov::Model> &model,
         if (op->get_type_info() == op::v0::Parameter::get_type_info_static()) {
             auto input_index = model->get_parameter_index(std::dynamic_pointer_cast<op::v0::Parameter>(op));
             OPENVINO_ASSERT(input_index >= 0,
-                            "CPU plugin cannot find op: ", op->get_friendly_name(), " in model parameter list!");
+                            "CPU plugin cannot find op: ",
+                            op->get_friendly_name(),
+                            " in model parameter list!");
 
             const auto& config = static_cast<size_t>(input_index) < inputConfigs.size() ? inputConfigs[input_index]
                                                                                         : node::Input::InputConfig{};
@@ -152,7 +152,9 @@ void Graph::Replicate(const std::shared_ptr<const ov::Model> &model,
         if (op->get_type_info() == op::v0::Result::get_type_info_static()) {
             auto output_index = model->get_result_index(std::dynamic_pointer_cast<op::v0::Result>(op));
             OPENVINO_ASSERT(output_index >= 0,
-                            "CPU plugin cannot find op: ", op->get_friendly_name(), " in model result list!");
+                            "CPU plugin cannot find op: ",
+                            op->get_friendly_name(),
+                            " in model result list!");
 
             const auto& config = static_cast<size_t>(output_index) < outputConfigs.size() ? outputConfigs[output_index]
                                                                                           : node::Input::OutputConfig{};
@@ -179,9 +181,9 @@ void Graph::Replicate(const std::shared_ptr<const ov::Model> &model,
         }
 
         if (!one_of(op->get_type_info(),
-                op::v0::Result::get_type_info_static(),
-                op::v3::Assign::get_type_info_static(),
-                op::v6::Assign::get_type_info_static())) {
+                    op::v0::Result::get_type_info_static(),
+                    op::v3::Assign::get_type_info_static(),
+                    op::v6::Assign::get_type_info_static())) {
             for (size_t oi = 0; oi < op->get_output_size(); oi++) {
                 if (op->get_output_target_inputs(oi).empty()) {
                     unusedOutputs.push_back(op->output(oi));
@@ -194,10 +196,13 @@ void Graph::Replicate(const std::shared_ptr<const ov::Model> &model,
     for (auto unusedOutput : unusedOutputs) {
         auto parentNode = op2node[unusedOutput.get_node_shared_ptr()];
         const auto port = unusedOutput.get_index();
-        const auto nodeName = std::string("stub_") + std::to_string(unusedOutput.get_index()) + "_" + parentNode->getName();
+        const auto nodeName =
+            std::string("stub_") + std::to_string(unusedOutput.get_index()) + "_" + parentNode->getName();
         const NodePtr outNode = std::make_shared<node::Input>(parentNode->outputShapes[port],
                                                               parentNode->getOriginalOutputPrecisionAtPort(port),
-                                                              nodeName, "Result", m_context);
+                                                              nodeName,
+                                                              "Result",
+                                                              m_context);
         CreateEdge(parentNode, outNode, port, 0);
         AddNode(outNode);
     }
@@ -216,7 +221,7 @@ void Graph::Replicate(const std::shared_ptr<const ov::Model> &model,
     EnforceInferencePrecision();
 
     // update input precisions of consumers to avoid extra reorders
-    for (auto &input : inputNodesMap) {
+    for (auto& input : inputNodesMap) {
         const auto& inputNode = input.second;
         const auto precToSet = inputNode->getOriginalOutputPrecisionAtPort(0);
         const auto childEdges = inputNode->getChildEdgesAtPort(0);
@@ -233,7 +238,7 @@ void Graph::Replicate(const std::shared_ptr<const ov::Model> &model,
     // update output precisions of producers to avoid extra reorders
     // do this only in case output configration is not provided explicitly
     if (outputConfigs.empty()) {
-        for (auto &output : outputNodesMap) {
+        for (auto& output : outputNodesMap) {
             const auto& outputNode = output.second;
             const auto precToSet = outputNode->getOriginalInputPrecisionAtPort(0);
             const auto parentEdge = outputNode->getParentEdgeAt(0);
@@ -254,11 +259,12 @@ static std::vector<size_t> IdentifySyncPoints(const std::vector<NodePtr>& graphN
             continue;
 
         if (node->outputShapeDataDependency() ||
-            // WA: for convolution plus sum(broadcast). Due to the fact that a convolution with sum use the same memory for second sum term and the output
-            // tensors (inPlace) resizing the output tensor, may lead to reallocation of this second term memory and possible data lost. The reallocation
-            // may happen when the second term shape is broadcasted to the output tensor shape. To avoid the data loss, we have a special processing for
-            // such cases inside the convolution node, but it works properly only when dynamic shapes inference, preparation and execution a called
-            // for this node sequentially.
+            // WA: for convolution plus sum(broadcast). Due to the fact that a convolution with sum use the same memory
+            // for second sum term and the output tensors (inPlace) resizing the output tensor, may lead to reallocation
+            // of this second term memory and possible data lost. The reallocation may happen when the second term shape
+            // is broadcasted to the output tensor shape. To avoid the data loss, we have a special processing for such
+            // cases inside the convolution node, but it works properly only when dynamic shapes inference, preparation
+            // and execution a called for this node sequentially.
             (node->getType() == Type::Convolution && node->isInPlace()) ||
             // Due to the special handling of the internal states and initialization subgraphs, MemoryInput nodes must
             // be processed as a internal dynamism node, allowing to hide the aforementioned complexity inside the
@@ -271,15 +277,17 @@ static std::vector<size_t> IdentifySyncPoints(const std::vector<NodePtr>& graphN
     return syncNodesInds;
 }
 
-static std::tuple<std::vector<NodePtr>, std::vector<size_t>> ExtractExecutableNodesAndSyncPoints(const std::vector<size_t>& syncNodesInds,
-                                                                                                 const std::vector<NodePtr>& graphNodes) {
+static std::tuple<std::vector<NodePtr>, std::vector<size_t>> ExtractExecutableNodesAndSyncPoints(
+    const std::vector<size_t>& syncNodesInds,
+    const std::vector<NodePtr>& graphNodes) {
     OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, "Graph::ExtractExecutableNodesAndSyncPoints");
     std::unordered_map<size_t, size_t> graphIdToExecutableId;
     std::vector<NodePtr> executableGraphNodes;
     for (size_t i = 0; i < graphNodes.size(); i++) {
         const auto& graphNode = graphNodes[i];
-        if ((!graphNode->isConstant() && graphNode->isExecutable()) || // non-constant executable or
-            (graphNode->isDynamicNode() && !one_of(graphNode->getType(), Type::Input, Type::Output))) { // dynamic, except inputs / outputs
+        if ((!graphNode->isConstant() && graphNode->isExecutable()) ||  // non-constant executable or
+            (graphNode->isDynamicNode() &&
+             !one_of(graphNode->getType(), Type::Input, Type::Output))) {  // dynamic, except inputs / outputs
             graphIdToExecutableId[i] = executableGraphNodes.size();
             executableGraphNodes.emplace_back(graphNode);
         }
@@ -291,17 +299,17 @@ static std::tuple<std::vector<NodePtr>, std::vector<size_t>> ExtractExecutableNo
         auto it = graphIdToExecutableId.find(syncNodesInd);
         if (it != graphIdToExecutableId.end()) {
             uniqueExecutableSyncNodesInds.insert(it->second);
-            // since sometimes we need to run the synchronization node  alone (for example in the case of internal dynamism)
-            // let's add another sync index after the sync point node
+            // since sometimes we need to run the synchronization node  alone (for example in the case of internal
+            // dynamism) let's add another sync index after the sync point node
             uniqueExecutableSyncNodesInds.insert(it->second + 1);
         }
     }
     uniqueExecutableSyncNodesInds.insert(executableGraphNodes.size());
     // convert to a vector to reduce runtime overhead
-    std::vector<size_t> executableSyncNodesInds(uniqueExecutableSyncNodesInds.begin(), uniqueExecutableSyncNodesInds.end());
+    std::vector<size_t> executableSyncNodesInds(uniqueExecutableSyncNodesInds.begin(),
+                                                uniqueExecutableSyncNodesInds.end());
 
-    return std::make_tuple(std::move(executableGraphNodes),
-                           std::move(executableSyncNodesInds));
+    return std::make_tuple(std::move(executableGraphNodes), std::move(executableSyncNodesInds));
 }
 
 void Graph::Init(const std::shared_ptr<const ov::Model>& model,
@@ -346,7 +354,7 @@ static void UseExternalOutputMemory(const std::map<std::size_t, NodePtr>& output
 }
 
 void Graph::Activate(const std::vector<MemoryPtr>& externalInputMemory,
-                               const std::vector<MemoryPtr>& externalOutputMemory) {
+                     const std::vector<MemoryPtr>& externalOutputMemory) {
     OPENVINO_ASSERT(status == Status::Initialized, "Invalid graph status");
 
     const bool hasDynNodes = ProcessDynNodes();
@@ -360,12 +368,13 @@ void Graph::Activate(const std::vector<MemoryPtr>& externalInputMemory,
     CreatePrimitivesAndExecConstants();
 
 #ifndef CPU_DEBUG_CAPS
-    for (auto &graphNode : graphNodes) {
+    for (auto& graphNode : graphNodes) {
         graphNode->cleanup();
     }
 #endif
 
-    std::tie(m_executableGraphNodes, m_executableSyncNodesInds) = ExtractExecutableNodesAndSyncPoints(syncNodesInds, graphNodes);
+    std::tie(m_executableGraphNodes, m_executableSyncNodesInds) =
+        ExtractExecutableNodesAndSyncPoints(syncNodesInds, graphNodes);
 
     if (hasDynNodes) {
         status = Status::ReadyDynamic;
@@ -424,7 +433,7 @@ void Graph::Configure(bool optimize) {
 
 void Graph::InitNodes() {
     OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, "Graph::InitNodes");
-    for (auto &node : graphNodes) {
+    for (auto& node : graphNodes) {
         node->init();
     }
 }
@@ -432,7 +441,7 @@ void Graph::InitNodes() {
 void Graph::InitDescriptors() {
     OV_ITT_SCOPE_CHAIN(FIRST_INFERENCE, taskChain, itt::domains::intel_cpu_LT, "InitDescriptors", "Prepare");
 
-    for (auto &node : graphNodes) {
+    for (auto& node : graphNodes) {
         OV_ITT_SCOPE_NEXT(FIRST_INFERENCE, taskChain, node->profiling.getSupportedDescriptors);
         DEBUG_LOG("Get supported primitive descriptors for node: ", node->getName());
         node->getSupportedDescriptors();
@@ -445,15 +454,15 @@ void Graph::InitDescriptors() {
             const auto& SPDs = node->getSupportedPrimitiveDescriptors();
             for (size_t i = 0; i < SPDs.size(); i++) {
                 DEBUG_LOG("#",
-                        node->getExecIndex(),
-                        " ",
-                        node->getName(),
-                        " Before filter, SupportedPrimitiveDescriptors [",
-                        i,
-                        "/",
-                        SPDs.size(),
-                        "]: \n",
-                        SPDs[i]);
+                          node->getExecIndex(),
+                          " ",
+                          node->getName(),
+                          " Before filter, SupportedPrimitiveDescriptors [",
+                          i,
+                          "/",
+                          SPDs.size(),
+                          "]: \n",
+                          SPDs[i]);
             }
         }
 #endif
@@ -478,7 +487,7 @@ void Graph::InitDescriptors() {
 #endif
     }
 
-    for (auto &node : graphNodes) {
+    for (auto& node : graphNodes) {
         OV_ITT_SCOPE_NEXT(FIRST_INFERENCE, taskChain, node->profiling.selectOptimalPrimitiveDescriptor);
         DEBUG_LOG("Select optimal primitive descriptors for node: ", node->getName());
         node->selectOptimalPrimitiveDescriptor();
@@ -495,12 +504,18 @@ void Graph::ResolveInplaceDirections() {
 
 void Graph::InitOptimalPrimitiveDescriptors() {
     OV_ITT_SCOPED_TASK(itt::domains::intel_cpu, "Graph::InitOptimalPrimitiveDescriptors");
-    for (auto &node : graphNodes) {
+    for (auto& node : graphNodes) {
         OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, node->profiling.initOptimalPrimitiveDescriptor);
         DEBUG_LOG("Init optimal primitive descriptors for node: ", node->getName());
         node->initOptimalPrimitiveDescriptor();
-        DEBUG_LOG("#", node->getExecIndex(), " ", node->getName(), "\n",
-                  *node->getSelectedPrimitiveDescriptor(), "selectedPrimitiveDescriptorIdx = ", node->selectedPrimitiveDescriptorIndex);
+        DEBUG_LOG("#",
+                  node->getExecIndex(),
+                  " ",
+                  node->getName(),
+                  "\n",
+                  *node->getSelectedPrimitiveDescriptor(),
+                  "selectedPrimitiveDescriptorIdx = ",
+                  node->selectedPrimitiveDescriptorIndex);
     }
 }
 
@@ -508,7 +523,7 @@ void Graph::CreatePrimitivesAndExecConstants() const {
     OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, "Graph::CreatePrimitivesAndExecConstants");
     using shared_memory_ptr = WeightsSharing::SharedMemory::Ptr;
 
-    auto acquireSharedOutputs = [this](const NodePtr & node) {
+    auto acquireSharedOutputs = [this](const NodePtr& node) {
         std::vector<shared_memory_ptr> outputs;
         bool hasLocalAllocatedEdges = false;
         bool hasExternalInvalidEdges = false;
@@ -530,7 +545,7 @@ void Graph::CreatePrimitivesAndExecConstants() const {
         return std::make_tuple(hasExternalInvalidEdges, hasLocalAllocatedEdges, outputs);
     };
 
-    for (const auto &node : graphNodes) {
+    for (const auto& node : graphNodes) {
         {
             OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, node->profiling.createPrimitive);
             DEBUG_LOG(*node);
@@ -547,7 +562,7 @@ void Graph::CreatePrimitivesAndExecConstants() const {
             if (std::get<0>(sharedOutputs) || std::get<1>(sharedOutputs)) {
                 ExecuteNodeWithCatch(node);
 
-                for (auto & output : std::get<2>(sharedOutputs))
+                for (auto& output : std::get<2>(sharedOutputs))
                     output->valid(true);
             }
         } else {
@@ -556,7 +571,9 @@ void Graph::CreatePrimitivesAndExecConstants() const {
     }
 }
 
-static bool isReorderAvailable(const MemoryDescPtr& parentDesc, const MemoryDescPtr& childDesc, const dnnl::engine& eng) {
+static bool isReorderAvailable(const MemoryDescPtr& parentDesc,
+                               const MemoryDescPtr& childDesc,
+                               const dnnl::engine& eng) {
     auto definedParentDesc = parentDesc->isDefined() ? parentDesc : MemoryDescUtils::makeDummyDesc(*parentDesc);
     memory::desc srcMemDesc = MemoryDescUtils::convertToDnnlMemoryDesc(definedParentDesc)->getDnnlDesc();
 
@@ -566,14 +583,16 @@ static bool isReorderAvailable(const MemoryDescPtr& parentDesc, const MemoryDesc
     dnnl::primitive_attr attr;
 
     dnnl_primitive_desc_t result = nullptr;
-    auto status = dnnl_reorder_primitive_desc_create(&result, srcMemDesc.get(), eng.get(), dstMemDesc.get(), eng.get(),
+    auto status = dnnl_reorder_primitive_desc_create(&result,
+                                                     srcMemDesc.get(),
+                                                     eng.get(),
+                                                     dstMemDesc.get(),
+                                                     eng.get(),
                                                      attr.get());
 #if defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)
     // temporary WA for slow FP32->FP16 conversion reorder in oneDNN on ARM
     // pretend the reorder is not available to use Convert node instead
-    if (hasHardwareSupport(ov::element::f16) &&
-        result &&
-        parse_impl_name(result->impl()->name()) == ref_any) {
+    if (hasHardwareSupport(ov::element::f16) && result && parse_impl_name(result->impl()->name()) == ref_any) {
         dnnl_primitive_desc_destroy(result);
         return false;
     }
@@ -587,8 +606,8 @@ static bool isReorderAvailable(const MemoryDescPtr& parentDesc, const MemoryDesc
 
 void Graph::insertReorder(EdgePtr& edge, bool isOptimized, std::unordered_set<std::string>& uniqueLayerNames) {
     std::string basicLayerName = edge->getParent()->getName() + "_" +
-                                    node::Reorder::getReorderArgs(edge->getInputDesc(), edge->getOutputDesc()) + "_" +
-                                    edge->getChild()->getName();
+                                 node::Reorder::getReorderArgs(edge->getInputDesc(), edge->getOutputDesc()) + "_" +
+                                 edge->getChild()->getName();
     std::string layerName = basicLayerName;
     int idx = 0;
     while (uniqueLayerNames.find(layerName) != uniqueLayerNames.end()) {
@@ -605,11 +624,14 @@ void Graph::insertConvert(EdgePtr& edge) {
     const auto& inDesc = edge->getInputDesc();
     const auto& outDesc = edge->getOutputDesc();
 
-    std::string convertName = edge->getParent()->getName() + "_" +
-        inDesc.getPrecision().get_type_name() + "_" + outDesc.getPrecision().get_type_name();
+    std::string convertName = edge->getParent()->getName() + "_" + inDesc.getPrecision().get_type_name() + "_" +
+                              outDesc.getPrecision().get_type_name();
 
-    auto convertNode = std::make_shared<node::Convert>(inDesc.getShape(), inDesc.getPrecision(), outDesc.getPrecision(),
-                                                       convertName, m_context);
+    auto convertNode = std::make_shared<node::Convert>(inDesc.getShape(),
+                                                       inDesc.getPrecision(),
+                                                       outDesc.getPrecision(),
+                                                       convertName,
+                                                       m_context);
     convertNode->setDescs(inDesc, outDesc);
     InsertNode(edge, convertNode, true);
 }
@@ -720,9 +742,9 @@ void Graph::AllocateWithReuse(const std::vector<size_t>& syncNodesInds) {
 
     // Resolve special cases:
     for (size_t i = 0; i < remaining_edge_clusters_count;) {
-        auto &cluster = edge_clusters[i];
+        auto& cluster = edge_clusters[i];
         bool erase = false;
-        for (auto &edge : cluster) {
+        for (auto& edge : cluster) {
             // Remove already allocated edges from the mem reuse algo
             if (edge->getStatus() == Edge::Status::Allocated) {
                 erase = true;
@@ -730,18 +752,23 @@ void Graph::AllocateWithReuse(const std::vector<size_t>& syncNodesInds) {
             }
 
             // Special allocation for string tensors
-            if (edge->getDesc().getPrecision() == element::string && edge->getStatus() == Edge::Status::NeedAllocation) {
+            if (edge->getDesc().getPrecision() == element::string &&
+                edge->getStatus() == Edge::Status::NeedAllocation) {
                 StringMemory::StringMemoryBlockPtr memBlcok;
                 if (edge->getParent()->isConstant()) {
                     if (edge->getParent()->getType() == Type::Input) {
-                        auto constNode = static_cast<node::Input *>(edge->getParent().get());
+                        auto constNode = static_cast<node::Input*>(edge->getParent().get());
                         edge->reuse(std::const_pointer_cast<IMemory>(constNode->getMemoryPtr()));
                     } else {
                         edge->externalAllocate(m_context->getWeightsCache());
                     }
-                    auto stringMemory = dynamic_cast<StringMemory *>(edge->getMemoryPtr().get());
-                    OPENVINO_ASSERT(stringMemory, "[CPU] Edge between nodes '",
-                            edge->getParent()->getName(), "' and '", edge->getChild()->getName(), "' must have StringMemory.");
+                    auto stringMemory = dynamic_cast<StringMemory*>(edge->getMemoryPtr().get());
+                    OPENVINO_ASSERT(stringMemory,
+                                    "[CPU] Edge between nodes '",
+                                    edge->getParent()->getName(),
+                                    "' and '",
+                                    edge->getChild()->getName(),
+                                    "' must have StringMemory.");
                     memBlcok = stringMemory->getStringMemoryBlockPtr();
                 } else {
                     auto memory = std::make_shared<StringMemory>(getEngine(), edge->getDesc());
@@ -752,13 +779,18 @@ void Graph::AllocateWithReuse(const std::vector<size_t>& syncNodesInds) {
                     if (edge_c == edge) {
                         continue;
                     }
-                    OPENVINO_ASSERT(edge_c->getDesc().getPrecision() == element::string, "All edges in the cluster must be string.");
+                    OPENVINO_ASSERT(edge_c->getDesc().getPrecision() == element::string,
+                                    "All edges in the cluster must be string.");
                     if (edge_c->getStatus() == Edge::Status::NotAllocated) {
                         auto memory = std::make_shared<StringMemory>(getEngine(), edge_c->getDesc(), memBlcok);
                         edge_c->reuse(memory);
                     } else {
-                        OPENVINO_THROW("[CPU] String tensors allocation in the cluster. Edge between nodes '", edge_c->getParent()->getName(), "' and '",
-                            edge_c->getChild()->getName(), "' has an unexpected status: ", static_cast<int>(edge_c->getStatus()));
+                        OPENVINO_THROW("[CPU] String tensors allocation in the cluster. Edge between nodes '",
+                                       edge_c->getParent()->getName(),
+                                       "' and '",
+                                       edge_c->getChild()->getName(),
+                                       "' has an unexpected status: ",
+                                       static_cast<int>(edge_c->getStatus()));
                     }
                 }
                 erase = true;
@@ -800,14 +832,15 @@ void Graph::AllocateWithReuse(const std::vector<size_t>& syncNodesInds) {
 
         int64_t boxSize = 0;
         bool isConst = false, isOutput = false, isInput = false;
-        for (auto &edge : edge_clusters[i]) {
+        for (auto& edge : edge_clusters[i]) {
             int e_start = edge->getParent()->getExecIndex();
             int e_finish = edge->getChild()->getExecIndex();
 
             auto&& desc = edge->getDesc();
 
             if (boxSize != -1 && desc.isDefined()) {
-                int64_t e_size = desc.getCurrentMemSize();  // size in bytes (from the beginning of data to the last element)
+                int64_t e_size =
+                    desc.getCurrentMemSize();  // size in bytes (from the beginning of data to the last element)
                 boxSize = std::max(e_size, boxSize);
             } else {
                 boxSize = -1;
@@ -824,9 +857,9 @@ void Graph::AllocateWithReuse(const std::vector<size_t>& syncNodesInds) {
             }
             reg.alloc_type = allocType;
 
-            isConst  |= isConstOutput(edge);
+            isConst |= isConstOutput(edge);
             isOutput |= edge->getChild()->getType() == Type::Output;
-            isInput  |= edge->getParent()->getType() == Type::Input;
+            isInput |= edge->getParent()->getType() == Type::Input;
         }
 
         reg.size = boxSize;
@@ -878,7 +911,7 @@ void Graph::AllocateWithReuse(const std::vector<size_t>& syncNodesInds) {
 
     memoryRegions.erase(it, memoryRegions.end());
 
-    //Set up the memory control subsystem.
+    // Set up the memory control subsystem.
     this->m_pMemoryControl = &(getGraphContext()->getNetworkMemoryControl()->createMemoryControlUnit(syncNodesInds));
     auto memoryBlocks = m_pMemoryControl->insert(memoryRegions);
 
@@ -911,9 +944,8 @@ void Graph::AllocateWithReuse(const std::vector<size_t>& syncNodesInds) {
             }
             std::vector<EdgePtr> edges_to_process;
             edges_to_process.push_back(edge);
-            for (auto next_edge = edge->getSharedEdge(std::nothrow);
-                next_edge;
-                next_edge = next_edge->getSharedEdge(std::nothrow)) {
+            for (auto next_edge = edge->getSharedEdge(std::nothrow); next_edge;
+                 next_edge = next_edge->getSharedEdge(std::nothrow)) {
                 edges_to_process.push_back(next_edge);
             }
             std::for_each(edges_to_process.rbegin(), edges_to_process.rend(), [](const EdgePtr& edge) {
@@ -937,16 +969,15 @@ void Graph::AllocateWithReuse(const std::vector<size_t>& syncNodesInds) {
 void Graph::Allocate(const std::vector<size_t>& syncNodesInds) {
     OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, "Graph::Allocate");
 
-    //resolve inplace dead end nodes
+    // resolve inplace dead end nodes
     for (const auto& edge : graphEdges) {
         if (edge->getStatus() == Edge::Status::Uninitialized) {
             if (edge->getParent()->getParentEdges().empty() &&
-                one_of(edge->getParent()->getType(), Type::Input, Type::MemoryInput) &&
-                edge->inPlace(Edge::LOOK_UP)) {
+                one_of(edge->getParent()->getType(), Type::Input, Type::MemoryInput) && edge->inPlace(Edge::LOOK_UP)) {
                 edge->getParent()->resolveInPlaceEdges(Edge::LOOK_UP);
             } else if (edge->getChild()->getChildEdges().empty() &&
-                one_of(edge->getChild()->getType(), Type::Output, Type::MemoryOutput) &&
-                edge->inPlace(Edge::LOOK_DOWN)) {
+                       one_of(edge->getChild()->getType(), Type::Output, Type::MemoryOutput) &&
+                       edge->inPlace(Edge::LOOK_DOWN)) {
                 edge->getChild()->resolveInPlaceEdges(Edge::LOOK_DOWN);
             }
         }
@@ -955,13 +986,15 @@ void Graph::Allocate(const std::vector<size_t>& syncNodesInds) {
     // resolve edges. Define which will be a view on others
     //   NeedAllocation - real blob
     //   NotAllocated - view on other blob, peer or in-place
-    for (auto& edge : graphEdges) edge->init();
+    for (auto& edge : graphEdges)
+        edge->init();
 
     // Allocate memory space for all edges marked with NeedAllocation
     AllocateWithReuse(syncNodesInds);
 
     // Check all getters. Should work.
-    for (auto& edge : graphEdges) edge->validate();
+    for (auto& edge : graphEdges)
+        edge->validate();
 }
 
 bool Graph::ProcessDynNodes() {
@@ -975,7 +1008,8 @@ bool Graph::ProcessDynNodes() {
 }
 
 void Graph::PushInputData(const std::size_t& index, const ov::SoPtr<ITensor>& input) {
-    if (!IsReady()) OPENVINO_THROW("Wrong state. Topology not ready.");
+    if (!IsReady())
+        OPENVINO_THROW("Wrong state. Topology not ready.");
     auto input_itr = inputNodesMap.find(index);
     if (input_itr != inputNodesMap.end()) {
         auto node = input_itr->second;
@@ -1010,7 +1044,7 @@ void Graph::PullOutputData(std::unordered_map<std::size_t, ov::SoPtr<ITensor>>&
     if (!IsReady())
         OPENVINO_THROW("Wrong state. Topology not ready.");
 
-    for (auto &outputMap : outputNodesMap) {
+    for (auto& outputMap : outputNodesMap) {
         auto output_index = outputMap.first;
         auto node = outputMap.second;
         auto parentEdge = node->getParentEdgeAt(0);
@@ -1040,17 +1074,32 @@ void Graph::PullOutputData(std::unordered_map<std::size_t, ov::SoPtr<ITensor>>&
         if (ext_blob->get_shape() != outDims && !isScalarOutput) {
             // WA: because input/output info initially contains non empty dims, order etc.
             // and setDims (called inside setShape) can't correct modify blocked desc for desc with blocked layout
-            DEBUG_LOG(output_index, ", tensor data addr ", static_cast<void*>(output[output_index]->data()),
-            " dims ", PartialShape(output[output_index]->get_shape()), " -> ", PartialShape(outDims),
-            ", intr ptr ", intr_blob.getData(), " , parentedge's memory object ", parentEdge->getMemoryPtr().get());
+            DEBUG_LOG(output_index,
+                      ", tensor data addr ",
+                      static_cast<void*>(output[output_index]->data()),
+                      " dims ",
+                      PartialShape(output[output_index]->get_shape()),
+                      " -> ",
+                      PartialShape(outDims),
+                      ", intr ptr ",
+                      intr_blob.getData(),
+                      " , parentedge's memory object ",
+                      parentEdge->getMemoryPtr().get());
             ext_blob->set_shape(outDims);
-            DEBUG_LOG(output_index, ", tensor data addr ", static_cast<void*>(output[output_index]->data()),
-            " dims ", PartialShape(output[output_index]->get_shape()), ", intr ptr ", intr_blob.getData());
+            DEBUG_LOG(output_index,
+                      ", tensor data addr ",
+                      static_cast<void*>(output[output_index]->data()),
+                      " dims ",
+                      PartialShape(output[output_index]->get_shape()),
+                      ", intr ptr ",
+                      intr_blob.getData());
             expected_desc_ptr = MemoryDescUtils::generateCpuBlockedMemoryDesc(ext_blob);
         }
 
         // check for empty output blob
-        if (std::any_of(outDims.begin(), outDims.end(), [](const Dim dim) {return dim == 0;})) {
+        if (std::any_of(outDims.begin(), outDims.end(), [](const Dim dim) {
+                return dim == 0;
+            })) {
             continue;
         }
 
@@ -1063,12 +1112,22 @@ void Graph::PullOutputData(std::unordered_map<std::size_t, ov::SoPtr<ITensor>>&
                            intr_blob.getSize(),
                            ").");
 
-        void *ext_blob_ptr = ext_blob->data();
-        void *intr_blob_ptr = intr_blob.getData();
-        DEBUG_LOG(output_index, " @ ", intr_blob_ptr, " -> ", ext_blob_ptr, " zero-copy: ", intr_blob_ptr == ext_blob_ptr, " graph ", this, "\r\n");
+        void* ext_blob_ptr = ext_blob->data();
+        void* intr_blob_ptr = intr_blob.getData();
+        DEBUG_LOG(output_index,
+                  " @ ",
+                  intr_blob_ptr,
+                  " -> ",
+                  ext_blob_ptr,
+                  " zero-copy: ",
+                  intr_blob_ptr == ext_blob_ptr,
+                  " graph ",
+                  this,
+                  "\r\n");
 
         // That is the same memory. No need to copy
-        if (ext_blob_ptr == intr_blob_ptr) continue;
+        if (ext_blob_ptr == intr_blob_ptr)
+            continue;
 
         if (actualDesc->getPrecision() == element::string) {
             StringMemory outBloMem(getEngine(), expected_desc_ptr, ext_blob_ptr);
@@ -1077,7 +1136,10 @@ void Graph::PullOutputData(std::unordered_map<std::size_t, ov::SoPtr<ITensor>>&
             Memory outBloMem(getEngine(), expected_desc_ptr, ext_blob_ptr, false);
             outBloMem.load(intr_blob, false);
         } else {
-            OPENVINO_ASSERT(srcPrec == dstPrec, "The precision of the CPU output tensor index", output_index, " is different from the external one");
+            OPENVINO_ASSERT(srcPrec == dstPrec,
+                            "The precision of the CPU output tensor index",
+                            output_index,
+                            " is different from the external one");
             size_t size_to_copy = intr_blob.getSize();
             cpu_parallel_memcpy(ext_blob_ptr, intr_blob_ptr, size_to_copy);
         }
@@ -1108,7 +1170,8 @@ namespace {
 
 class UpdateNodesSeq {
 public:
-    explicit UpdateNodesSeq(std::vector<NodePtr>& executableGraphNodes) : m_executableGraphNodes(executableGraphNodes) {}
+    explicit UpdateNodesSeq(std::vector<NodePtr>& executableGraphNodes)
+        : m_executableGraphNodes(executableGraphNodes) {}
 
     void operator()(size_t stopIndx) {
         for (; prepareCounter < stopIndx; ++prepareCounter) {
@@ -1126,7 +1189,7 @@ class UpdateNodesSeq {
 };
 
 #if (OV_THREAD == OV_THREAD_SEQ)
-    using UpdateNodes = UpdateNodesSeq;
+using UpdateNodes = UpdateNodesSeq;
 #endif
 
 #if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO || OV_THREAD == OV_THREAD_OMP)
@@ -1143,7 +1206,8 @@ class UpdateNodesSeq {
 
 class UpdateNodesBase {
 public:
-    explicit UpdateNodesBase(std::vector<NodePtr>& executableGraphNodes) : m_executableGraphNodes(executableGraphNodes) {}
+    explicit UpdateNodesBase(std::vector<NodePtr>& executableGraphNodes)
+        : m_executableGraphNodes(executableGraphNodes) {}
     void updateShapes(size_t node_indx, size_t stop_indx) {
         try {
             for (size_t i = node_indx; i < stop_indx; i++) {
@@ -1153,8 +1217,7 @@ class UpdateNodesBase {
                 }
                 m_prepareCounter.store(i, ov_memory_order_release);
             }
-        }
-        catch(...) {
+        } catch (...) {
             m_completion.store(true, ov_memory_order_relaxed);
             throw;
         }
@@ -1185,13 +1248,16 @@ class UpdateNodesBase {
     std::vector<NodePtr>& m_executableGraphNodes;
 };
 
-#if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO)
-#if (TBB_VERSION_MAJOR > 2020)
+#    if (OV_THREAD == OV_THREAD_TBB || OV_THREAD == OV_THREAD_TBB_AUTO)
+#        if (TBB_VERSION_MAJOR > 2020)
 template <typename Body>
 class AsyncTask : public tbb::detail::d1::task {
 public:
-    AsyncTask(Body& body, tbb::detail::d1::wait_context& wait, size_t node_indx, size_t stop_indx) :
-        m_body(body), m_wait(wait), m_node_indx(node_indx), m_stop_indx(stop_indx) {}
+    AsyncTask(Body& body, tbb::detail::d1::wait_context& wait, size_t node_indx, size_t stop_indx)
+        : m_body(body),
+          m_wait(wait),
+          m_node_indx(node_indx),
+          m_stop_indx(stop_indx) {}
     task* execute(tbb::detail::d1::execution_data&) override {
         m_body(m_node_indx, m_stop_indx);
         m_wait.release();
@@ -1235,11 +1301,14 @@ class UpdateNodes : public UpdateNodesBase {
 private:
     tbb::task_group_context ctx;
 };
-#else
+#        else
 template <typename Body>
 class AsyncTask : public tbb::task {
 public:
-    AsyncTask(Body& body, size_t node_indx, size_t stop_indx) : m_body(body), m_node_indx(node_indx), m_stop_indx(stop_indx) {}
+    AsyncTask(Body& body, size_t node_indx, size_t stop_indx)
+        : m_body(body),
+          m_node_indx(node_indx),
+          m_stop_indx(stop_indx) {}
     task* execute() override {
         m_body(m_node_indx, m_stop_indx);
         return nullptr;
@@ -1257,28 +1326,30 @@ class UpdateNodes : public UpdateNodesBase {
     void operator()(size_t stopIndx) {
         m_completion.store(false);
         auto startCounter = m_prepareCounter.load();
-        tbb::task& root = *new(tbb::task::allocate_root()) tbb::empty_task;
-        root.set_ref_count(3); // two for children and one preserved
+        tbb::task& root = *new (tbb::task::allocate_root()) tbb::empty_task;
+        root.set_ref_count(3);  // two for children and one preserved
 
         auto task1 = [this](size_t start, size_t stop) {
             this->updateShapes(start, stop);
         };
-        AsyncTask<decltype(task1)>& a = *new (root.allocate_child()) AsyncTask<decltype(task1)>(task1, startCounter, stopIndx);
+        AsyncTask<decltype(task1)>& a =
+            *new (root.allocate_child()) AsyncTask<decltype(task1)>(task1, startCounter, stopIndx);
 
         auto task2 = [this](size_t start, size_t stop) {
             this->updateDynParams(start, stop);
         };
-        AsyncTask<decltype(task2)>& b = *new (root.allocate_child()) AsyncTask<decltype(task2)>(task2, startCounter, stopIndx);
+        AsyncTask<decltype(task2)>& b =
+            *new (root.allocate_child()) AsyncTask<decltype(task2)>(task2, startCounter, stopIndx);
 
-        b.set_affinity(2); // slot 1 plus 1
+        b.set_affinity(2);  // slot 1 plus 1
         tbb::task::spawn(b);
         root.spawn_and_wait_for_all(a);
     }
 };
-#endif
-#endif
+#        endif
+#    endif
 
-#if (OV_THREAD == OV_THREAD_OMP)
+#    if (OV_THREAD == OV_THREAD_OMP)
 class UpdateNodes : public UpdateNodesBase {
 public:
     using UpdateNodesBase::UpdateNodesBase;
@@ -1293,14 +1364,15 @@ class UpdateNodes : public UpdateNodesBase {
         if (origin_nested_levels < 2) {
             set_max_nested_levels(2);
         }
-        // In OpenMP, an exception that is thrown in a parallel region must be caught and handled in the same region by the same thread.
-        // Therefore, need to pass the error message and throw a new exception outside the parallel region.
+        // In OpenMP, an exception that is thrown in a parallel region must be caught and handled in the same region by
+        // the same thread. Therefore, need to pass the error message and throw a new exception outside the parallel
+        // region.
         const char* what = nullptr;
 
-        #pragma omp parallel
-        #pragma omp sections
+#        pragma omp parallel
+#        pragma omp sections
         {
-            #pragma omp section
+#        pragma omp section
             {
                 try {
                     updateDynParams(startCounter, stopIndx);
@@ -1310,7 +1382,7 @@ class UpdateNodes : public UpdateNodesBase {
                     what = "[ CPU ] Could not update dynamic parameters.";
                 }
             }
-            #pragma omp section
+#        pragma omp section
             {
                 try {
                     updateShapes(startCounter, stopIndx);
@@ -1329,18 +1401,18 @@ class UpdateNodes : public UpdateNodesBase {
         OPENVINO_ASSERT(what == nullptr, what);
     }
 };
-#endif
+#    endif
 
 #endif
-} // namespace
+}  // namespace
 
 /* group all the profiling macros into a single one
  * to avoid cluttering a core logic */
 #define VERBOSE_PERF_DUMP_ITT_DEBUG_LOG(ittScope, node, config) \
-    VERBOSE(node, config.debugCaps.verbose); \
-    PERF(node, config.collectPerfCounters); \
-    DUMP(node, config.debugCaps, infer_count); \
-    OV_ITT_SCOPED_TASK(ittScope, node->profiling.execute); \
+    VERBOSE(node, config.debugCaps.verbose);                    \
+    PERF(node, config.collectPerfCounters);                     \
+    DUMP(node, config.debugCaps, infer_count);                  \
+    OV_ITT_SCOPED_TASK(ittScope, node->profiling.execute);      \
     DEBUG_LOG(*node);
 
 inline void Graph::ExecuteNode(const NodePtr& node, SyncInferRequest* request, int numaId) const {
@@ -1362,7 +1434,7 @@ inline void Graph::ExecuteNodeWithCatch(const NodePtr& node, SyncInferRequest* r
     }
 }
 
-template<typename UpdateStrategy>
+template <typename UpdateStrategy>
 void Graph::InferDynamic(SyncInferRequest* request, int numaId, UpdateStrategy&& update) {
     size_t inferCounter = 0;
     for (auto stopIndx : m_executableSyncNodesInds) {
@@ -1410,17 +1482,20 @@ void Graph::Infer(SyncInferRequest* request) {
         InferStatic(request, numaId);
         break;
     default:
-        OPENVINO_ASSERT(IsReady(), "Wrong state of the ov::intel_cpu::Graph. Topology is not ready: ", static_cast<int>(status));
+        OPENVINO_ASSERT(IsReady(),
+                        "Wrong state of the ov::intel_cpu::Graph. Topology is not ready: ",
+                        static_cast<int>(status));
     }
 
-    if (infer_count != -1) infer_count++;
+    if (infer_count != -1)
+        infer_count++;
 }
 
 void Graph::SortTopologically() {
     OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, "Graph::SortTopologically");
 
     // Set execIndex of all nodes to default invaild value
-    for (auto &node : graphNodes) {
+    for (auto& node : graphNodes) {
         node->execIndex = -1;
     }
 
@@ -1433,7 +1508,7 @@ void Graph::SortTopologically() {
         std::function<void(const NodePtr)> visit;
         visit = [&execIndexCnt, &sorted, &visit](const NodePtr node) {
             if (node->execIndex >= 0)
-                return; // already visited
+                return;  // already visited
 
             for (size_t i = 0; i < node->getParentEdges().size(); i++) {
                 visit(node->getParentEdgeAt(i)->getParent());
@@ -1467,7 +1542,7 @@ void Graph::SortTopologically() {
 
     // Sort in / out child edges by port index
     // Make first N (N == port_num) edge indexes match with port index
-    for (auto &node : graphNodes) {
+    for (auto& node : graphNodes) {
         int port_num = node->outputShapes.size();
         std::vector<EdgePtr> res(port_num);
 
@@ -1512,10 +1587,7 @@ void Graph::GetPerfData(std::vector<ov::ProfilingInfo>& perfMap) const {
     }
 }
 
-void Graph::CreateEdge(const NodePtr& parent,
-                       const NodePtr& child,
-                       int parentPort,
-                       int childPort) {
+void Graph::CreateEdge(const NodePtr& parent, const NodePtr& child, int parentPort, int childPort) {
     assert(parentPort >= 0 && childPort >= 0);
 
     auto edge = std::make_shared<Edge>(parent, child, parentPort, childPort);
@@ -1539,24 +1611,28 @@ void Graph::AddNode(NodePtr node) {
     graphNodes.push_back(node);
 }
 
-void Graph::DropNode(const NodePtr &node) {
+void Graph::DropNode(const NodePtr& node) {
     auto children = node->childEdges;
     auto parents = node->parentEdges;
 
     for (size_t i = 0; i < parents.size(); i++) {
         auto p_edge = parents[i].lock();
-        if (!p_edge) continue;
+        if (!p_edge)
+            continue;
         auto parent = p_edge->getParent();
-        if (!parent) continue;
+        if (!parent)
+            continue;
 
         const int inNum = p_edge->getInputNum();
         RemoveEdge(p_edge);
 
         for (size_t j = 0; j < children.size(); j++) {
             auto c_edge = children[j].lock();
-            if (!c_edge) continue;
+            if (!c_edge)
+                continue;
             auto child = c_edge->getChild();
-            if (!child) continue;
+            if (!child)
+                continue;
 
             const int outNum = c_edge->getOutputNum();
             RemoveEdge(c_edge);
@@ -1565,31 +1641,37 @@ void Graph::DropNode(const NodePtr &node) {
     }
 }
 
-void Graph::DropDWConvNode(const NodePtr &node) {
+void Graph::DropDWConvNode(const NodePtr& node) {
     auto children = node->childEdges;
     auto parents = node->parentEdges;
 
     auto parentConvEdge = parents[0].lock();
-    if (!parentConvEdge) return;
+    if (!parentConvEdge)
+        return;
     auto parentConv = parentConvEdge->getParent();
-    if (!parentConv) return;
+    if (!parentConv)
+        return;
 
     parentConv->outputShapes[0] = node->outputShapes[0];
 
     for (size_t i = 0; i < 1; i++) {
         auto p_edge = parents[i].lock();
-        if (!p_edge) continue;
+        if (!p_edge)
+            continue;
         auto parent = p_edge->getParent();
-        if (!parent) continue;
+        if (!parent)
+            continue;
 
         const int inNum = p_edge->getInputNum();
         RemoveEdge(p_edge);
 
         for (size_t j = 0; j < children.size(); j++) {
             auto c_edge = children[j].lock();
-            if (!c_edge) continue;
+            if (!c_edge)
+                continue;
             auto child = c_edge->getChild();
-            if (!child) continue;
+            if (!child)
+                continue;
 
             const int outNum = c_edge->getOutputNum();
             RemoveEdge(c_edge);
@@ -1599,9 +1681,11 @@ void Graph::DropDWConvNode(const NodePtr &node) {
 
     for (size_t i = 1; i < parents.size(); i++) {
         auto p_edge = parents[i].lock();
-        if (!p_edge) continue;
+        if (!p_edge)
+            continue;
         auto parent = p_edge->getParent();
-        if (!parent) continue;
+        if (!parent)
+            continue;
 
         const int inNum = p_edge->getInputNum();
         const int portCandidate = p_edge->getOutputNum();
@@ -1615,14 +1699,20 @@ void Graph::DropDWConvNode(const NodePtr &node) {
 }
 
 void Graph::RemoveDroppedNodes() {
-    graphNodes.erase(std::remove_if(graphNodes.begin(), graphNodes.end(),
-                                    [](const NodePtr& node){ return node->isDropped(); }),
+    graphNodes.erase(std::remove_if(graphNodes.begin(),
+                                    graphNodes.end(),
+                                    [](const NodePtr& node) {
+                                        return node->isDropped();
+                                    }),
                      graphNodes.end());
 }
 
 void Graph::RemoveDroppedEdges() {
-    graphEdges.erase(std::remove_if(graphEdges.begin(), graphEdges.end(),
-                                    [](const EdgePtr& node){ return node->isDropped(); }),
+    graphEdges.erase(std::remove_if(graphEdges.begin(),
+                                    graphEdges.end(),
+                                    [](const EdgePtr& node) {
+                                        return node->isDropped();
+                                    }),
                      graphEdges.end());
 }
 
@@ -1631,19 +1721,28 @@ NodePtr Graph::InsertReorder(EdgePtr edge,
                              const MemoryDesc& inDesc,
                              const MemoryDesc& outDesc,
                              bool isOptimized,
-                             const std::vector<int> & src_perm) {
+                             const std::vector<int>& src_perm) {
     auto reorder = std::make_shared<node::Reorder>(inDesc, outDesc, layerName, m_context);
     reorder->setOptimized(isOptimized);
     reorder->setSrcPermutation(src_perm);
 
     DEBUG_LOG(reorder->getName(), " edge=", *edge, " isOptimized=", isOptimized);
-    DEBUG_LOG("    inDesc: ", inDesc.getShape().toString(), inDesc.getPrecision().get_type_name(), " ", inDesc.serializeFormat());
-    DEBUG_LOG("   outDesc: ", outDesc.getShape().toString(), outDesc.getPrecision().get_type_name(), " ", outDesc.serializeFormat());
+    DEBUG_LOG("    inDesc: ",
+              inDesc.getShape().toString(),
+              inDesc.getPrecision().get_type_name(),
+              " ",
+              inDesc.serializeFormat());
+    DEBUG_LOG("   outDesc: ",
+              outDesc.getShape().toString(),
+              outDesc.getPrecision().get_type_name(),
+              " ",
+              outDesc.serializeFormat());
 
     InsertNode(edge, reorder, true);
 
     // Using the method Edge::getDesc() we can check that input and output tensor descriptors are equal.
-    // Due to the specificity of GraphOptimizer::MergeTransposeAndReorder() that isOptimized flag uses, we shouldn't do these checks.
+    // Due to the specificity of GraphOptimizer::MergeTransposeAndReorder() that isOptimized flag uses, we shouldn't do
+    // these checks.
     if (!isOptimized) {
         reorder->getParentEdgeAt(0)->getDesc();
         reorder->getChildEdgeAt(0)->getDesc();
@@ -1692,10 +1791,10 @@ void Graph::EnforceInferencePrecision() {
     const auto inferPrec = getConfig().inferencePrecision;
 
     if (one_of(inferPrec, element::f32, element::undefined, ov::element::f16))
-        return; // nothing to do, only precision reduction is currently allowed
+        return;  // nothing to do, only precision reduction is currently allowed
 #if defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)
     if (inferPrec == ov::element::f16)
-        return; // precision of configured by ov::pass::ConvertPrecision
+        return;  // precision of configured by ov::pass::ConvertPrecision
 #endif
     std::function<void(const NodePtr&, std::unordered_set<NodePtr>& skipNodes)> searchForNodesToSkip;
     searchForNodesToSkip = [&](const NodePtr& node, std::unordered_set<NodePtr>& skipNodes) -> void {
@@ -1703,35 +1802,35 @@ void Graph::EnforceInferencePrecision() {
             const auto& parent = node->getParentEdgeAt(i)->getParent();
             if (inferPrec == ov::element::bf16) {
                 /* list of node types that must be forced to be executed in BF16 precision
-                * because of performance gains */
+                 * because of performance gains */
                 if (one_of(parent->getType(),
-                        Type::Convolution,    // conv nets
-                        Type::FullyConnected, // conv / bert nets
-                        Type::RNNCell,        // recurent nets
-                        Type::RNNSeq,         // recurent nets
-                        Type::MatMul,         // bert nets
-                        Type::ROIPooling,     // object detection nets
-                        Type::Interpolate,    // super resolution nets
-                        Type::PagedAttention, // page attention
-                        Type::QKVProjection,
-                        Type::LLMMLP))
-                    continue;   // stop at significant nodes
+                           Type::Convolution,     // conv nets
+                           Type::FullyConnected,  // conv / bert nets
+                           Type::RNNCell,         // recurent nets
+                           Type::RNNSeq,          // recurent nets
+                           Type::MatMul,          // bert nets
+                           Type::ROIPooling,      // object detection nets
+                           Type::Interpolate,     // super resolution nets
+                           Type::PagedAttention,  // page attention
+                           Type::QKVProjection,
+                           Type::LLMMLP))
+                    continue;  // stop at significant nodes
             } else if (inferPrec == ov::element::f16) {
                 /* list of node types that must be forced to be executed in FP16 precision
-                * because of performance gains */
+                 * because of performance gains */
                 if (one_of(parent->getType(),
-                        Type::Convolution,    // conv nets
-                        Type::Deconvolution,  // deconv
-                        Type::FullyConnected, // conv / bert nets
-                        Type::MatMul,         // bert nets
-                        Type::Pooling,
-                        Type::MVN))
-                    continue;   // stop at significant nodes
+                           Type::Convolution,     // conv nets
+                           Type::Deconvolution,   // deconv
+                           Type::FullyConnected,  // conv / bert nets
+                           Type::MatMul,          // bert nets
+                           Type::Pooling,
+                           Type::MVN))
+                    continue;  // stop at significant nodes
             }
 
             const auto res = skipNodes.insert(parent);
 
-            if (res.second) // node not visited yet
+            if (res.second)  // node not visited yet
                 searchForNodesToSkip(parent, skipNodes);
         }
     };
@@ -1772,10 +1871,10 @@ void Graph::EnforceInferencePrecision() {
                 // kvcache of PagedAttention should be written directly
                 if (node->getType() == Type::PagedAttention && (inPort == 3 || inPort == 4))
                     return true;
-                const auto &parent = node->getParentEdgeAt(inPort)->getParent();
+                const auto& parent = node->getParentEdgeAt(inPort)->getParent();
                 /* Skip BF16 enforcement for nodes after Constant Inputs for maintaining precision for fusing.
-                 * Element type conversion to bf16 is done automatically, if convolution follows up after Constant Inputs
-                 * and activation is bf16 */
+                 * Element type conversion to bf16 is done automatically, if convolution follows up after Constant
+                 * Inputs and activation is bf16 */
                 if (parent->getType() == Type::Input && parent->isConstant() &&
                     // Concatenation node is exception because it doesn't change an accuracy for BF16 activation
                     node->getType() != Type::Concatenation)
@@ -1815,7 +1914,7 @@ void Graph::EnforceInferencePrecision() {
 
             // exclude Convert before Range since it may cause precision loss when integter type to LP.
             // TODO: Incorrect subgraph is generated by ONNX FE + ticket 117861.
-            const auto &child = node->getChildEdgeAt(i)->getChild();
+            const auto& child = node->getChildEdgeAt(i)->getChild();
             if (child->getType() == Type::Range && node->getType() == Type::Convert)
                 continue;
             // skip second output of PagedAttention
@@ -1845,5 +1944,5 @@ const std::unordered_map<std::string, node::MemoryStateNode*>& Graph::getInterna
     return m_context->getMemoryStatesRegister()->getMemoryStates();
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/graph.h b/src/plugins/intel_cpu/src/graph.h
index d50ccc152c9186..bdf3205d2baaaf 100644
--- a/src/plugins/intel_cpu/src/graph.h
+++ b/src/plugins/intel_cpu/src/graph.h
@@ -4,22 +4,20 @@
 
 #pragma once
 
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
 #include "config.h"
 #include "cpu_memory.h"
-#include "nodes/input.h"
-#include "openvino/core/node_vector.hpp"
-#include "openvino/runtime/profiling_info.hpp"
-#include "node.h"
 #include "edge.h"
 #include "graph_context.h"
 #include "memory_control.hpp"
+#include "node.h"
+#include "nodes/input.h"
+#include "openvino/core/node_vector.hpp"
 #include "openvino/runtime/profiling_info.hpp"
-
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
 #include "openvino/runtime/so_ptr.hpp"
 #include "proxy_mem_blk.h"
 
@@ -29,7 +27,7 @@ namespace intel_cpu {
 class SyncInferRequest;
 namespace node {
 class MemoryStateNode;
-} // namespace node
+}  // namespace node
 
 class Graph {
 public:
@@ -61,15 +59,15 @@ class Graph {
         return IsStatic() || IsDynamic();
     }
 
-    const Config & getConfig() const {
+    const Config& getConfig() const {
         return m_context->getConfig();
     }
 
-    template<typename NET>
-    void CreateGraph(NET &model, const GraphContext::CPtr context);
+    template <typename NET>
+    void CreateGraph(NET& model, const GraphContext::CPtr context);
 
-    void CreateGraph(const std::vector<NodePtr> &graphNodes,
-                     const std::vector<EdgePtr> &graphEdges,
+    void CreateGraph(const std::vector<NodePtr>& graphNodes,
+                     const std::vector<EdgePtr>& graphEdges,
                      const GraphContext::CPtr context,
                      std::string name);
 
@@ -97,14 +95,14 @@ class Graph {
         return outputNodesMap;
     }
 
-    NodePtr getInputNodeByIndex(const std::size_t &index) {
+    NodePtr getInputNodeByIndex(const std::size_t& index) {
         auto input = inputNodesMap.find(index);
         if (input == inputNodesMap.end())
             OPENVINO_THROW("CPU execution graph doesn't contain input node with index: ", index);
         return input->second;
     }
 
-    NodePtr getOutputNodeByIndex(const std::size_t &index) {
+    NodePtr getOutputNodeByIndex(const std::size_t& index) {
         auto output = outputNodesMap.find(index);
         if (output == outputNodesMap.end())
             OPENVINO_THROW("CPU execution graph doesn't contain output node with index: ", index);
@@ -119,12 +117,9 @@ class Graph {
         return m_context;
     }
 
-    void GetPerfData(std::vector<ov::ProfilingInfo> &perfMap) const;
+    void GetPerfData(std::vector<ov::ProfilingInfo>& perfMap) const;
 
-    void CreateEdge(const NodePtr& parent,
-                 const NodePtr& child,
-                 int parentPort = 0,
-                 int childPort = 0);
+    void CreateEdge(const NodePtr& parent, const NodePtr& child, int parentPort = 0, int childPort = 0);
     void RemoveEdge(const EdgePtr& edge);
     void RemoveDroppedNodes();
     void RemoveDroppedEdges();
@@ -134,9 +129,9 @@ class Graph {
 
     /**
      * @brief Insert Reorder node at the edge-specified location.
-     * The Reorder node must be inserted in case when there are inplace conflicts or the input and output tensor descriptors do not match.
-     * The Reorder node rearranges the elements in memory according to inDesc and outDesc, or reinterprets memory descriptor without
-     * rearrangement of elements if isOptimized is true.
+     * The Reorder node must be inserted in case when there are inplace conflicts or the input and output tensor
+     * descriptors do not match. The Reorder node rearranges the elements in memory according to inDesc and outDesc, or
+     * reinterprets memory descriptor without rearrangement of elements if isOptimized is true.
      * @param edge
      * pointer to the edge in the graph where Reorder node will be inserted
      * @param layerName
@@ -153,14 +148,18 @@ class Graph {
      * pointer to the blob containing scales
      * @return pointer to the new Reorder node.
      */
-    NodePtr InsertReorder(EdgePtr edge, std::string layerName, const MemoryDesc& inDesc,
-            const MemoryDesc& outDesc, bool isOptimized = false, const std::vector<int> & src_perm = {});
+    NodePtr InsertReorder(EdgePtr edge,
+                          std::string layerName,
+                          const MemoryDesc& inDesc,
+                          const MemoryDesc& outDesc,
+                          bool isOptimized = false,
+                          const std::vector<int>& src_perm = {});
 
     /**
      * @brief Insert Node at the edge-specified location.
-     * This method supports two regimes. First, the node is inserted without initialization (i.e. supported descriptors initialization,
-     * supported primitive descriptors selection, etc.), which can be useful after the ResolveEdgeConflicts() completes. The second is just inserting the
-     * node without initialization.
+     * This method supports two regimes. First, the node is inserted without initialization (i.e. supported descriptors
+     * initialization, supported primitive descriptors selection, etc.), which can be useful after the
+     * ResolveEdgeConflicts() completes. The second is just inserting the node without initialization.
      * @param edge
      * pointer to the edge in the graph where the node will be inserted
      * @param node
@@ -173,10 +172,10 @@ class Graph {
 
     /**
      * @brief Insert Node between two specified nodes.
-     * This procedure creates two edges that link the parent and child nodes to the inserted one and adds all created objects to the graph.
-     * This method supports two regimes. First, the node is inserted without initialization (i.e. supported descriptors initialization,
-     * supported primitive descriptors selection, etc.), which can be useful after the ResolveEdgeConflicts() completes. The second is just inserting the
-     * node without initialization.
+     * This procedure creates two edges that link the parent and child nodes to the inserted one and adds all created
+     * objects to the graph. This method supports two regimes. First, the node is inserted without initialization (i.e.
+     * supported descriptors initialization, supported primitive descriptors selection, etc.), which can be useful after
+     * the ResolveEdgeConflicts() completes. The second is just inserting the node without initialization.
      * @param parent
      * pointer to the parent node
      * @param child
@@ -193,7 +192,9 @@ class Graph {
 
     std::shared_ptr<ov::Model> dump() const;
 
-    void ResetInferCount() { infer_count = 0; }
+    void ResetInferCount() {
+        infer_count = 0;
+    }
 
     void SortTopologically();
 
@@ -215,7 +216,7 @@ class Graph {
      * Activate execution graph using \p externalInputMemory and \p externalOutputMemory
      */
     void Activate(const std::vector<MemoryPtr>& externalInputMemory = {},
-                            const std::vector<MemoryPtr>& externalOutputMemory = {});
+                  const std::vector<MemoryPtr>& externalOutputMemory = {});
 
     const std::unordered_map<std::size_t, ProxyMemoryBlockPtr>& getOutputNodesMemBlocksMap() const {
         return outputNodesMemBlocksMap;
@@ -231,7 +232,7 @@ class Graph {
         graphEdges.clear();
         m_executableSyncNodesInds.clear();
     }
-    Status status { Status::NotReady };
+    Status status{Status::NotReady};
 
     // For dumping purposes. -1 - no counting, all other positive
     // values mean increment it within each Infer() call
@@ -244,7 +245,7 @@ class Graph {
 
     bool graphHasDynamicInput = false;
 
-    void Replicate(const std::shared_ptr<const ov::Model> &subgraph,
+    void Replicate(const std::shared_ptr<const ov::Model>& subgraph,
                    const std::vector<node::Input::InputConfig>& inputConfigs = {},
                    const std::vector<node::Input::OutputConfig>& outputConfigs = {});
 
@@ -281,10 +282,10 @@ class Graph {
     void ExecuteNode(const NodePtr& node, SyncInferRequest* request = nullptr, int numaId = -1) const;
 
     void InferStatic(SyncInferRequest* request, int numaId);
-    template<typename UpdateStrategy>
+    template <typename UpdateStrategy>
     void InferDynamic(SyncInferRequest* request, int numaId, UpdateStrategy&& update);
 
-    friend std::shared_ptr<ov::Model> dump_graph_as_ie_ngraph_net(const Graph &graph);
+    friend std::shared_ptr<ov::Model> dump_graph_as_ie_ngraph_net(const Graph& graph);
 
 private:
     using event_t = void (Graph::*)(void);
diff --git a/src/plugins/intel_cpu/src/graph_context.cpp b/src/plugins/intel_cpu/src/graph_context.cpp
index 5b967ed58a7918..462cdab2a9b5c0 100644
--- a/src/plugins/intel_cpu/src/graph_context.cpp
+++ b/src/plugins/intel_cpu/src/graph_context.cpp
@@ -1,10 +1,11 @@
 // Copyright (C) 2018-2024 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
-#include "dnnl_types.h"
 #include "graph_context.h"
-#include "nodes/memory.hpp"
+
+#include "dnnl_types.h"
 #include "memory_control.hpp"
+#include "nodes/memory.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -42,5 +43,5 @@ const dnnl::engine& GraphContext::getEngine() {
     return eng;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/graph_context.h b/src/plugins/intel_cpu/src/graph_context.h
index ce51af0c81b4bd..d13872129325b4 100644
--- a/src/plugins/intel_cpu/src/graph_context.h
+++ b/src/plugins/intel_cpu/src/graph_context.h
@@ -4,11 +4,11 @@
 
 #pragma once
 
-#include "openvino/runtime/threading/cpu_streams_executor.hpp"
-#include "sub_memory_manager.hpp"
 #include "cache/multi_cache.h"
 #include "config.h"
 #include "dnnl_scratch_pad.h"
+#include "openvino/runtime/threading/cpu_streams_executor.hpp"
+#include "sub_memory_manager.hpp"
 #include "weights_cache.hpp"
 
 namespace ov {
@@ -16,7 +16,7 @@ namespace intel_cpu {
 
 namespace node {
 class MemoryStatesRegister;
-} // namespace node
+}  // namespace node
 
 class NetworkMemoryControl;
 
@@ -39,7 +39,6 @@ class GraphContext {
         return weightsCache;
     }
 
-
     MultiCachePtr getParamsCache() const {
         return rtParamsCache;
     }
@@ -81,7 +80,7 @@ class GraphContext {
 private:
     Config config;  // network-level config
 
-    WeightsSharing::Ptr weightsCache;         // per NUMA node caches for sharing weights data
+    WeightsSharing::Ptr weightsCache;  // per NUMA node caches for sharing weights data
 
     MultiCachePtr rtParamsCache;     // primitive cache
     DnnlScratchPadPtr rtScratchPad;  // scratch pad
@@ -90,9 +89,9 @@ class GraphContext {
 
     std::vector<DnnlScratchPadPtr> rtScratchPads;  // scratch pad (each sub-stream has its own copy)
 
-    ov::threading::IStreamsExecutor::Ptr streamExecutor;   // stream executor for current graph
+    ov::threading::IStreamsExecutor::Ptr streamExecutor;  // stream executor for current graph
 
-    ov::threading::CPUStreamsExecutor::Ptr cpuStreamExecutor;   // cpu stream executor for current graph
+    ov::threading::CPUStreamsExecutor::Ptr cpuStreamExecutor;  // cpu stream executor for current graph
 
     std::shared_ptr<SubMemoryManager> subMemoryManager;
 
diff --git a/src/plugins/intel_cpu/src/graph_dumper.cpp b/src/plugins/intel_cpu/src/graph_dumper.cpp
index 04c15408743c71..5a3a95362267fe 100644
--- a/src/plugins/intel_cpu/src/graph_dumper.cpp
+++ b/src/plugins/intel_cpu/src/graph_dumper.cpp
@@ -4,28 +4,28 @@
 
 #include "graph_dumper.h"
 
-#include "dnnl_debug.h"
-#include "openvino/pass/manager.hpp"
-#include "openvino/pass/serialize.hpp"
-#include "openvino/runtime/exec_model_info.hpp"
-#include "utils/debug_capabilities.h"
-
 #include <chrono>
+#include <fstream>
 #include <map>
 #include <memory>
 #include <string>
 #include <vector>
-#include <fstream>
+
+#include "dnnl_debug.h"
+#include "openvino/pass/manager.hpp"
+#include "openvino/pass/serialize.hpp"
+#include "openvino/runtime/exec_model_info.hpp"
+#include "utils/debug_capabilities.h"
 
 namespace ov {
 namespace intel_cpu {
 
-void serializeToCout(const Graph &graph);
-void serializeToXML(const Graph &graph, const std::string& path);
+void serializeToCout(const Graph& graph);
+void serializeToXML(const Graph& graph, const std::string& path);
 
 namespace {
 
-std::map<std::string, std::string> extract_node_metadata(const NodePtr &node) {
+std::map<std::string, std::string> extract_node_metadata(const NodePtr& node) {
     std::map<std::string, std::string> serialization_info;
 
     if (node->getType() == Type::Input && node->isConstant()) {
@@ -47,7 +47,8 @@ std::map<std::string, std::string> extract_node_metadata(const NodePtr &node) {
 
         bool isAllEqual = true;
         for (size_t i = 1; i < node->getChildEdges().size(); i++) {
-            if (node->getChildEdgeAt(i - 1)->getMemory().getDesc().getPrecision() != node->getChildEdgeAt(i)->getMemory().getDesc().getPrecision()) {
+            if (node->getChildEdgeAt(i - 1)->getMemory().getDesc().getPrecision() !=
+                node->getChildEdgeAt(i)->getMemory().getDesc().getPrecision()) {
                 isAllEqual = false;
                 break;
             }
@@ -56,7 +57,8 @@ std::map<std::string, std::string> extract_node_metadata(const NodePtr &node) {
         // If all output precisions are the same, we store the name only once
         if (!isAllEqual) {
             for (size_t i = 1; i < node->getChildEdges().size(); i++)
-                outputPrecisionsStr += "," + std::string(node->getChildEdgeAt(i)->getMemory().getDesc().getPrecision().get_type_name());
+                outputPrecisionsStr +=
+                    "," + std::string(node->getChildEdgeAt(i)->getMemory().getDesc().getPrecision().get_type_name());
         }
     } else {
         // Branch to correctly handle output nodes
@@ -107,8 +109,8 @@ std::map<std::string, std::string> extract_node_metadata(const NodePtr &node) {
 
 }  // namespace
 
-std::shared_ptr<ov::Model> dump_graph_as_ie_ngraph_net(const Graph &graph) {
-    std::map<NodePtr, std::shared_ptr<ov::Node> > node2layer;
+std::shared_ptr<ov::Model> dump_graph_as_ie_ngraph_net(const Graph& graph) {
+    std::map<NodePtr, std::shared_ptr<ov::Node>> node2layer;
 
     ov::ResultVector results;
     ov::ParameterVector params;
@@ -117,7 +119,7 @@ std::shared_ptr<ov::Model> dump_graph_as_ie_ngraph_net(const Graph &graph) {
     std::map<std::size_t, std::shared_ptr<op::v0::Parameter>> paramsMap;
     std::map<std::size_t, std::shared_ptr<ov::op::v0::Result>> resultsMap;
 
-    auto get_inputs = [&] (const NodePtr & node) {
+    auto get_inputs = [&](const NodePtr& node) {
         auto pr_edges = node->getParentEdges();
         ov::OutputVector inputs(pr_edges.size());
 
@@ -136,10 +138,10 @@ std::shared_ptr<ov::Model> dump_graph_as_ie_ngraph_net(const Graph &graph) {
         return inputs;
     };
 
-    auto create_ngraph_node = [&](const NodePtr &node) {
+    auto create_ngraph_node = [&](const NodePtr& node) {
         bool is_input = false, is_output = false, should_be_hold = false;
         size_t input_index = -1, output_index = -1;
-        for (auto && kvp : graph.inputNodesMap) {
+        for (auto&& kvp : graph.inputNodesMap) {
             if (kvp.second == node) {
                 is_input = true;
                 input_index = kvp.first;
@@ -147,7 +149,7 @@ std::shared_ptr<ov::Model> dump_graph_as_ie_ngraph_net(const Graph &graph) {
             }
         }
 
-        for (auto && kvp : graph.outputNodesMap) {
+        for (auto&& kvp : graph.outputNodesMap) {
             if (kvp.second == node) {
                 is_output = true;
                 output_index = kvp.first;
@@ -174,7 +176,8 @@ std::shared_ptr<ov::Model> dump_graph_as_ie_ngraph_net(const Graph &graph) {
             return_node = result;
         } else {
             return_node = std::make_shared<ov::exec_model_info::ExecutionNode>(
-                get_inputs(node), node->getSelectedPrimitiveDescriptor()->getConfig().outConfs.size());
+                get_inputs(node),
+                node->getSelectedPrimitiveDescriptor()->getConfig().outConfs.size());
 
             for (size_t port = 0; port < return_node->get_output_size(); ++port) {
                 auto& desc = node->getChildEdgeAt(port)->getMemory().getDesc();
@@ -186,7 +189,7 @@ std::shared_ptr<ov::Model> dump_graph_as_ie_ngraph_net(const Graph &graph) {
             to_hold.push_back(return_node);
         }
 
-        for (auto && kvp : meta_data)
+        for (auto&& kvp : meta_data)
             return_node->get_rt_info()[kvp.first] = kvp.second;
         return_node->set_friendly_name(node->getName());
 
@@ -195,18 +198,18 @@ std::shared_ptr<ov::Model> dump_graph_as_ie_ngraph_net(const Graph &graph) {
 
     ov::NodeVector nodes;
     nodes.reserve(graph.graphNodes.size());
-    for (auto &node : graph.graphNodes) {  // important: graph.graphNodes are in topological order
+    for (auto& node : graph.graphNodes) {  // important: graph.graphNodes are in topological order
         nodes.emplace_back(create_ngraph_node(node));
         node2layer[node] = nodes.back();
     }
 
-    for (auto && kvp : paramsMap)
+    for (auto&& kvp : paramsMap)
         params.push_back(kvp.second);
-    for (auto && kvp : resultsMap)
+    for (auto&& kvp : resultsMap)
         results.push_back(kvp.second);
 
     auto holder = !results.empty() ? results[0] : std::make_shared<ov::op::v0::Result>();
-    for (auto &node : to_hold) {
+    for (auto& node : to_hold) {
         holder->add_control_dependency(node);
     }
 
@@ -214,7 +217,7 @@ std::shared_ptr<ov::Model> dump_graph_as_ie_ngraph_net(const Graph &graph) {
 }
 
 #ifdef CPU_DEBUG_CAPS
-void serialize(const Graph &graph) {
+void serialize(const Graph& graph) {
     const std::string& path = graph.getConfig().debugCaps.execGraphPath;
 
     if (path.empty())
@@ -231,19 +234,17 @@ void serialize(const Graph &graph) {
     }
 }
 
-void serializeToXML(const Graph &graph, const std::string& path) {
+void serializeToXML(const Graph& graph, const std::string& path) {
     if (path.empty())
         return;
 
     std::string binPath;
     ov::pass::Manager manager;
-    manager.register_pass<ov::pass::Serialize>(path,
-                                               binPath,
-                                               ov::pass::Serialize::Version::IR_V10);
+    manager.register_pass<ov::pass::Serialize>(path, binPath, ov::pass::Serialize::Version::IR_V10);
     manager.run_passes(graph.dump());
 }
 
-void serializeToCout(const Graph &graph) {
+void serializeToCout(const Graph& graph) {
     for (const auto& node : graph.GetNodes()) {
         std::cout << "name: " << node->getName() << " [ ";
         auto nodeDesc = node->getSelectedPrimitiveDescriptor();
@@ -251,8 +252,7 @@ void serializeToCout(const Graph &graph) {
             auto& inConfs = nodeDesc->getConfig().inConfs;
             if (!inConfs.empty()) {
                 std::cout << "in: " << inConfs.front().getMemDesc()->getPrecision().get_type_name()
-                          << "/l=" << inConfs.front().getMemDesc()->serializeFormat()
-                          << "; ";
+                          << "/l=" << inConfs.front().getMemDesc()->serializeFormat() << "; ";
             }
             auto& outConfs = nodeDesc->getConfig().outConfs;
             if (!outConfs.empty()) {
@@ -260,11 +260,11 @@ void serializeToCout(const Graph &graph) {
                           << "/l=" << outConfs.front().getMemDesc()->serializeFormat();
             }
         }
-        std::cout << " ]"  << std::endl;
+        std::cout << " ]" << std::endl;
     }
 }
 
-void summary_perf(const Graph &graph) {
+void summary_perf(const Graph& graph) {
     if (!graph.getGraphContext()) {
         return;
     }
@@ -277,7 +277,7 @@ void summary_perf(const Graph &graph) {
     std::map<NodePtr, double> perf_by_node;
     double total_avg = 0;
     uint64_t total = 0;
-    for (auto &node : graph.GetNodes()) {  // important: graph.graphNodes are in topological order
+    for (auto& node : graph.GetNodes()) {  // important: graph.graphNodes are in topological order
         double avg = node->PerfCounter().avg();
         auto type = node->getTypeStr() + "_" + node->getPrimitiveDescriptorType();
         auto name = node->getName();
@@ -296,59 +296,60 @@ void summary_perf(const Graph &graph) {
             perf_by_node[node] = avg;
     }
 
-    if (total_avg < 1) return;
+    if (total_avg < 1)
+        return;
 
     std::cout << "======= ENABLE_DEBUG_CAPS:OV_CPU_SUMMARY_PERF ======" << std::endl;
-    std::cout << "Summary of " << graph.GetName() << " @" << std::hash<uint64_t>{}(reinterpret_cast<uint64_t>(&graph)) << std::endl;
+    std::cout << "Summary of " << graph.GetName() << " @" << std::hash<uint64_t>{}(reinterpret_cast<uint64_t>(&graph))
+              << std::endl;
     std::cout << "     Total(us): " << (uint64_t)(total) << std::endl;
     std::cout << " Total_avg(us): " << (uint64_t)(total_avg) << std::endl;
     {
         std::cout << " perf_by_type:" << std::endl;
-        std::vector<std::pair<std::string, double> > A;
+        std::vector<std::pair<std::string, double>> A;
         for (auto& it : perf_by_type)
             A.push_back(it);
-        sort(A.begin(), A.end(),
-             [](std::pair<std::string, double>& a,
-                std::pair<std::string, double>& b){
-                 return a.second > b.second;
-             });
+        sort(A.begin(), A.end(), [](std::pair<std::string, double>& a, std::pair<std::string, double>& b) {
+            return a.second > b.second;
+        });
 
         for (auto& it : A) {
             std::stringstream ss;
-            int percentage = static_cast<int>(it.second*100/total_avg);
-            if (percentage == 0) break;
-            ss << std::setw(10) << std::right << percentage << " % :  " << std::setw(8) << std::right << it.second << "(us)  " << it.first << std::endl;
+            int percentage = static_cast<int>(it.second * 100 / total_avg);
+            if (percentage == 0)
+                break;
+            ss << std::setw(10) << std::right << percentage << " % :  " << std::setw(8) << std::right << it.second
+               << "(us)  " << it.first << std::endl;
             std::cout << ss.str();
         }
     }
     {
         std::cout << " perf_by_node:" << std::endl;
-        std::vector<std::pair<NodePtr, double> > A;
+        std::vector<std::pair<NodePtr, double>> A;
         for (auto& it : perf_by_node)
             A.push_back(it);
-        sort(A.begin(), A.end(),
-            [](std::pair<NodePtr, double>& a,
-                std::pair<NodePtr, double>& b){
+        sort(A.begin(), A.end(), [](std::pair<NodePtr, double>& a, std::pair<NodePtr, double>& b) {
             return a.second > b.second;
         });
 
         for (auto& it : A) {
             std::stringstream ss;
-            auto percentage = it.second*100/total_avg;
+            auto percentage = it.second * 100 / total_avg;
             auto node = it.first;
-            if (node->PerfCounter().count() == 0) continue;
-            if (node->PerfCounter().avg() < 1) continue;
+            if (node->PerfCounter().count() == 0)
+                continue;
+            if (node->PerfCounter().avg() < 1)
+                continue;
             ss << std::setw(10) << std::right << std::fixed << std::setprecision(2) << percentage << " %  "
-               << std::setw(8) << std::right  << node->PerfCounter().avg() << "(us)x" << node->PerfCounter().count()
-               << " #" << node->getExecIndex()
-               << " " << node->getName()
-               << " " << node->getTypeStr() + "_" + node->getPrimitiveDescriptorType() << std::endl;
+               << std::setw(8) << std::right << node->PerfCounter().avg() << "(us)x" << node->PerfCounter().count()
+               << " #" << node->getExecIndex() << " " << node->getName() << " "
+               << node->getTypeStr() + "_" + node->getPrimitiveDescriptorType() << std::endl;
             std::cout << ss.str();
         }
     }
 }
 
-void average_counters(const Graph &graph) {
+void average_counters(const Graph& graph) {
     /**
      * @todo improve logic for a graph with inner graphs:
      * - collect counters only for the outer graph if full path is specified
@@ -359,7 +360,8 @@ void average_counters(const Graph &graph) {
     static int graphIndex = 0;
 
     std::ofstream file;
-    std::string fileName = graph.getConfig().debugCaps.averageCountersPath + "_" + std::to_string(graphIndex++) + ".csv";
+    std::string fileName =
+        graph.getConfig().debugCaps.averageCountersPath + "_" + std::to_string(graphIndex++) + ".csv";
 
     file.open(fileName);
 
@@ -379,18 +381,14 @@ void average_counters(const Graph &graph) {
         const auto cpuTime = toMs(avg);
         const auto realTime = cpuTime;
 
-        file << node->getName() << ";"
-               << status << ";"
-               << node->getTypeStr() << ";"
-               << node->getPrimitiveDescriptorType() << ";"
-               << realTime << ";"
-               << cpuTime << ";"
-               << "\n";
+        file << node->getName() << ";" << status << ";" << node->getTypeStr() << ";"
+             << node->getPrimitiveDescriptorType() << ";" << realTime << ";" << cpuTime << ";"
+             << "\n";
 
         return avg;
     };
 
-    for (auto &node : graph.GetNodes()) {
+    for (auto& node : graph.GetNodes()) {
         if (node->isConstant())
             continue;
 
@@ -399,11 +397,12 @@ void average_counters(const Graph &graph) {
 
     const auto totalMs = toMs(total);
 
-    file << "Total;;;;" << totalMs << ";" << totalMs << ";" << "\n";
+    file << "Total;;;;" << totalMs << ";" << totalMs << ";"
+         << "\n";
 
     file.close();
 }
 
 #endif
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/graph_dumper.h b/src/plugins/intel_cpu/src/graph_dumper.h
index 417db7e4c3cdc5..40af2fd44c61e6 100644
--- a/src/plugins/intel_cpu/src/graph_dumper.h
+++ b/src/plugins/intel_cpu/src/graph_dumper.h
@@ -4,19 +4,19 @@
 
 #pragma once
 
-#include "graph.h"
-
 #include <memory>
 
+#include "graph.h"
+
 namespace ov {
 namespace intel_cpu {
 
-std::shared_ptr<ov::Model> dump_graph_as_ie_ngraph_net(const Graph &graph);
+std::shared_ptr<ov::Model> dump_graph_as_ie_ngraph_net(const Graph& graph);
 #ifdef CPU_DEBUG_CAPS
-void serialize(const Graph &graph);
-void summary_perf(const Graph &graph);
-void average_counters(const Graph &graph);
-#endif // CPU_DEBUG_CAPS
+void serialize(const Graph& graph);
+void summary_perf(const Graph& graph);
+void average_counters(const Graph& graph);
+#endif  // CPU_DEBUG_CAPS
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/graph_optimizer.cpp b/src/plugins/intel_cpu/src/graph_optimizer.cpp
index 94f54fc4c59b55..fe0df309dc32f1 100644
--- a/src/plugins/intel_cpu/src/graph_optimizer.cpp
+++ b/src/plugins/intel_cpu/src/graph_optimizer.cpp
@@ -4,6 +4,7 @@
 
 #include "graph_optimizer.h"
 
+#include "cpu_types.h"
 #include "dnnl_extension_utils.h"
 #include "nodes/bin_conv.h"
 #include "nodes/common/cpu_convert.h"
@@ -22,28 +23,26 @@
 #include "nodes/transpose.h"
 #include "onednn/dnnl.h"
 #include "openvino/opsets/opset1.hpp"
-#include "cpu_types.h"
 #include "utils/cpu_utils.hpp"
 #include "utils/debug_capabilities.h"
 #include "utils/general_utils.h"
 
 // WA for xbyak.h
 #ifdef _WIN32
-# ifndef _WINSOCKAPI_
-#  define _WINSOCKAPI_
-# endif
-# ifndef _WINSOCK2API_
-#  define _WINSOCK2API_
-#endif
+#    ifndef _WINSOCKAPI_
+#        define _WINSOCKAPI_
+#    endif
+#    ifndef _WINSOCK2API_
+#        define _WINSOCK2API_
+#    endif
 #endif
-#include "cpu/x64/cpu_isa_traits.hpp"
-
-#include <string>
+#include <algorithm>
 #include <list>
 #include <memory>
 #include <set>
-#include <algorithm>
+#include <string>
 
+#include "cpu/x64/cpu_isa_traits.hpp"
 #include "itt.h"
 #include "memory_desc/cpu_memory_desc_utils.h"
 
@@ -55,11 +54,15 @@ namespace intel_cpu {
 
 GraphOptimizer::GraphOptimizer() {}
 
-void GraphOptimizer::ApplyCommonGraphOptimizations(Graph &graph) {
+void GraphOptimizer::ApplyCommonGraphOptimizations(Graph& graph) {
     // For conv with input zp, canBeExecutedInInt8() check has dependency on input zero point check.
-    // Also zero point node is the input of computing-intensive nodes. Most others fusing are the output of computing-intensive nodes.
-    // So Locate the FuseConvolutionAndZeroPoints() as the first optimization.
-    OV_ITT_SCOPE_CHAIN(FIRST_INFERENCE, taskChain, itt::domains::intel_cpu_LT, "ApplyCommonGraphOptimizations", "FuseConvolutionAndZeroPoints");
+    // Also zero point node is the input of computing-intensive nodes. Most others fusing are the output of
+    // computing-intensive nodes. So Locate the FuseConvolutionAndZeroPoints() as the first optimization.
+    OV_ITT_SCOPE_CHAIN(FIRST_INFERENCE,
+                       taskChain,
+                       itt::domains::intel_cpu_LT,
+                       "ApplyCommonGraphOptimizations",
+                       "FuseConvolutionAndZeroPoints");
     FuseConvolutionAndZeroPoints(graph);
     graph.RemoveDroppedNodes();
 
@@ -187,7 +190,7 @@ void GraphOptimizer::ApplyCommonGraphOptimizations(Graph &graph) {
     graph.RemoveDroppedEdges();
 }
 
-void GraphOptimizer::ApplyImplSpecificGraphOptimizations(Graph &graph) {
+void GraphOptimizer::ApplyImplSpecificGraphOptimizations(Graph& graph) {
     OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, "GraphOptimizer::ApplyImplSpecificGraphOptimizations");
 
     DropDoubleReorders(graph);
@@ -202,7 +205,7 @@ void GraphOptimizer::ApplyImplSpecificGraphOptimizations(Graph &graph) {
     graph.RemoveDroppedEdges();
 }
 
-void GraphOptimizer::FuseConvMatmulFCDeconvAndDQScales(Graph &graph) {
+void GraphOptimizer::FuseConvMatmulFCDeconvAndDQScales(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isDQScaleGraphPattern = [](NodePtr node) {
@@ -211,13 +214,12 @@ void GraphOptimizer::FuseConvMatmulFCDeconvAndDQScales(Graph &graph) {
         }
         auto parentNode = node->getParentEdgeAt(0)->getParent();
         auto scaleNode = node->getParentEdgeAt(1)->getParent();
-        if (!(parentNode->getType() == Type::Convolution
-                        || parentNode->getType() == Type::MatMul
-                        || parentNode->getType() == Type::Deconvolution))
+        if (!(parentNode->getType() == Type::Convolution || parentNode->getType() == Type::MatMul ||
+              parentNode->getType() == Type::Deconvolution))
             return false;
         if (!scaleNode->isConstant())
             return false;
-        //Only Fusing scales for INT8 precision.
+        // Only Fusing scales for INT8 precision.
         if (!parentNode->canBeExecutedInInt8())
             return false;
         return (parentNode->getParentEdges().size() == 2);
@@ -233,8 +235,7 @@ void GraphOptimizer::FuseConvMatmulFCDeconvAndDQScales(Graph &graph) {
         if (!node->getFusedWith().empty() || !scales->getFusedWith().empty())
             return false;
 
-        const auto scalesDims = getNormalizedDimsBySize(scales->getOutputShapeAtPort(0).getDims(),
-                                                nodeOutDims.size());
+        const auto scalesDims = getNormalizedDimsBySize(scales->getOutputShapeAtPort(0).getDims(), nodeOutDims.size());
         if (nodeOutDims.size() != scalesDims.size() || scalesDims.size() < 2)
             return false;
 
@@ -261,7 +262,7 @@ void GraphOptimizer::FuseConvMatmulFCDeconvAndDQScales(Graph &graph) {
         if (scalesData == nullptr)
             OPENVINO_THROW("scalesBlob has not allocated buffer");
         auto scalesDims = getNormalizedDimsBySize(scales->getOutputShapeAtPort(0).getDims(),
-                                                node->getOutputShapeAtPort(0).getDims().size());
+                                                  node->getOutputShapeAtPort(0).getDims().size());
         auto scaleSize = std::accumulate(scalesDims.begin(), scalesDims.end(), 1, std::multiplies<size_t>());
         node->fuseDQScales(scalesData, scaleSize);
         return true;
@@ -269,16 +270,21 @@ void GraphOptimizer::FuseConvMatmulFCDeconvAndDQScales(Graph &graph) {
 
     for (size_t i = 0; i < graphNodes.size(); i++) {
         auto mul = graphNodes[i];
-        if (!isDQScaleGraphPattern(mul)) continue;
+        if (!isDQScaleGraphPattern(mul))
+            continue;
 
         CPU_GRAPH_OPTIMIZER_SCOPE(FuseConvMatmulFCDeconvAndDQScales);
 
         auto node = mul->getParentEdgeAt(0)->getParent();
         auto scales = mul->getParentEdgeAt(1)->getParent();
-        if (!scaleDimsCheck(node, scales)) continue;
+        if (!scaleDimsCheck(node, scales))
+            continue;
 
         if (initializeDeQuantizedScales(node, scales)) {
-            DEBUG_LOG("GraphOptimizer##FusingDQ: Node ##", mul->getName(), " optimized as DQ scales of Node ##", node->getName());
+            DEBUG_LOG("GraphOptimizer##FusingDQ: Node ##",
+                      mul->getName(),
+                      " optimized as DQ scales of Node ##",
+                      node->getName());
             node->addOriginalLayer(mul->getOriginalLayers());
             auto p_edge = mul->getParentEdgeAt(1);
             graph.RemoveEdge(p_edge);
@@ -287,7 +293,7 @@ void GraphOptimizer::FuseConvMatmulFCDeconvAndDQScales(Graph &graph) {
     }
 }
 
-void GraphOptimizer::FuseConvolutionMatMulDeconvAndBias(Graph &graph) {
+void GraphOptimizer::FuseConvolutionMatMulDeconvAndBias(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableParentNode = [](const NodePtr& node) {
@@ -300,16 +306,14 @@ void GraphOptimizer::FuseConvolutionMatMulDeconvAndBias(Graph &graph) {
             return false;
 
         if (!deconv)
-            return (one_of(node->getType(), Type::Convolution, Type::MatMul) &&
-                   node->getParentEdges().size() == 2);
+            return (one_of(node->getType(), Type::Convolution, Type::MatMul) && node->getParentEdges().size() == 2);
         else
             return deconv->canFuseBias();
     };
 
     auto isSuitableChildNode = [&](const NodePtr& parentNode, const NodePtr& childNode) {
-        if (childNode->getAlgorithm() != Algorithm::EltwiseAdd
-            || !childNode->getFusedWith().empty()
-            || childNode->getParentEdges().size() != 2)
+        if (childNode->getAlgorithm() != Algorithm::EltwiseAdd || !childNode->getFusedWith().empty() ||
+            childNode->getParentEdges().size() != 2)
             return false;
 
         auto biasPort = childNode->getParentEdgeAt(0)->getParent() == parentNode ? 1 : 0;
@@ -318,10 +322,11 @@ void GraphOptimizer::FuseConvolutionMatMulDeconvAndBias(Graph &graph) {
             return false;
 
         const auto parentOutDims = parentNode->getOutputShapeAtPort(0).getDims();
-        const auto biasDims = getNormalizedDimsBySize(biasNode->getOutputShapeAtPort(0).getDims(),
-                                                parentOutDims.size());
-        // TODO [NM]: Legacy ConvBias fusion transformation supports both per-tensor (via explicit broadcasing) and per-channel cases.
-        // Most of the real models contain per-channel bias, so we need to reavaluate the need to support per-tensor variant.
+        const auto biasDims =
+            getNormalizedDimsBySize(biasNode->getOutputShapeAtPort(0).getDims(), parentOutDims.size());
+        // TODO [NM]: Legacy ConvBias fusion transformation supports both per-tensor (via explicit broadcasing) and
+        // per-channel cases. Most of the real models contain per-channel bias, so we need to reavaluate the need to
+        // support per-tensor variant.
         if (parentOutDims.size() != biasDims.size() || biasDims.size() < 2)
             return false;
 
@@ -357,9 +362,11 @@ void GraphOptimizer::FuseConvolutionMatMulDeconvAndBias(Graph &graph) {
 
         for (size_t i = 0; i < parents.size(); i++) {
             auto p_edge = parents[i].lock();
-            if (!p_edge) continue;
+            if (!p_edge)
+                continue;
             auto parent = p_edge->getParent();
-            if (!parent) continue;
+            if (!parent)
+                continue;
 
             if (parent == parentNode) {
                 for (size_t j = 0; j < childs.size(); j++) {
@@ -369,7 +376,7 @@ void GraphOptimizer::FuseConvolutionMatMulDeconvAndBias(Graph &graph) {
                     if (!child)
                         continue;
 
-                    EdgePtr &remEdge = p_edge;
+                    EdgePtr& remEdge = p_edge;
                     int inNum = 0;
                     if (remEdge) {
                         inNum = remEdge->getInputNum();
@@ -384,7 +391,7 @@ void GraphOptimizer::FuseConvolutionMatMulDeconvAndBias(Graph &graph) {
                     graph.CreateEdge(parent, child, inNum, outNum);
                 }
             } else {
-                EdgePtr &remEdge = p_edge;
+                EdgePtr& remEdge = p_edge;
                 int inNum = 0;
                 if (remEdge) {
                     inNum = remEdge->getInputNum();
@@ -398,48 +405,57 @@ void GraphOptimizer::FuseConvolutionMatMulDeconvAndBias(Graph &graph) {
                 // ONEDNN Conv, Deconv, FC would need the bias to be flatten into 1D tensor.
                 // Usually the bias output shape would be normalized to align rank with Conv/Deconv/FC output.
                 // To avoid duplicate reshape WA code in nodes, here we flatten the shape.
-                // Most bias nodes are const Input and bias memory primitive has been initialized as const memory when constructing CPU Input node.
-                // Const memory is not allowed to be modified after initialized. It means we can't redefine const bias memory primitive.
-                // So let's insert a reshape node to flatten the bias shape into 1D and const folding node will be executed during the compiling stage.
-                const bool needReshape = (targetNode->getType() != Type::MatMul &&
-                                         biasOutputShape.getRank() != 1);
+                // Most bias nodes are const Input and bias memory primitive has been initialized as const memory when
+                // constructing CPU Input node. Const memory is not allowed to be modified after initialized. It means
+                // we can't redefine const bias memory primitive. So let's insert a reshape node to flatten the bias
+                // shape into 1D and const folding node will be executed during the compiling stage.
+                const bool needReshape = (targetNode->getType() != Type::MatMul && biasOutputShape.getRank() != 1);
                 if (needReshape) {
                     // Bias -> Reshape -> Conv/Deconv/FC
                     const VectorDims flattenShape = {biasOutputShape.getElementsCount()};
                     // Construct Ngraph Reshape node and CPU Reshape node.
-                    auto reshapeConstInput = std::make_shared<ov::opset1::Constant>(ov::element::i32, ov::Shape{1}, flattenShape);
-                    auto reshapeDummyInput = std::make_shared<ov::opset1::Parameter>(
-                                                biasNode->getOriginalOutputPrecisionAtPort(0),
-                                                biasOutputShape.toPartialShape());
-                    const auto reshape = std::make_shared<ov::opset1::Reshape>(reshapeDummyInput, reshapeConstInput, false);
+                    auto reshapeConstInput =
+                        std::make_shared<ov::opset1::Constant>(ov::element::i32, ov::Shape{1}, flattenShape);
+                    auto reshapeDummyInput =
+                        std::make_shared<ov::opset1::Parameter>(biasNode->getOriginalOutputPrecisionAtPort(0),
+                                                                biasOutputShape.toPartialShape());
+                    const auto reshape =
+                        std::make_shared<ov::opset1::Reshape>(reshapeDummyInput, reshapeConstInput, false);
                     reshape->set_friendly_name(biasNode->getName() + "_flatten_reshape");
-                    const auto cpuReshapeNode = std::make_shared<ov::intel_cpu::node::Reshape>(reshape, graph.getGraphContext());
+                    const auto cpuReshapeNode =
+                        std::make_shared<ov::intel_cpu::node::Reshape>(reshape, graph.getGraphContext());
                     // Insert Reshape between bias node and Conv/Deconv/FC
                     graph.InsertNode(biasNode, targetNode, cpuReshapeNode, inNum, outNum, false);
                     // Insert the Reshape const input node and edge into CPU graph.
-                    const auto cpuReshapeConstInput = std::make_shared<node::Input>(reshapeConstInput, graph.getGraphContext());
+                    const auto cpuReshapeConstInput =
+                        std::make_shared<node::Input>(reshapeConstInput, graph.getGraphContext());
                     graph.AddNode(cpuReshapeConstInput);
                     graph.CreateEdge(cpuReshapeConstInput, cpuReshapeNode, 0, 1);
-                    DEBUG_LOG("GraphOptimizer##FusingBias:Flatten Bias node from shape ", PartialShape{biasOutputShape.getDims()},
-                                        "  to  ", PartialShape{flattenShape});
+                    DEBUG_LOG("GraphOptimizer##FusingBias:Flatten Bias node from shape ",
+                              PartialShape{biasOutputShape.getDims()},
+                              "  to  ",
+                              PartialShape{flattenShape});
                     // Update bias output shape to be flatten shape.
                     biasOutputShape = Shape{flattenShape};
                 } else {
                     // Bias is connected as input edge.
                     graph.CreateEdge(biasNode, targetNode, inNum, outNum);
                 }
-                //Add the Bias inputshape into conv/FC/Deconv/Matmul.
+                // Add the Bias inputshape into conv/FC/Deconv/Matmul.
                 targetNode->inputShapes.push_back(biasOutputShape);
             }
         }
-        DEBUG_LOG("GraphOptimizer##FusingBias:Node ##: ", childNode->getName(), " initialize as Bias of Node ##", parentNode->getName());
+        DEBUG_LOG("GraphOptimizer##FusingBias:Node ##: ",
+                  childNode->getName(),
+                  " initialize as Bias of Node ##",
+                  parentNode->getName());
         parentNode->addOriginalLayer(childNode->getOriginalLayers());
         parentNode->addOriginalInputPrecision(childNode->getOriginalInputPrecisionAtPort(biasPort));
         graph.DropNode(childNode);
     }
 }
 
-void GraphOptimizer::FuseDeconvolutionAndSimpleOperation(Graph &graph) {
+void GraphOptimizer::FuseDeconvolutionAndSimpleOperation(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableParentNode = [](NodePtr node) {
@@ -485,7 +501,7 @@ void GraphOptimizer::FuseDeconvolutionAndSimpleOperation(Graph &graph) {
         childNode->fuseInto(parentNode);
 
         auto parentEdges = childNode->parentEdges;
-        for (auto &parentEdge : parentEdges) {
+        for (auto& parentEdge : parentEdges) {
             auto p_edge = parentEdge.lock();
             if (p_edge->getParent()->getType() == Type::Deconvolution)
                 continue;
@@ -497,7 +513,7 @@ void GraphOptimizer::FuseDeconvolutionAndSimpleOperation(Graph &graph) {
     }
 }
 
-void GraphOptimizer::FuseMultiplyAndAdd(Graph &graph) {
+void GraphOptimizer::FuseMultiplyAndAdd(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableSecondInput = [](const NodePtr& node, VectorDims dataDims) {
@@ -509,9 +525,9 @@ void GraphOptimizer::FuseMultiplyAndAdd(Graph &graph) {
 
         auto getChannelAxis = [](const VectorDims& dims) {
             auto channelAxis = -1;
-            for (size_t i = 0; i < dims.size(); i ++) {
+            for (size_t i = 0; i < dims.size(); i++) {
                 if (dims[i] != 1) {
-                    if (channelAxis != -1) // more than one axis is != 1
+                    if (channelAxis != -1)  // more than one axis is != 1
                         return -1;
                     else
                         channelAxis = i;
@@ -539,11 +555,13 @@ void GraphOptimizer::FuseMultiplyAndAdd(Graph &graph) {
     };
 
     auto isSuitableChildNode = [&](const NodePtr& parentNode, const NodePtr& childNode) {
-        if (childNode->getAlgorithm() != Algorithm::EltwiseAdd || !childNode->getFusedWith().empty() || childNode->getParentEdges().size() != 2)
+        if (childNode->getAlgorithm() != Algorithm::EltwiseAdd || !childNode->getFusedWith().empty() ||
+            childNode->getParentEdges().size() != 2)
             return false;
 
-        return isSuitableSecondInput(childNode->getParentEdgeAt(1)->getParent(), childNode->getInputShapeAtPort(0).getDims()) &&
-                                     parentNode->canFuse(childNode);
+        return isSuitableSecondInput(childNode->getParentEdgeAt(1)->getParent(),
+                                     childNode->getInputShapeAtPort(0).getDims()) &&
+               parentNode->canFuse(childNode);
     };
 
     auto parent = graphNodes.begin();
@@ -569,9 +587,11 @@ void GraphOptimizer::FuseMultiplyAndAdd(Graph &graph) {
 
         for (size_t i = 0; i < parents.size(); i++) {
             auto p_edge = parents[i].lock();
-            if (!p_edge) continue;
+            if (!p_edge)
+                continue;
             auto parent = p_edge->getParent();
-            if (!parent) continue;
+            if (!parent)
+                continue;
 
             if (parent == parentNode) {
                 for (size_t j = 0; j < childs.size(); j++) {
@@ -581,7 +601,7 @@ void GraphOptimizer::FuseMultiplyAndAdd(Graph &graph) {
                     if (!child)
                         continue;
 
-                    EdgePtr &remEdge = p_edge;
+                    EdgePtr& remEdge = p_edge;
                     int inNum = 0;
                     if (remEdge) {
                         inNum = remEdge->getInputNum();
@@ -596,7 +616,7 @@ void GraphOptimizer::FuseMultiplyAndAdd(Graph &graph) {
                     graph.CreateEdge(parent, child, inNum, outNum);
                 }
             } else {
-                EdgePtr &remEdge = p_edge;
+                EdgePtr& remEdge = p_edge;
                 int inNum = 0;
                 if (remEdge) {
                     inNum = remEdge->getInputNum();
@@ -652,9 +672,11 @@ void GraphOptimizer::MergeConvertAndScaleShift(Graph& graph) {
         const auto parents = parentNode->parentEdges;
         for (size_t i = 0; i < parents.size(); i++) {
             auto p_edge = parents[i].lock();
-            if (!p_edge) continue;
+            if (!p_edge)
+                continue;
             auto parent = p_edge->getParent();
-            if (!parent) continue;
+            if (!parent)
+                continue;
 
             if (!parentNode->childEdges[0].lock())
                 continue;
@@ -688,8 +710,8 @@ void GraphOptimizer::FuseFCAndConvertOnWeights(Graph& graph) {
     return;
 #endif
 
-    // This optimization fuses Convert (fp16 -> bf16/fp32) on weights directly to FC input to allow precision conversion handling based on internal logic
-    // (e.g. fuse conversion with weights reordering)
+    // This optimization fuses Convert (fp16 -> bf16/fp32) on weights directly to FC input to allow precision conversion
+    // handling based on internal logic (e.g. fuse conversion with weights reordering)
     auto& graphNodes = graph.GetNodes();
     for (const auto& fullyConnected : graphNodes) {
         if (fullyConnected->getType() != Type::FullyConnected) {
@@ -722,14 +744,13 @@ void GraphOptimizer::FuseFCAndTransposeOnWeights(Graph& graph) {
     return;
 #endif
 
-    // This optimization allows us to avoid transposing the weights in Transpose node and do it directly along with reordering in FC node
+    // This optimization allows us to avoid transposing the weights in Transpose node and do it directly along with
+    // reordering in FC node
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitablePattern = [](NodePtr parent) {
-        bool res = true && parent->getType() == Type::Transpose
-                        && parent->getChildEdges().size() == 1
-                        && parent->getChildEdgeAt(0)->getChild()->getType() == Type::FullyConnected
-                        && parent->isConstant();
+        bool res = true && parent->getType() == Type::Transpose && parent->getChildEdges().size() == 1 &&
+                   parent->getChildEdgeAt(0)->getChild()->getType() == Type::FullyConnected && parent->isConstant();
         return res;
     };
 
@@ -744,7 +765,7 @@ void GraphOptimizer::FuseFCAndTransposeOnWeights(Graph& graph) {
     }
 }
 
-void GraphOptimizer::FuseConvolutionAndZeroPoints(Graph &graph) {
+void GraphOptimizer::FuseConvolutionAndZeroPoints(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableConvNode = [](NodePtr node) {
@@ -777,9 +798,10 @@ void GraphOptimizer::FuseConvolutionAndZeroPoints(Graph &graph) {
             return false;
 
         // The plug-in doesn't support FP32 convolution with input/weights zero points.
-        // In case weights are in FP32 (or we have zero points on weights which are not supported by INT8 convolution) we cannot use
-        // INT8 implementation so we have to disable input zero points fusing as well.
-        if (parent1->getType() != Type::Input || !parent1->isConstant() || parent1->getOriginalOutputPrecisionAtPort(0) != ov::element::i8) {
+        // In case weights are in FP32 (or we have zero points on weights which are not supported by INT8 convolution)
+        // we cannot use INT8 implementation so we have to disable input zero points fusing as well.
+        if (parent1->getType() != Type::Input || !parent1->isConstant() ||
+            parent1->getOriginalOutputPrecisionAtPort(0) != ov::element::i8) {
             return false;
         }
 
@@ -827,7 +849,7 @@ void GraphOptimizer::FuseConvolutionAndZeroPoints(Graph &graph) {
         if (zeroPointsData == nullptr)
             OPENVINO_THROW("zeroPointsBlob has not allocated buffer");
 
-        auto zeroPointDataSize =  parent0->getInputShapeAtPort(1).getDims()[1];
+        auto zeroPointDataSize = parent0->getInputShapeAtPort(1).getDims()[1];
         if (Shape::UNDEFINED_DIM == zeroPointDataSize) {
             return false;
         }
@@ -863,8 +885,10 @@ void GraphOptimizer::FuseConvolutionAndZeroPoints(Graph &graph) {
 
         auto OC = weightsConstantDims[0 + groupOffset];
         auto IC = weightsConstantDims[1 + groupOffset];
-        auto KD = weightsConstantDims.size() == (5 + groupOffset) ? weightsConstantDims[weightsConstantDims.size() - 3] : 1;
-        auto KH = weightsConstantDims.size() == (3 + groupOffset) ? 1 : weightsConstantDims[weightsConstantDims.size() - 2];
+        auto KD =
+            weightsConstantDims.size() == (5 + groupOffset) ? weightsConstantDims[weightsConstantDims.size() - 3] : 1;
+        auto KH =
+            weightsConstantDims.size() == (3 + groupOffset) ? 1 : weightsConstantDims[weightsConstantDims.size() - 2];
         auto KW = weightsConstantDims[weightsConstantDims.size() - 1];
 
         for (size_t g = 0; g < G; g++) {
@@ -874,20 +898,19 @@ void GraphOptimizer::FuseConvolutionAndZeroPoints(Graph &graph) {
                     for (size_t kd = 0; kd < KD; kd++) {
                         for (size_t kh = 0; kh < KH; kh++) {
                             for (size_t kw = 0; kw < KW; kw++) {
-                                size_t widx = g * OC * IC * KD * KH * KW +
-                                              oc * IC * KD * KH * KW +
-                                              ic * KD * KH * KW +
-                                              kd * KH * KW +
-                                              kh * KW +
-                                              kw;
+                                size_t widx = g * OC * IC * KD * KH * KW + oc * IC * KD * KH * KW + ic * KD * KH * KW +
+                                              kd * KH * KW + kh * KW + kw;
 
                                 auto w = static_cast<int32_t>(weightsPtr[widx]);
 
-                                auto izp = !convNode->legacyInputZeroPoints.empty() ? static_cast<int32_t>(convNode->legacyInputZeroPoints[g * IC + ic]) : 0;
+                                auto izp = !convNode->legacyInputZeroPoints.empty()
+                                               ? static_cast<int32_t>(convNode->legacyInputZeroPoints[g * IC + ic])
+                                               : 0;
                                 a += w * izp;
 
-                                auto wzp = !convNode->legacyWeightsZeroPoints.empty() ?
-                                            static_cast<int32_t>(convNode->legacyWeightsZeroPoints[g * OC + oc]) : 0;
+                                auto wzp = !convNode->legacyWeightsZeroPoints.empty()
+                                               ? static_cast<int32_t>(convNode->legacyWeightsZeroPoints[g * OC + oc])
+                                               : 0;
                                 a -= wzp * izp;
                             }
                         }
@@ -900,7 +923,8 @@ void GraphOptimizer::FuseConvolutionAndZeroPoints(Graph &graph) {
 
     for (size_t i = 0; i < graphNodes.size(); i++) {
         auto conv = graphNodes[i];
-        if (!isSuitableConvNode(conv)) continue;
+        if (!isSuitableConvNode(conv))
+            continue;
 
         CPU_GRAPH_OPTIMIZER_SCOPE(FuseConvolutionAndZeroPoints_ConvNode);
 
@@ -908,8 +932,10 @@ void GraphOptimizer::FuseConvolutionAndZeroPoints(Graph &graph) {
         auto weightsEltwise = conv->getParentEdgeAt(1)->getParent();
         if (initializeInputZeroPoints(conv, dataEltwise, weightsEltwise)) {
             auto p_edge = dataEltwise->getParentEdgeAt(1);
-            DEBUG_LOG("[GraphOptimizer##FusingZeorPoint]:Eltwise Subtract Node ##", dataEltwise->getName(),
-                        " is optimized as zeropoint of Conv ##", conv->getName());
+            DEBUG_LOG("[GraphOptimizer##FusingZeorPoint]:Eltwise Subtract Node ##",
+                      dataEltwise->getName(),
+                      " is optimized as zeropoint of Conv ##",
+                      conv->getName());
             graph.RemoveEdge(p_edge);
             graph.DropNode(dataEltwise);
             initializeOutputCompensation(conv);
@@ -917,7 +943,7 @@ void GraphOptimizer::FuseConvolutionAndZeroPoints(Graph &graph) {
     }
 }
 
-void GraphOptimizer::FuseFullyConnectedAndSimpleOperation(Graph &graph) {
+void GraphOptimizer::FuseFullyConnectedAndSimpleOperation(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableParentNode = [](NodePtr node) {
@@ -944,7 +970,7 @@ void GraphOptimizer::FuseFullyConnectedAndSimpleOperation(Graph &graph) {
 
         if (childNode->getType() == Type::FakeQuantize || childNode->getType() == Type::Eltwise) {
             auto parentEdges = childNode->parentEdges;
-            for (auto &parentEdge : parentEdges) {
+            for (auto& parentEdge : parentEdges) {
                 auto p_edge = parentEdge.lock();
                 if (p_edge->getParent()->getType() == Type::FullyConnected)
                     continue;
@@ -957,7 +983,7 @@ void GraphOptimizer::FuseFullyConnectedAndSimpleOperation(Graph &graph) {
     }
 }
 
-void GraphOptimizer::FuseMatMulAndSimpleOperation(Graph &graph) {
+void GraphOptimizer::FuseMatMulAndSimpleOperation(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSutableParentNode = [](const NodePtr& node) {
@@ -984,7 +1010,7 @@ void GraphOptimizer::FuseMatMulAndSimpleOperation(Graph &graph) {
 
         if (childNode->getType() == Type::FakeQuantize || childNode->getType() == Type::Eltwise) {
             auto parentEdges = childNode->parentEdges;
-            for (auto &parentEdge : parentEdges) {
+            for (auto& parentEdge : parentEdges) {
                 auto p_edge = parentEdge.lock();
                 if (p_edge->getParent()->getType() == Type::MatMul)
                     continue;
@@ -997,14 +1023,14 @@ void GraphOptimizer::FuseMatMulAndSimpleOperation(Graph &graph) {
     }
 }
 
-void GraphOptimizer::FuseConvolutionAndDWConvolution(Graph &graph) {
+void GraphOptimizer::FuseConvolutionAndDWConvolution(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
-    auto isConvolutionNode = [](const NodePtr &node) {
+    auto isConvolutionNode = [](const NodePtr& node) {
         return node->getType() == Type::Convolution;
     };
 
-    auto is1x1Convolution = [](const std::shared_ptr<Convolution> &conv) {
+    auto is1x1Convolution = [](const std::shared_ptr<Convolution>& conv) {
         const auto weightRank = conv->getWeightDims().size();
         return conv->getWeightDims()[weightRank - 1] == 1 && conv->getWeightDims()[weightRank - 2] == 1;
     };
@@ -1023,10 +1049,10 @@ void GraphOptimizer::FuseConvolutionAndDWConvolution(Graph &graph) {
         if (!conv->legacyWeightsZeroPoints.empty())
             return false;
 
-        const auto &strides = conv->getStride();
-        const auto &paddings = conv->getPaddingL();
-        const auto &inDims = node->getInputShapeAtPort(0).getDims();
-        const auto &outDims = node->getOutputShapeAtPort(0).getDims();
+        const auto& strides = conv->getStride();
+        const auto& paddings = conv->getPaddingL();
+        const auto& inDims = node->getInputShapeAtPort(0).getDims();
+        const auto& outDims = node->getOutputShapeAtPort(0).getDims();
         bool isSupportedParams =
             conv->getGroupNum() == 1 && inDims.size() == 4 &&
             dimsEqualStrong(inDims[inDims.size() - 1], outDims[outDims.size() - 1]) &&
@@ -1039,12 +1065,13 @@ void GraphOptimizer::FuseConvolutionAndDWConvolution(Graph &graph) {
                         static_cast<unsigned int>(paddings[paddings.size() - 1]),
                         static_cast<unsigned int>(paddings[paddings.size() - 2])) &&
             !conv->canBeExecutedInInt8();
-        if (!isSupportedParams) return false;
+        if (!isSupportedParams)
+            return false;
 
         return node->getChildEdges().size() == 1 && isConvolutionNode(node->getChildEdgeAt(0)->getChild());
     };
 
-    auto isSuitableChildConvolution = [&](const NodePtr &parentNode, const NodePtr &childNode) {
+    auto isSuitableChildConvolution = [&](const NodePtr& parentNode, const NodePtr& childNode) {
         if (parentNode->isDropped() || childNode->isDropped())
             return false;
 
@@ -1059,15 +1086,19 @@ void GraphOptimizer::FuseConvolutionAndDWConvolution(Graph &graph) {
         if (convParent == nullptr)
             OPENVINO_THROW("Cannot cast to convolution node ", parentNode->getName());
 
-        if (!everyone_is(ov::element::f32, convParent->getOriginalOutputPrecisionAtPort(0), convChild->getOriginalInputPrecisionAtPort(0),
-                convChild->getOriginalOutputPrecisionAtPort(0)))
+        if (!everyone_is(ov::element::f32,
+                         convParent->getOriginalOutputPrecisionAtPort(0),
+                         convChild->getOriginalInputPrecisionAtPort(0),
+                         convChild->getOriginalOutputPrecisionAtPort(0)))
             return false;
 
-        auto parentOutputPrecision = !parentNode->fusedWith.empty()
+        auto parentOutputPrecision =
+            !parentNode->fusedWith.empty()
                 ? parentNode->fusedWith[parentNode->fusedWith.size() - 1]->getOriginalOutputPrecisionAtPort(0)
                 : parentNode->getOriginalOutputPrecisionAtPort(0);
 
-        auto childOutputPrecision = !childNode->fusedWith.empty()
+        auto childOutputPrecision =
+            !childNode->fusedWith.empty()
                 ? childNode->fusedWith[childNode->fusedWith.size() - 1]->getOriginalOutputPrecisionAtPort(0)
                 : childNode->getOriginalOutputPrecisionAtPort(0);
 
@@ -1103,7 +1134,7 @@ void GraphOptimizer::FuseConvolutionAndDWConvolution(Graph &graph) {
         return isSupportedParams;
     };
 
-    auto isFusingWorthwhile = [&](const NodePtr &parentNode, const NodePtr &childNode) {
+    auto isFusingWorthwhile = [&](const NodePtr& parentNode, const NodePtr& childNode) {
         if (!childNode->inputShapes[0].isStatic() || !childNode->outputShapes[0].isStatic()) {
             return false;
         }
@@ -1114,7 +1145,7 @@ void GraphOptimizer::FuseConvolutionAndDWConvolution(Graph &graph) {
 
         int L3_cache_size = dnnl::utils::get_cache_size(3, false);
         int dw_conv_input_size = inDims[0] * inDims[1] * inDims[2] * inDims[3] * elemSize;
-        int dw_conv_output_size = outDims[0] * outDims[1]* outDims[2] * outDims[3] * elemSize;
+        int dw_conv_output_size = outDims[0] * outDims[1] * outDims[2] * outDims[3] * elemSize;
 
         auto parentConvolutionNode = std::dynamic_pointer_cast<Convolution>(parentNode);
         if (parentConvolutionNode == nullptr)
@@ -1127,19 +1158,23 @@ void GraphOptimizer::FuseConvolutionAndDWConvolution(Graph &graph) {
     };
 
     for (size_t i = 0; i < graphNodes.size(); i++) {
-        if (!isConvolutionNode(graphNodes[i])) continue;
+        if (!isConvolutionNode(graphNodes[i]))
+            continue;
 
         auto parentConvNode = graphNodes[i];
-        if (!isSuitableParentConvolution(parentConvNode)) continue;
+        if (!isSuitableParentConvolution(parentConvNode))
+            continue;
 
         CPU_GRAPH_OPTIMIZER_SCOPE(FuseConvolutionAndDWConvolution_ParentConv);
 
         auto childConvNode = parentConvNode->getChildEdgeAt(0)->getChild();
-        if (!isSuitableChildConvolution(parentConvNode, childConvNode)) continue;
+        if (!isSuitableChildConvolution(parentConvNode, childConvNode))
+            continue;
 
         CPU_GRAPH_OPTIMIZER_SCOPE(FuseConvolutionAndDWConvolution_ChildConv);
 
-        if (!isFusingWorthwhile(parentConvNode, childConvNode)) continue;
+        if (!isFusingWorthwhile(parentConvNode, childConvNode))
+            continue;
 
         parentConvNode->addFusedNode(childConvNode);
 
@@ -1153,12 +1188,12 @@ void GraphOptimizer::FuseConvolutionAndDWConvolution(Graph &graph) {
 }
 
 // TODO [NM]: unite with FuseConvolutionAndSimpleOperation
-void GraphOptimizer::FuseConvolutionAndSimpleOperationThroughMaxPool(Graph &graph) {
+void GraphOptimizer::FuseConvolutionAndSimpleOperationThroughMaxPool(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableParentNode = [](NodePtr node) {
-        return (node->getType() == Type::Convolution || node->getType() == Type::BinaryConvolution) && node->getChildEdges().size() == 1 &&
-               node->getOriginalOutputPrecisionAtPort(0) == ov::element::f32;
+        return (node->getType() == Type::Convolution || node->getType() == Type::BinaryConvolution) &&
+               node->getChildEdges().size() == 1 && node->getOriginalOutputPrecisionAtPort(0) == ov::element::f32;
     };
 
     auto parent = graphNodes.begin();
@@ -1197,7 +1232,7 @@ void GraphOptimizer::FuseConvolutionAndSimpleOperationThroughMaxPool(Graph &grap
         parentNode->addFusedNode(fuseCandidate);
         parentNode->addOriginalLayer(fuseCandidate->getOriginalLayers());
         auto parentEdges = fuseCandidate->parentEdges;
-        for (auto &parentEdge : parentEdges) {
+        for (auto& parentEdge : parentEdges) {
             auto p_edge = parentEdge.lock();
             if (p_edge->getParent() == childNode)
                 continue;
@@ -1208,11 +1243,12 @@ void GraphOptimizer::FuseConvolutionAndSimpleOperationThroughMaxPool(Graph &grap
     }
 }
 
-void GraphOptimizer::FuseConvolutionAndSimpleOperation(Graph &graph) {
+void GraphOptimizer::FuseConvolutionAndSimpleOperation(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableParentNode = [](NodePtr node) {
-        return (node->getType() == Type::Convolution || node->getType() == Type::BinaryConvolution) && node->getChildEdges().size() == 1;
+        return (node->getType() == Type::Convolution || node->getType() == Type::BinaryConvolution) &&
+               node->getChildEdges().size() == 1;
     };
 
     auto parent = graphNodes.begin();
@@ -1237,7 +1273,7 @@ void GraphOptimizer::FuseConvolutionAndSimpleOperation(Graph &graph) {
 
         if (childNode->getType() == Type::FakeQuantize || childNode->getType() == Type::Eltwise) {
             auto parentEdges = childNode->parentEdges;
-            for (auto &parentEdge : parentEdges) {
+            for (auto& parentEdge : parentEdges) {
                 auto p_edge = parentEdge.lock();
                 if (p_edge->getParent()->getType() == parentNodeType)
                     continue;
@@ -1250,7 +1286,7 @@ void GraphOptimizer::FuseConvolutionAndSimpleOperation(Graph &graph) {
     }
 }
 
-void GraphOptimizer::FusePoolingAndFakeQuantize(Graph &graph) {
+void GraphOptimizer::FusePoolingAndFakeQuantize(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableParentNode = [](NodePtr node) {
@@ -1268,12 +1304,14 @@ void GraphOptimizer::FusePoolingAndFakeQuantize(Graph &graph) {
 
     for (size_t i = 0; i < graphNodes.size(); i++) {
         auto parent = graphNodes[i];
-        if (!isSuitableParentNode(parent)) continue;
+        if (!isSuitableParentNode(parent))
+            continue;
 
         CPU_GRAPH_OPTIMIZER_SCOPE(FusePoolingAndFakeQuantize_ParentNode);
 
         auto child = parent->getChildEdgeAt(0)->getChild();
-        if (!isSuitableChildNode(child)) continue;
+        if (!isSuitableChildNode(child))
+            continue;
 
         CPU_GRAPH_OPTIMIZER_SCOPE(FusePoolingAndFakeQuantize_ChildNode);
 
@@ -1300,14 +1338,14 @@ void GraphOptimizer::FusePoolingAndFakeQuantize(Graph &graph) {
  * @param child node we try to find
  * @return True if child is one of data supplier
  */
-static bool is_data_dependency(const std::shared_ptr<Node> &parent,
-                               const std::shared_ptr<Node> &child) {
+static bool is_data_dependency(const std::shared_ptr<Node>& parent, const std::shared_ptr<Node>& child) {
     std::set<Node*> visited;
-    std::list<Node*> nextLayers {parent.get()};
+    std::list<Node*> nextLayers{parent.get()};
 
     for (; !nextLayers.empty();) {
         auto layer = *nextLayers.begin();
-        if (layer == child.get()) return true;
+        if (layer == child.get())
+            return true;
         for (auto& oe : layer->getChildEdges()) {
             auto nn = oe.lock()->getChild();
             if (visited.find(nn.get()) == visited.end()) {
@@ -1358,19 +1396,18 @@ static bool is_data_dependency(const std::shared_ptr<Node> &parent,
  *                ***
  */
 
-void GraphOptimizer::FuseConvolutionSumAndConvolutionSumActivation(Graph &graph) {
+void GraphOptimizer::FuseConvolutionSumAndConvolutionSumActivation(Graph& graph) {
 #if !defined(OPENVINO_ARCH_X86) && !defined(OPENVINO_ARCH_X86_64)
     return;
 #endif
 
-    auto &graphNodes = graph.GetNodes();
+    auto& graphNodes = graph.GetNodes();
 
     auto isFusingSupported = [&](NodePtr conv, NodePtr child) {
-        return child->getType() == Type::Eltwise &&
-            DnnlExtensionUtils::isUnarySupportedAsPostOp(child->getAlgorithm());
+        return child->getType() == Type::Eltwise && DnnlExtensionUtils::isUnarySupportedAsPostOp(child->getAlgorithm());
     };
 
-    for (auto &graphNode : graphNodes) {
+    for (auto& graphNode : graphNodes) {
         const auto eltwiseNode = std::dynamic_pointer_cast<Eltwise>(graphNode);
         if (graphNode->getType() != Type::Eltwise || graphNode->getAlgorithm() != Algorithm::EltwiseAdd ||
             !eltwiseNode || eltwiseNode->isWithBroadcast())
@@ -1384,12 +1421,12 @@ void GraphOptimizer::FuseConvolutionSumAndConvolutionSumActivation(Graph &graph)
         auto parent1 = graphNode->getParentEdgeAt(0)->getParent();
         auto parent2 = graphNode->getParentEdgeAt(1)->getParent();
 
-        bool isSuitableParent1 = parent1->getType() == Type::Convolution
-                                    || parent1->getType() == Type::BinaryConvolution;
-        bool isSuitableParent2 = parent2->getType() == Type::Convolution
-                                    || parent2->getType() == Type::BinaryConvolution;
+        bool isSuitableParent1 =
+            parent1->getType() == Type::Convolution || parent1->getType() == Type::BinaryConvolution;
+        bool isSuitableParent2 =
+            parent2->getType() == Type::Convolution || parent2->getType() == Type::BinaryConvolution;
 
-        auto canFuseSum = [](node::BinaryConvolution *binConv, NodePtr fuseCandidate) {
+        auto canFuseSum = [](node::BinaryConvolution* binConv, NodePtr fuseCandidate) {
             if (binConv->getImplType() == impl_desc_type::ref)
                 return false;
 
@@ -1408,12 +1445,12 @@ void GraphOptimizer::FuseConvolutionSumAndConvolutionSumActivation(Graph &graph)
             return false;
         };
 
-        auto* binConvNode1 = dynamic_cast<node::BinaryConvolution *>(parent1.get());
+        auto* binConvNode1 = dynamic_cast<node::BinaryConvolution*>(parent1.get());
         if (binConvNode1) {
             isSuitableParent1 = isSuitableParent1 && canFuseSum(binConvNode1, graphNode);
         }
 
-        auto* binConvNode2 = dynamic_cast<node::BinaryConvolution *>(parent2.get());
+        auto* binConvNode2 = dynamic_cast<node::BinaryConvolution*>(parent2.get());
         if (binConvNode2) {
             isSuitableParent2 = isSuitableParent2 && canFuseSum(binConvNode2, graphNode);
         }
@@ -1427,7 +1464,7 @@ void GraphOptimizer::FuseConvolutionSumAndConvolutionSumActivation(Graph &graph)
             return false;
         };
 
-        auto* convNode1 = dynamic_cast<Convolution *>(parent1.get());
+        auto* convNode1 = dynamic_cast<Convolution*>(parent1.get());
         if (convNode1) {
             if (!convNode1->canBeExecutedInInt8()) {
                 isSuitableParent1 = isSuitableParent1 && convNode1->getFusedWith().empty();
@@ -1436,7 +1473,7 @@ void GraphOptimizer::FuseConvolutionSumAndConvolutionSumActivation(Graph &graph)
             }
         }
 
-        auto* convNode2 = dynamic_cast<Convolution *>(parent2.get());
+        auto* convNode2 = dynamic_cast<Convolution*>(parent2.get());
         if (convNode2) {
             if (!convNode2->canBeExecutedInInt8()) {
                 isSuitableParent2 = isSuitableParent2 && convNode2->getFusedWith().empty();
@@ -1455,9 +1492,9 @@ void GraphOptimizer::FuseConvolutionSumAndConvolutionSumActivation(Graph &graph)
             // not merged operation (peerNode) has to be in low precision
             const auto isBranchQuantized = [](const NodePtr& branchParent) {
                 const auto& fused = branchParent->getFusedWith();
-                const auto branchPrecision = fused.empty() ?
-                        branchParent->getOriginalOutputPrecisionAtPort(0) :
-                        fused[fused.size() - 1]->getOriginalOutputPrecisionAtPort(0);
+                const auto branchPrecision = fused.empty()
+                                                 ? branchParent->getOriginalOutputPrecisionAtPort(0)
+                                                 : fused[fused.size() - 1]->getOriginalOutputPrecisionAtPort(0);
                 return (branchPrecision == ov::element::i8) || (branchPrecision == ov::element::u8);
             };
 
@@ -1527,15 +1564,16 @@ void GraphOptimizer::FuseConvolutionSumAndConvolutionSumActivation(Graph &graph)
         // be overwritten. Should verify that all other consumer already read it and
         // we can spoil input data.
         // TODO: rewrite once we add "Inplace" reporting mechanism
-        for (auto & edge : peerNode->getChildEdges()) {
+        for (auto& edge : peerNode->getChildEdges()) {
             if (!fuse_allowed)
                 break;
             fuse_allowed &= is_data_dependency(edge.lock()->getChild(), sum);
         }
-        if (!fuse_allowed) continue;
+        if (!fuse_allowed)
+            continue;
 
         if (graphNode->getChildEdges().size() == 1 &&
-                isFusingSupported(graphNode, graphNode->getChildEdgeAt(0)->getChild())) {
+            isFusingSupported(graphNode, graphNode->getChildEdgeAt(0)->getChild())) {
             auto relu_shared = graphNode->getChildEdgeAt(0)->getChild();
             lastNode = relu_shared;
             if (mergedConv->isConstant() && !lastNode->isConstant())
@@ -1545,8 +1583,8 @@ void GraphOptimizer::FuseConvolutionSumAndConvolutionSumActivation(Graph &graph)
 
         lastNode->fuseInto(mergedConv);
 
-        if (mergedConv->fusedWith.size() > 0 &&
-           (mergedConv->fusedWith[0]->getType() == Type::Convolution || mergedConv->fusedWith[0]->getType() == Type::BinaryConvolution)) {
+        if (mergedConv->fusedWith.size() > 0 && (mergedConv->fusedWith[0]->getType() == Type::Convolution ||
+                                                 mergedConv->fusedWith[0]->getType() == Type::BinaryConvolution)) {
             // Merged with DW_conv. Shape may change
             mergedConv->inputShapes.push_back(mergedConv->fusedWith[0]->getOutputShapeAtPort(0));
         } else {
@@ -1577,7 +1615,7 @@ void GraphOptimizer::FuseConvolutionSumAndConvolutionSumActivation(Graph &graph)
         graph.CreateEdge(peerNode, mergedConv, peer_port, childPort);
 
         std::vector<EdgeWeakPtr> edges_to_reconnect = lastNode->getChildEdges();
-        for (auto &edge_w : edges_to_reconnect) {
+        for (auto& edge_w : edges_to_reconnect) {
             auto edge = edge_w.lock();
             auto child = edge->getChild();
             int idxParent = edge->getInputNum();
@@ -1597,7 +1635,7 @@ void GraphOptimizer::FuseConvolutionSumAndConvolutionSumActivation(Graph &graph)
     }
 }
 
-void GraphOptimizer::FuseMVNAndSimpleOperation(Graph &graph) {
+void GraphOptimizer::FuseMVNAndSimpleOperation(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableParentNode = [](NodePtr node) {
@@ -1624,7 +1662,7 @@ void GraphOptimizer::FuseMVNAndSimpleOperation(Graph &graph) {
 
         if (childNode->getType() == Type::FakeQuantize || childNode->getType() == Type::Eltwise) {
             auto parentEdges = childNode->parentEdges;
-            for (auto &parentEdge : parentEdges) {
+            for (auto& parentEdge : parentEdges) {
                 auto p_edge = parentEdge.lock();
                 if (p_edge->getParent()->getType() == Type::MVN)
                     continue;
@@ -1637,7 +1675,7 @@ void GraphOptimizer::FuseMVNAndSimpleOperation(Graph &graph) {
     }
 }
 
-void GraphOptimizer::FuseInterpolateAndSimpleOperation(Graph &graph) {
+void GraphOptimizer::FuseInterpolateAndSimpleOperation(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableParentNode = [](NodePtr node) {
@@ -1646,8 +1684,8 @@ void GraphOptimizer::FuseInterpolateAndSimpleOperation(Graph &graph) {
 
     auto isSuitableChildNode = [&](NodePtr parentNode, NodePtr childNode) {
         // Avoid cycle dependencies
-        for (auto &childParentEdge : childNode->getParentEdges()) {
-            for (auto &parentParentEdge : parentNode->getParentEdges()) {
+        for (auto& childParentEdge : childNode->getParentEdges()) {
+            for (auto& parentParentEdge : parentNode->getParentEdges()) {
                 if (childParentEdge.lock()->getParent() == parentParentEdge.lock()->getParent())
                     return false;
             }
@@ -1683,7 +1721,7 @@ void GraphOptimizer::FuseInterpolateAndSimpleOperation(Graph &graph) {
 
         if (childNode->getType() == Type::FakeQuantize || childNode->getType() == Type::Eltwise) {
             auto parentEdges = childNode->parentEdges;
-            for (auto &parentEdge : parentEdges) {
+            for (auto& parentEdge : parentEdges) {
                 auto p_edge = parentEdge.lock();
                 if (p_edge->getParent()->getType() == Type::Interpolate)
                     continue;
@@ -1696,7 +1734,7 @@ void GraphOptimizer::FuseInterpolateAndSimpleOperation(Graph &graph) {
     }
 }
 
-void GraphOptimizer::FuseNormalizeL2AndSimpleOperation(Graph &graph) {
+void GraphOptimizer::FuseNormalizeL2AndSimpleOperation(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableParentNode = [](NodePtr node) {
@@ -1723,7 +1761,7 @@ void GraphOptimizer::FuseNormalizeL2AndSimpleOperation(Graph &graph) {
 
         if (childNode->getType() == Type::FakeQuantize || childNode->getType() == Type::Eltwise) {
             auto parentEdges = childNode->parentEdges;
-            for (auto &parentEdge : parentEdges) {
+            for (auto& parentEdge : parentEdges) {
                 auto p_edge = parentEdge.lock();
                 if (p_edge->getParent()->getType() == Type::NormalizeL2)
                     continue;
@@ -1736,7 +1774,7 @@ void GraphOptimizer::FuseNormalizeL2AndSimpleOperation(Graph &graph) {
     }
 }
 
-void GraphOptimizer::FuseReduceAndSimpleOperation(Graph &graph) {
+void GraphOptimizer::FuseReduceAndSimpleOperation(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableParentNode = [](NodePtr node) {
@@ -1763,7 +1801,7 @@ void GraphOptimizer::FuseReduceAndSimpleOperation(Graph &graph) {
 
         if (childNode->getType() == Type::FakeQuantize || childNode->getType() == Type::Eltwise) {
             auto parentEdges = childNode->parentEdges;
-            for (auto &parentEdge : parentEdges) {
+            for (auto& parentEdge : parentEdges) {
                 auto p_edge = parentEdge.lock();
                 if (p_edge == nullptr)
                     OPENVINO_THROW("Cannot get parent edge ", childNode->getName());
@@ -1778,7 +1816,7 @@ void GraphOptimizer::FuseReduceAndSimpleOperation(Graph &graph) {
     }
 }
 
-void GraphOptimizer::FuseEltwiseAndSimple(Graph &graph) {
+void GraphOptimizer::FuseEltwiseAndSimple(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableParentNode = [](NodePtr node) {
@@ -1788,14 +1826,14 @@ void GraphOptimizer::FuseEltwiseAndSimple(Graph &graph) {
     auto isSuitableChildNode = [&](NodePtr parentNode, NodePtr childNode) {
         if (parentNode->isConstant() && !childNode->isConstant())
             return false;
-        for (auto &childParentEdge : childNode->getParentEdges()) {
+        for (auto& childParentEdge : childNode->getParentEdges()) {
             // WA to prevent unsupported reorder exception issue in some cases
             if (childParentEdge.lock()->getParent()->getType() == Type::Split) {
                 return false;
             }
 
             // Avoid cycle dependencies
-            for (auto &parentParentEdge : parentNode->getParentEdges()) {
+            for (auto& parentParentEdge : parentNode->getParentEdges()) {
                 if (childParentEdge.lock()->getParent() == parentParentEdge.lock()->getParent())
                     return false;
             }
@@ -1819,7 +1857,8 @@ void GraphOptimizer::FuseEltwiseAndSimple(Graph &graph) {
 
         auto childNode = parentNode->getChildEdgeAt(0)->getChild();
 
-        if ((parentNode->isDynamicNode() && !childNode->isDynamicNode()) || (!parentNode->isDynamicNode() && childNode->isDynamicNode())) {
+        if ((parentNode->isDynamicNode() && !childNode->isDynamicNode()) ||
+            (!parentNode->isDynamicNode() && childNode->isDynamicNode())) {
             parent++;
             continue;
         }
@@ -1835,7 +1874,7 @@ void GraphOptimizer::FuseEltwiseAndSimple(Graph &graph) {
 
         if (childNode->getType() == Type::FakeQuantize) {
             auto parentEdges = childNode->parentEdges;
-            for (auto &parentEdge : parentEdges) {
+            for (auto& parentEdge : parentEdges) {
                 auto p_edge = parentEdge.lock();
                 if (p_edge->getParent()->getType() == Type::Eltwise)
                     continue;
@@ -1851,9 +1890,11 @@ void GraphOptimizer::FuseEltwiseAndSimple(Graph &graph) {
 
             for (size_t i = 0; i < parents.size(); i++) {
                 auto p_edge = parents[i].lock();
-                if (!p_edge) continue;
+                if (!p_edge)
+                    continue;
                 auto parent = p_edge->getParent();
-                if (!parent) continue;
+                if (!parent)
+                    continue;
 
                 if (parent == parentNode) {
                     for (size_t j = 0; j < children.size(); j++) {
@@ -1863,7 +1904,7 @@ void GraphOptimizer::FuseEltwiseAndSimple(Graph &graph) {
                         if (!child)
                             continue;
 
-                        EdgePtr &remEdge = p_edge;
+                        EdgePtr& remEdge = p_edge;
                         int inNum = 0;
                         if (remEdge) {
                             inNum = remEdge->getInputNum();
@@ -1879,7 +1920,7 @@ void GraphOptimizer::FuseEltwiseAndSimple(Graph &graph) {
                         graph.CreateEdge(parent, child, inNum, outNum);
                     }
                 } else {
-                    EdgePtr &remEdge = p_edge;
+                    EdgePtr& remEdge = p_edge;
                     int inNum = 0;
                     int outNum = parentNode->getParentEdges().size();
                     if (remEdge) {
@@ -1970,15 +2011,14 @@ void GraphOptimizer::ShareReorders(Graph& graph) {
     }
 }
 
-void GraphOptimizer::DropDoubleReorders(Graph &graph) {
+void GraphOptimizer::DropDoubleReorders(Graph& graph) {
     std::set<NodePtr> processed;
 
     auto& nodes = graph.GetNodes();
     for (size_t i = 0; i < nodes.size(); i++) {
         auto node = nodes[i];
-        if (processed.find(node) == processed.end() && node->getType() == Type::Reorder
-            && node->getChildEdges().size() == 1
-            && node->getChildEdgeAt(0)->getChild()->getType() == Type::Reorder ) {
+        if (processed.find(node) == processed.end() && node->getType() == Type::Reorder &&
+            node->getChildEdges().size() == 1 && node->getChildEdgeAt(0)->getChild()->getType() == Type::Reorder) {
             auto nextNode = node->getChildEdgeAt(0)->getChild();
             Reorder* n = dynamic_cast<Reorder*>(node.get());
             if (n == nullptr)
@@ -2003,7 +2043,8 @@ void GraphOptimizer::DropDoubleReorders(Graph &graph) {
                 if (cur->getChild() == c)
                     edge = cur;
             }
-            if (!edge) OPENVINO_THROW("Inappropriate graph processing");
+            if (!edge)
+                OPENVINO_THROW("Inappropriate graph processing");
 
             std::string layerName = edge->getParent()->getName() + "_ScaleReorder_" + edge->getChild()->getName();
             graph.InsertReorder(edge, layerName, n->getInput(), nn->getOutput(), false);
@@ -2012,11 +2053,12 @@ void GraphOptimizer::DropDoubleReorders(Graph &graph) {
     }
 }
 
-void GraphOptimizer::FuseClampAndFakeQuantize(Graph &graph) {
+void GraphOptimizer::FuseClampAndFakeQuantize(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableClampNode = [](NodePtr node) {
-        return node->getType() == Type::Eltwise && node->getChildEdges().size() == 1 && node->getAlgorithm() == Algorithm::EltwiseClamp;
+        return node->getType() == Type::Eltwise && node->getChildEdges().size() == 1 &&
+               node->getAlgorithm() == Algorithm::EltwiseClamp;
     };
 
     auto isSuitableFakeQuantizeNode = [](NodePtr node) {
@@ -2024,7 +2066,7 @@ void GraphOptimizer::FuseClampAndFakeQuantize(Graph &graph) {
     };
 
     auto fuseClampAndFakeQuantizeNodes = [](NodePtr parent, NodePtr child) {
-        auto* eltwiseNode = dynamic_cast<Eltwise *>(parent.get());
+        auto* eltwiseNode = dynamic_cast<Eltwise*>(parent.get());
         if (eltwiseNode == nullptr)
             OPENVINO_THROW("Cannot cast ", parent->getName(), " to Eltwise node");
 
@@ -2050,12 +2092,14 @@ void GraphOptimizer::FuseClampAndFakeQuantize(Graph &graph) {
 
     for (size_t i = 0; i < graphNodes.size(); i++) {
         auto parent = graphNodes[i];
-        if (!isSuitableClampNode(parent)) continue;
+        if (!isSuitableClampNode(parent))
+            continue;
 
         CPU_GRAPH_OPTIMIZER_SCOPE(FuseClampAndFakeQuantize_ClalmpNode);
 
         auto child = parent->getChildEdgeAt(0)->getChild();
-        if (!isSuitableFakeQuantizeNode(child)) continue;
+        if (!isSuitableFakeQuantizeNode(child))
+            continue;
 
         CPU_GRAPH_OPTIMIZER_SCOPE(FuseClampAndFakeQuantize_QuantizeNode);
 
@@ -2065,7 +2109,7 @@ void GraphOptimizer::FuseClampAndFakeQuantize(Graph &graph) {
     }
 }
 
-void GraphOptimizer::FusePerformedAsScaleShiftAndFakeQuantize(Graph &graph) {
+void GraphOptimizer::FusePerformedAsScaleShiftAndFakeQuantize(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto getNonConstPort = [](const NodePtr& node) {
@@ -2083,11 +2127,12 @@ void GraphOptimizer::FusePerformedAsScaleShiftAndFakeQuantize(Graph &graph) {
     };
 
     auto isSuitableScaleShiftNode = [getNonConstPort](const NodePtr& node) {
-        if (!one_of(node->getAlgorithm(), Algorithm::EltwiseAdd,
-                                          Algorithm::EltwiseSubtract,
-                                          Algorithm::EltwiseMultiply,
-                                          Algorithm::EltwiseDivide,
-                                          Algorithm::EltwiseMulAdd))
+        if (!one_of(node->getAlgorithm(),
+                    Algorithm::EltwiseAdd,
+                    Algorithm::EltwiseSubtract,
+                    Algorithm::EltwiseMultiply,
+                    Algorithm::EltwiseDivide,
+                    Algorithm::EltwiseMulAdd))
             return false;
 
         const auto nonConstPort = getNonConstPort(node);
@@ -2117,7 +2162,7 @@ void GraphOptimizer::FusePerformedAsScaleShiftAndFakeQuantize(Graph &graph) {
         const NodePtr eltwiseInput = parentEltwise->getParentEdgeAt(getNonConstPort(parent))->getParent();
         std::tie(scalesBuffer, shiftsBuffer) = parentEltwise->getScalesAndShifts(eltwiseInput.get());
 
-        const auto &outputShape = child->getOutputShapeAtPort(0);
+        const auto& outputShape = child->getOutputShapeAtPort(0);
         VectorDims outputDims = outputShape.getDims();
 
         // We need to compute explicitly port with unfolded parent,
@@ -2178,7 +2223,7 @@ void GraphOptimizer::FusePerformedAsScaleShiftAndFakeQuantize(Graph &graph) {
         std::vector<float> zeroShift(newInputScale.size(), 0.f);
 
         const auto isSubnormal = [](const float value) {
-            const uint32_t *u32data = reinterpret_cast<const uint32_t*>(&value);
+            const uint32_t* u32data = reinterpret_cast<const uint32_t*>(&value);
             return (*u32data) && (((*u32data) & (0xFF << 23)) == 0);
         };
 
@@ -2220,18 +2265,20 @@ void GraphOptimizer::FusePerformedAsScaleShiftAndFakeQuantize(Graph &graph) {
 
     for (size_t i = 0; i < graphNodes.size(); i++) {
         auto parent = graphNodes[i];
-        if (!isSuitableScaleShiftNode(parent)) continue;
+        if (!isSuitableScaleShiftNode(parent))
+            continue;
 
         CPU_GRAPH_OPTIMIZER_SCOPE(FusePerformedAsScaleShiftAndFakeQuantize_ShiftNode);
 
         auto child = parent->getChildEdgeAt(0)->getChild();
-        if (!isSuitableFakeQuantizeNode(child)) continue;
+        if (!isSuitableFakeQuantizeNode(child))
+            continue;
 
         CPU_GRAPH_OPTIMIZER_SCOPE(FusePerformedAsScaleShiftAndFakeQuantize_QuantizeNode);
 
         if (fuseScaleShiftAndFakeQuantizeNodes(parent, child)) {
             auto parentEdges = parent->parentEdges;
-            for (auto &parentEdge : parentEdges) {
+            for (auto& parentEdge : parentEdges) {
                 auto p_edge = parentEdge.lock();
                 if (!p_edge->getParent()->isConstant())
                     continue;
@@ -2355,7 +2402,12 @@ void GraphOptimizer::mergeTransposeReshapeReorder(Graph& graph,
                     transposeNode->getName(),
                     " is not a transpose node");
 
-    const auto& inOrder = transposeNode->getSelectedPrimitiveDescriptor()->getConfig().inConfs[0].getMemDesc()->as<BlockedMemoryDesc>()->getOrder();
+    const auto& inOrder = transposeNode->getSelectedPrimitiveDescriptor()
+                              ->getConfig()
+                              .inConfs[0]
+                              .getMemDesc()
+                              ->as<BlockedMemoryDesc>()
+                              ->getOrder();
     const auto& outOrder = reorderOutDesc->as<BlockedMemoryDesc>()->getOrder();
     // Permutation must be set and reorder mustn't be optimized in 2 cases:
     // 1. Transpose has blocked input & non-blocked output
@@ -2371,11 +2423,13 @@ void GraphOptimizer::mergeTransposeReshapeReorder(Graph& graph,
         }
     }
 
-    std::string reorderName = nodeBeforeSequence->getName() + "_" + Reorder::getReorderArgs(*reorderInDesc, *reorderOutDesc);
+    std::string reorderName =
+        nodeBeforeSequence->getName() + "_" + Reorder::getReorderArgs(*reorderInDesc, *reorderOutDesc);
     if (isOptimized)
-         reorderName += "_fake";
+        reorderName += "_fake";
     DEBUG_LOG("mergeTransposeAndReorder ", parentNode->getName(), " and ", childNode->getName(), " -> ", reorderName);
-    auto reorder_layout = std::make_shared<node::Reorder>(*reorderInDesc, *reorderOutDesc, reorderName, graph.getGraphContext());
+    auto reorder_layout =
+        std::make_shared<node::Reorder>(*reorderInDesc, *reorderOutDesc, reorderName, graph.getGraphContext());
     reorder_layout->setOptimized(isOptimized);
     reorder_layout->setSrcPermutation(srcPerm);
 
@@ -2388,10 +2442,8 @@ void GraphOptimizer::mergeTransposeReshapeReorder(Graph& graph,
                                         Reorder::getReorderArgs(*reorderOutDesc, *finalDesc) + "_" +
                                         nodeAfterSequence->getName();
 
-        reorder_last = std::make_shared<node::Reorder>(*reorderOutDesc,
-                                                        *finalDesc,
-                                                        reorderLayerName2,
-                                                        graph.getGraphContext());
+        reorder_last =
+            std::make_shared<node::Reorder>(*reorderOutDesc, *finalDesc, reorderLayerName2, graph.getGraphContext());
         reorder_last->setOptimized(false);
         reorder_last->setSrcPermutation(srcPerm);
         graph.CreateEdge(reorder_layout, reorder_last, 0, 0);
@@ -2445,10 +2497,10 @@ void GraphOptimizer::MergeTransposeAndReorder(Graph& graph) {
             return false;
         };
 
-        return node->getType() == Type::Transpose
-                && node->getChildEdges().size() == 1
-                && !node->isDynamicNode() // TODO [DS]: enable for dynamic shapes when inPlace in the dynamic case is available (CVS-74863)
-                && !prevNodeIsConvSum(node);
+        return node->getType() == Type::Transpose && node->getChildEdges().size() == 1 &&
+               !node->isDynamicNode()  // TODO [DS]: enable for dynamic shapes when inPlace in the dynamic case is
+                                       // available (CVS-74863)
+               && !prevNodeIsConvSum(node);
     };
 
     auto isSuitableReshape = [](NodePtr node) {
@@ -2473,8 +2525,9 @@ void GraphOptimizer::MergeTransposeAndReorder(Graph& graph) {
     };
 
     auto isSuitableReorder = [](NodePtr node) {
-        return node->getType() == Type::Reorder
-                && !node->isDynamicNode();   // TODO [DS]: enable for dynamic shapes when inPlace in the dynamic case is available (CVS-74863)
+        return node->getType() == Type::Reorder &&
+               !node->isDynamicNode();  // TODO [DS]: enable for dynamic shapes when inPlace in the dynamic case is
+                                        // available (CVS-74863)
     };
 
     auto updateOrder = [](const VectorDims& originalOrder, NodePtr reshape) {
@@ -2542,17 +2595,28 @@ void GraphOptimizer::MergeTransposeAndReorder(Graph& graph) {
 
         const auto transposeNode = std::dynamic_pointer_cast<Transpose>(parentNode);
         const auto reorderNode = std::dynamic_pointer_cast<Reorder>(childNode);
-        std::shared_ptr<Reshape> reshapeNode = intermNode != nullptr ? std::dynamic_pointer_cast<Reshape>(intermNode) : nullptr;
+        std::shared_ptr<Reshape> reshapeNode =
+            intermNode != nullptr ? std::dynamic_pointer_cast<Reshape>(intermNode) : nullptr;
         if (!transposeNode || !reorderNode || (intermNode && !reshapeNode)) {
             continue;
         }
 
         auto transposeOrder = updateOrder(transposeNode->getOrder(), reshapeNode);
-        auto descBeforeReorder = reorderNode->getParentEdgeAt(0)->getParent()->getSelectedPrimitiveDescriptor()->getConfig().outConfs[0].getMemDesc();
+        auto descBeforeReorder = reorderNode->getParentEdgeAt(0)
+                                     ->getParent()
+                                     ->getSelectedPrimitiveDescriptor()
+                                     ->getConfig()
+                                     .outConfs[0]
+                                     .getMemDesc();
         auto layoutOrder = descBeforeReorder->as<BlockedMemoryDesc>()->getOrder();
 
-        auto inBlockedDesc = reorderNode->getSelectedPrimitiveDescriptor()->getConfig().inConfs[0].getMemDesc()->as<BlockedMemoryDesc>();
-        auto outBlockedDesc = reorderNode->getSelectedPrimitiveDescriptor()->getConfig().outConfs[0].getMemDesc()->as<BlockedMemoryDesc>();
+        auto inBlockedDesc =
+            reorderNode->getSelectedPrimitiveDescriptor()->getConfig().inConfs[0].getMemDesc()->as<BlockedMemoryDesc>();
+        auto outBlockedDesc = reorderNode->getSelectedPrimitiveDescriptor()
+                                  ->getConfig()
+                                  .outConfs[0]
+                                  .getMemDesc()
+                                  ->as<BlockedMemoryDesc>();
 
         auto& inOrder = inBlockedDesc->getOrder();
         auto& outOrder = outBlockedDesc->getOrder();
@@ -2563,13 +2627,11 @@ void GraphOptimizer::MergeTransposeAndReorder(Graph& graph) {
     }
 }
 
-void GraphOptimizer::MergeReorderAndTranspose(Graph &graph) {
+void GraphOptimizer::MergeReorderAndTranspose(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableTranspose = [](NodePtr node) {
-        return node->getType() == Type::Transpose
-                && node->getChildEdges().size() == 1
-                && !node->isDynamicNode();
+        return node->getType() == Type::Transpose && node->getChildEdges().size() == 1 && !node->isDynamicNode();
     };
 
     auto isSuitableReshape = [](NodePtr node) {
@@ -2659,7 +2721,8 @@ void GraphOptimizer::MergeReorderAndTranspose(Graph &graph) {
 
         auto transposeNode = std::dynamic_pointer_cast<Transpose>(childNode);
         auto reorderNode = std::dynamic_pointer_cast<Reorder>(parentNode);
-        std::shared_ptr<Reshape> reshapeNode = intermNode != nullptr ? std::dynamic_pointer_cast<Reshape>(intermNode) : nullptr;
+        std::shared_ptr<Reshape> reshapeNode =
+            intermNode != nullptr ? std::dynamic_pointer_cast<Reshape>(intermNode) : nullptr;
         if (!transposeNode || !reorderNode || (intermNode && !reshapeNode)) {
             continue;
         }
@@ -2668,15 +2731,20 @@ void GraphOptimizer::MergeReorderAndTranspose(Graph &graph) {
         auto descAfterTranspose = transposeNode->getSelectedPrimitiveDescriptor()->getConfig().outConfs[0].getMemDesc();
         auto layoutOrder = updateOrder(descAfterTranspose->as<BlockedMemoryDesc>()->getOrder(), reshapeNode);
 
-        auto inBlockedDesc = reorderNode->getSelectedPrimitiveDescriptor()->getConfig().inConfs[0].getMemDesc()->as<BlockedMemoryDesc>();
-        auto outBlockedDesc = reorderNode->getSelectedPrimitiveDescriptor()->getConfig().outConfs[0].getMemDesc()->as<BlockedMemoryDesc>();
+        auto inBlockedDesc =
+            reorderNode->getSelectedPrimitiveDescriptor()->getConfig().inConfs[0].getMemDesc()->as<BlockedMemoryDesc>();
+        auto outBlockedDesc = reorderNode->getSelectedPrimitiveDescriptor()
+                                  ->getConfig()
+                                  .outConfs[0]
+                                  .getMemDesc()
+                                  ->as<BlockedMemoryDesc>();
 
         auto& inOrder = inBlockedDesc->getOrder();
         auto& outOrder = outBlockedDesc->getOrder();
 
         if (checkAscendingFinalOrder(transposeOrder, layoutOrder, inOrder, outOrder)) {
-            // Reorder node doesn't support (with rare exceptions) reordering in case of different ranks on input and output.
-            // So the merge can be performed only in the case when the fused reorder will be optimized.
+            // Reorder node doesn't support (with rare exceptions) reordering in case of different ranks on input and
+            // output. So the merge can be performed only in the case when the fused reorder will be optimized.
             if (parentNode->getInputShapeAtPort(0).getRank() != childNode->getOutputShapeAtPort(0).getRank() &&
                 !canBeInplaced(parentNode, childNode)) {
                 continue;
@@ -2686,14 +2754,15 @@ void GraphOptimizer::MergeReorderAndTranspose(Graph &graph) {
     }
 }
 
-void GraphOptimizer::reshapeRnnSeq(Graph &graph) {
+void GraphOptimizer::reshapeRnnSeq(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableParentNode = [](NodePtr node) {
         if (node->type != Type::RNNSeq)
             return false;
         auto rnnNode = std::dynamic_pointer_cast<RNN>(node);
-        return rnnNode && !rnnNode->hasNativeOrder() && node->outputShapes[0].getRank() == 4 && node->outputShapes[0].getDims()[1] == 1;
+        return rnnNode && !rnnNode->hasNativeOrder() && node->outputShapes[0].getRank() == 4 &&
+               node->outputShapes[0].getDims()[1] == 1;
     };
 
     for (size_t i = 0; i < graphNodes.size(); i++) {
@@ -2715,10 +2784,12 @@ void GraphOptimizer::reshapeRnnSeq(Graph &graph) {
             auto edge = childrenEdges[j];
             auto childNode = edge->getChild();
 
-            const auto secondInput = std::make_shared<ov::opset1::Constant>(ov::element::i32, ov::Shape{1}, std::vector<int>{1});
+            const auto secondInput =
+                std::make_shared<ov::opset1::Constant>(ov::element::i32, ov::Shape{1}, std::vector<int>{1});
             const auto unsqueeze = std::make_shared<ov::opset1::Unsqueeze>(
                 std::make_shared<ov::opset1::Parameter>(parentNode->getOriginalOutputPrecisionAtPort(0),
-                                                            parentNode->getOutputShapeAtPort(0).toPartialShape()), secondInput);
+                                                        parentNode->getOutputShapeAtPort(0).toPartialShape()),
+                secondInput);
             unsqueeze->set_friendly_name(parentNode->getName() + "_abc_a1bc_" + std::to_string(j));
 
             const auto cpuUnsqueeze = std::make_shared<Reshape>(unsqueeze, graph.getGraphContext());
@@ -2758,7 +2829,7 @@ void GraphOptimizer::RemoveSameConvert(Graph& graph) {
     }
 }
 
-void GraphOptimizer::RemoveMemoryInputConvert(Graph &graph) {
+void GraphOptimizer::RemoveMemoryInputConvert(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableNode = [](const NodePtr& node) {
@@ -2784,7 +2855,7 @@ void GraphOptimizer::RemoveMemoryInputConvert(Graph &graph) {
     }
 }
 
-void GraphOptimizer::RemoveConvertMemoryOutput(Graph &graph) {
+void GraphOptimizer::RemoveConvertMemoryOutput(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableNode = [](const NodePtr& node) {
@@ -2812,7 +2883,7 @@ void GraphOptimizer::RemoveConvertMemoryOutput(Graph &graph) {
     }
 }
 
-void GraphOptimizer::MatchSdpaKvCache(Graph &graph) {
+void GraphOptimizer::MatchSdpaKvCache(Graph& graph) {
     auto& graphNodes = graph.GetNodes();
 
     auto isSuitableMemInput = [](const NodePtr& node) -> bool {
@@ -2829,7 +2900,7 @@ void GraphOptimizer::MatchSdpaKvCache(Graph &graph) {
 
             if (Type::ScaledDotProductAttention == childNode->getType()) {
                 if (childSdpa && childSdpa != childNode) {
-                    //only one child SDPA supported
+                    // only one child SDPA supported
                     return false;
                 }
                 childSdpa = childNode;
@@ -2872,7 +2943,7 @@ void GraphOptimizer::MatchSdpaKvCache(Graph &graph) {
             input_prc = ov::optional<ov::element::Type>(node->getOriginalInputPrecisionAtPort(0));
         }
 
-        //search for SDPA
+        // search for SDPA
         std::shared_ptr<ScaledDotProductAttention> sdpa;
         for (auto&& edge : node->getChildEdgesAtPort(0)) {
             auto child = edge->getChild();
@@ -2886,19 +2957,18 @@ void GraphOptimizer::MatchSdpaKvCache(Graph &graph) {
             }
         }
 
-        //capture reference to the original mem output before graph transformations
+        // capture reference to the original mem output before graph transformations
         auto& memOutput = memInputNode->getOutputNode();
 
-        auto memInputSdpa = std::make_shared<MemoryInputSDPA>(
-            memInputNode->getId(),
-            memInputNode->getName(),
-            memInputNode->getTypeStr(),
-            memInputNode->getOutputShapeAtPort(0),
-            memInputNode->getOriginalOutputPrecisionAtPort(0),
-            graph.getGraphContext(),
-            input_shape,
-            input_prc,
-            sdpa);
+        auto memInputSdpa = std::make_shared<MemoryInputSDPA>(memInputNode->getId(),
+                                                              memInputNode->getName(),
+                                                              memInputNode->getTypeStr(),
+                                                              memInputNode->getOutputShapeAtPort(0),
+                                                              memInputNode->getOriginalOutputPrecisionAtPort(0),
+                                                              graph.getGraphContext(),
+                                                              input_shape,
+                                                              input_prc,
+                                                              sdpa);
 
         if (!memInputNode->getParentEdges().empty()) {
             auto parentEdge = memInputNode->getParentEdgeAt(0);
@@ -2915,14 +2985,13 @@ void GraphOptimizer::MatchSdpaKvCache(Graph &graph) {
             graph.CreateEdge(memInputSdpa, child, 0, outputNum);
         }
 
-        //create a stub memory output
-        auto memOutputStub = std::make_shared<MemoryOutputStub>(
-            memOutput.getId(),
-            memOutput.getName(),
-            memOutput.getTypeStr(),
-            memOutput.getInputShapeAtPort(0),
-            memOutput.getOriginalInputPrecisionAtPort(0),
-            graph.getGraphContext());
+        // create a stub memory output
+        auto memOutputStub = std::make_shared<MemoryOutputStub>(memOutput.getId(),
+                                                                memOutput.getName(),
+                                                                memOutput.getTypeStr(),
+                                                                memOutput.getInputShapeAtPort(0),
+                                                                memOutput.getOriginalInputPrecisionAtPort(0),
+                                                                graph.getGraphContext());
 
         auto memOutputEdge = memOutput.getParentEdgeAt(0);
         const auto inputNum = memOutputEdge->getInputNum();
@@ -2934,7 +3003,7 @@ void GraphOptimizer::MatchSdpaKvCache(Graph &graph) {
     }
 }
 
-void GraphOptimizer::DropRedundantMemoryOutput(Graph &graph) {
+void GraphOptimizer::DropRedundantMemoryOutput(Graph& graph) {
     // When we have a MemoryInput->MemoryOutput pair, that means that the state is immediately populated with the init
     // subgraph values when the init subgraph exists. In all the other cases the state is simply a read only object.
     // We can optimize such a case removing the MemoryOutput node and transferring the state values update
@@ -2975,7 +3044,7 @@ void GraphOptimizer::DropRedundantMemoryOutput(Graph &graph) {
                 }
 
                 if (MemoryOutput && MemoryOutput != childNode) {
-                    //only one child MemoryOutput is expected
+                    // only one child MemoryOutput is expected
                     return false;
                 }
                 MemoryOutput = childNode;
@@ -3003,7 +3072,7 @@ void GraphOptimizer::DropRedundantMemoryOutput(Graph &graph) {
             inputPrc = ov::optional<ov::element::Type>(node->getOriginalInputPrecisionAtPort(0));
         }
 
-        //search for the MemoryOutputNode
+        // search for the MemoryOutputNode
         NodePtr memoryOutputNode;
         for (auto&& edge : node->getChildEdgesAtPort(0)) {
             auto child = edge->getChild();
@@ -3046,5 +3115,5 @@ void GraphOptimizer::DropRedundantMemoryOutput(Graph &graph) {
     }
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/graph_optimizer.h b/src/plugins/intel_cpu/src/graph_optimizer.h
index 536ef468a09816..90cf9c41c0907e 100644
--- a/src/plugins/intel_cpu/src/graph_optimizer.h
+++ b/src/plugins/intel_cpu/src/graph_optimizer.h
@@ -16,42 +16,42 @@ class GraphOptimizer {
 public:
     void ApplyCommonGraphOptimizations(Graph& graph);
     void ApplyImplSpecificGraphOptimizations(Graph& graph);
-    void ShareReorders(Graph &graph);
+    void ShareReorders(Graph& graph);
 
 private:
-    void FuseConvMatmulFCDeconvAndDQScales(Graph &graph);
-    void FuseConvolutionMatMulDeconvAndBias(Graph &graph);
-    void FuseDeconvolutionAndSimpleOperation(Graph &graph);
-    void FuseMultiplyAndAdd(Graph &graph);
+    void FuseConvMatmulFCDeconvAndDQScales(Graph& graph);
+    void FuseConvolutionMatMulDeconvAndBias(Graph& graph);
+    void FuseDeconvolutionAndSimpleOperation(Graph& graph);
+    void FuseMultiplyAndAdd(Graph& graph);
     void MergeConvertAndScaleShift(Graph& graph);
     void FuseFCAndConvertOnWeights(Graph& graph);
     void FuseFCAndTransposeOnWeights(Graph& graph);
-    void FuseFullyConnectedAndSimpleOperation(Graph &graph);
-    void FuseMatMulAndSimpleOperation(Graph &graph);
-    void FuseConvolutionAndSimpleOperationThroughMaxPool(Graph &graph);
-    void FuseConvolutionAndSimpleOperation(Graph &graph);
-    void FuseConvolutionAndDWConvolution(Graph &graph);
-    void FusePoolingAndFakeQuantize(Graph &graph);
-    void FuseConvolutionSumAndConvolutionSumActivation(Graph &graph);
-    void FuseMVNAndSimpleOperation(Graph &graph);
-    void FuseInterpolateAndSimpleOperation(Graph &graph);
-    void FuseNormalizeL2AndSimpleOperation(Graph &graph);
-    void FuseReduceAndSimpleOperation(Graph &graph);
+    void FuseFullyConnectedAndSimpleOperation(Graph& graph);
+    void FuseMatMulAndSimpleOperation(Graph& graph);
+    void FuseConvolutionAndSimpleOperationThroughMaxPool(Graph& graph);
+    void FuseConvolutionAndSimpleOperation(Graph& graph);
+    void FuseConvolutionAndDWConvolution(Graph& graph);
+    void FusePoolingAndFakeQuantize(Graph& graph);
+    void FuseConvolutionSumAndConvolutionSumActivation(Graph& graph);
+    void FuseMVNAndSimpleOperation(Graph& graph);
+    void FuseInterpolateAndSimpleOperation(Graph& graph);
+    void FuseNormalizeL2AndSimpleOperation(Graph& graph);
+    void FuseReduceAndSimpleOperation(Graph& graph);
 
     void DropDoubleReorders(Graph& graph);
-    void FuseConvolutionAndZeroPoints(Graph &graph);
-    void FuseBroadcastAndEltwise(Graph &graph);
-    void FuseEltwiseAndSimple(Graph &graph);
-    void FusePerformedAsScaleShiftAndFakeQuantize(Graph &graph);
-    void FuseClampAndFakeQuantize(Graph &graph);
-    void MergeTransposeAndReorder(Graph &graph);
-    void MergeReorderAndTranspose(Graph &graph);
-    void reshapeRnnSeq(Graph &graph);
-    void RemoveSameConvert(Graph &graph);
-    void RemoveMemoryInputConvert(Graph &graph);
-    void RemoveConvertMemoryOutput(Graph &graph);
-    void MatchSdpaKvCache(Graph &graph);
-    void DropRedundantMemoryOutput(Graph &graph);
+    void FuseConvolutionAndZeroPoints(Graph& graph);
+    void FuseBroadcastAndEltwise(Graph& graph);
+    void FuseEltwiseAndSimple(Graph& graph);
+    void FusePerformedAsScaleShiftAndFakeQuantize(Graph& graph);
+    void FuseClampAndFakeQuantize(Graph& graph);
+    void MergeTransposeAndReorder(Graph& graph);
+    void MergeReorderAndTranspose(Graph& graph);
+    void reshapeRnnSeq(Graph& graph);
+    void RemoveSameConvert(Graph& graph);
+    void RemoveMemoryInputConvert(Graph& graph);
+    void RemoveConvertMemoryOutput(Graph& graph);
+    void MatchSdpaKvCache(Graph& graph);
+    void DropRedundantMemoryOutput(Graph& graph);
 
     bool canBeInplaced(const NodePtr& parentNode, const NodePtr& childNode);
     // Method checks that after the sequential execution of Transpose and Reorder nodes,
@@ -68,19 +68,22 @@ class GraphOptimizer {
     // Examples:
     // 1. Direct order, no Reshape node.
     //    Before: [N,C,H,W]abcd==>Transpose(0312)==>[N,W,C,H]abcd==>Reorder(abcd->acdb)==>[N,W,C,H]acdb
-    //    [N,C,H,W]abcd is equivalent to the [N,W,C,H]acdb, so the Transpose and Reorder can be fused into single optimized Reorder:
-    //    After:  [N,C,H,W]abcd==>Reorder(abcd->acdb, isOptimized=true)==>[N,W,C,H]acdb
+    //    [N,C,H,W]abcd is equivalent to the [N,W,C,H]acdb, so the Transpose and Reorder can be fused into single
+    //    optimized Reorder: After:  [N,C,H,W]abcd==>Reorder(abcd->acdb, isOptimized=true)==>[N,W,C,H]acdb
     // 2. Reverse order, no Reshape node.
     //    Before: [N,W,C,H]acdb==>Reorder(acdb->abcd)==>[N,W,C,H]abcd==>Transpose(0231)==>[N,C,H,W]abcd
-    //    [N,W,C,H]acdb is equivalent to the [N,C,H,W]abcd, so the Transpose and Reorder can be fused into single optimized Reorder:
-    //    After:  [N,W,C,H]acdb==>Reorder(acdb->abcd, isOptimized=true)==>[N,C,H,W]abcd
+    //    [N,W,C,H]acdb is equivalent to the [N,C,H,W]abcd, so the Transpose and Reorder can be fused into single
+    //    optimized Reorder: After:  [N,W,C,H]acdb==>Reorder(acdb->abcd, isOptimized=true)==>[N,C,H,W]abcd
     // 3. Direct order with Reshape node (L = H x w).
-    //    Before: [N,L,C]abc==>Transpose(021)==>[N,C,L]abc==>Reshape==>[N,C,H,W]abcd==>Reoder(abcd->acdb)==>[N,C,H,W]acdb
-    //    After:  [N,L,C]abc==>Reorder(abc->acdb, isOptimized=true)==>[N,C,H,W]acdb
+    //    Before:
+    //    [N,L,C]abc==>Transpose(021)==>[N,C,L]abc==>Reshape==>[N,C,H,W]abcd==>Reoder(abcd->acdb)==>[N,C,H,W]acdb After:
+    //    [N,L,C]abc==>Reorder(abc->acdb, isOptimized=true)==>[N,C,H,W]acdb
     // 4. Reverse order with Reshape node (L = H x W).
-    //    Before: [N,C,H,W]acdb==>Reorder(acdb->abcd)==>[N,C,H,W]abcd==>Reshape==>[N,C,L]abc==>Transpose(021)==>[N,L,C]abc
+    //    Before:
+    //    [N,C,H,W]acdb==>Reorder(acdb->abcd)==>[N,C,H,W]abcd==>Reshape==>[N,C,L]abc==>Transpose(021)==>[N,L,C]abc
     //    After:  [N,C,H,W]acdb==>Reorder(acdb->abc, isOptimized=true)==>[N,L,C]abc
-    // Note: in some cases (inplace conflicts or transpose with blocked input and non-blocked output) the merged Reorder can not be optimized.
+    // Note: in some cases (inplace conflicts or transpose with blocked input and non-blocked output) the merged Reorder
+    // can not be optimized.
     void mergeTransposeReshapeReorder(Graph& graph,
                                       const NodePtr& transposeNode,
                                       const NodePtr& reshapeNode,
@@ -88,5 +91,5 @@ class GraphOptimizer {
                                       const bool reverseOrder);
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/infer_request.cpp b/src/plugins/intel_cpu/src/infer_request.cpp
index 26cdaf0860168a..3cfc34589623d2 100644
--- a/src/plugins/intel_cpu/src/infer_request.cpp
+++ b/src/plugins/intel_cpu/src/infer_request.cpp
@@ -8,17 +8,17 @@
 #include "compiled_model.h"
 #include "dnnl_extension_utils.h"
 #include "itt.h"
+#include "memory_desc/cpu_memory_desc_utils.h"
 #include "memory_state.h"
 #include "nodes/common/cpu_convert.h"
-#include "memory_desc/cpu_memory_desc_utils.h"
 #include "nodes/memory_state_base.h"
 #include "openvino/core/shape.hpp"
 #include "openvino/runtime/make_tensor.hpp"
 #include "openvino/runtime/tensor.hpp"
+#include "openvino/runtime/threading/cpu_message.hpp"
 #include "proxy_mem_blk.h"
 #include "utils/general_utils.h"
 #include "utils/ngraph_utils.hpp"
-#include "openvino/runtime/threading/cpu_message.hpp"
 
 using OvString = ov::element_type_traits<ov::element::string>::value_type;
 
@@ -56,7 +56,7 @@ void SyncInferRequest::create_infer_request() {
         init_tensor(it.first, ov::ISyncInferRequest::FoundPort::Type::OUTPUT);
     }
 
-    //create states according to the list of the MemoryStateNodes
+    // create states according to the list of the MemoryStateNodes
     for (auto&& node : m_graph->getInternalStateNodes()) {
         m_memory_states.emplace_back(node.second->makeState());
     }
@@ -162,7 +162,7 @@ static inline void change_edge_ptr(const EdgePtr& edge, ov::SoPtr<ov::ITensor>&
     OPENVINO_ASSERT(mem != nullptr, "Edge with name '", *edge, "' doesn't have allocated memory object.");
 
     if (tensor->get_element_type() == element::string) {
-        auto memBlock = dynamic_cast<StringMemory *>(mem.get())->getStringMemoryBlockPtr();
+        auto memBlock = dynamic_cast<StringMemory*>(mem.get())->getStringMemoryBlockPtr();
         OPENVINO_ASSERT(memBlock);
         memBlock->setExtBuff(tensor->data<StringMemory::OvString>(), tensor->get_size());
     } else {
@@ -177,14 +177,14 @@ void SyncInferRequest::change_default_ptr() {
     const auto& outputNodesMap = m_graph->GetOutputNodesMap();
 
     std::unordered_set<const void*> inputPtrs;
-    std::function<void(const EdgePtr &edge, ov::SoPtr<ov::ITensor>& tensor)> changeInpPtr;
+    std::function<void(const EdgePtr& edge, ov::SoPtr<ov::ITensor>& tensor)> changeInpPtr;
     if (m_graph->IsDynamic()) {
-        changeInpPtr = [&inputPtrs](const EdgePtr &edge, ov::SoPtr<ov::ITensor>& tensor) {
+        changeInpPtr = [&inputPtrs](const EdgePtr& edge, ov::SoPtr<ov::ITensor>& tensor) {
             change_edge_ptr(edge, tensor);
             inputPtrs.insert(tensor->data());
         };
     } else {
-        changeInpPtr = [](const EdgePtr &edge, ov::SoPtr<ov::ITensor>& tensor) {
+        changeInpPtr = [](const EdgePtr& edge, ov::SoPtr<ov::ITensor>& tensor) {
             change_edge_ptr(edge, tensor);
         };
     }
@@ -279,7 +279,7 @@ void SyncInferRequest::change_default_ptr() {
     }
 
     if (m_graph->IsDynamic()) {
-        const auto &outMemBlocksMap = m_graph->getOutputNodesMemBlocksMap();
+        const auto& outMemBlocksMap = m_graph->getOutputNodesMemBlocksMap();
         for (auto&& item : outMemBlocksMap) {
             const auto& name = item.first;
 
@@ -291,20 +291,32 @@ void SyncInferRequest::change_default_ptr() {
 
             if (controlBlockItr != m_outputControlBlocks.end()) {
                 auto output = outputNodesMap.find(name);
-                OPENVINO_ASSERT(outputNodesMap.end() != output, "Node with name: ", name, " is absent in the outputNodesMap");
+                OPENVINO_ASSERT(outputNodesMap.end() != output,
+                                "Node with name: ",
+                                name,
+                                " is absent in the outputNodesMap");
                 auto parentEdge = output->second->getParentEdgeAt(0);
-                //avoid cyclic memory use
+                // avoid cyclic memory use
                 auto&& controlBlock = controlBlockItr->second;
 
-                std::shared_ptr<IMemoryBlock> memBlock = inputPtrs.count(controlBlock.rawPtr()) ? // same memory is used on the input and output
-                    controlBlock.nextMemBlock() : // then swap internal buffer to avoid data corruption
-                    controlBlock.currentMemBlock(); // else reuse the existing buffer
+                std::shared_ptr<IMemoryBlock> memBlock =
+                    inputPtrs.count(controlBlock.rawPtr()) ?  // same memory is used on the input and output
+                        controlBlock.nextMemBlock()
+                                                           :  // then swap internal buffer to avoid data corruption
+                        controlBlock.currentMemBlock();       // else reuse the existing buffer
 
                 outputMemBlock->setMemBlockResize(memBlock);
-                DEBUG_LOG("reset proxy ", outputMemBlock, ", actual ", controlBlock.currentMemBlock(), " graph ", m_graph, " inferrequest ", this);
+                DEBUG_LOG("reset proxy ",
+                          outputMemBlock,
+                          ", actual ",
+                          controlBlock.currentMemBlock(),
+                          " graph ",
+                          m_graph,
+                          " inferrequest ",
+                          this);
                 DEBUG_LOG(name, ", tensor ", controlBlock.tensor());
             } else {
-                outputMemBlock->reset(); // switch to the internal memory since memory sharing is no longer possible
+                outputMemBlock->reset();  // switch to the internal memory since memory sharing is no longer possible
             }
         }
     }
@@ -456,12 +468,13 @@ void SyncInferRequest::set_tensor(const ov::Output<const ov::Node>& in_port, con
         }
 
         m_outputs[output_index] = tensor;
-        m_outputControlBlocks.erase(output_index); // now the memory is under user's control
+        m_outputControlBlocks.erase(output_index);  // now the memory is under user's control
     }
     ov::ISyncInferRequest::set_tensor(port, tensor);
 }
 
-void SyncInferRequest::set_tensors_impl(const ov::Output<const ov::Node> port, const std::vector<ov::SoPtr<ITensor>>& tensors) {
+void SyncInferRequest::set_tensors_impl(const ov::Output<const ov::Node> port,
+                                        const std::vector<ov::SoPtr<ITensor>>& tensors) {
     if (find_port(port).is_input()) {
         m_batched_tensors[port.get_tensor_ptr()] = tensors;
         return;
@@ -541,7 +554,8 @@ void SyncInferRequest::init_tensor(const std::size_t& port_index, const ov::ISyn
                         }
 
                         dnnl::engine eng(dnnl::engine::kind::cpu, 0);
-                        CpuBlockedMemoryDescPtr desc = std::make_shared<CpuBlockedMemoryDesc>(model_prec, Shape{memDims});
+                        CpuBlockedMemoryDescPtr desc =
+                            std::make_shared<CpuBlockedMemoryDesc>(model_prec, Shape{memDims});
                         auto memory = std::make_shared<StringMemory>(eng, desc);
 
                         tensor = std::make_shared<Tensor>(memory);
@@ -551,12 +565,12 @@ void SyncInferRequest::init_tensor(const std::size_t& port_index, const ov::ISyn
                         OutputControlBlock control_block{model_prec, Shape{shape}};
 
                         DEBUG_LOG(port_index,
-                                ", tensor ",
-                                control_block.tensor(),
-                                ", memBlock ",
-                                control_block.tensor()->get_memory()->getMemoryBlock(),
-                                "memory object ",
-                                control_block.tensor()->get_memory().get());
+                                  ", tensor ",
+                                  control_block.tensor(),
+                                  ", memBlock ",
+                                  control_block.tensor()->get_memory()->getMemoryBlock(),
+                                  "memory object ",
+                                  control_block.tensor()->get_memory().get());
 
                         tensor = control_block.tensor();
                         if (model_prec == graph_prec)
@@ -602,7 +616,7 @@ SyncInferRequest::OutputControlBlock::OutputControlBlock(const ov::element::Type
     m_proxyMemBlock = std::make_shared<ProxyMemoryBlock>(m_buffers[m_buffIndx]);
 
     VectorDims memDims;
-    if (shape.isDynamic()) { // this is a WA since the ITensor doesn't allow dyn shapes
+    if (shape.isDynamic()) {  // this is a WA since the ITensor doesn't allow dyn shapes
         for (auto&& item : shape.getDims()) {
             memDims.push_back(item != Shape::UNDEFINED_DIM ? item : 0);
         }
@@ -610,8 +624,7 @@ SyncInferRequest::OutputControlBlock::OutputControlBlock(const ov::element::Type
         memDims = shape.getStaticDims();
     }
 
-    CpuBlockedMemoryDescPtr desc =
-        std::make_shared<CpuBlockedMemoryDesc>(precision, Shape{memDims});
+    CpuBlockedMemoryDescPtr desc = std::make_shared<CpuBlockedMemoryDesc>(precision, Shape{memDims});
 
     auto memory = std::make_shared<Memory>(eng, desc, m_proxyMemBlock);
     m_tensor = std::make_shared<Tensor>(memory);
@@ -649,6 +662,5 @@ void SyncInferRequest::sub_streams_infer() {
     }
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
-
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/infer_request.h b/src/plugins/intel_cpu/src/infer_request.h
index a9def63d359744..b66387ecc4d4d5 100644
--- a/src/plugins/intel_cpu/src/infer_request.h
+++ b/src/plugins/intel_cpu/src/infer_request.h
@@ -4,11 +4,11 @@
 
 #pragma once
 
-#include "graph.h"
 #include "cpu_tensor.h"
+#include "graph.h"
+#include "memory_state.h"
 #include "openvino/runtime/iinfer_request.hpp"
 #include "openvino/runtime/isync_infer_request.hpp"
-#include "memory_state.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -29,7 +29,8 @@ class SyncInferRequest : public ov::ISyncInferRequest {
 
     void set_tensor(const ov::Output<const ov::Node>& port, const ov::SoPtr<ov::ITensor>& tensor) override;
 
-    void set_tensors_impl(const ov::Output<const ov::Node> port, const std::vector<ov::SoPtr<ov::ITensor>>& tensors) override;
+    void set_tensors_impl(const ov::Output<const ov::Node> port,
+                          const std::vector<ov::SoPtr<ov::ITensor>>& tensors) override;
 
     ov::SoPtr<ov::ITensor> get_tensor(const ov::Output<const ov::Node>& port) const override;
     std::vector<ov::SoPtr<ov::ITensor>> get_tensors(const ov::Output<const ov::Node>& _port) const override;
diff --git a/src/plugins/intel_cpu/src/memory_control.cpp b/src/plugins/intel_cpu/src/memory_control.cpp
index 0f202c296891c1..26cd8459458b9d 100644
--- a/src/plugins/intel_cpu/src/memory_control.cpp
+++ b/src/plugins/intel_cpu/src/memory_control.cpp
@@ -16,8 +16,7 @@ namespace {
 
 class StaticPartitionMemoryBlock : public IMemoryBlockObserver {
 public:
-    StaticPartitionMemoryBlock(MemoryBlockPtr pBlock, ptrdiff_t offset)
-        : m_pBlock(pBlock), m_offset(offset) {
+    StaticPartitionMemoryBlock(MemoryBlockPtr pBlock, ptrdiff_t offset) : m_pBlock(pBlock), m_offset(offset) {
         OPENVINO_ASSERT(m_pBlock, "Memory block is uninitialized");
     }
 
@@ -92,7 +91,7 @@ class IMemoryManager {
 
 using MemoryManagerPtr = std::shared_ptr<IMemoryManager>;
 
-template<typename T, typename... Args>
+template <typename T, typename... Args>
 std::shared_ptr<DnnlMemoryBlock> makeDnnlMemoryBlock(Args&&... args) {
     return std::make_shared<DnnlMemoryBlock>(make_unique<T>(std::forward<Args>(args)...));
 }
@@ -152,10 +151,12 @@ class MemoryManagerStatic : public IMemoryManager {
     }
 
     void allocate() override {
-        if (m_workspace) m_workspace->resize(m_totalSize);
+        if (m_workspace)
+            m_workspace->resize(m_totalSize);
     }
     void release() override {
-        if (m_workspace) m_workspace->free();
+        if (m_workspace)
+            m_workspace->free();
     }
 
 private:
@@ -171,14 +172,13 @@ class MemoryManageNonOverlapingSets : public IMemoryManager {
     void insert(const MemoryRegion& reg) override {
         MemorySolver::Box box = {reg.start, reg.finish, reg.size, reg.id};
         if (-1 != reg.finish) {
-            //We have to extend the lifespan of tensors that are crossing a sync point border in order to save
-            //the intermediate computation results from possible loss due to the tensor resize
-            auto itr_upper =
-                std::upper_bound(m_syncInds.begin(), m_syncInds.end(), box.finish, [](int y, int x) {
-                    return y <= x;
-                });
+            // We have to extend the lifespan of tensors that are crossing a sync point border in order to save
+            // the intermediate computation results from possible loss due to the tensor resize
+            auto itr_upper = std::upper_bound(m_syncInds.begin(), m_syncInds.end(), box.finish, [](int y, int x) {
+                return y <= x;
+            });
             auto itr_lower = std::lower_bound(m_syncInds.begin(), m_syncInds.end(), box.start);
-            if (itr_lower != itr_upper) { // across sections
+            if (itr_lower != itr_upper) {  // across sections
                 if (itr_upper == m_syncInds.end()) {
                     box.finish = -1;
                 } else {
@@ -201,7 +201,7 @@ class MemoryManageNonOverlapingSets : public IMemoryManager {
     void solve() {
         ov::MemorySolver::normalize_boxes(m_boxes);
 
-        std::vector<std::vector<ov::MemorySolver::Box>> groups; //groups of nonoverlapping boxes
+        std::vector<std::vector<ov::MemorySolver::Box>> groups;  // groups of nonoverlapping boxes
         groups.push_back({m_boxes.front()});
         for (size_t i = 1; i < m_boxes.size(); ++i) {
             const auto& box = m_boxes[i];
@@ -229,7 +229,7 @@ class MemoryManageNonOverlapingSets : public IMemoryManager {
     }
 
     void allocate() override {
-        //nothing to do
+        // nothing to do
     }
     void release() override {
         for (auto&& item : m_internalBlocks) {
@@ -305,15 +305,17 @@ MemoryControl::MemoryControl(std::vector<size_t> syncInds) {
     }));
 
     // handler for static tensors
-    m_handlers.emplace_back(buildHandler<MemoryManageNonOverlapingSets>([](const MemoryRegion& reg) {
-        if (reg.size >= 0 || MemoryRegion::RegionType::VARIABLE != reg.type ||
-            MemoryRegion::AllocType::POD != reg.alloc_type) {
-            return false;
-        }
-        return true;
-    }, std::move(syncInds)));
+    m_handlers.emplace_back(buildHandler<MemoryManageNonOverlapingSets>(
+        [](const MemoryRegion& reg) {
+            if (reg.size >= 0 || MemoryRegion::RegionType::VARIABLE != reg.type ||
+                MemoryRegion::AllocType::POD != reg.alloc_type) {
+                return false;
+            }
+            return true;
+        },
+        std::move(syncInds)));
 
-    //handler for I/O tensors, so far simply individual blocks
+    // handler for I/O tensors, so far simply individual blocks
     m_handlers.emplace_back(buildHandler<MemoryManagerIO>([](const MemoryRegion& reg) {
         if (MemoryRegion::RegionType::VARIABLE == reg.type || reg.alloc_type != MemoryRegion::AllocType::POD) {
             return false;
diff --git a/src/plugins/intel_cpu/src/memory_desc/blocked_memory_desc.cpp b/src/plugins/intel_cpu/src/memory_desc/blocked_memory_desc.cpp
index 4b75d5c5263398..7dff6905df09d9 100644
--- a/src/plugins/intel_cpu/src/memory_desc/blocked_memory_desc.cpp
+++ b/src/plugins/intel_cpu/src/memory_desc/blocked_memory_desc.cpp
@@ -15,9 +15,9 @@ namespace intel_cpu {
 constexpr BlockedMemoryDesc::CmpMask BlockedMemoryDesc::FULL_MASK;
 constexpr BlockedMemoryDesc::CmpMask BlockedMemoryDesc::EMPTY_MASK;
 constexpr BlockedMemoryDesc::CmpMask BlockedMemoryDesc::SKIP_OFFSET_MASK;
-constexpr size_t                     BlockedMemoryDesc::OFFSET_MASK_POS;
+constexpr size_t BlockedMemoryDesc::OFFSET_MASK_POS;
 
-bool BlockedMemoryDesc::isCompatibleInternal(const BlockedMemoryDesc &rhs, CmpMask cmpMask) const {
+bool BlockedMemoryDesc::isCompatibleInternal(const BlockedMemoryDesc& rhs, CmpMask cmpMask) const {
     if (this->getShape() != rhs.getShape() || this->getPrecision() != rhs.getPrecision())
         return false;
 
@@ -77,5 +77,5 @@ std::string BlockedMemoryDesc::serializeFormat() const {
     return result.str();
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/memory_desc/blocked_memory_desc.h b/src/plugins/intel_cpu/src/memory_desc/blocked_memory_desc.h
index d938a4ba585602..9ff132965bdc0b 100644
--- a/src/plugins/intel_cpu/src/memory_desc/blocked_memory_desc.h
+++ b/src/plugins/intel_cpu/src/memory_desc/blocked_memory_desc.h
@@ -21,7 +21,7 @@ class BlockedMemoryDesc : public virtual MemoryDesc {
     static constexpr CmpMask FULL_MASK{0xffffffff};
     static constexpr CmpMask EMPTY_MASK{0x0};
     static constexpr CmpMask SKIP_OFFSET_MASK{0x7fffffff};
-    static constexpr size_t  OFFSET_MASK_POS{31};
+    static constexpr size_t OFFSET_MASK_POS{31};
 
     /**
      * @brief Returns the blocked dimensions
@@ -73,7 +73,7 @@ class BlockedMemoryDesc : public virtual MemoryDesc {
      *
      * @return the result of the compatibility check
      */
-    virtual bool isCompatible(const BlockedMemoryDesc &rhs, CmpMask cmpMask) const = 0;
+    virtual bool isCompatible(const BlockedMemoryDesc& rhs, CmpMask cmpMask) const = 0;
     using MemoryDesc::isCompatible;
 
     ~BlockedMemoryDesc() override = default;
@@ -88,7 +88,7 @@ class BlockedMemoryDesc : public virtual MemoryDesc {
      * Doesn't perform descs specific attributes check
      * @return true if compatible, otherwise false
      */
-    bool isCompatibleInternal(const BlockedMemoryDesc &rhs, CmpMask cmpMask = FULL_MASK) const;
+    bool isCompatibleInternal(const BlockedMemoryDesc& rhs, CmpMask cmpMask = FULL_MASK) const;
 
     mutable VectorDims blockedDims;
     mutable VectorDims strides;
@@ -99,5 +99,5 @@ class BlockedMemoryDesc : public virtual MemoryDesc {
 using BlockedMemoryDescPtr = std::shared_ptr<BlockedMemoryDesc>;
 using BlockedMemoryDescCPtr = std::shared_ptr<const BlockedMemoryDesc>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/memory_desc/cpu_blocked_memory_desc.cpp b/src/plugins/intel_cpu/src/memory_desc/cpu_blocked_memory_desc.cpp
index d1c50d0048c57d..c95463207a9c46 100644
--- a/src/plugins/intel_cpu/src/memory_desc/cpu_blocked_memory_desc.cpp
+++ b/src/plugins/intel_cpu/src/memory_desc/cpu_blocked_memory_desc.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "cpu_blocked_memory_desc.h"
+
 #include "dnnl_blocked_memory_desc.h"
 #include "utils/general_utils.h"
 
@@ -15,17 +16,27 @@ static VectorDims makeRange(size_t size) {
     return retVec;
 }
 
-CpuBlockedMemoryDesc::CpuBlockedMemoryDesc(ov::element::Type prc, const Shape& shape) :
-    CpuBlockedMemoryDesc(prc, shape, shape.getDims(), makeRange(shape.getDims().size())) {}
-
-CpuBlockedMemoryDesc::CpuBlockedMemoryDesc(ov::element::Type prc, const Shape& shape, const VectorDims& blockedDims,
-                  const VectorDims& order, size_t offsetPadding, const VectorDims& offsetPaddingToData,
-                  const VectorDims& strides) : MemoryDesc(shape, Blocked), precision(prc) {
-    if (std::any_of(order.begin(), order.end(), [](size_t val) { return val == Shape::UNDEFINED_DIM; })) {
+CpuBlockedMemoryDesc::CpuBlockedMemoryDesc(ov::element::Type prc, const Shape& shape)
+    : CpuBlockedMemoryDesc(prc, shape, shape.getDims(), makeRange(shape.getDims().size())) {}
+
+CpuBlockedMemoryDesc::CpuBlockedMemoryDesc(ov::element::Type prc,
+                                           const Shape& shape,
+                                           const VectorDims& blockedDims,
+                                           const VectorDims& order,
+                                           size_t offsetPadding,
+                                           const VectorDims& offsetPaddingToData,
+                                           const VectorDims& strides)
+    : MemoryDesc(shape, Blocked),
+      precision(prc) {
+    if (std::any_of(order.begin(), order.end(), [](size_t val) {
+            return val == Shape::UNDEFINED_DIM;
+        })) {
         OPENVINO_THROW("CpuBlockedMemoryDesc do not support undefined order.");
     }
 
-    if (std::any_of(blockedDims.begin() + shape.getRank(), blockedDims.end(), [](size_t val) { return val == Shape::UNDEFINED_DIM; })) {
+    if (std::any_of(blockedDims.begin() + shape.getRank(), blockedDims.end(), [](size_t val) {
+            return val == Shape::UNDEFINED_DIM;
+        })) {
         OPENVINO_THROW("CpuBlockedMemoryDesc doesn't support undefined blockedDims.");
     }
 
@@ -51,29 +62,43 @@ CpuBlockedMemoryDesc::CpuBlockedMemoryDesc(ov::element::Type prc, const Shape& s
     if (strides.empty() && !order.empty()) {
         if (shape.hasZeroDims()) {
             this->strides.resize(order.size(), 0);
-        } else if (std::any_of(this->blockedDims.begin(), this->blockedDims.end(), [](size_t val) { return val == Shape::UNDEFINED_DIM; })) {
+        } else if (std::any_of(this->blockedDims.begin(), this->blockedDims.end(), [](size_t val) {
+                       return val == Shape::UNDEFINED_DIM;
+                   })) {
             this->strides.resize(order.size(), Shape::UNDEFINED_DIM);
         } else {
             this->strides.resize(order.size(), 1);
             for (size_t i = 2; i <= order.size(); i++) {
-                this->strides[order.size() - i] = this->strides[order.size() - (i - 1)] * this->blockedDims[blockedDims.size() - (i - 1)];
+                this->strides[order.size() - i] =
+                    this->strides[order.size() - (i - 1)] * this->blockedDims[blockedDims.size() - (i - 1)];
             }
         }
     } else {
         this->strides = strides;
     }
 
-    if (!everyone_is(this->order.size(), this->blockedDims.size(), this->offsetPaddingToData.size(), this->strides.size())) {
+    if (!everyone_is(this->order.size(),
+                     this->blockedDims.size(),
+                     this->offsetPaddingToData.size(),
+                     this->strides.size())) {
         OPENVINO_THROW("Order, blocked dims, offset padding to data and strides must have equals size");
     }
 }
 
 bool CpuBlockedMemoryDesc::isDefinedImp() const {
     bool defined = true;
-    defined = defined && std::none_of(blockedDims.cbegin(), blockedDims.cend(), [](size_t val) { return val == Shape::UNDEFINED_DIM; });
-    defined = defined && std::none_of(strides.cbegin(), strides.cend(), [](size_t val) { return val == Shape::UNDEFINED_DIM; });
-    defined = defined && std::none_of(order.cbegin(), order.cend(), [](size_t val) { return val == Shape::UNDEFINED_DIM; });
-    defined = defined && std::none_of(offsetPaddingToData.cbegin(), offsetPaddingToData.cend(), [](size_t val) { return val == Shape::UNDEFINED_DIM; });
+    defined = defined && std::none_of(blockedDims.cbegin(), blockedDims.cend(), [](size_t val) {
+                  return val == Shape::UNDEFINED_DIM;
+              });
+    defined = defined && std::none_of(strides.cbegin(), strides.cend(), [](size_t val) {
+                  return val == Shape::UNDEFINED_DIM;
+              });
+    defined = defined && std::none_of(order.cbegin(), order.cend(), [](size_t val) {
+                  return val == Shape::UNDEFINED_DIM;
+              });
+    defined = defined && std::none_of(offsetPaddingToData.cbegin(), offsetPaddingToData.cend(), [](size_t val) {
+                  return val == Shape::UNDEFINED_DIM;
+              });
     defined = defined && offsetPadding != Shape::UNDEFINED_DIM;
 
     return defined;
@@ -90,15 +115,15 @@ bool CpuBlockedMemoryDesc::isCompatible(const MemoryDesc& rhs) const {
     }
 }
 
-bool CpuBlockedMemoryDesc::isCompatible(const CpuBlockedMemoryDesc &rhs, CmpMask cmpMask) const {
+bool CpuBlockedMemoryDesc::isCompatible(const CpuBlockedMemoryDesc& rhs, CmpMask cmpMask) const {
     return BlockedMemoryDesc::isCompatibleInternal(rhs, cmpMask);
 }
 
-bool CpuBlockedMemoryDesc::isCompatible(const DnnlBlockedMemoryDesc &rhs, CmpMask cmpMask) const {
+bool CpuBlockedMemoryDesc::isCompatible(const DnnlBlockedMemoryDesc& rhs, CmpMask cmpMask) const {
     return rhs.isCompatible(*this, cmpMask);
 }
 
-bool CpuBlockedMemoryDesc::isCompatible(const BlockedMemoryDesc &rhs, CmpMask cmpMask) const {
+bool CpuBlockedMemoryDesc::isCompatible(const BlockedMemoryDesc& rhs, CmpMask cmpMask) const {
     const BlockedMemoryDesc* pRhs = &rhs;
     if (auto cpuBlkDesc = dynamic_cast<const CpuBlockedMemoryDesc*>(pRhs)) {
         return isCompatible(*cpuBlkDesc, cmpMask);
@@ -149,7 +174,9 @@ size_t CpuBlockedMemoryDesc::getMaxMemSize() const {
     }
 
     const auto& maxDims = shape.getMaxDims();
-    if (std::any_of(maxDims.begin(), maxDims.end(), [](size_t x){ return Shape::UNDEFINED_DIM == x; })) {
+    if (std::any_of(maxDims.begin(), maxDims.end(), [](size_t x) {
+            return Shape::UNDEFINED_DIM == x;
+        })) {
         return UNDEFINED_SIZE;
     }
 
@@ -193,16 +220,16 @@ size_t CpuBlockedMemoryDesc::getElementOffset(size_t elemNumber) const {
 
 bool CpuBlockedMemoryDesc::hasLayoutType(LayoutType layoutType) const {
     switch (layoutType) {
-        case LayoutType::ncsp:
-            return isPlainFormat();
-        case LayoutType::nspc:
-            return isTailCFormat();
-        case LayoutType::nCsp8c:
-            return isBlockedCFormat(8);
-        case LayoutType::nCsp16c:
-            return isBlockedCFormat(16);
-        default:
-            return false;
+    case LayoutType::ncsp:
+        return isPlainFormat();
+    case LayoutType::nspc:
+        return isTailCFormat();
+    case LayoutType::nCsp8c:
+        return isBlockedCFormat(8);
+    case LayoutType::nCsp16c:
+        return isBlockedCFormat(16);
+    default:
+        return false;
     }
 }
 
@@ -252,13 +279,15 @@ bool CpuBlockedMemoryDesc::isTailCFormat() const {
     return true;
 }
 
-MemoryDescPtr CpuBlockedMemoryDesc::cloneWithNewDimsImp(const VectorDims &dims) const {
-    if (std::any_of(dims.begin(), dims.end(), [](size_t x){ return Shape::UNDEFINED_DIM == x; })) {
+MemoryDescPtr CpuBlockedMemoryDesc::cloneWithNewDimsImp(const VectorDims& dims) const {
+    if (std::any_of(dims.begin(), dims.end(), [](size_t x) {
+            return Shape::UNDEFINED_DIM == x;
+        })) {
         OPENVINO_THROW("Can't clone desc if new dims are undefined");
     }
 
     // TODO [DS]: add stride recalculation for strided blobs
-    for (int i = strides.size() - 2; i >= 0 ; i--) {
+    for (int i = strides.size() - 2; i >= 0; i--) {
         if (strides[i] == Shape::UNDEFINED_DIM)
             break;
 
@@ -280,11 +309,18 @@ MemoryDescPtr CpuBlockedMemoryDesc::cloneWithNewDimsImp(const VectorDims &dims)
     }
 
     VectorDims newOffsetPaddingToData;
-    if (std::none_of(offsetPaddingToData.begin(), offsetPaddingToData.end(), [](size_t x){ return x == Shape::UNDEFINED_DIM;})) {
+    if (std::none_of(offsetPaddingToData.begin(), offsetPaddingToData.end(), [](size_t x) {
+            return x == Shape::UNDEFINED_DIM;
+        })) {
         newOffsetPaddingToData = offsetPaddingToData;
     }
 
-    return std::make_shared<CpuBlockedMemoryDesc>(precision, Shape(dims), newBlockedDims, order, offsetPadding, newOffsetPaddingToData);
+    return std::make_shared<CpuBlockedMemoryDesc>(precision,
+                                                  Shape(dims),
+                                                  newBlockedDims,
+                                                  order,
+                                                  offsetPadding,
+                                                  newOffsetPaddingToData);
 }
 
 bool CpuBlockedMemoryDesc::blocksExtended() const {
@@ -311,7 +347,9 @@ size_t CpuBlockedMemoryDesc::getPaddedElementsCount() const {
     if (getShape().hasZeroDims()) {
         return 0;
     }
-    if (std::any_of(blockedDims.begin(), blockedDims.end(), [](Dim dim) { return dim == Shape::UNDEFINED_DIM; })) {
+    if (std::any_of(blockedDims.begin(), blockedDims.end(), [](Dim dim) {
+            return dim == Shape::UNDEFINED_DIM;
+        })) {
         OPENVINO_THROW("Can't compute padded elements count for non undefined blocked dims");
     }
     return std::accumulate(blockedDims.begin(), blockedDims.end(), size_t{1}, std::multiplies<size_t>());
@@ -323,5 +361,5 @@ MemoryDescPtr CpuBlockedMemoryDesc::cloneWithNewPrecision(const ov::element::Typ
     return newDesc;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/memory_desc/cpu_blocked_memory_desc.h b/src/plugins/intel_cpu/src/memory_desc/cpu_blocked_memory_desc.h
index 28badb4dac15fb..fdf931a262e854 100644
--- a/src/plugins/intel_cpu/src/memory_desc/cpu_blocked_memory_desc.h
+++ b/src/plugins/intel_cpu/src/memory_desc/cpu_blocked_memory_desc.h
@@ -16,8 +16,12 @@ class CpuBlockedMemoryDesc : public BlockedMemoryDesc {
 public:
     CpuBlockedMemoryDesc(ov::element::Type prc, const Shape& shape);
 
-    CpuBlockedMemoryDesc(ov::element::Type prc, const Shape& shape, const VectorDims& blockedDims,
-                         const VectorDims& order, size_t offsetPadding = 0, const VectorDims& offsetPaddingToData = {},
+    CpuBlockedMemoryDesc(ov::element::Type prc,
+                         const Shape& shape,
+                         const VectorDims& blockedDims,
+                         const VectorDims& order,
+                         size_t offsetPadding = 0,
+                         const VectorDims& offsetPaddingToData = {},
                          const VectorDims& strides = {});
 
     MemoryDescPtr clone() const override {
@@ -26,8 +30,8 @@ class CpuBlockedMemoryDesc : public BlockedMemoryDesc {
 
     bool isCompatible(const MemoryDesc& rhs) const override;
     bool isCompatible(const BlockedMemoryDesc& rhs, CmpMask cmpMask) const override;
-    bool isCompatible(const CpuBlockedMemoryDesc &rhs, CmpMask cmpMask = BlockedMemoryDesc::FULL_MASK) const;
-    bool isCompatible(const DnnlBlockedMemoryDesc &rhs, CmpMask cmpMask = BlockedMemoryDesc::FULL_MASK) const;
+    bool isCompatible(const CpuBlockedMemoryDesc& rhs, CmpMask cmpMask = BlockedMemoryDesc::FULL_MASK) const;
+    bool isCompatible(const DnnlBlockedMemoryDesc& rhs, CmpMask cmpMask = BlockedMemoryDesc::FULL_MASK) const;
 
     ov::element::Type getPrecision() const override {
         return precision;
@@ -105,5 +109,5 @@ class CpuBlockedMemoryDesc : public BlockedMemoryDesc {
 using CpuBlockedMemoryDescPtr = std::shared_ptr<CpuBlockedMemoryDesc>;
 using CpuBlockedMemoryDescCPtr = std::shared_ptr<const CpuBlockedMemoryDesc>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/memory_desc/cpu_memory_desc.h b/src/plugins/intel_cpu/src/memory_desc/cpu_memory_desc.h
index c3936528abed7b..e6d260066118ee 100644
--- a/src/plugins/intel_cpu/src/memory_desc/cpu_memory_desc.h
+++ b/src/plugins/intel_cpu/src/memory_desc/cpu_memory_desc.h
@@ -22,7 +22,7 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 class Split;
-}   // namespace node
+}  // namespace node
 
 class MemoryDesc;
 
@@ -39,10 +39,10 @@ enum MemoryDescType {
 };
 
 enum class LayoutType : unsigned {
-    nspc,      // general per channels format
-    ncsp,      // general planar
-    nCsp8c,    // general channels blocked by 8
-    nCsp16c    // general channels blocked by 16
+    nspc,    // general per channels format
+    ncsp,    // general planar
+    nCsp8c,  // general channels blocked by 8
+    nCsp16c  // general channels blocked by 16
 };
 
 class MemoryDesc {
@@ -70,8 +70,8 @@ class MemoryDesc {
 
     /**
      * @brief Clone descriptor with new dims.
-     * Throws an exception if relaxedCheck is false and some of the new dims conflicts with the internal shape (i.e. its defined dims ,rank, upper bounds)
-     * or if internal shape and dims have different ranks
+     * Throws an exception if relaxedCheck is false and some of the new dims conflicts with the internal shape (i.e. its
+     * defined dims ,rank, upper bounds) or if internal shape and dims have different ranks
      * @param dims new dims
      * @param relaxedCheck flag which defined must we check dims with internal desc on compatibility
      * @return MemoryDescPtr with new dims
@@ -136,8 +136,8 @@ class MemoryDesc {
     }
 
     template <typename T,
-            typename std::enable_if<!std::is_pointer<T>::value && !std::is_reference<T>::value, int>::type = 0,
-            typename std::enable_if<std::is_base_of<MemoryDesc, T>::value, int>::type = 0>
+              typename std::enable_if<!std::is_pointer<T>::value && !std::is_reference<T>::value, int>::type = 0,
+              typename std::enable_if<std::is_base_of<MemoryDesc, T>::value, int>::type = 0>
     T* as() {
         T* casted = dynamic_cast<T*>(this);
         if (!casted)
@@ -146,8 +146,8 @@ class MemoryDesc {
     }
 
     template <typename T,
-            typename std::enable_if<!std::is_pointer<T>::value && !std::is_reference<T>::value, int>::type = 0,
-            typename std::enable_if<std::is_base_of<MemoryDesc, T>::value, int>::type = 0>
+              typename std::enable_if<!std::is_pointer<T>::value && !std::is_reference<T>::value, int>::type = 0,
+              typename std::enable_if<std::is_base_of<MemoryDesc, T>::value, int>::type = 0>
     const T* as() const {
         const T* casted = dynamic_cast<const T*>(this);
         if (!casted)
@@ -159,17 +159,16 @@ class MemoryDesc {
 
 protected:
     MemoryDesc() : type(MemoryDescType::Undef) {}
-    MemoryDesc(Shape shape, MemoryDescType type)
-            : type(type), shape(std::move(shape)) {}
+    MemoryDesc(Shape shape, MemoryDescType type) : type(type), shape(std::move(shape)) {}
 
-    MemoryDesc(const VectorDims& dims, MemoryDescType type)
-            : type(type), shape(dims) {}
+    MemoryDesc(const VectorDims& dims, MemoryDescType type) : type(type), shape(dims) {}
 
     virtual void setPrecision(ov::element::Type prc) = 0;
 
     virtual size_t getCurrentMemSizeImp() const = 0;
 
-    // Get offset to the n'th element. Returns physical index of the element by the logical one considering padding, layout, blocking etc.
+    // Get offset to the n'th element. Returns physical index of the element by the logical one considering padding,
+    // layout, blocking etc.
     virtual size_t getElementOffset(size_t elemNumber) const = 0;
 
     virtual bool canComputeMemSizeZeroDims() const = 0;
@@ -195,5 +194,5 @@ class MemoryDesc {
     friend class node::Split;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/memory_desc/cpu_memory_desc_utils.cpp b/src/plugins/intel_cpu/src/memory_desc/cpu_memory_desc_utils.cpp
index 0ae17d6c00322b..2937b73409b67d 100644
--- a/src/plugins/intel_cpu/src/memory_desc/cpu_memory_desc_utils.cpp
+++ b/src/plugins/intel_cpu/src/memory_desc/cpu_memory_desc_utils.cpp
@@ -4,29 +4,33 @@
 
 #include "memory_desc/cpu_memory_desc_utils.h"
 
-#include "memory_desc/cpu_blocked_memory_desc.h"
-#include "memory_desc/dnnl_blocked_memory_desc.h"
-#include "graph_context.h"
-#include "cpu_memory_desc.h"
-#include "memory_desc/empty_memory_desc.h"
-#include <cpu_memory.h>
-#include <vector>
 #include <cpu_memory.h>
 #include <dnnl_types.h>
+
 #include <numeric>
 #include <vector>
 
+#include "cpu_memory_desc.h"
+#include "graph_context.h"
+#include "memory_desc/cpu_blocked_memory_desc.h"
+#include "memory_desc/dnnl_blocked_memory_desc.h"
+#include "memory_desc/empty_memory_desc.h"
+
 using namespace dnnl;
 
 namespace ov {
 namespace intel_cpu {
 
-DnnlMemoryDescPtr MemoryDescUtils::convertToDnnlMemoryDesc(const MemoryDescPtr &desc) {
+DnnlMemoryDescPtr MemoryDescUtils::convertToDnnlMemoryDesc(const MemoryDescPtr& desc) {
     if (MemoryDescType::Blocked == desc->getType()) {
         const auto cpuDesc = desc->as<CpuBlockedMemoryDesc>();
-        return std::shared_ptr<DnnlBlockedMemoryDesc>(new DnnlBlockedMemoryDesc(cpuDesc->getPrecision(), cpuDesc->getShape(), cpuDesc->getBlockDims(),
-                                                        cpuDesc->getOrder(), cpuDesc->getOffsetPadding(),
-                                                        cpuDesc->getOffsetPaddingToData(), cpuDesc->getStrides()));
+        return std::shared_ptr<DnnlBlockedMemoryDesc>(new DnnlBlockedMemoryDesc(cpuDesc->getPrecision(),
+                                                                                cpuDesc->getShape(),
+                                                                                cpuDesc->getBlockDims(),
+                                                                                cpuDesc->getOrder(),
+                                                                                cpuDesc->getOffsetPadding(),
+                                                                                cpuDesc->getOffsetPaddingToData(),
+                                                                                cpuDesc->getStrides()));
     } else if (MemoryDescType::Empty == desc->getType()) {
         return DnnlExtensionUtils::makeDescriptor(dnnl::memory::desc());
     } else if (MemoryDescType::Dnnl & desc->getType()) {
@@ -41,14 +45,19 @@ DnnlBlockedMemoryDesc MemoryDescUtils::convertToDnnlBlockedMemoryDesc(const Memo
         return DnnlBlockedMemoryDesc(*desc.as<DnnlBlockedMemoryDesc>());
     } else if (MemoryDescType::Blocked == desc.getType()) {
         const auto cpuDesc = desc.as<CpuBlockedMemoryDesc>();
-        return DnnlBlockedMemoryDesc(cpuDesc->getPrecision(), cpuDesc->getShape(), cpuDesc->getBlockDims(), cpuDesc->getOrder(), cpuDesc->getOffsetPadding(),
-                                     cpuDesc->getOffsetPaddingToData(), cpuDesc->getStrides());
+        return DnnlBlockedMemoryDesc(cpuDesc->getPrecision(),
+                                     cpuDesc->getShape(),
+                                     cpuDesc->getBlockDims(),
+                                     cpuDesc->getOrder(),
+                                     cpuDesc->getOffsetPadding(),
+                                     cpuDesc->getOffsetPaddingToData(),
+                                     cpuDesc->getStrides());
     } else {
         OPENVINO_THROW("Cannot convert MemoryDesc to DnnlBlockedMemoryDesc");
     }
 }
 
-BlockedMemoryDescPtr MemoryDescUtils::convertToBlockedMemoryDesc(const MemoryDescPtr &desc) {
+BlockedMemoryDescPtr MemoryDescUtils::convertToBlockedMemoryDesc(const MemoryDescPtr& desc) {
     if (desc->getType() & MemoryDescType::Blocked) {
         return std::dynamic_pointer_cast<BlockedMemoryDesc>(desc);
     } else {
@@ -57,7 +66,7 @@ BlockedMemoryDescPtr MemoryDescUtils::convertToBlockedMemoryDesc(const MemoryDes
 }
 
 CpuBlockedMemoryDescPtr MemoryDescUtils::generateCpuBlockedMemoryDesc(const ov::SoPtr<ov::ITensor>& tensor) {
-    const auto& shape = tensor->get_shape().empty() ?  ov::Shape{tensor->get_size()} : tensor->get_shape();
+    const auto& shape = tensor->get_shape().empty() ? ov::Shape{tensor->get_size()} : tensor->get_shape();
 
     VectorDims blk_order(shape.size());
     std::iota(blk_order.begin(), blk_order.end(), 0);
@@ -87,17 +96,16 @@ CpuBlockedMemoryDescPtr MemoryDescUtils::generateCpuBlockedMemoryDesc(const ov::
                        });
     }
 
-    return std::make_shared<CpuBlockedMemoryDesc>(
-        element_type,
-        Shape{shape},
-        shape,
-        blk_order,
-        0UL,
-        VectorDims{},
-        blk_strides);
+    return std::make_shared<CpuBlockedMemoryDesc>(element_type,
+                                                  Shape{shape},
+                                                  shape,
+                                                  blk_order,
+                                                  0UL,
+                                                  VectorDims{},
+                                                  blk_strides);
 }
 
-std::shared_ptr<MemoryDesc> MemoryDescUtils::makeDummyDesc(const MemoryDesc &desc, Dim dummyVal) {
+std::shared_ptr<MemoryDesc> MemoryDescUtils::makeDummyDesc(const MemoryDesc& desc, Dim dummyVal) {
     auto dummyShape = makeDummyShape(desc.getShape(), dummyVal);
     return desc.cloneWithNewDims(dummyShape.getStaticDims());
 }
@@ -111,7 +119,7 @@ std::shared_ptr<IMemory> MemoryDescUtils::makeEmptyMemory(const GraphContext::CP
     return std::make_shared<StaticMemory>(context->getEngine(), makeEmptyDesc(), nullptr);
 }
 
-Shape MemoryDescUtils::makeDummyShape(const Shape &shape, Dim dummyVal) {
+Shape MemoryDescUtils::makeDummyShape(const Shape& shape, Dim dummyVal) {
     const auto& minDims = shape.getMinDims();
     const auto& maxDims = shape.getMaxDims();
     const auto& dims = shape.getDims();
@@ -122,7 +130,7 @@ Shape MemoryDescUtils::makeDummyShape(const Shape &shape, Dim dummyVal) {
     return Shape(dummyDims);
 }
 
-Shape MemoryDescUtils::makeDummyShape(const Shape &shape, const VectorDims& dummyVals) {
+Shape MemoryDescUtils::makeDummyShape(const Shape& shape, const VectorDims& dummyVals) {
     if (shape.getRank() != dummyVals.size()) {
         OPENVINO_THROW("makeDummyShape(): dummyVals vector size and shape ranks mismatch");
     }
@@ -131,9 +139,10 @@ Shape MemoryDescUtils::makeDummyShape(const Shape &shape, const VectorDims& dumm
     const auto& dims = shape.getDims();
     VectorDims dummyDims(dims.size());
     for (size_t i = 0; i < dims.size(); ++i) {
-        dummyDims[i] = dims[i] == Shape::UNDEFINED_DIM ? std::min(maxDims[i], std::max(minDims[i], dummyVals[i])) : dims[i];
+        dummyDims[i] =
+            dims[i] == Shape::UNDEFINED_DIM ? std::min(maxDims[i], std::max(minDims[i], dummyVals[i])) : dims[i];
     }
     return Shape(dummyDims);
 }
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/memory_desc/cpu_memory_desc_utils.h b/src/plugins/intel_cpu/src/memory_desc/cpu_memory_desc_utils.h
index a4acd3eb2aa778..388c9a21c5df8e 100644
--- a/src/plugins/intel_cpu/src/memory_desc/cpu_memory_desc_utils.h
+++ b/src/plugins/intel_cpu/src/memory_desc/cpu_memory_desc_utils.h
@@ -5,11 +5,12 @@
 #pragma once
 
 #include <memory>
+
 #include "cpu_shape.h"
 #include "cpu_types.h"
+#include "graph_context.h"
 #include "openvino/runtime/itensor.hpp"
 #include "openvino/runtime/so_ptr.hpp"
-#include "graph_context.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -32,7 +33,7 @@ class MemoryDescUtils {
      * @param desc MemoryDesc to be converted
      * @return converted DnnlMemoryDesc
      */
-    static std::shared_ptr<DnnlMemoryDesc> convertToDnnlMemoryDesc(const std::shared_ptr<MemoryDesc> &desc);
+    static std::shared_ptr<DnnlMemoryDesc> convertToDnnlMemoryDesc(const std::shared_ptr<MemoryDesc>& desc);
 
     /**
      * @brief Converts MemoryDesc to DnnlBlockedMemoryDesc
@@ -46,7 +47,7 @@ class MemoryDescUtils {
      * @param desc MemoryDesc to be converted
      * @return converted BlockedMemoryDesc
      */
-    static std::shared_ptr<BlockedMemoryDesc> convertToBlockedMemoryDesc(const std::shared_ptr<MemoryDesc> &desc);
+    static std::shared_ptr<BlockedMemoryDesc> convertToBlockedMemoryDesc(const std::shared_ptr<MemoryDesc>& desc);
 
     /**
      * @brief Builds CpuBlockedMemoryDesc for given ov::ITensor
@@ -58,7 +59,8 @@ class MemoryDescUtils {
     static constexpr Dim DEFAULT_DUMMY_VAL = 64;
 
     /**
-     * @brief Makes a dummy descriptor where all undefined values are replaced with the smallest value between the parameter and the upper bound dim
+     * @brief Makes a dummy descriptor where all undefined values are replaced with the smallest value between the
+     * parameter and the upper bound dim
      * @param desc MemoryDesc from which the new descriptor is generated
      * @param dummyVal Dim value to replace undefined dimensions
      * @return a new MemoryDesc with dummy values instead of undefined dims
@@ -66,27 +68,29 @@ class MemoryDescUtils {
     static std::shared_ptr<MemoryDesc> makeDummyDesc(const MemoryDesc& desc, Dim dummyVal = DEFAULT_DUMMY_VAL);
 
     /**
-    * @brief Make an empty memory descriptor
-    * @note Shape{0}, undefined
-    * @return empty memory descriptor
-    */
+     * @brief Make an empty memory descriptor
+     * @note Shape{0}, undefined
+     * @return empty memory descriptor
+     */
     static std::shared_ptr<MemoryDesc> makeEmptyDesc();
     static std::shared_ptr<IMemory> makeEmptyMemory(const GraphContext::CPtr context);
 
     /**
-    * @brief Makes a static dummy shape where all undefined values are replaced with the smallest value between the parameter and the upper bound dim
-    * @param shape a Shape object from which the new static shape is generated
-    * @param dummyVal Dim value to replace undefined dimensions
-    * @return a new Shape with dummy values instead of undefined dims
-    */
+     * @brief Makes a static dummy shape where all undefined values are replaced with the smallest value between the
+     * parameter and the upper bound dim
+     * @param shape a Shape object from which the new static shape is generated
+     * @param dummyVal Dim value to replace undefined dimensions
+     * @return a new Shape with dummy values instead of undefined dims
+     */
     static Shape makeDummyShape(const Shape& shape, Dim dummyVal = DEFAULT_DUMMY_VAL);
 
     /**
-    * @brief Makes a static dummy shape where all undefined values are replaced with the smallest value between the parameter and the upper bound dim
-    * @param shape a Shape object from which the new static shape is generated
-    * @param dummyVals vector of values to replace undefined dimensions
-    * @return a new Shape with dummy values instead of undefined dims
-    */
+     * @brief Makes a static dummy shape where all undefined values are replaced with the smallest value between the
+     * parameter and the upper bound dim
+     * @param shape a Shape object from which the new static shape is generated
+     * @param dummyVals vector of values to replace undefined dimensions
+     * @return a new Shape with dummy values instead of undefined dims
+     */
     static Shape makeDummyShape(const Shape& shape, const VectorDims& dummyVals);
 
     /**
@@ -104,5 +108,5 @@ class MemoryDescUtils {
     static std::string dims2str(const VectorDims& dims);
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/memory_desc/dnnl_blocked_memory_desc.cpp b/src/plugins/intel_cpu/src/memory_desc/dnnl_blocked_memory_desc.cpp
index a24b55831c2c7c..38c020674c7168 100644
--- a/src/plugins/intel_cpu/src/memory_desc/dnnl_blocked_memory_desc.cpp
+++ b/src/plugins/intel_cpu/src/memory_desc/dnnl_blocked_memory_desc.cpp
@@ -4,26 +4,28 @@
 
 #include "memory_desc/dnnl_blocked_memory_desc.h"
 
+#include <algorithm>
 #include <common/memory_desc_wrapper.hpp>
+#include <cstdint>
 #include <oneapi/dnnl/dnnl.hpp>
+
 #include "cpu_types.h"
 #include "dnnl_extension_utils.h"
 #include "memory_desc/cpu_blocked_memory_desc.h"
 #include "utils/general_utils.h"
 
-#include <algorithm>
-#include <cstdint>
-
 namespace ov {
 namespace intel_cpu {
 
 DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(ov::element::Type prc, const Shape& shape, const VectorDims& strides)
     : MemoryDesc(shape, DnnlBlocked) {
     const auto ndims = shape.getRank();
-    const auto &dims = shape.getDims();
+    const auto& dims = shape.getDims();
 
-    if (!strides.empty()) { // custom strides
-        if (shape.hasZeroDims() && std::any_of(strides.begin(), strides.end(), [](size_t stride) { return stride != 0; } )) {
+    if (!strides.empty()) {  // custom strides
+        if (shape.hasZeroDims() && std::any_of(strides.begin(), strides.end(), [](size_t stride) {
+                return stride != 0;
+            })) {
             OPENVINO_THROW("Can't create DnnlBlockedMemoryDesc with zero dim, but with non zero strides");
         }
         desc = {DnnlExtensionUtils::convertToDnnlDims(dims),
@@ -33,16 +35,20 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(ov::element::Type prc, const Shape&
         dnnl::memory::dims plain_strides;
         if (shape.hasZeroDims()) {
             plain_strides.resize(ndims, 0);
-        } else if (std::any_of(dims.begin(), dims.end(), [](size_t val) { return val == Shape::UNDEFINED_DIM; })) {
+        } else if (std::any_of(dims.begin(), dims.end(), [](size_t val) {
+                       return val == Shape::UNDEFINED_DIM;
+                   })) {
             plain_strides.resize(ndims, DNNL_RUNTIME_DIM_VAL);
         } else {
             plain_strides.resize(ndims, 1);
             for (size_t i = 1; i < ndims; i++) {
-                plain_strides[ndims - i -1] = plain_strides[ndims - i] * dims[ndims - i];
+                plain_strides[ndims - i - 1] = plain_strides[ndims - i] * dims[ndims - i];
             }
         }
 
-        desc = {DnnlExtensionUtils::convertToDnnlDims(dims), DnnlExtensionUtils::ElementTypeToDataType(prc), plain_strides};
+        desc = {DnnlExtensionUtils::convertToDnnlDims(dims),
+                DnnlExtensionUtils::ElementTypeToDataType(prc),
+                plain_strides};
     }
 
     order.resize(ndims);
@@ -55,11 +61,12 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(ov::element::Type prc, const Shape&
  * Construct from blocked parameters
  *
  * OV  IOhw_4i16o4i   dims(N) = {32, 64, 128, 128}
- *   blockedDims  {4, 2, 128, 128, 4, 16, 4}                      // total dims(inner, outermost, auto blocked/padded). Generally sorted by strides.
- *   strides      {8388608, 4194304,  32768, 256, 64,  4, 1}      // strides for blockedDims, growing sequence
- *   order        {1, 0,   2,   3, 1,  0, 1}                      // matching to original dims
+ *   blockedDims  {4, 2, 128, 128, 4, 16, 4}                      // total dims(inner, outermost, auto blocked/padded).
+ * Generally sorted by strides. strides      {8388608, 4194304,  32768, 256, 64,  4, 1}      // strides for blockedDims,
+ * growing sequence order        {1, 0,   2,   3, 1,  0, 1}                      // matching to original dims
  *
- *   All vectors blockedDims/strides/order have same size equals total num of internal blocked dims(inner_dims + outer_dims)
+ *   All vectors blockedDims/strides/order have same size equals total num of internal blocked dims(inner_dims +
+ * outer_dims)
  *
  *   Tensor descriptor filing is not deterministic. It allows any permutation of index which keeps order of
  *   real dims spliting.
@@ -70,9 +77,14 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(ov::element::Type prc, const Shape&
  *
  *   Limitation of conversion first N elements of order should be permutation of [0,1,2 ... N]
  */
-DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(ov::element::Type prc, const Shape& shape, const VectorDims& blockedDims,
-                                             const VectorDims& order, size_t offsetPadding, const VectorDims& offsetPaddingToData,
-                                             const VectorDims& strides) : MemoryDesc(shape, DnnlBlocked) {
+DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(ov::element::Type prc,
+                                             const Shape& shape,
+                                             const VectorDims& blockedDims,
+                                             const VectorDims& order,
+                                             size_t offsetPadding,
+                                             const VectorDims& offsetPaddingToData,
+                                             const VectorDims& strides)
+    : MemoryDesc(shape, DnnlBlocked) {
     using namespace dnnl;
     // scalar case
     if (shape.getRank() == 0) {
@@ -128,7 +140,9 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(ov::element::Type prc, const Shape&
 
     const bool emptyDesc = shape.hasZeroDims();
     if (!strides.empty()) {
-        if (emptyDesc && std::any_of(strides.begin(), strides.end(), [](size_t dim) { return dim != 0; } )) {
+        if (emptyDesc && std::any_of(strides.begin(), strides.end(), [](size_t dim) {
+                return dim != 0;
+            })) {
             OPENVINO_THROW("Can't create DnnlBlockedMemoryDesc with zero dim, but with non zero strides");
         }
 
@@ -143,7 +157,9 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(ov::element::Type prc, const Shape&
             OPENVINO_THROW("Can not construct DnnlBlockedMemoryDesc from strides: ", vec2str(strides));
     }
 
-    if (!strides.empty() && !emptyDesc && std::none_of(strides.begin(), strides.end(), [](size_t x) { return Shape::UNDEFINED_DIM == x; })) {
+    if (!strides.empty() && !emptyDesc && std::none_of(strides.begin(), strides.end(), [](size_t x) {
+            return Shape::UNDEFINED_DIM == x;
+        })) {
         bool inner_block_are_dense = one_of(strides.back(), 0u, 1u);  // stride 1 - is dense case, 0 - broad casted
         for (size_t i = outer_ndims; i < strides.size() - 1; i++) {
             inner_block_are_dense &= (strides[i] == strides[i + 1] * blockedDims[i + 1]);
@@ -164,8 +180,10 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(ov::element::Type prc, const Shape&
     std::copy(dims.begin(), dims.end(), desc.get()->dims);
 
     if (!offsetPaddingToData.empty()) {
-        bool inner_pad_offsets_is_zero = std::all_of(offsetPaddingToData.begin() + outer_ndims, offsetPaddingToData.end(),
-                                                     [](size_t pad) { return pad == 0; });
+        bool inner_pad_offsets_is_zero =
+            std::all_of(offsetPaddingToData.begin() + outer_ndims, offsetPaddingToData.end(), [](size_t pad) {
+                return pad == 0;
+            });
 
         if (!inner_pad_offsets_is_zero)
             OPENVINO_THROW("Can not construct DnnlBlockedMemoryDesc, inner pad offsets is not zero: ",
@@ -189,7 +207,7 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(ov::element::Type prc, const Shape&
     }
 
     // Fill blocking desc
-    auto &dnn_blk_desc = desc.get()->format_desc.blocking;
+    auto& dnn_blk_desc = desc.get()->format_desc.blocking;
     dnn_blk_desc.inner_nblks = inner_ndims;
     std::copy(dnnlBlkDims.end() - inner_ndims, dnnlBlkDims.end(), dnn_blk_desc.inner_blks);
     std::copy(order.end() - inner_ndims, order.end(), dnn_blk_desc.inner_idxs);
@@ -209,8 +227,10 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(ov::element::Type prc, const Shape&
     }
 }
 
-DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(const Shape& shape, dnnl::memory::data_type dataType, dnnl::memory::format_tag format) :
-        MemoryDesc(shape, DnnlBlocked) {
+DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(const Shape& shape,
+                                             dnnl::memory::data_type dataType,
+                                             dnnl::memory::format_tag format)
+    : MemoryDesc(shape, DnnlBlocked) {
     using namespace dnnl;
     if (format == memory::format_tag::any || format == memory::format_tag::undef)
         OPENVINO_THROW("Unexpected: Can't create dnnl::desc with any or undef format");
@@ -249,7 +269,7 @@ bool DnnlBlockedMemoryDesc::isCompatible(const MemoryDesc& rhs) const {
     }
 }
 
-bool DnnlBlockedMemoryDesc::isCompatible(const BlockedMemoryDesc &rhs, CmpMask cmpMask) const {
+bool DnnlBlockedMemoryDesc::isCompatible(const BlockedMemoryDesc& rhs, CmpMask cmpMask) const {
     if (auto desc = dynamic_cast<const DnnlBlockedMemoryDesc*>(&rhs)) {
         return isCompatible(*desc, cmpMask);
     } else if (auto desc = dynamic_cast<const CpuBlockedMemoryDesc*>(&rhs)) {
@@ -261,7 +281,8 @@ bool DnnlBlockedMemoryDesc::isCompatible(const BlockedMemoryDesc &rhs, CmpMask c
 
 bool DnnlBlockedMemoryDesc::isCompatible(const CpuBlockedMemoryDesc& rhs, CmpMask cmpMask) const {
     dnnl::impl::memory_desc_wrapper wrapped(desc.get());
-    return wrapped.extra().flags == dnnl_memory_extra_flag_none && BlockedMemoryDesc::isCompatibleInternal(rhs, cmpMask);
+    return wrapped.extra().flags == dnnl_memory_extra_flag_none &&
+           BlockedMemoryDesc::isCompatibleInternal(rhs, cmpMask);
 }
 
 bool DnnlBlockedMemoryDesc::isCompatible(const DnnlBlockedMemoryDesc& rhs, CmpMask cmpMask) const {
@@ -288,8 +309,10 @@ bool DnnlBlockedMemoryDesc::isCompatible(const DnnlBlockedMemoryDesc& rhs, CmpMa
 
     const auto thisExtra = wrappedThis.extra();
     const auto rhsExtra = wrappedRhs.extra();
-    return this->getOrder() == rhs.getOrder() && (thisExtra.flags == rhsExtra.flags && thisExtra.compensation_mask == rhsExtra.compensation_mask &&
-           thisExtra.scale_adjust == rhsExtra.scale_adjust) && wrappedThis.similar_to(wrappedRhs, true, true, 0, true, checkOffset, stride_mask);
+    return this->getOrder() == rhs.getOrder() &&
+           (thisExtra.flags == rhsExtra.flags && thisExtra.compensation_mask == rhsExtra.compensation_mask &&
+            thisExtra.scale_adjust == rhsExtra.scale_adjust) &&
+           wrappedThis.similar_to(wrappedRhs, true, true, 0, true, checkOffset, stride_mask);
 }
 
 static VectorDims extractOrder(const dnnl::memory::desc& desc) {
@@ -300,7 +323,7 @@ static VectorDims extractOrder(const dnnl::memory::desc& desc) {
         OPENVINO_THROW("Unexpected: Cannot calculate order from undefined dims or strides");
     }
 
-    const auto &blk_desc = descWrapped.blocking_desc();
+    const auto& blk_desc = descWrapped.blocking_desc();
 
     const size_t outer_ndims = dims.size();
     const size_t inner_ndims = blk_desc.inner_nblks;
@@ -319,11 +342,11 @@ static VectorDims extractOrder(const dnnl::memory::desc& desc) {
     // order of outer dims. In case of IOhw_ will be {1, 0, 2, 3}
     VectorDims outer_order(outer_ndims);
     std::iota(outer_order.begin(), outer_order.end(), 0);
-    std::sort(outer_order.begin(), outer_order.end(),
-              [&blk_desc, &outer_block_dims](size_t ind_l, size_t ind_r) {
-                  return (blk_desc.strides[ind_l] > blk_desc.strides[ind_r]) ||
-                         (blk_desc.strides[ind_l] == blk_desc.strides[ind_r] && outer_block_dims[ind_l] > outer_block_dims[ind_r]);
-              });
+    std::sort(outer_order.begin(), outer_order.end(), [&blk_desc, &outer_block_dims](size_t ind_l, size_t ind_r) {
+        return (blk_desc.strides[ind_l] > blk_desc.strides[ind_r]) ||
+               (blk_desc.strides[ind_l] == blk_desc.strides[ind_r] &&
+                outer_block_dims[ind_l] > outer_block_dims[ind_r]);
+    });
 
     // blocked order
     // [new_outer_order] U [inner_idxs]
@@ -333,8 +356,8 @@ static VectorDims extractOrder(const dnnl::memory::desc& desc) {
     return blk_order;
 }
 
-DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(const_dnnl_memory_desc_t cdesc) :
-    MemoryDesc(DnnlExtensionUtils::convertToVectorDims(cdesc->dims, cdesc->ndims), DnnlBlocked) {
+DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(const_dnnl_memory_desc_t cdesc)
+    : MemoryDesc(DnnlExtensionUtils::convertToVectorDims(cdesc->dims, cdesc->ndims), DnnlBlocked) {
     desc = dnnl::memory::desc(DnnlExtensionUtils::clone_desc(cdesc));
 
     if (desc.get_format_kind() == dnnl::memory::format_kind::any)
@@ -356,16 +379,16 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(const_dnnl_memory_desc_t cdesc) :
 
 bool DnnlBlockedMemoryDesc::hasLayoutType(LayoutType layoutType) const {
     switch (layoutType) {
-        case LayoutType::ncsp:
-            return isPlainFormat();
-        case LayoutType::nspc:
-            return isTailCFormat();
-        case LayoutType::nCsp8c:
-            return isBlockedCFormat(8);
-        case LayoutType::nCsp16c:
-            return isBlockedCFormat(16);
-        default:
-            return false;
+    case LayoutType::ncsp:
+        return isPlainFormat();
+    case LayoutType::nspc:
+        return isTailCFormat();
+    case LayoutType::nCsp8c:
+        return isBlockedCFormat(8);
+    case LayoutType::nCsp16c:
+        return isBlockedCFormat(16);
+    default:
+        return false;
     }
 }
 
@@ -382,8 +405,7 @@ bool DnnlBlockedMemoryDesc::isPlainFormat() const {
 }
 
 bool DnnlBlockedMemoryDesc::isBlockedCFormat(size_t blk_size) const {
-    if (desc.get_format_kind()   != dnnl::memory::format_kind::blocked ||
-        desc.get_inner_nblks()   != 1 ||
+    if (desc.get_format_kind() != dnnl::memory::format_kind::blocked || desc.get_inner_nblks() != 1 ||
         desc.get_inner_idxs()[0] != 1)
         return false;
 
@@ -452,13 +474,15 @@ static dnnl::memory::desc cloneDescWithNewDims(const dnnl::memory::desc& desc,
     return newMklDesc;
 }
 
-MemoryDescPtr DnnlBlockedMemoryDesc::cloneWithNewDimsImp(const VectorDims &dims) const {
-    if (std::any_of(dims.begin(), dims.end(), [](size_t x){ return Shape::UNDEFINED_DIM == x; })) {
+MemoryDescPtr DnnlBlockedMemoryDesc::cloneWithNewDimsImp(const VectorDims& dims) const {
+    if (std::any_of(dims.begin(), dims.end(), [](size_t x) {
+            return Shape::UNDEFINED_DIM == x;
+        })) {
         OPENVINO_THROW("Can't clone desc if new dims are undefined");
     }
 
     // TODO [DS]: add stride recalculation for strided blobs
-    for (int i = strides.size() - 2; i >= 0 ; i--) {
+    for (int i = strides.size() - 2; i >= 0; i--) {
         if (strides[i] == Shape::UNDEFINED_DIM)
             break;
 
@@ -499,7 +523,7 @@ bool DnnlBlockedMemoryDesc::isSame(dnnl::memory::format_tag fmt) const {
     {
         const auto dims = desc.get_dims();
         VectorDims total_block_per_dim(dims.size(), 1);
-        const auto &blk_desc = desc.get()->format_desc.blocking;
+        const auto& blk_desc = desc.get()->format_desc.blocking;
         for (int i = 0; i < blk_desc.inner_nblks; i++) {
             total_block_per_dim[blk_desc.inner_idxs[i]] *= blk_desc.inner_blks[i];
         }
@@ -509,10 +533,12 @@ bool DnnlBlockedMemoryDesc::isSame(dnnl::memory::format_tag fmt) const {
         }
 
         std::iota(actualOrder.begin(), actualOrder.end(), 0);
-        std::sort(actualOrder.begin(), actualOrder.end(),
-                  [&actualStrides, &outer_block_dims] (size_t ind_l, size_t ind_r) {
+        std::sort(actualOrder.begin(),
+                  actualOrder.end(),
+                  [&actualStrides, &outer_block_dims](size_t ind_l, size_t ind_r) {
                       return (actualStrides[ind_l] > actualStrides[ind_r]) ||
-                             (actualStrides[ind_l] == actualStrides[ind_r] && outer_block_dims[ind_l] > outer_block_dims[ind_r]);
+                             (actualStrides[ind_l] == actualStrides[ind_r] &&
+                              outer_block_dims[ind_l] > outer_block_dims[ind_r]);
                   });
     }
 
@@ -520,7 +546,7 @@ bool DnnlBlockedMemoryDesc::isSame(dnnl::memory::format_tag fmt) const {
     {
         const auto dims = refDesc.get_dims();
         VectorDims total_block_per_dim(dims.size(), 1);
-        const auto &blk_desc = refDesc.get()->format_desc.blocking;
+        const auto& blk_desc = refDesc.get()->format_desc.blocking;
         for (int i = 0; i < blk_desc.inner_nblks; i++) {
             total_block_per_dim[blk_desc.inner_idxs[i]] *= blk_desc.inner_blks[i];
         }
@@ -530,11 +556,10 @@ bool DnnlBlockedMemoryDesc::isSame(dnnl::memory::format_tag fmt) const {
         }
 
         std::iota(refOrder.begin(), refOrder.end(), 0);
-        std::sort(refOrder.begin(), refOrder.end(),
-                  [&refStrides, &outer_block_dims] (size_t ind_l, size_t ind_r) {
-                      return (refStrides[ind_l] > refStrides[ind_r]) ||
-                             (refStrides[ind_l] == refStrides[ind_r] && outer_block_dims[ind_l] > outer_block_dims[ind_r]);
-                  });
+        std::sort(refOrder.begin(), refOrder.end(), [&refStrides, &outer_block_dims](size_t ind_l, size_t ind_r) {
+            return (refStrides[ind_l] > refStrides[ind_r]) ||
+                   (refStrides[ind_l] == refStrides[ind_r] && outer_block_dims[ind_l] > outer_block_dims[ind_r]);
+        });
     }
 
     if (actualOrder != refOrder) {
@@ -549,7 +574,9 @@ size_t DnnlBlockedMemoryDesc::getMaxMemSize() const {
     }
 
     const auto& maxDims = shape.getMaxDims();
-    if (std::any_of(maxDims.begin(), maxDims.end(), [](size_t x){ return Shape::UNDEFINED_DIM == x; })) {
+    if (std::any_of(maxDims.begin(), maxDims.end(), [](size_t x) {
+            return Shape::UNDEFINED_DIM == x;
+        })) {
         return UNDEFINED_SIZE;
     }
 
@@ -563,11 +590,13 @@ size_t DnnlBlockedMemoryDesc::getPaddedElementsCount() const {
     }
 
     auto padded_dims = desc.get_padded_dims();
-    if (std::any_of(std::begin(padded_dims), std::begin(padded_dims) + desc.get_ndims(),
-            [](dnnl_dim_t dim) { return dim == DNNL_RUNTIME_DIM_VAL; })) {
+    if (std::any_of(std::begin(padded_dims), std::begin(padded_dims) + desc.get_ndims(), [](dnnl_dim_t dim) {
+            return dim == DNNL_RUNTIME_DIM_VAL;
+        })) {
         OPENVINO_THROW("Can't compute padded elements count for non undefined blocked dims");
     }
-    return std::accumulate(std::begin(padded_dims), std::begin(padded_dims) + desc.get_ndims(),
+    return std::accumulate(std::begin(padded_dims),
+                           std::begin(padded_dims) + desc.get_ndims(),
                            size_t{1},
                            std::multiplies<int64_t>());
 }
@@ -586,7 +615,7 @@ void DnnlBlockedMemoryDesc::initBlockDims() {
     const auto dims = desc.get_dims();
 
     const size_t outer_ndims = dims.size();
-    const auto inner_ndims =   desc.get_inner_nblks();
+    const auto inner_ndims = desc.get_inner_nblks();
     const size_t total_ndims = outer_ndims + inner_ndims;
 
     // total inner block size. in case of 4i16o4i will be {16, 16, 1, 1}
@@ -612,10 +641,10 @@ void DnnlBlockedMemoryDesc::initBlockDims() {
     std::copy(order.begin(), order.begin() + outer_ndims, outer_order.begin());
 
     blockedDims.resize(total_ndims, 0);
-    std::copy(inner_blks.begin(), inner_blks.begin() + inner_nblks,
-              blockedDims.end() - inner_nblks);
-    std::transform(outer_order.begin(), outer_order.end(), blockedDims.begin(),
-                   [&] (size_t i) { return outer_block_dims[i]; });
+    std::copy(inner_blks.begin(), inner_blks.begin() + inner_nblks, blockedDims.end() - inner_nblks);
+    std::transform(outer_order.begin(), outer_order.end(), blockedDims.begin(), [&](size_t i) {
+        return outer_block_dims[i];
+    });
 }
 
 void DnnlBlockedMemoryDesc::initStrides() {
@@ -623,7 +652,7 @@ void DnnlBlockedMemoryDesc::initStrides() {
 
     const size_t outer_ndims = dims.size();
     const size_t inner_nblks = desc.get_inner_nblks();
-    const auto   inner_blks  = desc.get_inner_blks();
+    const auto inner_blks = desc.get_inner_blks();
     const size_t total_ndims = outer_ndims + inner_nblks;
 
     // strides of inner dims. In case of 4i16o4i will be {64, 4, 1}
@@ -642,8 +671,9 @@ void DnnlBlockedMemoryDesc::initStrides() {
     std::copy(inner_strides.rbegin(), inner_strides.rend(), strides.rbegin());
 
     const auto desc_strides = desc.get_strides();
-    std::transform(outer_order.begin(), outer_order.end(), strides.begin(),
-                   [&](size_t i) { return desc_strides[i] == DNNL_RUNTIME_DIM_VAL ? Shape::UNDEFINED_DIM : desc_strides[i]; });
+    std::transform(outer_order.begin(), outer_order.end(), strides.begin(), [&](size_t i) {
+        return desc_strides[i] == DNNL_RUNTIME_DIM_VAL ? Shape::UNDEFINED_DIM : desc_strides[i];
+    });
 }
 
 void DnnlBlockedMemoryDesc::initOffsetPadding() {
@@ -659,15 +689,17 @@ MemoryDescPtr DnnlBlockedMemoryDesc::cloneWithNewPrecision(const ov::element::Ty
 }
 
 void DnnlBlockedMemoryDesc::recomputeDefaultStrides() {
-    const auto &rank = getShape().getRank();
+    const auto& rank = getShape().getRank();
 
     if (order.size() != blockedDims.size())
         OPENVINO_THROW("Can't recompute stride: order size != blocked dims size");
 
-    auto &oneDnnStrides = desc.get()->format_desc.blocking.strides;
+    auto& oneDnnStrides = desc.get()->format_desc.blocking.strides;
     if (getShape().hasZeroDims()) {
         std::fill(std::begin(oneDnnStrides), std::begin(oneDnnStrides) + getShape().getRank(), 0);
-    } else if (std::any_of(blockedDims.begin(), blockedDims.end(), [](Dim val) { return val == Shape::UNDEFINED_DIM; })) {
+    } else if (std::any_of(blockedDims.begin(), blockedDims.end(), [](Dim val) {
+                   return val == Shape::UNDEFINED_DIM;
+               })) {
         std::fill(std::begin(oneDnnStrides), std::begin(oneDnnStrides) + rank, DNNL_RUNTIME_DIM_VAL);
         initStrides();
     } else {
@@ -682,8 +714,8 @@ void DnnlBlockedMemoryDesc::recomputeDefaultStrides() {
     }
 }
 
-DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(const dnnl::memory::desc& mdesc, const Shape& shape) :
-        MemoryDesc(shape, DnnlBlocked) {
+DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(const dnnl::memory::desc& mdesc, const Shape& shape)
+    : MemoryDesc(shape, DnnlBlocked) {
     if (mdesc.get_format_kind() == dnnl::memory::format_kind::any)
         OPENVINO_THROW("Unexpected: Memory format any is prohibited!");
 
@@ -715,5 +747,5 @@ std::string DnnlBlockedMemoryDesc::serializeFormat() const {
     return BlockedMemoryDesc::serializeFormat();
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/memory_desc/dnnl_blocked_memory_desc.h b/src/plugins/intel_cpu/src/memory_desc/dnnl_blocked_memory_desc.h
index a6c6a3297ba044..91388c12e2abf7 100644
--- a/src/plugins/intel_cpu/src/memory_desc/dnnl_blocked_memory_desc.h
+++ b/src/plugins/intel_cpu/src/memory_desc/dnnl_blocked_memory_desc.h
@@ -4,19 +4,20 @@
 
 #pragma once
 
+#include <common/memory_desc_wrapper.hpp>
+
+#include "dnnl_extension_utils.h"
 #include "dnnl_memory_desc.h"
 #include "memory_desc/blocked_memory_desc.h"
 #include "openvino/util/util.hpp"
-#include "dnnl_extension_utils.h"
-#include <common/memory_desc_wrapper.hpp>
 
 namespace ov {
 namespace intel_cpu {
 
 class CpuBlockedMemoryDesc;
 
-OPENVINO_DISABLE_WARNING_MSVC_BEGIN(4250)  // Visual Studio warns us about inheritance via dominance but it's done intentionally
-                                           // so turn it off
+OPENVINO_DISABLE_WARNING_MSVC_BEGIN(4250)  // Visual Studio warns us about inheritance via dominance but it's done
+                                           // intentionally so turn it off
 class DnnlBlockedMemoryDesc : public BlockedMemoryDesc, public DnnlMemoryDesc {
 public:
     // Creates planar DnnlBlockedMemoryDesc
@@ -30,8 +31,8 @@ class DnnlBlockedMemoryDesc : public BlockedMemoryDesc, public DnnlMemoryDesc {
 
     bool isCompatible(const MemoryDesc& rhs) const override;
     bool isCompatible(const BlockedMemoryDesc& rhs, CmpMask cmpMask) const override;
-    bool isCompatible(const CpuBlockedMemoryDesc &rhs, CmpMask cmpMask = FULL_MASK) const;
-    bool isCompatible(const DnnlBlockedMemoryDesc &rhs, CmpMask cmpMask = FULL_MASK) const;
+    bool isCompatible(const CpuBlockedMemoryDesc& rhs, CmpMask cmpMask = FULL_MASK) const;
+    bool isCompatible(const DnnlBlockedMemoryDesc& rhs, CmpMask cmpMask = FULL_MASK) const;
 
     const VectorDims& getBlockDims() const override {
         return blockedDims;
@@ -63,17 +64,22 @@ class DnnlBlockedMemoryDesc : public BlockedMemoryDesc, public DnnlMemoryDesc {
 
     MemoryDescPtr cloneWithNewPrecision(const ov::element::Type prec) const override;
 
-    using DnnlMemoryDesc::setPrecision;
     using DnnlMemoryDesc::getPrecision;
+    using DnnlMemoryDesc::setPrecision;
 
 private:
-    DnnlBlockedMemoryDesc(ov::element::Type prc, const Shape& shape, const VectorDims& blockedDims,
-                          const VectorDims& order, size_t offsetPadding = 0, const VectorDims& offsetPaddingToData = {},
+    DnnlBlockedMemoryDesc(ov::element::Type prc,
+                          const Shape& shape,
+                          const VectorDims& blockedDims,
+                          const VectorDims& order,
+                          size_t offsetPadding = 0,
+                          const VectorDims& offsetPaddingToData = {},
                           const VectorDims& strides = {});
 
-    // Creates DnnlBlockedMemoryDesc using the shape parameter as a true shape but all other params (layout, blocks, etc.) are used from the mdesc, but
-    // the mdesc own shape is ignored. The main purpose of this constructor is making dynamic descriptor from some dummy mdesc, which stores info about
-    // layout, blocking, strides, etc., and the provided dynamic shape.
+    // Creates DnnlBlockedMemoryDesc using the shape parameter as a true shape but all other params (layout, blocks,
+    // etc.) are used from the mdesc, but the mdesc own shape is ignored. The main purpose of this constructor is making
+    // dynamic descriptor from some dummy mdesc, which stores info about layout, blocking, strides, etc., and the
+    // provided dynamic shape.
     DnnlBlockedMemoryDesc(const dnnl::memory::desc& mdesc, const Shape& shape);
 
     explicit DnnlBlockedMemoryDesc(const_dnnl_memory_desc_t cdesc);
@@ -84,7 +90,8 @@ class DnnlBlockedMemoryDesc : public BlockedMemoryDesc, public DnnlMemoryDesc {
     bool isBlockedCFormat(size_t blk_size = UNREACHABLE_DIM) const;
     bool isTailCFormat() const;
 
-    // WA: we need to initialize blocked params into ctor to avoid bugs when we calculate these params in throughput mode
+    // WA: we need to initialize blocked params into ctor to avoid bugs when we calculate these params in throughput
+    // mode
     // TODO [DS]: should be reimplemented to avoid useless calculation
     void initBlockedParams() {
         initBlockDims();
@@ -99,7 +106,8 @@ class DnnlBlockedMemoryDesc : public BlockedMemoryDesc, public DnnlMemoryDesc {
     void recomputeDefaultStrides();
 
     friend DnnlMemoryDescPtr DnnlExtensionUtils::makeDescriptor(const_dnnl_memory_desc_t desc);
-    friend std::shared_ptr<DnnlBlockedMemoryDesc> DnnlExtensionUtils::makeUndefinedDesc(const dnnl::memory::desc &desc, const Shape& shape);
+    friend std::shared_ptr<DnnlBlockedMemoryDesc> DnnlExtensionUtils::makeUndefinedDesc(const dnnl::memory::desc& desc,
+                                                                                        const Shape& shape);
     friend class MemoryDescUtils;
 };
 OPENVINO_DISABLE_WARNING_MSVC_END(4250)
@@ -107,5 +115,5 @@ OPENVINO_DISABLE_WARNING_MSVC_END(4250)
 using DnnlBlockedMemoryDescPtr = std::shared_ptr<DnnlBlockedMemoryDesc>;
 using DnnlBlockedMemoryDescCPtr = std::shared_ptr<const DnnlBlockedMemoryDesc>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/memory_desc/dnnl_memory_desc.cpp b/src/plugins/intel_cpu/src/memory_desc/dnnl_memory_desc.cpp
index 3e3af41cfc523a..375b218272ed57 100644
--- a/src/plugins/intel_cpu/src/memory_desc/dnnl_memory_desc.cpp
+++ b/src/plugins/intel_cpu/src/memory_desc/dnnl_memory_desc.cpp
@@ -3,20 +3,21 @@
 //
 
 #include "dnnl_memory_desc.h"
-#include "dnnl_extension_utils.h"
+
 #include <common/memory_desc.hpp>
 #include <common/memory_desc_wrapper.hpp>
+
+#include "dnnl_extension_utils.h"
 #include "onednn/dnnl.h"
 
 namespace ov {
 namespace intel_cpu {
 
-DnnlMemoryDesc::DnnlMemoryDesc(const dnnl::memory::desc& desc) :
-    DnnlMemoryDesc(desc.get()) {}
+DnnlMemoryDesc::DnnlMemoryDesc(const dnnl::memory::desc& desc) : DnnlMemoryDesc(desc.get()) {}
 
-DnnlMemoryDesc::DnnlMemoryDesc(const_dnnl_memory_desc_t cdesc) :
-    MemoryDesc(Shape(DnnlExtensionUtils::convertToVectorDims(cdesc->dims, cdesc->ndims)), Dnnl),
-    desc(DnnlExtensionUtils::clone_desc(cdesc)) {
+DnnlMemoryDesc::DnnlMemoryDesc(const_dnnl_memory_desc_t cdesc)
+    : MemoryDesc(Shape(DnnlExtensionUtils::convertToVectorDims(cdesc->dims, cdesc->ndims)), Dnnl),
+      desc(DnnlExtensionUtils::clone_desc(cdesc)) {
     if (getFormatKind() == dnnl::memory::format_kind::any)
         OPENVINO_THROW("Unexpected: Memory format any is prohibited!");
 }
@@ -35,7 +36,7 @@ MemoryDescPtr DnnlMemoryDesc::cloneWithNewPrecision(const ov::element::Type prec
     return newDesc;
 }
 
-bool DnnlMemoryDesc::isCompatible(const MemoryDesc &rhs) const {
+bool DnnlMemoryDesc::isCompatible(const MemoryDesc& rhs) const {
     if (MemoryDescType::Dnnl & rhs.getType()) {
         auto* dnnMemDesc = rhs.as<DnnlMemoryDesc>();
         return isCompatible(*dnnMemDesc);
@@ -52,17 +53,25 @@ std::string DnnlMemoryDesc::serializeFormat() const {
     dnnl::impl::memory_desc_wrapper wrapped(desc.get());
     if (wrapped.is_wino_desc()) {
         switch (desc.get()->format_desc.wino_desc.wino_format) {
-            case dnnl::impl::wino_memory_format_t::wino_wei_aaOio: return "wino_aaOio";
-            case dnnl::impl::wino_memory_format_t::wino_wei_aaOBiOo: return "wino_aaOBiOo";
-            case dnnl::impl::wino_memory_format_t::wino_wei_OBaaIBOIio: return "wino_OBaaIBOIio";
-            default: return "wino_undef";
+        case dnnl::impl::wino_memory_format_t::wino_wei_aaOio:
+            return "wino_aaOio";
+        case dnnl::impl::wino_memory_format_t::wino_wei_aaOBiOo:
+            return "wino_aaOBiOo";
+        case dnnl::impl::wino_memory_format_t::wino_wei_OBaaIBOIio:
+            return "wino_OBaaIBOIio";
+        default:
+            return "wino_undef";
         }
     } else if (wrapped.is_rnn_packed_desc()) {
         switch (desc.get()->format_desc.rnn_packed_desc.format) {
-            case dnnl::impl::rnn_packed_format::ldigo_p: return "packed_ldigo";
-            case dnnl::impl::rnn_packed_format::ldgoi_p: return "packed_ldgoi";
-            case dnnl::impl::rnn_packed_format::ldio_p: return "packed_ldio";
-            default: return "packed_undef";
+        case dnnl::impl::rnn_packed_format::ldigo_p:
+            return "packed_ldigo";
+        case dnnl::impl::rnn_packed_format::ldgoi_p:
+            return "packed_ldgoi";
+        case dnnl::impl::rnn_packed_format::ldio_p:
+            return "packed_ldio";
+        default:
+            return "packed_undef";
         }
     }
     return "undef";
@@ -116,7 +125,7 @@ bool DnnlMemoryDesc::isDefinedImp() const {
     return wrappedThis.offset0() != DNNL_RUNTIME_DIM_VAL;
 }
 
-MemoryDescPtr DnnlMemoryDesc::cloneWithNewDimsImp(const VectorDims &dims) const {
+MemoryDescPtr DnnlMemoryDesc::cloneWithNewDimsImp(const VectorDims& dims) const {
     OPENVINO_THROW("Unexpected: Cannot clone non blocked oneDNN desc with new dims");
 }
 
@@ -125,6 +134,5 @@ size_t DnnlMemoryDesc::getOffsetPadding() const {
     return DnnlExtensionUtils::convertToDim(wrap.offset0());
 }
 
-
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/memory_desc/dnnl_memory_desc.h b/src/plugins/intel_cpu/src/memory_desc/dnnl_memory_desc.h
index f2722a5170f871..6b3692c5663078 100644
--- a/src/plugins/intel_cpu/src/memory_desc/dnnl_memory_desc.h
+++ b/src/plugins/intel_cpu/src/memory_desc/dnnl_memory_desc.h
@@ -4,11 +4,11 @@
 
 #pragma once
 
-#include "dnnl_extension_utils.h"
 #include <common/memory_desc.hpp>
 #include <oneapi/dnnl/dnnl.hpp>
-#include "memory_desc/cpu_memory_desc.h"
+
 #include "dnnl_extension_utils.h"
+#include "memory_desc/cpu_memory_desc.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -29,13 +29,17 @@ class DnnlMemoryDesc : public virtual MemoryDesc {
     bool isCompatible(const MemoryDesc& rhs) const override;
     bool isCompatible(const DnnlMemoryDesc& rhs) const;
 
-    bool hasLayoutType(LayoutType layoutType) const override { return false; }
+    bool hasLayoutType(LayoutType layoutType) const override {
+        return false;
+    }
 
     std::string serializeFormat() const override;
 
     size_t getMaxMemSize() const override;
 
-    virtual bool isSame(dnnl::memory::format_tag fmt) const { return false; }
+    virtual bool isSame(dnnl::memory::format_tag fmt) const {
+        return false;
+    }
 
     const dnnl::memory::desc& getDnnlDesc() const {
         return desc;
@@ -70,10 +74,9 @@ class DnnlMemoryDesc : public virtual MemoryDesc {
     bool isDefinedImp() const override;
     MemoryDescPtr cloneWithNewDimsImp(const VectorDims& dims) const override;
 
-    friend DnnlMemoryDescPtr DnnlExtensionUtils::makeDescriptor(const dnnl::memory::desc &desc);
+    friend DnnlMemoryDescPtr DnnlExtensionUtils::makeDescriptor(const dnnl::memory::desc& desc);
     friend DnnlMemoryDescPtr DnnlExtensionUtils::makeDescriptor(const_dnnl_memory_desc_t desc);
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
-
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/memory_desc/empty_memory_desc.h b/src/plugins/intel_cpu/src/memory_desc/empty_memory_desc.h
index 1575841cb2be9e..c26cc6aa33a251 100644
--- a/src/plugins/intel_cpu/src/memory_desc/empty_memory_desc.h
+++ b/src/plugins/intel_cpu/src/memory_desc/empty_memory_desc.h
@@ -5,7 +5,6 @@
 #pragma once
 
 #include "cpu_memory_desc.h"
-
 #include "cpu_shape.h"
 #include "openvino/core/except.hpp"
 #include "openvino/core/type/element_type.hpp"
@@ -23,8 +22,7 @@ namespace intel_cpu {
  */
 class EmptyMemoryDesc : public MemoryDesc {
 public:
-    EmptyMemoryDesc():
-        MemoryDesc(Shape{0}, Empty) {
+    EmptyMemoryDesc() : MemoryDesc(Shape{0}, Empty) {
         /* status never changes for an empty memory desc
          * so "define" beforehand to ensure isDefined() is thread safe */
         status = MemoryDesc::descStatus::Defined;
@@ -60,7 +58,9 @@ class EmptyMemoryDesc : public MemoryDesc {
 
     MemoryDescPtr cloneWithNewPrecision(const ov::element::Type prec) const override {
         OPENVINO_ASSERT(prec == ov::element::undefined,
-                        "Clone an empty memory desc with defined precision: ", prec, " is prohibited");
+                        "Clone an empty memory desc with defined precision: ",
+                        prec,
+                        " is prohibited");
         return clone();
     }
 
@@ -92,5 +92,5 @@ class EmptyMemoryDesc : public MemoryDesc {
 using EmptyMemoryDescPtr = std::shared_ptr<EmptyMemoryDesc>;
 using EmptyMemoryDescCPtr = std::shared_ptr<const EmptyMemoryDesc>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/memory_state.cpp b/src/plugins/intel_cpu/src/memory_state.cpp
index aa06f4ebd82957..c0dc85c4103ce4 100644
--- a/src/plugins/intel_cpu/src/memory_state.cpp
+++ b/src/plugins/intel_cpu/src/memory_state.cpp
@@ -5,30 +5,33 @@
 #include "memory_state.h"
 
 #include <nodes/common/cpu_convert.h>
+
 #include "cpu_memory.h"
+#include "cpu_tensor.h"
+#include "dnnl_extension_utils.h"
 #include "memory_desc/cpu_blocked_memory_desc.h"
 #include "memory_desc/cpu_memory_desc_utils.h"
-#include "dnnl_extension_utils.h"
-#include "cpu_tensor.h"
-#include "utils/plain_tensor.hpp"
-#include "openvino/core/parallel.hpp"
 #include "nodes/common/cpu_convert.h"
 #include "nodes/kernels/scaled_attn/attn_quant.hpp"
+#include "openvino/core/parallel.hpp"
+#include "utils/plain_tensor.hpp"
 
 using namespace ov::Extensions::Cpu::XARCH;
 
 namespace ov {
 namespace intel_cpu {
 
-VariableStateBase::VariableStateBase(const std::string& name, const MemoryDescPtr& external_desc) :
-    IVariableState{name} , m_external_desc{external_desc} {}
+VariableStateBase::VariableStateBase(const std::string& name, const MemoryDescPtr& external_desc)
+    : IVariableState{name},
+      m_external_desc{external_desc} {}
 
 MemoryDescPtr VariableStateBase::to_static(const MemoryDescPtr& desc) {
     if (!desc->isDefined()) {
         auto&& current_dims = desc->getShape().getDims();
         VectorDims new_dims(current_dims.size());
         std::transform(current_dims.begin(), current_dims.end(), new_dims.begin(), [](Dim x) {
-            return x == Shape::UNDEFINED_DIM ? 0 : x; });
+            return x == Shape::UNDEFINED_DIM ? 0 : x;
+        });
 
         return desc->cloneWithNewDims(new_dims, true);
     }
@@ -71,21 +74,26 @@ ov::SoPtr<ov::ITensor> VariableStateBase::get_state() const {
         return std::make_shared<Tensor>(internal_state_mem());
     }
 
-    //test precision
+    // test precision
     {
         auto internal_prc = current_internal_desc->getPrecision();
         auto tmp_desc = current_ext_desc->cloneWithNewPrecision(internal_prc);
         if (tmp_desc->isCompatible(*current_internal_desc)) {
             auto mem = std::make_shared<Memory>(get_engine(), current_ext_desc);
-            size_t elements_to_convert = internal_state_mem()->getDescWithType<BlockedMemoryDesc>()->getPaddedElementsCount();
+            size_t elements_to_convert =
+                internal_state_mem()->getDescWithType<BlockedMemoryDesc>()->getPaddedElementsCount();
             auto external_prc = current_ext_desc->getPrecision();
 
-            cpu_convert(internal_state_mem()->getData(), mem->getData(), internal_prc, external_prc, elements_to_convert);
+            cpu_convert(internal_state_mem()->getData(),
+                        mem->getData(),
+                        internal_prc,
+                        external_prc,
+                        elements_to_convert);
             return std::make_shared<Tensor>(mem);
         }
     }
 
-    //reorder
+    // reorder
     auto mem = std::make_shared<Memory>(get_engine(), current_ext_desc);
     mem->load(*(internal_state_mem()));
     return std::make_shared<Tensor>(mem);
@@ -108,19 +116,19 @@ void VariableStateBase::commit() {
 VariableStateDoubleBuffer::VariableStateDoubleBuffer(const std::string& name,
                                                      const MemoryPtr& first_buffer,
                                                      const MemoryPtr& second_buffer,
-                                                     const MemoryDescPtr& external_desc) :
-    VariableStateBase(name, external_desc) {
+                                                     const MemoryDescPtr& external_desc)
+    : VariableStateBase(name, external_desc) {
     OPENVINO_ASSERT(first_buffer && second_buffer);
     reset_prime_mem(first_buffer);
     reset_second_mem(second_buffer);
     m_internal_desc = prime_mem()->getDescPtr();
     auto&& shape = m_internal_desc->getShape();
-    //TODO what if by some reason we already have internal static state while the node is dynamic, is it even possible?
+    // TODO what if by some reason we already have internal static state while the node is dynamic, is it even possible?
 
     if (shape.isStatic()) {
         prime_mem()->nullify();
     } else {
-        //in the case of the original desc has dynamic shape we create an empty tensor
+        // in the case of the original desc has dynamic shape we create an empty tensor
         auto new_desc = to_static(m_internal_desc);
         prime_mem()->redefineDesc(new_desc);
     }
@@ -199,11 +207,11 @@ void VariableStateSingleBuffer::commit_impl() {
     // nothing to do
 }
 
-VariableStateKVcache::VariableStateKVcache(
-    const std::string& name,
-    const MemoryDescPtr& external_desc,
-    const BlockedMemoryDescPtr& dense_internal_desc) :
-    VariableStateBase(name, external_desc), m_dense_internal_desc(dense_internal_desc) {
+VariableStateKVcache::VariableStateKVcache(const std::string& name,
+                                           const MemoryDescPtr& external_desc,
+                                           const BlockedMemoryDescPtr& dense_internal_desc)
+    : VariableStateBase(name, external_desc),
+      m_dense_internal_desc(dense_internal_desc) {
     auto&& shape = external_desc->getShape();
 
     OPENVINO_ASSERT(shape.isDynamic(), "VariableStateKVcache is unexpectedly initalized with a static tensor");
@@ -227,7 +235,7 @@ ov::SoPtr<ov::ITensor> VariableStateKVcache::get_state() const {
     OPENVINO_ASSERT(actual_external_desc->getShape().getRank() == 4);
 
     auto&& actual_internal_order = actual_internal_desc->getOrder();
-    //sanity check
+    // sanity check
     OPENVINO_ASSERT(actual_internal_order == m_dense_internal_desc->getOrder());
 
     PlainTensor output, pastkv, beam_table;
@@ -253,20 +261,12 @@ ov::SoPtr<ov::ITensor> VariableStateKVcache::get_state() const {
                             S,
                             m_scale_zp.ptr<float>(m, b_kv, h)[0],
                             m_scale_zp.ptr<float>(m, b_kv, h)[1]);
-            cpu_convert(buffers[ithr].ptr<float>(),
-                        output.ptr_v(m, b, h),
-                        element::f32,
-                        output.m_dt,
-                        S);
+            cpu_convert(buffers[ithr].ptr<float>(), output.ptr_v(m, b, h), element::f32, output.m_dt, S);
         });
     } else {
         parallel_for3d(L0, B, H, [&](size_t m, size_t b, size_t h) {
             auto b_kv = static_cast<size_t>(beam_table.at<int32_t>({b, m}));
-            cpu_convert(pastkv.ptr_v(m, b_kv, h),
-                        output.ptr_v(m, b, h),
-                        pastkv.m_dt,
-                        output.m_dt,
-                        S);
+            cpu_convert(pastkv.ptr_v(m, b_kv, h), output.ptr_v(m, b, h), pastkv.m_dt, output.m_dt, S);
         });
     }
 
@@ -274,11 +274,11 @@ ov::SoPtr<ov::ITensor> VariableStateKVcache::get_state() const {
 }
 
 void VariableStateKVcache::set_state_impl(const ov::SoPtr<ov::ITensor>& state) {
-    //1. reset the memory object
-    m_state = state; // simply to extend the lifetime
+    // 1. reset the memory object
+    m_state = state;  // simply to extend the lifetime
     auto state_desc = MemoryDescUtils::generateCpuBlockedMemoryDesc(m_state);
 
-    //May be optimized by reusing the state tensor underlining memory pointer, but corner cases should be considered
+    // May be optimized by reusing the state tensor underlining memory pointer, but corner cases should be considered
     auto dense_internal_desc = m_dense_internal_desc->cloneWithNewDims(state_desc->getShape().getStaticDims());
 
     m_internal_mem = std::make_shared<Memory>(get_engine(), dense_internal_desc);
@@ -287,7 +287,10 @@ void VariableStateKVcache::set_state_impl(const ov::SoPtr<ov::ITensor>& state) {
     if (dense_internal_desc->getPrecision() == element::u8) {
         PlainTensor external, internal;
         auto&& actual_internal_order = m_dense_internal_desc->getOrder();
-        external.resize(external_mem.getStaticDims(), state_desc->getPrecision().size(), state_desc->getPrecision(), m_state->data());
+        external.resize(external_mem.getStaticDims(),
+                        state_desc->getPrecision().size(),
+                        state_desc->getPrecision(),
+                        m_state->data());
         internal.reset(m_internal_mem);
         external = external.permute(actual_internal_order);
         internal = internal.permute(actual_internal_order);
@@ -300,11 +303,7 @@ void VariableStateKVcache::set_state_impl(const ov::SoPtr<ov::ITensor>& state) {
         m_scale_zp.resize<float>({L0, B, H, 2});
         parallel_for3d(B, H, L0, [&](size_t ithr, size_t b, size_t h, size_t m) {
             buffers[ithr].resize<float>({S});
-            cpu_convert(external.ptr_v(m, b, h),
-                        buffers[ithr].ptr<float>(),
-                        external.m_dt,
-                        element::f32,
-                        S);
+            cpu_convert(external.ptr_v(m, b, h), buffers[ithr].ptr<float>(), external.m_dt, element::f32, S);
             attn_quant_u8(buffers[ithr].ptr<float>(),
                           internal.ptr<uint8_t>(m, b, h),
                           S,
@@ -315,14 +314,13 @@ void VariableStateKVcache::set_state_impl(const ov::SoPtr<ov::ITensor>& state) {
         m_internal_mem->load(external_mem);
     }
 
-    //2. Reset the beam search table
+    // 2. Reset the beam search table
     auto&& state_dims = dense_internal_desc->getShape().getStaticDims();
     auto&& order = m_dense_internal_desc->getOrder();
 
     const size_t size_B = state_dims[order.at(1)];
     const size_t size_L = state_dims[order.at(0)];
-    auto mem_desc =
-        std::make_shared<CpuBlockedMemoryDesc>(ov::element::i32, Shape{size_B, size_L});
+    auto mem_desc = std::make_shared<CpuBlockedMemoryDesc>(ov::element::i32, Shape{size_B, size_L});
 
     m_hidden_state = std::make_shared<Memory>(get_engine(), mem_desc);
     auto buff = m_hidden_state->getDataAs<int>();
@@ -336,11 +334,11 @@ void VariableStateKVcache::set_state_impl(const ov::SoPtr<ov::ITensor>& state) {
 }
 
 void VariableStateKVcache::reset_impl() {
-    //nothing to do
+    // nothing to do
 }
 
 void VariableStateKVcache::commit_impl() {
-    //nothing to do
+    // nothing to do
 }
 
 MemoryPtr VariableStateKVcache::input_mem() {
@@ -352,7 +350,7 @@ MemoryPtr VariableStateKVcache::output_mem() {
 }
 
 MemoryDescPtr VariableStateKVcache::internal_desc() const {
-    return m_dense_internal_desc; //since we don't store initial one
+    return m_dense_internal_desc;  // since we don't store initial one
 }
 
 MemoryPtr VariableStateKVcache::internal_state_mem() const {
diff --git a/src/plugins/intel_cpu/src/memory_state.h b/src/plugins/intel_cpu/src/memory_state.h
index e7493f327e93fa..f35e78989b02f8 100644
--- a/src/plugins/intel_cpu/src/memory_state.h
+++ b/src/plugins/intel_cpu/src/memory_state.h
@@ -29,12 +29,12 @@ class VariableStateBase : public IVariableState {
 public:
     VariableStateBase(const std::string& name, const MemoryDescPtr& external_desc);
 
-    //ov::IVariableState
-    void set_state(const ov::SoPtr<ov::ITensor>& state) override final; // NOLINT
+    // ov::IVariableState
+    void set_state(const ov::SoPtr<ov::ITensor>& state) override final;  // NOLINT
     ov::SoPtr<ov::ITensor> get_state() const override;
-    void reset() override final; // NOLINT
-    bool is_reset_state() const override final; // NOLINT
-    void commit() override final; // NOLINT
+    void reset() override final;                 // NOLINT
+    bool is_reset_state() const override final;  // NOLINT
+    void commit() override final;                // NOLINT
 
 protected:
     virtual MemoryPtr internal_state_mem() const = 0;
@@ -66,7 +66,7 @@ class VariableStateDoubleBuffer : public VariableStateBase {
     MemoryDescPtr internal_desc() const override;
 
 private:
-    //ov::intel_cpu::VariableStateBase
+    // ov::intel_cpu::VariableStateBase
     void reset_impl() override;
     void commit_impl() override;
 
@@ -89,7 +89,7 @@ class VariableStateDoubleBuffer : public VariableStateBase {
     MemoryPtr internal_state_mem() const override;
 
 private:
-    MemoryDescPtr m_internal_desc; //mem desc required by the graph internal tensor
+    MemoryDescPtr m_internal_desc;  // mem desc required by the graph internal tensor
     std::array<MemoryPtr, 2> m_internal_mem{};
     size_t buffer_num = 0;
 };
@@ -111,7 +111,7 @@ class VariableStateSingleBuffer : public VariableStateBase {
     MemoryPtr internal_state_mem() const override;
 
 private:
-    MemoryDescPtr m_internal_desc; //mem desc required by the graph internal tensor
+    MemoryDescPtr m_internal_desc;  // mem desc required by the graph internal tensor
     MemoryPtr m_internal_mem;
 };
 
@@ -121,10 +121,10 @@ class VariableStateKVcache : public VariableStateBase {
                          const MemoryDescPtr& external_desc,
                          const BlockedMemoryDescPtr& dense_internal_desc);
 
-    //ov::IVariableState
+    // ov::IVariableState
     ov::SoPtr<ov::ITensor> get_state() const override;
 
-    //ov::intel_cpu::VariableStateBase
+    // ov::intel_cpu::VariableStateBase
     MemoryPtr input_mem() override;
     MemoryPtr output_mem() override;
     MemoryDescPtr internal_desc() const override;
@@ -158,14 +158,14 @@ class VariableStateKVcache : public VariableStateBase {
     }
 
 private:
-    //ov::intel_cpu::VariableStateBase
+    // ov::intel_cpu::VariableStateBase
     void set_state_impl(const ov::SoPtr<ov::ITensor>& state) override;
     void reset_impl() override;
     void commit_impl() override;
 
 private:
-    MemoryPtr m_internal_mem; // kv cache
-    MemoryPtr m_hidden_state; // beam access table
+    MemoryPtr m_internal_mem;  // kv cache
+    MemoryPtr m_hidden_state;  // beam access table
     size_t m_internal_mem_max_size = 0;
     size_t m_hidden_state_max_size = 0;
 
@@ -178,5 +178,5 @@ class VariableStateKVcache : public VariableStateBase {
 
 using MemStatePtr = std::shared_ptr<IVariableState>;
 using MemStateCPtr = std::shared_ptr<const IVariableState>;
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/mlas/thread_pool.hpp b/src/plugins/intel_cpu/src/mlas/thread_pool.hpp
index 536b3746be1d69..5af8b0cce915fa 100644
--- a/src/plugins/intel_cpu/src/mlas/thread_pool.hpp
+++ b/src/plugins/intel_cpu/src/mlas/thread_pool.hpp
@@ -7,6 +7,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <functional>
+
 #include "mlas.h"
 
 namespace ov {
@@ -17,6 +18,7 @@ class OVMlasThreadPool : public IMlasThreadPool {
     explicit OVMlasThreadPool(const size_t& threadNum) : threadNum(threadNum) {}
     size_t DegreeOfParallelism() override;
     void TrySimpleParallelFor(const std::ptrdiff_t total, const std::function<void(std::ptrdiff_t)>& fn) override;
+
 public:
     // the actual threads used for sgemm
     size_t threadNum = 0;
diff --git a/src/plugins/intel_cpu/src/node.cpp b/src/plugins/intel_cpu/src/node.cpp
index ee0a99c3bba44e..ddf8d068f920a2 100644
--- a/src/plugins/intel_cpu/src/node.cpp
+++ b/src/plugins/intel_cpu/src/node.cpp
@@ -3,39 +3,38 @@
 //
 
 #include "node.h"
-#include "cpu_types.h"
-#include "edge.h"
-#include "partitioned_mem_blk.h"
-#include "openvino/core/type/element_type.hpp"
 
+#include <dnnl_debug.h>
+#include <dnnl_types.h>
+
+#include <common/primitive_desc.hpp>
+#include <common/primitive_desc_iface.hpp>
+#include <cstdint>
 #include <memory>
 #include <oneapi/dnnl/dnnl.hpp>
-#include <vector>
+#include <openvino/opsets/opset1.hpp>
 #include <string>
-#include <cstdint>
 #include <unordered_map>
+#include <vector>
 
+#include "cpu_types.h"
+#include "dnnl_extension_utils.h"
+#include "edge.h"
+#include "memory_desc/cpu_memory_desc_utils.h"
+#include "memory_desc/dnnl_blocked_memory_desc.h"
+#include "nodes/common/cpu_convert.h"
 #include "nodes/conv.h"
 #include "nodes/eltwise.h"
 #include "nodes/input.h"
-#include "nodes/reorder.h"
 #include "nodes/reference.h"
-#include "dnnl_extension_utils.h"
-
+#include "nodes/reorder.h"
+#include "openvino/core/type/element_type.hpp"
+#include "partitioned_mem_blk.h"
+#include "utils/cpu_utils.hpp"
 #include "utils/debug_capabilities.h"
+#include "utils/general_utils.h"
 #include "utils/ngraph_utils.hpp"
 #include "utils/rt_info/memory_formats_attribute.hpp"
-#include <openvino/opsets/opset1.hpp>
-
-#include <dnnl_types.h>
-#include <dnnl_debug.h>
-#include "utils/general_utils.h"
-#include "utils/cpu_utils.hpp"
-#include "nodes/common/cpu_convert.h"
-#include "memory_desc/cpu_memory_desc_utils.h"
-#include "memory_desc/dnnl_blocked_memory_desc.h"
-#include <common/primitive_desc.hpp>
-#include <common/primitive_desc_iface.hpp>
 
 using namespace dnnl;
 using namespace openvino;
@@ -44,7 +43,7 @@ using namespace ov::intel_cpu::node;
 namespace ov {
 namespace intel_cpu {
 
-Node::NodesFactory & Node::factory() {
+Node::NodesFactory& Node::factory() {
     static NodesFactory factoryInstance;
     return factoryInstance;
 }
@@ -63,7 +62,7 @@ Node::Node(const std::shared_ptr<ov::Node>& op,
       type(TypeFromName(op->get_type_name())),
       profiling(op->get_friendly_name()) {
     for (size_t i = 0; i < op->get_input_size(); i++) {
-        const auto &shape = op->get_input_partial_shape(i);
+        const auto& shape = op->get_input_partial_shape(i);
         if (shape.rank().is_dynamic()) {
             OPENVINO_THROW("Unexpected: CPU plug-in doesn't support ",
                            getTypeStr(),
@@ -83,7 +82,7 @@ Node::Node(const std::shared_ptr<ov::Node>& op,
             OPENVINO_THROW("Node with type '", typeStr, "' and name '", name, "' does not have any outputs.");
         }
         for (size_t i = 0; i < op->get_output_size(); i++) {
-            const auto &shape = op->get_output_partial_shape(i);
+            const auto& shape = op->get_output_partial_shape(i);
             if (shape.rank().is_dynamic()) {
                 OPENVINO_THROW("Unexpected: CPU plug-in doesn't support ",
                                getTypeStr(),
@@ -99,8 +98,14 @@ Node::Node(const std::shared_ptr<ov::Node>& op,
         childEdges.reserve(outputShapes.size());
     }
 
-    isDynamic = std::any_of(inputShapes.begin(), inputShapes.end(), [](const Shape& shape){ return shape.isDynamic(); }) ||
-                std::any_of(outputShapes.begin(), outputShapes.end(), [](const Shape& shape){ return shape.isDynamic(); });
+    isDynamic = std::any_of(inputShapes.begin(),
+                            inputShapes.end(),
+                            [](const Shape& shape) {
+                                return shape.isDynamic();
+                            }) ||
+                std::any_of(outputShapes.begin(), outputShapes.end(), [](const Shape& shape) {
+                    return shape.isDynamic();
+                });
 
     if (isDynamic) {
         shapeInference = shapeInferFactory.makeShapeInfer();
@@ -127,12 +132,13 @@ Node::Node(const std::shared_ptr<ov::Node>& op,
             if (str.substr(0, 4) != "cpu:")
                 continue;
             customImplPriorities.push_back(parse_impl_name(str));
-            if (customImplPriorities.back() == impl_desc_type::unknown &&
-                str != "cpu:unknown")
+            if (customImplPriorities.back() == impl_desc_type::unknown && str != "cpu:unknown")
                 OPENVINO_THROW("Unsupported CPU implementation ", str, " for node ", getName());
         }
         const auto& defaultImplPriorities = getDefaultImplPriority();
-        customImplPriorities.insert(customImplPriorities.end(), defaultImplPriorities.begin(), defaultImplPriorities.end());
+        customImplPriorities.insert(customImplPriorities.end(),
+                                    defaultImplPriorities.begin(),
+                                    defaultImplPriorities.end());
     }
 
     std::string inputMemoryFormats = getInputMemoryFormats(op);
@@ -199,10 +205,11 @@ void Node::addEdge(const EdgePtr& edge) {
 }
 
 void Node::remove() {
-    auto drop = [](std::vector<EdgeWeakPtr> edges){
+    auto drop = [](std::vector<EdgeWeakPtr> edges) {
         for (auto& edge : edges) {
             auto edgePtr = edge.lock();
-            if (!edgePtr) continue;
+            if (!edgePtr)
+                continue;
             edgePtr->getParent()->removeChildEdge(edgePtr);
             edgePtr->getChild()->removeParentEdge(edgePtr);
         }
@@ -213,7 +220,7 @@ void Node::remove() {
 }
 
 bool Node::isEdgesEmpty(const std::vector<EdgeWeakPtr>& edges) const {
-    for (auto &edge : edges) {
+    for (auto& edge : edges) {
         if (edge.lock())
             return false;
     }
@@ -265,7 +272,8 @@ void Node::selectPreferPrimitiveDescriptor(const std::vector<impl_desc_type>& pr
                 auto parentEdge = getParentEdgeAt(j);
                 auto parentPtr = parentEdge->getParent();
 
-                // We don't take into account constant edges since reorders on them will be executed on load network stage
+                // We don't take into account constant edges since reorders on them will be executed on load network
+                // stage
                 if (ignoreConstInputs && j > 0 && parentPtr->isConstant()) {
                     equalsLocalFormatCount++;
                     continue;
@@ -286,10 +294,20 @@ void Node::selectPreferPrimitiveDescriptor(const std::vector<impl_desc_type>& pr
                         equalsLocalFormatCount++;
                     }
 
-                    DEBUG_LOG(getName(), " pd[", i, "].inConfs[", j, "]"
-                              " is ", (isCompatible ? "compatible" : "not compatible"),
-                              " with parent ", parentPtr->getName(),
-                              " outConfs[", inNum, "], equalsLocalFormatCount add to ", equalsLocalFormatCount);
+                    DEBUG_LOG(getName(),
+                              " pd[",
+                              i,
+                              "].inConfs[",
+                              j,
+                              "]"
+                              " is ",
+                              (isCompatible ? "compatible" : "not compatible"),
+                              " with parent ",
+                              parentPtr->getName(),
+                              " outConfs[",
+                              inNum,
+                              "], equalsLocalFormatCount add to ",
+                              equalsLocalFormatCount);
                 }
 
                 if (equalsLocalFormatCount > equalsFormatCount) {
@@ -334,7 +352,8 @@ bool Node::isReorderRequired(ov::intel_cpu::MemoryDescPtr desc1, ov::intel_cpu::
     return !(isOneDimShape1 && isOneDimShape2 && samePrec);
 }
 
-void Node::selectPreferPrimitiveDescriptorWithShape(const std::vector<impl_desc_type>& priority, bool ignoreConstInputs) {
+void Node::selectPreferPrimitiveDescriptorWithShape(const std::vector<impl_desc_type>& priority,
+                                                    bool ignoreConstInputs) {
     // Filter out dynamic shape.
     if (isDynamic) {
         return selectPreferPrimitiveDescriptor(priority, ignoreConstInputs);
@@ -371,11 +390,22 @@ void Node::selectPreferPrimitiveDescriptorWithShape(const std::vector<impl_desc_
                     }
                 }
 
-                DEBUG_LOG(getName(), " pd[", i, "].inConfs[", j, "]"
-                          " is ", (isCompatible ? "compatible" : "not compatible"),
-                          " shape is ", (isOneDimShape(curDesc->getShape().toPartialShape()) ? "one dim shape" : "not one dim shape"),
-                          " with parent ", parentPtr->getName(),
-                          " outConfs[", inNum, "], estimate add to ", estimate);
+                DEBUG_LOG(getName(),
+                          " pd[",
+                          i,
+                          "].inConfs[",
+                          j,
+                          "]"
+                          " is ",
+                          (isCompatible ? "compatible" : "not compatible"),
+                          " shape is ",
+                          (isOneDimShape(curDesc->getShape().toPartialShape()) ? "one dim shape" : "not one dim shape"),
+                          " with parent ",
+                          parentPtr->getName(),
+                          " outConfs[",
+                          inNum,
+                          "], estimate add to ",
+                          estimate);
             }
         }
         return estimate;
@@ -443,7 +473,7 @@ bool Node::canBeInPlace() const {
     }
 
     if (getParentEdges().size() != 1 || getParentEdgeAt(0)->getParent()->getChildEdges().size() != 1 ||
-            (getParentEdgeAt(0)->getParent()->isConstant() && !getParentEdgeAt(0)->getChild()->isConstant()))
+        (getParentEdgeAt(0)->getParent()->isConstant() && !getParentEdgeAt(0)->getChild()->isConstant()))
         return false;
 
     // TODO: we need to extend this logic to properly handle all possible inplace conflicts
@@ -463,7 +493,7 @@ bool Node::canBeInPlace() const {
 }
 
 void Node::resolveInPlaceEdges(Edge::LOOK look) {
-    const NodeDesc *selected_pd = getSelectedPrimitiveDescriptor();
+    const NodeDesc* selected_pd = getSelectedPrimitiveDescriptor();
     if (!selected_pd)
         OPENVINO_THROW("Cannot find selected primitive descriptor for node: ", getName());
     if (look & Edge::LOOK_DOWN) {
@@ -478,16 +508,19 @@ void Node::resolveInPlaceEdges(Edge::LOOK look) {
                             " Unexpected inplace resolve call to an allocated edge: ",
                             *parentEdge);
 
-            //search for already allocated edge
+            // search for already allocated edge
             const auto& childEdges = getChildEdgesAtPort(inplaceOutIndx);
-            auto itr = std::find_if(childEdges.begin(), childEdges.end(), [](const EdgePtr& edge) { return edge->getStatus() == Edge::Status::Allocated; });
+            auto itr = std::find_if(childEdges.begin(), childEdges.end(), [](const EdgePtr& edge) {
+                return edge->getStatus() == Edge::Status::Allocated;
+            });
             OPENVINO_ASSERT(itr != childEdges.end(),
                             " Could not find an allocated edge to resolve in-place for node: ",
                             getName());
 
             auto baseMemBlock = (*itr)->getMemory().getMemoryBlock();
             auto memBlock = std::make_shared<PartitionedMemoryBlock>(baseMemBlock);
-            auto newMem = std::make_shared<Memory>(getEngine(), selected_pd->getConfig().inConfs[i].getMemDesc(), memBlock);
+            auto newMem =
+                std::make_shared<Memory>(getEngine(), selected_pd->getConfig().inConfs[i].getMemDesc(), memBlock);
             parentEdge->reuse(newMem);
         }
     }
@@ -506,7 +539,8 @@ void Node::resolveInPlaceEdges(Edge::LOOK look) {
                 OPENVINO_ASSERT(childEdge->getStatus() == Edge::Status::NotAllocated,
                                 " Unexpected inplace resolve call to an allocated edge: ",
                                 *childEdge);
-                auto newMem = std::make_shared<Memory>(getEngine(), selected_pd->getConfig().outConfs[i].getMemDesc(), memBlock);
+                auto newMem =
+                    std::make_shared<Memory>(getEngine(), selected_pd->getConfig().outConfs[i].getMemDesc(), memBlock);
                 childEdge->reuse(newMem);
             }
         }
@@ -566,9 +600,9 @@ std::string Node::getPrimitiveDescriptorType() const {
         str_type += t;
     };
 
-#define SEARCH_TYPE(_type)                                          \
-    if ((type & impl_desc_type::_type) == impl_desc_type::_type)    \
-        add_type(#_type)
+#define SEARCH_TYPE(_type)                                       \
+    if ((type & impl_desc_type::_type) == impl_desc_type::_type) \
+    add_type(#_type)
 
     SEARCH_TYPE(undef);
     SEARCH_TYPE(reorder);
@@ -609,13 +643,19 @@ std::string Node::getPrimitiveDescriptorType() const {
     if (selectedPrimitiveDesc) {
         if (!selectedPrimitiveDesc->getConfig().inConfs.empty()) {
             if (selectedPrimitiveDesc->getConfig().inConfs[0].getMemDesc()->getPrecision() != ov::element::u8) {
-                str_type += "_" + std::string(selectedPrimitiveDesc->getConfig().inConfs[0].getMemDesc()->getPrecision().get_type_name());
+                str_type +=
+                    "_" +
+                    std::string(
+                        selectedPrimitiveDesc->getConfig().inConfs[0].getMemDesc()->getPrecision().get_type_name());
             } else {
                 str_type += "_I8";
             }
         } else {
             if (selectedPrimitiveDesc->getConfig().outConfs[0].getMemDesc()->getPrecision() != ov::element::u8) {
-                str_type += "_" + std::string(selectedPrimitiveDesc->getConfig().outConfs[0].getMemDesc()->getPrecision().get_type_name());
+                str_type +=
+                    "_" +
+                    std::string(
+                        selectedPrimitiveDesc->getConfig().outConfs[0].getMemDesc()->getPrecision().get_type_name());
             } else {
                 str_type += "_I8";
             }
@@ -651,7 +691,7 @@ std::vector<EdgePtr> Node::getChildEdgesAtPort(int inputNum) const {
         OPENVINO_THROW("Node ", getName(), " contains less output ports than ", inputNum);
 
     std::vector<EdgePtr> res;
-    for (auto &edge_w : childEdges) {
+    for (auto& edge_w : childEdges) {
         auto edge = edge_w.lock();
         if (!edge)
             OPENVINO_THROW("Node ", getName(), " contains dead weak ptr");
@@ -661,7 +701,7 @@ std::vector<EdgePtr> Node::getChildEdgesAtPort(int inputNum) const {
     return res;
 }
 
-std::vector<memory::format_tag> Node::getAvailableFormatsForDims(const Shape &dims) const {
+std::vector<memory::format_tag> Node::getAvailableFormatsForDims(const Shape& dims) const {
     if (dims.getRank() == 0)
         return {memory::format_tag::x};
     else if (dims.getRank() == 1)
@@ -669,8 +709,11 @@ std::vector<memory::format_tag> Node::getAvailableFormatsForDims(const Shape &di
     else if (dims.getRank() == 2)
         return {memory::format_tag::nc};
     else if (dims.getRank() == 3)
-        return {memory::format_tag::tnc, memory::format_tag::ntc,
-                memory::format_tag::ncw, memory::format_tag::nCw8c, memory::format_tag::nCw16c };
+        return {memory::format_tag::tnc,
+                memory::format_tag::ntc,
+                memory::format_tag::ncw,
+                memory::format_tag::nCw8c,
+                memory::format_tag::nCw16c};
     else if (dims.getRank() == 4)
         return {memory::format_tag::nchw, memory::format_tag::nChw8c, memory::format_tag::nChw16c};
     else if (dims.getRank() == 5)
@@ -695,36 +738,36 @@ void Node::updateShapes() {
                     getTypeStr(),
                     " with name: ",
                     getName());
-        try {
-            if (needShapeInfer()) {
-                auto result = shapeInfer();
-                if (ShapeInferStatus::success == result.status) {
-                    redefineOutputMemory(result.dims);
+    try {
+        if (needShapeInfer()) {
+            auto result = shapeInfer();
+            if (ShapeInferStatus::success == result.status) {
+                redefineOutputMemory(result.dims);
+            }
+        } else {
+            // guard check for internal dynamic nodes to avoid possible overestimation of the required memory size
+            if (shapeInference && FULL_PORT_MASK == shapeInference->get_port_mask())
+                return;
+
+            for (auto&& edge : getChildEdges()) {
+                auto edge_ptr = edge.lock();
+                CPU_NODE_ASSERT(edge_ptr, " has null edge");
+                if (edge_ptr->inPlace(Edge::LOOK_UP)) {
+                    continue;
                 }
-            } else {
-                //guard check for internal dynamic nodes to avoid possible overestimation of the required memory size
-                if (shapeInference && FULL_PORT_MASK == shapeInference->get_port_mask())
-                    return;
-
-                for (auto&& edge : getChildEdges()) {
-                    auto edge_ptr = edge.lock();
-                    CPU_NODE_ASSERT(edge_ptr, " has null edge");
-                    if (edge_ptr->inPlace(Edge::LOOK_UP)) {
-                        continue;
-                    }
 
-                    auto mem = edge_ptr->getMemoryPtr();
-                    CPU_NODE_ASSERT(mem, " has null output memory");
+                auto mem = edge_ptr->getMemoryPtr();
+                CPU_NODE_ASSERT(mem, " has null output memory");
 
-                    if (mem->getShape().hasZeroDims()) {
-                        continue;
-                    }
-                    fetchRawMemory(mem);
+                if (mem->getShape().hasZeroDims()) {
+                    continue;
                 }
+                fetchRawMemory(mem);
             }
-        } catch (const std::exception& exp) {
-            THROW_CPU_NODE_ERR(exp.what());
         }
+    } catch (const std::exception& exp) {
+        THROW_CPU_NODE_ERR(exp.what());
+    }
 }
 
 void Node::updateDynamicParams() {
@@ -736,10 +779,17 @@ void Node::updateDynamicParams() {
     try {
         if (isExecutable()) {
             if (needPrepareParams()) {
-                OPENVINO_ASSERT(inputShapesDefined(),
-                                "Input shapes are not defined.");
-                DEBUG_LOG(" prepareParams() on #", getExecIndex(), " ", getTypeStr(), " ", algToString(getAlgorithm()),
-                        " ", getName(), " ", getOriginalLayers());
+                OPENVINO_ASSERT(inputShapesDefined(), "Input shapes are not defined.");
+                DEBUG_LOG(" prepareParams() on #",
+                          getExecIndex(),
+                          " ",
+                          getTypeStr(),
+                          " ",
+                          algToString(getAlgorithm()),
+                          " ",
+                          getName(),
+                          " ",
+                          getOriginalLayers());
                 prepareParams();
             }
         }
@@ -782,7 +832,7 @@ bool Node::outputShapeDataDependency() const {
     return false;
 }
 
-void Node::redefineOutputMemory(const std::vector<VectorDims> &newOutputShapes) {
+void Node::redefineOutputMemory(const std::vector<VectorDims>& newOutputShapes) {
     if (newOutputShapes.size() != outputShapes.size()) {
         OPENVINO_THROW("Number shapes mismatch with real outputs number for node with name: ", getName());
     }
@@ -841,34 +891,45 @@ void Node::initSupportedPrimitiveDescriptors() {
     };
 
     /* When custom implementation priorities are NOT defined it is enough to
-    * just use the first implementation from the priority list.
-    * When custom implementation priorities are defined, all the implementations should be considered,
-    * since custom implementations can be not available at all, so a fallback to the default ones must happen
-    * To achive the fallback, it is necessary to create a supported primitive descriptor for each implementation
-    * since oneDNN primitive is mutating while iterating */
+     * just use the first implementation from the priority list.
+     * When custom implementation priorities are defined, all the implementations should be considered,
+     * since custom implementations can be not available at all, so a fallback to the default ones must happen
+     * To achive the fallback, it is necessary to create a supported primitive descriptor for each implementation
+     * since oneDNN primitive is mutating while iterating */
 #ifdef CPU_DEBUG_CAPS
     {
-       if (!customImplPriorities.empty()) {
-            DEBUG_LOG("#", getName(), " customImplPriorities [", 0 , "/", customImplPriorities.size(),
-                        "]: ", impl_type_to_string(customImplPriorities[0]));
-       }
+        if (!customImplPriorities.empty()) {
+            DEBUG_LOG("#",
+                      getName(),
+                      " customImplPriorities [",
+                      0,
+                      "/",
+                      customImplPriorities.size(),
+                      "]: ",
+                      impl_type_to_string(customImplPriorities[0]));
+        }
     }
 #endif
     for (auto& desc : descs) {
         auto first_desc = dnnl::primitive_desc(DnnlExtensionUtils::clone_primitive_desc(desc.get()));
         const bool first_match = customImplPriorities.empty();
-        DEBUG_LOG("#", getName(),
-                       ", itpd.impl_info_str(): ", desc.impl_info_str(),
-                    ", parsed imp_type: ", impl_type_to_string(parse_impl_name(desc.impl_info_str())),
-                    ", first_match: ", first_match ? "true" : "false");
-        DnnlExtensionUtils::for_each_implementation(desc,
-                                                    first_match,
-                                                    [&](impl_desc_type implType) {
-                                                        return contains(getImplPriority(), implType);
-                                                    },
-                                                    [&](dnnl::primitive_desc& desc) {
-                                                        addSupportedPrimitiveDescriptor(desc);
-                                                    });
+        DEBUG_LOG("#",
+                  getName(),
+                  ", itpd.impl_info_str(): ",
+                  desc.impl_info_str(),
+                  ", parsed imp_type: ",
+                  impl_type_to_string(parse_impl_name(desc.impl_info_str())),
+                  ", first_match: ",
+                  first_match ? "true" : "false");
+        DnnlExtensionUtils::for_each_implementation(
+            desc,
+            first_match,
+            [&](impl_desc_type implType) {
+                return contains(getImplPriority(), implType);
+            },
+            [&](dnnl::primitive_desc& desc) {
+                addSupportedPrimitiveDescriptor(desc);
+            });
 
         // fallback. if none of the primitive types is present in the priority list just add first implementation
         // @todo this fallback is not necessary if primitive priority list is filled correctly
@@ -889,22 +950,29 @@ void Node::filterSupportedPrimitiveDescriptors() {
     };
 
     auto isNotSuitableDesc = [&](const NodeDesc& desc) {
-        const auto &config = desc.getConfig();
-        if (inputMemoryFormatsFilter.size() > config.inConfs.size() || outputMemoryFormatsFilter.size() > config.outConfs.size())
+        const auto& config = desc.getConfig();
+        if (inputMemoryFormatsFilter.size() > config.inConfs.size() ||
+            outputMemoryFormatsFilter.size() > config.outConfs.size())
             OPENVINO_THROW("Incorrect number of input or output memory formats");
 
         for (size_t i = 0; i < inputMemoryFormatsFilter.size(); i++) {
             if (!areCompatible(*config.inConfs[i].getMemDesc(), inputMemoryFormatsFilter[i])) {
-                DEBUG_LOG(getName(), " input memory format filter: ", inputMemoryFormatsFilter[i],
-                          " not matched. Erase desc from supported primitive descriptors: ", desc);
+                DEBUG_LOG(getName(),
+                          " input memory format filter: ",
+                          inputMemoryFormatsFilter[i],
+                          " not matched. Erase desc from supported primitive descriptors: ",
+                          desc);
                 return true;
             }
         }
 
         for (size_t i = 0; i < outputMemoryFormatsFilter.size(); i++) {
             if (!areCompatible(*config.outConfs[i].getMemDesc(), outputMemoryFormatsFilter[i])) {
-                DEBUG_LOG(getName(), " Output memory format filter: ", outputMemoryFormatsFilter[i],
-                          " not matched. Erase desc from supported primitive descriptors: ", desc);
+                DEBUG_LOG(getName(),
+                          " Output memory format filter: ",
+                          outputMemoryFormatsFilter[i],
+                          " not matched. Erase desc from supported primitive descriptors: ",
+                          desc);
                 return true;
             }
         }
@@ -932,7 +1000,8 @@ void Node::initDescriptor(const NodeConfig& config) {
 
     if (descs.empty()) {
         const auto& selectedConfig = selectedPD->getConfig();
-        if (selectedConfig.inConfs.size() != config.inConfs.size() || selectedConfig.outConfs.size() != config.outConfs.size())
+        if (selectedConfig.inConfs.size() != config.inConfs.size() ||
+            selectedConfig.outConfs.size() != config.outConfs.size())
             return;
 
         for (size_t i = 0; i < selectedConfig.inConfs.size(); i++) {
@@ -949,19 +1018,19 @@ void Node::initDescriptor(const NodeConfig& config) {
         return;
     }
 
-    auto updateNodeConfig = [&](const NodeConfig& cfg){
+    auto updateNodeConfig = [&](const NodeConfig& cfg) {
         auto updatedConfig = cfg;
 
         for (size_t i = 0; i < descInputNumbers(); i++) {
             PortConfig& dataConfig = updatedConfig.inConfs[i];
-            dataConfig.inPlace(canBeInPlace() ? 0 : -1);    // update inPlace
-            dataConfig.setMemDesc(dataConfig.getMemDesc()); // reset desc with default compatibility mask
+            dataConfig.inPlace(canBeInPlace() ? 0 : -1);     // update inPlace
+            dataConfig.setMemDesc(dataConfig.getMemDesc());  // reset desc with default compatibility mask
         }
 
         for (size_t i = 0; i < descOutputNumbers(); i++) {
             PortConfig& dataConfig = updatedConfig.outConfs[i];
-            dataConfig.inPlace(-1);                         // update inPlace
-            dataConfig.setMemDesc(dataConfig.getMemDesc()); // reset desc with default compatibility mask
+            dataConfig.inPlace(-1);                          // update inPlace
+            dataConfig.setMemDesc(dataConfig.getMemDesc());  // reset desc with default compatibility mask
         }
 
         return updatedConfig;
@@ -1017,8 +1086,8 @@ void Node::prepareMemory(const DnnlMemoryDescPtr& intDesc, size_t indx) {
     MemoryPtr ptr;
     auto weightCache = context->getWeightsCache();
     if (weightCache != nullptr && memory::format_kind::blocked == intDesc->getDnnlDesc().get_format_kind()) {
-        const auto string_hash =
-            name + "_" + std::to_string(indx) + "_" + DnnlExtensionUtils::computeWeightsStringHash(internalBlob, intDesc);
+        const auto string_hash = name + "_" + std::to_string(indx) + "_" +
+                                 DnnlExtensionUtils::computeWeightsStringHash(internalBlob, intDesc);
         ptr = *weightCache->findOrCreate(string_hash, create);
     } else {
         ptr = create();
@@ -1043,7 +1112,7 @@ void Node::prepareMemory(const std::vector<DnnlMemoryDescPtr>& intDescs) {
 
 void Node::prepareMemory(dnnl::primitive_desc_iterator& itpd) {
     std::vector<DnnlMemoryDescPtr> intDescs;
-    for (auto &it : internalBlobDesc)
+    for (auto& it : internalBlobDesc)
         intDescs.push_back(it(itpd, 0));
 
     Node::prepareMemory(intDescs);
@@ -1063,8 +1132,8 @@ MemoryPtr Node::prepareWeightMemory(DnnlMemoryDescPtr dstWeightDesc, DnnlMemoryD
         srcWeightDesc = DnnlExtensionUtils::makeDescriptor(weightSrcDesc);
     }
 
-    auto create = [&] () {
-        Memory srcMemory{ getEngine(), srcWeightDesc, edgeMem->getData() };
+    auto create = [&]() {
+        Memory srcMemory{getEngine(), srcWeightDesc, edgeMem->getData()};
         MemoryPtr _ptr = std::make_shared<Memory>(getEngine(), dstWeightDesc);
         node::Reorder::reorderData(srcMemory, *_ptr, context->getParamsCache());
 
@@ -1128,13 +1197,13 @@ bool Node::isInPlace() const {
 
         inplace = InPlaceType::NoInPlace;
         auto config = selected_pd->getConfig();
-        for (auto &in : config.inConfs) {
+        for (auto& in : config.inConfs) {
             if (in.inPlace() >= 0) {
                 inplace = InPlaceType::InPlace;
                 break;
             }
         }
-        for (auto &out : config.outConfs) {
+        for (auto& out : config.outConfs) {
             if (out.inPlace() >= 0) {
                 inplace = InPlaceType::InPlace;
                 break;
@@ -1165,7 +1234,7 @@ void Node::updateConstantType() {
     const auto prevConstantType = constant;
     constant = isConst ? ConstantType::Const : ConstantType::NoConst;
     if (constant == prevConstantType)
-        return; // state has not changed, no reason to continue
+        return;  // state has not changed, no reason to continue
 
     for (const auto& childEdge : getChildEdges()) {
         const auto childNode = childEdge.lock()->getChild();
@@ -1174,7 +1243,8 @@ void Node::updateConstantType() {
 }
 
 void Node::addOriginalLayer(const std::string& layerName) {
-    if (layerName.empty()) return;
+    if (layerName.empty())
+        return;
     if (originalLayers.empty()) {
         originalLayers = layerName;
     } else {
@@ -1197,46 +1267,25 @@ void Node::cleanup() {
 const std::vector<impl_desc_type>& Node::getDefaultImplPriority() {
     static const std::vector<impl_desc_type> priorities {
         impl_desc_type::unknown,
-        // Undef impl type is used to express use-cases there real type is unkown during compilation
-        // Undef has higher priority than defined types in order to force primitive selection logic to make decision based on other properties
-        impl_desc_type::undef,
-        impl_desc_type::brgconv_avx512_amx_1x1,
-        impl_desc_type::brgconv_avx512_amx,
-        impl_desc_type::jit_avx512_amx_dw,
-        impl_desc_type::jit_avx512_amx_1x1,
-        impl_desc_type::jit_avx512_amx,
-        // Brgconv kernels disabled in order to prevent perf degradations on non AMX HW
-        // impl_desc_type::brgconv_avx512_1x1,
-        // impl_desc_type::brgconv_avx512,
-        impl_desc_type::jit_uni_dw,
-        impl_desc_type::jit_uni_1x1,
-        impl_desc_type::jit_uni,
-        impl_desc_type::jit_avx512_dw,
-        impl_desc_type::jit_avx512_1x1,
-        impl_desc_type::jit_avx512,
-        impl_desc_type::jit_avx2_dw,
-        impl_desc_type::jit_avx2_1x1,
-        impl_desc_type::jit_avx2,
-        impl_desc_type::jit_avx_dw,
-        impl_desc_type::jit_avx_1x1,
-        impl_desc_type::jit_avx,
-        impl_desc_type::jit_sse42_dw,
-        impl_desc_type::jit_sse42_1x1,
-        impl_desc_type::jit_sse42,
+            // Undef impl type is used to express use-cases there real type is unkown during compilation
+            // Undef has higher priority than defined types in order to force primitive selection logic to make decision
+            // based on other properties
+            impl_desc_type::undef, impl_desc_type::brgconv_avx512_amx_1x1, impl_desc_type::brgconv_avx512_amx,
+            impl_desc_type::jit_avx512_amx_dw, impl_desc_type::jit_avx512_amx_1x1, impl_desc_type::jit_avx512_amx,
+            // Brgconv kernels disabled in order to prevent perf degradations on non AMX HW
+            // impl_desc_type::brgconv_avx512_1x1,
+            // impl_desc_type::brgconv_avx512,
+            impl_desc_type::jit_uni_dw, impl_desc_type::jit_uni_1x1, impl_desc_type::jit_uni,
+            impl_desc_type::jit_avx512_dw, impl_desc_type::jit_avx512_1x1, impl_desc_type::jit_avx512,
+            impl_desc_type::jit_avx2_dw, impl_desc_type::jit_avx2_1x1, impl_desc_type::jit_avx2,
+            impl_desc_type::jit_avx_dw, impl_desc_type::jit_avx_1x1, impl_desc_type::jit_avx,
+            impl_desc_type::jit_sse42_dw, impl_desc_type::jit_sse42_1x1, impl_desc_type::jit_sse42,
 #if defined(OPENVINO_ARCH_ARM64)
-        impl_desc_type::jit_asimd,
+            impl_desc_type::jit_asimd,
 #endif
-        impl_desc_type::gemm_any,
-        impl_desc_type::gemm_blas,
-        impl_desc_type::gemm_avx512,
-        impl_desc_type::gemm_avx2,
-        impl_desc_type::gemm_avx,
-        impl_desc_type::gemm_sse42,
-        impl_desc_type::gemm_acl,
-        impl_desc_type::acl,
-        impl_desc_type::jit_gemm,
-        impl_desc_type::ref_any,
-        impl_desc_type::ref,
+            impl_desc_type::gemm_any, impl_desc_type::gemm_blas, impl_desc_type::gemm_avx512, impl_desc_type::gemm_avx2,
+            impl_desc_type::gemm_avx, impl_desc_type::gemm_sse42, impl_desc_type::gemm_acl, impl_desc_type::acl,
+            impl_desc_type::jit_gemm, impl_desc_type::ref_any, impl_desc_type::ref,
     };
 
     return priorities;
@@ -1246,30 +1295,31 @@ const std::vector<impl_desc_type>& Node::getImplPriority() {
     if (!customImplPriorities.empty())
         return customImplPriorities;
 
-
     return getDefaultImplPriority();
 }
 
-PortDescBasePtr Node::getConsistentInputDesc(const NodeConfig &config, size_t idx) const {
+PortDescBasePtr Node::getConsistentInputDesc(const NodeConfig& config, size_t idx) const {
     const auto& inConf = config.inConfs[idx];
 
-    if (inConf.inPlace() >= 0) { // node have inplace input
+    if (inConf.inPlace() >= 0) {  // node have inplace input
         auto inplaceIndx = static_cast<size_t>(inConf.inPlace());
         PortDescBasePtr outPortDesc;
         const auto& outConf = config.outConfs[inplaceIndx];
-        if (outConf.inPlace() == static_cast<int>(idx)) { // the input desc port is the same port used for inplace output
-            outPortDesc = outConf.getPortDesc(); // just use desc from this output port
+        if (outConf.inPlace() ==
+            static_cast<int>(idx)) {              // the input desc port is the same port used for inplace output
+            outPortDesc = outConf.getPortDesc();  // just use desc from this output port
         } else {
-            outPortDesc = getConsistentOutputDesc(config, inplaceIndx); // get consistent desc otherwise
+            outPortDesc = getConsistentOutputDesc(config, inplaceIndx);  // get consistent desc otherwise
         }
-        if (inConf.getPortDesc()->isCompatible(*outPortDesc)) { // use the desc if compatible
+        if (inConf.getPortDesc()->isCompatible(*outPortDesc)) {  // use the desc if compatible
             return outPortDesc;
         }
     }
 
-    auto *parentSelectedPD = getParentEdgeAt(idx)->getParent()->getSelectedPrimitiveDescriptor();
+    auto* parentSelectedPD = getParentEdgeAt(idx)->getParent()->getSelectedPrimitiveDescriptor();
     if (!parentSelectedPD)
-        OPENVINO_THROW("Cannot get selected primitive descriptor for node: ", getParentEdgeAt(idx)->getParent()->getName());
+        OPENVINO_THROW("Cannot get selected primitive descriptor for node: ",
+                       getParentEdgeAt(idx)->getParent()->getName());
 
     int num = getParentEdgeAt(idx)->getInputNum();
     if (num >= 0) {
@@ -1290,26 +1340,28 @@ PortDescBasePtr Node::getConsistentInputDesc(const NodeConfig &config, size_t id
     return inConf.getPortDesc();
 }
 
-PortDescBasePtr Node::getConsistentOutputDesc(const NodeConfig &config, size_t idx) const {
+PortDescBasePtr Node::getConsistentOutputDesc(const NodeConfig& config, size_t idx) const {
     const auto& outConf = config.outConfs[idx];
 
-    if (outConf.inPlace() >= 0) { // node have inplace output
+    if (outConf.inPlace() >= 0) {  // node have inplace output
         auto inplaceIndx = static_cast<size_t>(outConf.inPlace());
         PortDescBasePtr inpPortDesc;
         const auto& inpConf = config.inConfs[inplaceIndx];
-        if (inpConf.inPlace() == static_cast<int>(idx)) { // the input desc port is the same port used for inplace output
-            inpPortDesc = inpConf.getPortDesc(); // just use desc from this output port
+        if (inpConf.inPlace() ==
+            static_cast<int>(idx)) {              // the input desc port is the same port used for inplace output
+            inpPortDesc = inpConf.getPortDesc();  // just use desc from this output port
         } else {
-            inpPortDesc = getConsistentInputDesc(config, inplaceIndx); // get consistent desc otherwise
+            inpPortDesc = getConsistentInputDesc(config, inplaceIndx);  // get consistent desc otherwise
         }
-        if (outConf.getPortDesc()->isCompatible(*inpPortDesc)) { // use the desc if compatible
+        if (outConf.getPortDesc()->isCompatible(*inpPortDesc)) {  // use the desc if compatible
             return inpPortDesc;
         }
     }
 
-    auto *childSelectedPD = getChildEdgeAt(idx)->getChild()->getSelectedPrimitiveDescriptor();
+    auto* childSelectedPD = getChildEdgeAt(idx)->getChild()->getSelectedPrimitiveDescriptor();
     if (!childSelectedPD)
-        OPENVINO_THROW("Cannot get selected primitive descriptor for node: ", getChildEdgeAt(idx)->getChild()->getName());
+        OPENVINO_THROW("Cannot get selected primitive descriptor for node: ",
+                       getChildEdgeAt(idx)->getChild()->getName());
 
     int num = getChildEdgeAt(idx)->getOutputNum();
     if (num >= 0) {
@@ -1331,7 +1383,7 @@ PortDescBasePtr Node::getConsistentOutputDesc(const NodeConfig &config, size_t i
 }
 
 void Node::initOptimalPrimitiveDescriptor() {
-    if (one_of(getType(), Type::RNNCell, Type::RNNSeq)) // can be skipped for RNN node
+    if (one_of(getType(), Type::RNNCell, Type::RNNSeq))  // can be skipped for RNN node
         return;
 
     auto selected_pd = getSelectedPrimitiveDescriptor();
@@ -1358,7 +1410,8 @@ void Node::initOptimalPrimitiveDescriptor() {
             // it is assumed that the nodes will define dense tensors on output edges
             // if it is not the case the implementation must redefine this behaviour
             if (outMemDesc->getType() & Blocked) {
-                config.outConfs[i].setMemDesc(std::dynamic_pointer_cast<BlockedMemoryDesc>(outMemDesc), BlockedMemoryDesc::FULL_MASK);
+                config.outConfs[i].setMemDesc(std::dynamic_pointer_cast<BlockedMemoryDesc>(outMemDesc),
+                                              BlockedMemoryDesc::FULL_MASK);
             }
         }
     }
@@ -1366,9 +1419,9 @@ void Node::initOptimalPrimitiveDescriptor() {
     initDescriptor(config);
 }
 
-bool Node::isConfigDefined(const NodeConfig &config) const {
+bool Node::isConfigDefined(const NodeConfig& config) const {
     for (const auto& configs : {config.inConfs, config.outConfs}) {
-        for (const auto &dc : configs) {
+        for (const auto& dc : configs) {
             if (!dc.getMemDesc()->isDefined())
                 return false;
         }
@@ -1376,14 +1429,14 @@ bool Node::isConfigDefined(const NodeConfig &config) const {
     return true;
 }
 
-MemoryDescPtr Node::getSrcMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const {
+MemoryDescPtr Node::getSrcMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const {
     if (getInputShapeAtPort(idx).isDynamic()) {
         return DnnlExtensionUtils::makeUndefinedDesc(prim_desc.src_desc(idx), getInputShapeAtPort(idx));
     }
     return DnnlExtensionUtils::makeDescriptor(prim_desc.src_desc(idx));
 }
 
-MemoryDescPtr Node::getDstMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const {
+MemoryDescPtr Node::getDstMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const {
     if (getOutputShapeAtPort(idx).isDynamic()) {
         return DnnlExtensionUtils::makeUndefinedDesc(prim_desc.dst_desc(idx), getOutputShapeAtPort(idx));
     }
@@ -1393,7 +1446,7 @@ MemoryDescPtr Node::getDstMemDesc(const dnnl::primitive_desc &prim_desc, size_t
 void Node::appendPostOpArgs(const dnnl::primitive_attr& attr,
                             std::unordered_map<int, dnnl::memory>& primArgs,
                             const std::unordered_map<int, MemoryPtr>& postOpsArgs) {
-    for (auto & entry : postOpsArgs) {
+    for (auto& entry : postOpsArgs) {
         primArgs[entry.first] = entry.second->getPrimitive();
     }
 }
@@ -1426,11 +1479,17 @@ dnnl::memory::format_tag Node::getWeightsFormatTagByDims(const VectorDims& dims)
     }
 }
 
-void Node::appendPostOps(dnnl::post_ops& ops, const VectorDims &postOpDims, std::unordered_map<int, MemoryPtr>& postOpsMem, const int channelAxis) {
+void Node::appendPostOps(dnnl::post_ops& ops,
+                         const VectorDims& postOpDims,
+                         std::unordered_map<int, MemoryPtr>& postOpsMem,
+                         const int channelAxis) {
     OPENVINO_THROW("Fusing of ", NameFromType(this->getType()), " operation is not implemented");
 }
 
-void Node::appendPostOps(dnnl::post_ops& ops, const VectorDims &postOpDims, std::vector<const void*>& postOpsMem, const int channelAxis) {
+void Node::appendPostOps(dnnl::post_ops& ops,
+                         const VectorDims& postOpDims,
+                         std::vector<const void*>& postOpsMem,
+                         const int channelAxis) {
     OPENVINO_THROW("Fusing of ", NameFromType(this->getType()), " operation is not implemented");
 }
 
@@ -1474,12 +1533,12 @@ ov::element::Type Node::getRuntimePrecision() const {
 }
 
 Node* Node::NodesFactory::create(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) {
-    // getExceptionDescWithoutStatus removes redundant information from the exception message. For instance, the NotImplemented
-    // exception is generated in the form: full_path_to_src_file:line_number [ NOT_IMPLEMENTED ] reason.
+    // getExceptionDescWithoutStatus removes redundant information from the exception message. For instance, the
+    // NotImplemented exception is generated in the form: full_path_to_src_file:line_number [ NOT_IMPLEMENTED ] reason.
     // An example for gather node:
-    // /path-to-openVino-root/src/plugins/intel_cpu/nodes/gather.cpp:42 [ NOT_IMPLEMENTED ] Only opset7 Gather operation is supported
-    // The most important part of the message is the reason, so the lambda trims everything up to "]"
-    // Note that the op type and its friendly name will also be provided if we fail to create the node.
+    // /path-to-openVino-root/src/plugins/intel_cpu/nodes/gather.cpp:42 [ NOT_IMPLEMENTED ] Only opset7 Gather operation
+    // is supported The most important part of the message is the reason, so the lambda trims everything up to "]" Note
+    // that the op type and its friendly name will also be provided if we fail to create the node.
     auto getExceptionDescWithoutStatus = [](const ov::Exception& ex) {
         std::string desc = ex.what();
         size_t pos = desc.find(']');
@@ -1492,7 +1551,7 @@ Node* Node::NodesFactory::create(const std::shared_ptr<ov::Node>& op, const Grap
         }
         return desc;
     };
-    Node *newNode = nullptr;
+    Node* newNode = nullptr;
     std::string errorMessage;
     if (newNode == nullptr) {
         try {
@@ -1539,7 +1598,7 @@ Node* Node::NodesFactory::create(const std::shared_ptr<ov::Node>& op, const Grap
     return newNode;
 }
 
-bool Node::canBePerformedAsScaleShift(const Node *parentNode) const {
+bool Node::canBePerformedAsScaleShift(const Node* parentNode) const {
 #if defined(OPENVINO_ARCH_X86_64)
     OPENVINO_ASSERT(parentNode);
 
@@ -1547,7 +1606,7 @@ bool Node::canBePerformedAsScaleShift(const Node *parentNode) const {
     const auto channelAxis = parentNode->getFusingAxis();
 
     for (size_t i = 0; i < getParentEdges().size(); i++) {
-        Node *node = getParentEdgeAt(i)->getParent().get();
+        Node* node = getParentEdgeAt(i)->getParent().get();
         if (node == nullptr) {
             OPENVINO_THROW("Cannot get parent node for ", getName(), " on ", i, " port");
         }
@@ -1575,7 +1634,7 @@ bool Node::canBePerformedAsScaleShift(const Node *parentNode) const {
 
     const auto isConvertablePowerStatic = [&]() {
         if (getAlgorithm() == Algorithm::EltwisePowerStatic) {
-            const auto eltwise = dynamic_cast<const Eltwise *>(this);
+            const auto eltwise = dynamic_cast<const Eltwise*>(this);
             if (!eltwise) {
                 OPENVINO_THROW("Cannot cast ", getName(), " to Eltwise");
             }
@@ -1584,13 +1643,15 @@ bool Node::canBePerformedAsScaleShift(const Node *parentNode) const {
         return false;
     };
 
-    return (one_of(getAlgorithm(), Algorithm::EltwiseAdd,
-                                   Algorithm::EltwiseMultiply,
-                                   Algorithm::EltwiseSubtract,
-                                   Algorithm::EltwiseDivide,
-                                   Algorithm::EltwisePrelu,
-                                   Algorithm::EltwiseMulAdd) && isBroadcastableToDataInput())
-            || isConvertablePowerStatic();
+    return (one_of(getAlgorithm(),
+                   Algorithm::EltwiseAdd,
+                   Algorithm::EltwiseMultiply,
+                   Algorithm::EltwiseSubtract,
+                   Algorithm::EltwiseDivide,
+                   Algorithm::EltwisePrelu,
+                   Algorithm::EltwiseMulAdd) &&
+            isBroadcastableToDataInput()) ||
+           isConvertablePowerStatic();
 #else
     // TODO: provide correct list of operations for other backends
     return false;
@@ -1600,11 +1661,11 @@ bool Node::canBePerformedAsScaleShift(const Node *parentNode) const {
 // @todo shifts for Subtract and scales for Divide are replaced with
 // Add (with opposite sign) and Multiply (with inverse value) for legacy dephwise post ops
 // This can be avoided after dephwise post ops are gone
-std::pair<std::vector<float>, std::vector<float>> Node::getScalesAndShifts(const Node *parentNode) const {
+std::pair<std::vector<float>, std::vector<float>> Node::getScalesAndShifts(const Node* parentNode) const {
     std::vector<float> scales, shifts;
 
     const auto fillValuesFrom = [&](const NodePtr& constInput, std::vector<float>& buffer) {
-        auto *constInputNode = dynamic_cast<node::Input *>(constInput.get());
+        auto* constInputNode = dynamic_cast<node::Input*>(constInput.get());
         if (!constInputNode) {
             OPENVINO_THROW("Cannot cast ", constInput->getName(), " to Input");
         }
@@ -1628,7 +1689,7 @@ std::pair<std::vector<float>, std::vector<float>> Node::getScalesAndShifts(const
         fillValuesFrom(getParentEdgeAt(1)->getParent(), scales);
         fillValuesFrom(getParentEdgeAt(2)->getParent(), shifts);
     } else if (one_of(getAlgorithm(), Algorithm::EltwisePowerStatic)) {
-        const auto power = dynamic_cast<const Eltwise *>(this);
+        const auto power = dynamic_cast<const Eltwise*>(this);
         if (!power) {
             OPENVINO_THROW("Cannot cast ", getName(), " to Eltwise");
         }
@@ -1639,25 +1700,30 @@ std::pair<std::vector<float>, std::vector<float>> Node::getScalesAndShifts(const
     }
 
     switch (getAlgorithm()) {
-        case Algorithm::EltwiseAdd: {
-            scales.resize(shifts.size(), 1.0f);
-            break;
-        }
-        case Algorithm::EltwiseSubtract: {
-            scales.resize(shifts.size(), 1.0f);
-            std::transform(shifts.begin(), shifts.end(), shifts.begin(), [](float shift){ return -1.0f * shift; });
-            break;
-        }
-        case Algorithm::EltwiseMultiply: {
-            shifts.resize(scales.size(), 0.0f);
-            break;
-        }
-        case Algorithm::EltwiseDivide: {
-            shifts.resize(scales.size(), 0.0f);
-            std::transform(scales.begin(), scales.end(), scales.begin(), [](float scale){ return 1.0f / scale; });
-            break;
-        }
-        default: break;
+    case Algorithm::EltwiseAdd: {
+        scales.resize(shifts.size(), 1.0f);
+        break;
+    }
+    case Algorithm::EltwiseSubtract: {
+        scales.resize(shifts.size(), 1.0f);
+        std::transform(shifts.begin(), shifts.end(), shifts.begin(), [](float shift) {
+            return -1.0f * shift;
+        });
+        break;
+    }
+    case Algorithm::EltwiseMultiply: {
+        shifts.resize(scales.size(), 0.0f);
+        break;
+    }
+    case Algorithm::EltwiseDivide: {
+        shifts.resize(scales.size(), 0.0f);
+        std::transform(scales.begin(), scales.end(), scales.begin(), [](float scale) {
+            return 1.0f / scale;
+        });
+        break;
+    }
+    default:
+        break;
     }
 
     return {scales, shifts};
@@ -1824,22 +1890,25 @@ bool Node::canFuseSimpleOperation(const NodePtr& node) const {
         return ret;
     } else if (node->getType() == Type::Eltwise) {
         return DnnlExtensionUtils::isUnarySupportedAsPostOp(node->getAlgorithm()) ||
-            node->canBePerformedAsScaleShift(this);
+               node->canBePerformedAsScaleShift(this);
     }
     return false;
 }
 
-void Node::addFusedNode(const NodePtr &fusingNode) {
+void Node::addFusedNode(const NodePtr& fusingNode) {
     fusedWith.push_back(fusingNode);
 }
 
 void Node::addSupportedPrimDesc(const std::vector<PortConfigurator>& inPortConfigs,
                                 const std::vector<PortConfigurator>& outPortConfigs,
                                 impl_desc_type implType) {
-    auto fill_port = [] (const PortConfigurator& portConfigurator, const Shape& shape,
-                         ov::element::Type prc, std::vector<PortConfig>& port) -> bool {
-        // In order to simplify particular node initialization logic we just don't add config in case target shape is not supported by blockedDescCreator.
-        // This should be suitable for major of scenarios since almost all nodes add `ncsp` blockedDescCreator which supports any shape rank.
+    auto fill_port = [](const PortConfigurator& portConfigurator,
+                        const Shape& shape,
+                        ov::element::Type prc,
+                        std::vector<PortConfig>& port) -> bool {
+        // In order to simplify particular node initialization logic we just don't add config in case target shape is
+        // not supported by blockedDescCreator. This should be suitable for major of scenarios since almost all nodes
+        // add `ncsp` blockedDescCreator which supports any shape rank.
         if (shape.getRank() < portConfigurator.blockedDescCreator->getMinimalRank())
             return false;
 
@@ -1856,14 +1925,16 @@ void Node::addSupportedPrimDesc(const std::vector<PortConfigurator>& inPortConfi
     NodeConfig config;
     for (size_t i = 0; i < inPortConfigs.size(); i++) {
         auto shape = inPortConfigs[i].shape.getRank() == 0 ? getInputShapeAtPort(i) : inPortConfigs[i].shape;
-        auto prc = inPortConfigs[i].prc == ov::element::undefined ? getOriginalInputPrecisionAtPort(i) : inPortConfigs[i].prc;
+        auto prc =
+            inPortConfigs[i].prc == ov::element::undefined ? getOriginalInputPrecisionAtPort(i) : inPortConfigs[i].prc;
         if (!fill_port(inPortConfigs[i], shape, prc, config.inConfs))
             return;
     }
 
     for (size_t i = 0; i < outPortConfigs.size(); i++) {
         auto dims = outPortConfigs[i].shape.getRank() == 0 ? getOutputShapeAtPort(i) : outPortConfigs[i].shape;
-        auto prc = outPortConfigs[i].prc == ov::element::undefined ? getOriginalOutputPrecisionAtPort(i) : outPortConfigs[i].prc;
+        auto prc = outPortConfigs[i].prc == ov::element::undefined ? getOriginalOutputPrecisionAtPort(i)
+                                                                   : outPortConfigs[i].prc;
         if (!fill_port(outPortConfigs[i], dims, prc, config.outConfs))
             return;
     }
@@ -1884,23 +1955,27 @@ void Node::fuseDQScales(const float* scaleData, const size_t scaleSize) {
     if (scaleSize > DQScales.size())
         DQScales.resize(scaleSize, DQScales[0]);
     if (1 == scaleSize) {
-        std::transform(DQScales.begin(), DQScales.end(),  DQScales.begin(), [=](float val){ return (scaleData[0] * val); });
-     } else {
-         for (size_t i = 0; i < DQScales.size(); i++) {
-             DQScales[i] *= scaleData[i];
-         }
-     }
-     if (std::all_of(DQScales.begin(), DQScales.end(), [OV_CAPTURE_CPY_AND_THIS](float val){ return (val == DQScales[0]);}))
+        std::transform(DQScales.begin(), DQScales.end(), DQScales.begin(), [=](float val) {
+            return (scaleData[0] * val);
+        });
+    } else {
+        for (size_t i = 0; i < DQScales.size(); i++) {
+            DQScales[i] *= scaleData[i];
+        }
+    }
+    if (std::all_of(DQScales.begin(), DQScales.end(), [OV_CAPTURE_CPY_AND_THIS](float val) {
+            return (val == DQScales[0]);
+        }))
         DQScales.resize(1);
 }
 
 int Node::inPlaceInputPort(int portIdx) const {
     if (inputShapes.empty()) {
-        //special case - a dead end node
+        // special case - a dead end node
         return -1;
     }
 
-    const NodeDesc *selected_pd = getSelectedPrimitiveDescriptor();
+    const NodeDesc* selected_pd = getSelectedPrimitiveDescriptor();
     if (!selected_pd)
         OPENVINO_THROW("Cannot find selected primitive descriptor for node: ", getName());
 
@@ -1918,11 +1993,11 @@ int Node::inPlaceInputPort(int portIdx) const {
 
 int Node::inPlaceOutPort(int portIdx) const {
     if (outputShapes.empty()) {
-        //special case - a dead end node
+        // special case - a dead end node
         return -1;
     }
 
-    const NodeDesc *selected_pd = getSelectedPrimitiveDescriptor();
+    const NodeDesc* selected_pd = getSelectedPrimitiveDescriptor();
     if (!selected_pd)
         OPENVINO_THROW("Cannot find selected primitive descriptor for node: ", getName());
 
@@ -1939,8 +2014,8 @@ int Node::inPlaceOutPort(int portIdx) const {
 }
 
 void Node::resolveInPlaceDirection() {
-    enum InplaceDirectionType {UP, DOWN, CYCLIC, NONE};
-    enum PortType {INPUT, OUTPUT};
+    enum InplaceDirectionType { UP, DOWN, CYCLIC, NONE };
+    enum PortType { INPUT, OUTPUT };
 
     auto inPlaceDirection = [](const Node* node, PortType portType, int portNum) -> InplaceDirectionType {
         if (PortType::INPUT == portType) {
@@ -1990,7 +2065,8 @@ void Node::resolveInPlaceDirection() {
         if (auto pEdge = wEdge.lock()) {
             auto inpPort = pEdge->getOutputNum();
             auto inPlaceInpPort = inPlaceInputPort(inpPort);
-            if (inPlaceInpPort < 0 || inPlaceDirection(this, PortType::INPUT, inpPort) != InplaceDirectionType::CYCLIC) {
+            if (inPlaceInpPort < 0 ||
+                inPlaceDirection(this, PortType::INPUT, inpPort) != InplaceDirectionType::CYCLIC) {
                 continue;
             }
             // inPlace memory cyclic dependency detected, need to resolve
@@ -2002,12 +2078,14 @@ void Node::resolveInPlaceDirection() {
                 config.inConfs[inpPort].inPlace(-1);
                 initDescriptor(config);
             } else if (parentInPlaceDirection == InplaceDirectionType::DOWN) {
-                //search if siblings already have downstream direction
+                // search if siblings already have downstream direction
                 auto downstreamPeers = [&] {
                     for (auto& peerEdge : pParent->getChildEdgesAtPort(pEdge->getInputNum())) {
                         auto peerNode = peerEdge->getChild().get();
-                        if (peerNode == this) continue;
-                        if (inPlaceDirection(peerNode, PortType::INPUT, peerEdge->getOutputNum()) == InplaceDirectionType::DOWN) {
+                        if (peerNode == this)
+                            continue;
+                        if (inPlaceDirection(peerNode, PortType::INPUT, peerEdge->getOutputNum()) ==
+                            InplaceDirectionType::DOWN) {
                             return true;
                         }
                     }
@@ -2068,7 +2146,8 @@ void Node::resolveInPlaceDirection() {
                         // note: there are only non-inplace or cyclic-inplace descendants at the moment.
                         std::function<void(const Node* node, int portIdx)> searchReferencingOutput;
                         searchReferencingOutput = [&](const Node* node, int portIdx) -> void {
-                            if (numConflicts > 1) return;  // early stop
+                            if (numConflicts > 1)
+                                return;  // early stop
                             auto childEdges = node->getChildEdgesAtPort(portIdx);
                             for (auto& edge : childEdges) {
                                 auto pChild = edge->getChild().get();
@@ -2077,7 +2156,8 @@ void Node::resolveInPlaceDirection() {
                                 } else {
                                     auto result = inPlaceDirection(pChild, PortType::INPUT, edge->getOutputNum());
                                     if (InplaceDirectionType::CYCLIC == result) {
-                                        return searchReferencingOutput(pChild, pChild->inPlaceInputPort(edge->getOutputNum()));
+                                        return searchReferencingOutput(pChild,
+                                                                       pChild->inPlaceInputPort(edge->getOutputNum()));
                                     }
                                 }
                             }
@@ -2090,7 +2170,8 @@ void Node::resolveInPlaceDirection() {
                         // note: the parent node does not use inPlace memory at the moment, let's check the siblings
                         for (auto& peerEdge : pParent->getChildEdgesAtPort(pEdge->getInputNum())) {
                             auto peerNode = peerEdge->getChild().get();
-                            if (peerNode == this) continue;
+                            if (peerNode == this)
+                                continue;
                             if (Type::Output == peerNode->getType()) {
                                 numConflicts++;
                             } else {
@@ -2102,11 +2183,11 @@ void Node::resolveInPlaceDirection() {
                         }
                     }
 
-                    if (numConflicts == 1) { // downstream to make the only output edge be referenced.
+                    if (numConflicts == 1) {  // downstream to make the only output edge be referenced.
                         auto config = getSelectedPrimitiveDescriptor()->getConfig();
                         config.outConfs[inPlaceInpPort].inPlace(-1);
                         initDescriptor(config);
-                    } else { // the default direction of upstream
+                    } else {  // the default direction of upstream
                         auto config = getSelectedPrimitiveDescriptor()->getConfig();
                         config.inConfs[inpPort].inPlace(-1);
                         initDescriptor(config);
@@ -2121,8 +2202,7 @@ void Node::resolveInPlaceDirection() {
 
 #ifndef CPU_DEBUG_CAPS
 std::ostream& operator<<(std::ostream& out, const Node& node) {
-    return out << "Node " << node.getName() <<
-        " of type " << node.getTypeStr() << "\n";
+    return out << "Node " << node.getName() << " of type " << node.getTypeStr() << "\n";
 }
 
 std::ostream& operator<<(std::ostream& out, const Node* node) {
@@ -2130,5 +2210,5 @@ std::ostream& operator<<(std::ostream& out, const Node* node) {
 }
 #endif
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/node.h b/src/plugins/intel_cpu/src/node.h
index 453b8323fe9e66..9166e87dbf50e1 100644
--- a/src/plugins/intel_cpu/src/node.h
+++ b/src/plugins/intel_cpu/src/node.h
@@ -4,37 +4,38 @@
 
 #pragma once
 
+#include <nodes/common/blocked_desc_creator.h>
+
 #include <common/utils.hpp>
+#include <memory>
 #include <oneapi/dnnl/dnnl.hpp>
+#include <openvino/itt.hpp>
+#include <shape_inference/shape_inference_cpu.hpp>
+#include <string>
+#include <vector>
+
 #include "cpu_memory.h"
 #include "cpu_shape.h"
 #include "cpu_types.h"
 #include "edge.h"
+#include "graph_context.h"
 #include "memory_desc/cpu_memory_desc.h"
-#include "selective_build.h"
 #include "memory_desc/dnnl_memory_desc.h"
+#include "nodes/executors/executor.hpp"
+#include "nodes/node_config.h"
 #include "onednn/dnnl.h"
 #include "onednn/iml_type_mapper.h"
-#include <openvino/itt.hpp>
 #include "openvino/cc/factory.h"
 #include "openvino/core/node.hpp"
-#include <nodes/common/blocked_desc_creator.h>
-#include "nodes/node_config.h"
-#include <shape_inference/shape_inference_cpu.hpp>
 #include "perf_count.h"
-#include "utils/debug_capabilities.h"
+#include "selective_build.h"
 #include "utils/bit_util.hpp"
 #include "utils/debug_capabilities.h"
 
-#include "graph_context.h"
-#include "nodes/executors/executor.hpp"
-
-#include <memory>
-#include <vector>
-#include <string>
-
-#define THROW_CPU_NODE_ERR(...) OPENVINO_THROW("[CPU] ", getTypeStr(), " node with name '", getName(), "' ", __VA_ARGS__)
-#define CPU_NODE_ASSERT(condition, ...) OPENVINO_ASSERT(condition, getTypeStr(), " node with name '", getName(), "' ", __VA_ARGS__)
+#define THROW_CPU_NODE_ERR(...) \
+    OPENVINO_THROW("[CPU] ", getTypeStr(), " node with name '", getName(), "' ", __VA_ARGS__)
+#define CPU_NODE_ASSERT(condition, ...) \
+    OPENVINO_ASSERT(condition, getTypeStr(), " node with name '", getName(), "' ", __VA_ARGS__)
 
 namespace ov {
 namespace intel_cpu {
@@ -45,13 +46,25 @@ using NodeWeakPtr = std::weak_ptr<Node>;
 
 class PortConfigurator {
 public:
-    PortConfigurator(ov::intel_cpu::LayoutType blockedDescType, ov::element::Type prc, const Shape& shape,
-                     bool constant = false, int inPlace = -1) :
-            blockedDescCreator(getBlockedDescCreator(blockedDescType)), prc(prc), shape(shape), constant(constant), inPlace(inPlace) {}
-
-    PortConfigurator(ov::intel_cpu::LayoutType blockedDescType, ov::element::Type prc = ov::element::undefined,
-                     bool constant = false, int inPlace = -1) :
-            blockedDescCreator(getBlockedDescCreator(blockedDescType)), prc(prc), constant(constant), inPlace(inPlace) {}
+    PortConfigurator(ov::intel_cpu::LayoutType blockedDescType,
+                     ov::element::Type prc,
+                     const Shape& shape,
+                     bool constant = false,
+                     int inPlace = -1)
+        : blockedDescCreator(getBlockedDescCreator(blockedDescType)),
+          prc(prc),
+          shape(shape),
+          constant(constant),
+          inPlace(inPlace) {}
+
+    PortConfigurator(ov::intel_cpu::LayoutType blockedDescType,
+                     ov::element::Type prc = ov::element::undefined,
+                     bool constant = false,
+                     int inPlace = -1)
+        : blockedDescCreator(getBlockedDescCreator(blockedDescType)),
+          prc(prc),
+          constant(constant),
+          inPlace(inPlace) {}
 
     ov::intel_cpu::BlockedDescCreator::CreatorConstPtr blockedDescCreator;
     const ov::element::Type prc;
@@ -60,7 +73,8 @@ class PortConfigurator {
     int inPlace = -1;
 
 private:
-    static ov::intel_cpu::BlockedDescCreator::CreatorConstPtr getBlockedDescCreator(ov::intel_cpu::LayoutType blockedDescType) {
+    static ov::intel_cpu::BlockedDescCreator::CreatorConstPtr getBlockedDescCreator(
+        ov::intel_cpu::LayoutType blockedDescType) {
         auto& creators = ov::intel_cpu::BlockedDescCreator::getCommonCreators();
         if (creators.find(blockedDescType) == creators.end()) {
             OPENVINO_THROW("Cannot find tensor descriptor creator");
@@ -71,11 +85,15 @@ class PortConfigurator {
 
 class NodeDesc {
 public:
-    NodeDesc(NodeConfig conf, impl_desc_type type):
-        config(std::move(conf)), implementationType(type), executorFactory(nullptr) {}
+    NodeDesc(NodeConfig conf, impl_desc_type type)
+        : config(std::move(conf)),
+          implementationType(type),
+          executorFactory(nullptr) {}
 
-    NodeDesc(NodeConfig conf, impl_desc_type type, ExecutorFactoryLegacyPtr factory):
-        config(std::move(conf)), implementationType(type), executorFactory(factory) {}
+    NodeDesc(NodeConfig conf, impl_desc_type type, ExecutorFactoryLegacyPtr factory)
+        : config(std::move(conf)),
+          implementationType(type),
+          executorFactory(factory) {}
 
     const NodeConfig& getConfig() const {
         return config;
@@ -98,8 +116,8 @@ class NodeDesc {
     }
 
     template <typename T,
-            typename std::enable_if<!std::is_pointer<T>::value && !std::is_reference<T>::value, int>::type = 0,
-            typename std::enable_if<std::is_base_of<ExecutorFactoryLegacy, T>::value, int>::type = 0>
+              typename std::enable_if<!std::is_pointer<T>::value && !std::is_reference<T>::value, int>::type = 0,
+              typename std::enable_if<std::is_base_of<ExecutorFactoryLegacy, T>::value, int>::type = 0>
     std::shared_ptr<T> getExecutorFactoryAs() {
         auto casted = std::dynamic_pointer_cast<T>(executorFactory);
         if (!casted)
@@ -119,34 +137,41 @@ class NodeDesc {
 
 class Node {
 public:
-    Node(const Node &) = delete;
-    Node & operator = (const Node &) = delete;
+    Node(const Node&) = delete;
+    Node& operator=(const Node&) = delete;
 
     using AttrPtr = std::shared_ptr<dnnl::primitive_attr>;
 
 public:
-    template<typename T, int N>
+    template <typename T, int N>
     struct Tag {};
 
     struct PerfCounters {
         PerfCounters(std::string const& name)
-            : execute(openvino::itt::handle(name))
-            , getSupportedDescriptors(openvino::itt::handle<Tag<Node, 0>>("Node::getSupportedDescriptors"))
-            , initSupportedPrimitiveDescriptors(openvino::itt::handle<Tag<Node, 1>>("Node::initSupportedPrimitiveDescriptors"))
-            , filterSupportedPrimitiveDescriptors(openvino::itt::handle<Tag<Node, 2>>("Node::filterSupportedPrimitiveDescriptors"))
-            , selectOptimalPrimitiveDescriptor(openvino::itt::handle<Tag<Node, 3>>("Node::selectOptimalPrimitiveDescriptor"))
-            , createPrimitive(openvino::itt::handle<Tag<Node, 4>>("Node::createPrimitive"))
-            , initOptimalPrimitiveDescriptor(openvino::itt::handle<Tag<Node, 5>>("Node::initOptimalPrimitiveDescriptor"))
-        {}
-
-        template<typename NodeType>
+            : execute(openvino::itt::handle(name)),
+              getSupportedDescriptors(openvino::itt::handle<Tag<Node, 0>>("Node::getSupportedDescriptors")),
+              initSupportedPrimitiveDescriptors(
+                  openvino::itt::handle<Tag<Node, 1>>("Node::initSupportedPrimitiveDescriptors")),
+              filterSupportedPrimitiveDescriptors(
+                  openvino::itt::handle<Tag<Node, 2>>("Node::filterSupportedPrimitiveDescriptors")),
+              selectOptimalPrimitiveDescriptor(
+                  openvino::itt::handle<Tag<Node, 3>>("Node::selectOptimalPrimitiveDescriptor")),
+              createPrimitive(openvino::itt::handle<Tag<Node, 4>>("Node::createPrimitive")),
+              initOptimalPrimitiveDescriptor(
+                  openvino::itt::handle<Tag<Node, 5>>("Node::initOptimalPrimitiveDescriptor")) {}
+
+        template <typename NodeType>
         void buildClassCounters(const std::string& type_name) {
             getSupportedDescriptors = openvino::itt::handle<Tag<NodeType, 0>>(type_name + "::getSupportedDescriptors");
-            initSupportedPrimitiveDescriptors = openvino::itt::handle<Tag<NodeType, 1>>(type_name + "::initSupportedPrimitiveDescriptors");
-            filterSupportedPrimitiveDescriptors = openvino::itt::handle<Tag<NodeType, 2>>(type_name + "::filterSupportedPrimitiveDescriptors");
-            selectOptimalPrimitiveDescriptor = openvino::itt::handle<Tag<NodeType, 3>>(type_name + "::selectOptimalPrimitiveDescriptor");
+            initSupportedPrimitiveDescriptors =
+                openvino::itt::handle<Tag<NodeType, 1>>(type_name + "::initSupportedPrimitiveDescriptors");
+            filterSupportedPrimitiveDescriptors =
+                openvino::itt::handle<Tag<NodeType, 2>>(type_name + "::filterSupportedPrimitiveDescriptors");
+            selectOptimalPrimitiveDescriptor =
+                openvino::itt::handle<Tag<NodeType, 3>>(type_name + "::selectOptimalPrimitiveDescriptor");
             createPrimitive = openvino::itt::handle<Tag<NodeType, 4>>(type_name + "::createPrimitive");
-            initOptimalPrimitiveDescriptor = openvino::itt::handle<Tag<NodeType, 5>>(type_name + "::initOptimalPrimitiveDescriptor");
+            initOptimalPrimitiveDescriptor =
+                openvino::itt::handle<Tag<NodeType, 5>>(type_name + "::initOptimalPrimitiveDescriptor");
         }
 
         openvino::itt::handle_t execute;
@@ -159,7 +184,7 @@ class Node {
     };
 
     class NodesFactory;
-    static NodesFactory & factory();
+    static NodesFactory& factory();
 
     virtual ~Node() = default;
 
@@ -171,11 +196,12 @@ class Node {
     void remove();
 
     void addParentEdge(const EdgePtr& edge) {
-        assert(std::none_of(parentEdges.begin(), parentEdges.end(),
-                            [&edge](const EdgeWeakPtr& _edge){
-                                return _edge.lock()->getOutputNum() == edge->getOutputNum();
-                            }));
-        parentEdges.insert(std::upper_bound(parentEdges.begin(), parentEdges.end(), edge,
+        assert(std::none_of(parentEdges.begin(), parentEdges.end(), [&edge](const EdgeWeakPtr& _edge) {
+            return _edge.lock()->getOutputNum() == edge->getOutputNum();
+        }));
+        parentEdges.insert(std::upper_bound(parentEdges.begin(),
+                                            parentEdges.end(),
+                                            edge,
                                             [](const EdgeWeakPtr& lhs, const EdgeWeakPtr& rhs) {
                                                 return lhs.lock()->getOutputNum() < rhs.lock()->getOutputNum();
                                             }),
@@ -196,11 +222,11 @@ class Node {
         removeEdge(edge, childEdges);
     }
 
-    const std::vector<EdgeWeakPtr> &getParentEdges() const noexcept {
+    const std::vector<EdgeWeakPtr>& getParentEdges() const noexcept {
         return parentEdges;
     }
 
-    const std::vector<EdgeWeakPtr> &getChildEdges() const noexcept {
+    const std::vector<EdgeWeakPtr>& getChildEdges() const noexcept {
         return childEdges;
     }
 
@@ -238,7 +264,7 @@ class Node {
         return getSrcMemoryAtPort(idx)->getData();
     }
 
-    template<typename T>
+    template <typename T>
     T* getSrcDataAtPortAs(size_t idx) const {
         return getSrcMemoryAtPort(idx)->getDataAs<T>();
     }
@@ -247,7 +273,7 @@ class Node {
         return getDstMemoryAtPort(idx)->getData();
     }
 
-    template<typename T>
+    template <typename T>
     T* getDstDataAtPortAs(size_t idx) const {
         return getDstMemoryAtPort(idx)->getDataAs<T>();
     }
@@ -273,7 +299,8 @@ class Node {
     enum class ConstantType {
         Const,          // Node is placed in a constant subgraph
         NoConst,        // Node is placed in a non-constant subgraph
-        StrictNoConst,  // Node produces non-constant subgraph: this type can't be changed and it does not depend on the parent nodes' ConstantType.
+        StrictNoConst,  // Node produces non-constant subgraph: this type can't be changed and it does not depend on the
+                        // parent nodes' ConstantType.
     };
     ConstantType getConstantType() const;
     void updateConstantType();
@@ -290,10 +317,11 @@ class Node {
 
     bool isFusedWith(Type type) const;
 
-    virtual void addFusedNode(const NodePtr &fusingNode);
+    virtual void addFusedNode(const NodePtr& fusingNode);
 
     virtual void fuseInto(NodePtr& parentNode) {
-        // The graph supports fusing only of consecutive nodes and some graph logic requires to know through which input port a node was fused into parent one.
+        // The graph supports fusing only of consecutive nodes and some graph logic requires to know through which input
+        // port a node was fused into parent one.
         for (size_t i = 0; i < getParentEdges().size(); i++) {
             if (getParentEdgeAt(i)->getParent().get() == parentNode.get()) {
                 setFusingPort(i);
@@ -323,15 +351,15 @@ class Node {
         fusedWith.clear();
     }
 
-    void mergeWith(const NodePtr &merge) {
+    void mergeWith(const NodePtr& merge) {
         mergedWith.push_back(merge);
     }
 
-    const std::vector <NodePtr> &getMergeWith() {
+    const std::vector<NodePtr>& getMergeWith() {
         return mergedWith;
     }
 
-    const std::vector <NodePtr> &getFusedWith() {
+    const std::vector<NodePtr>& getFusedWith() {
         return fusedWith;
     }
 
@@ -343,17 +371,17 @@ class Node {
         this->fusingPort = fusingPort;
     }
 
-    const std::string &getName() const {
+    const std::string& getName() const {
         return name;
     }
 
     void addOriginalLayer(const std::string& layerName);
 
-    const std::string &getOriginalLayers() const {
+    const std::string& getOriginalLayers() const {
         return originalLayers;
     }
 
-    const std::string &getParallelDomain() const {
+    const std::string& getParallelDomain() const {
         return parallelDomain;
     }
 
@@ -437,7 +465,9 @@ class Node {
 
     virtual std::string getPrimitiveDescriptorType() const;
 
-    PerfCount &PerfCounter() { return perfCounter; }
+    PerfCount& PerfCounter() {
+        return perfCounter;
+    }
 
     virtual void resolveInPlaceEdges(Edge::LOOK look = Edge::LOOK_BOTH);
 
@@ -448,7 +478,7 @@ class Node {
     void updateShapes();
     void updateDynamicParams();
     void executeDynamic(dnnl::stream strm, int numaId = -1);
-    virtual void redefineOutputMemory(const std::vector<VectorDims> &newShapes);
+    virtual void redefineOutputMemory(const std::vector<VectorDims>& newShapes);
     void redefineOutputMemory(const size_t port, const VectorDims& new_output_shape);
     bool outputShapeDataDependency() const;
 
@@ -475,7 +505,8 @@ class Node {
 
     /**
      * @brief Performs Node initialization based on graph context.
-     * This is an auxiliary method that allows to use information not available in Node constructor (e.g. connection information with other nodes)
+     * This is an auxiliary method that allows to use information not available in Node constructor (e.g. connection
+     * information with other nodes)
      */
     virtual void init() {}
 
@@ -483,11 +514,11 @@ class Node {
         return execIndex;
     }
 
-    const std::string & getTypeStr() const {
+    const std::string& getTypeStr() const {
         return typeStr;
     }
 
-    void setTypeStr(const std::string &typeStr) {
+    void setTypeStr(const std::string& typeStr) {
         this->typeStr = typeStr;
     }
 
@@ -499,11 +530,11 @@ class Node {
         return 1;
     }
 
-    const PerfCounters & perfCounters() const {
+    const PerfCounters& perfCounters() const {
         return profiling;
     }
 
-    PerfCounters & perfCounters() {
+    PerfCounters& perfCounters() {
         return profiling;
     }
 
@@ -588,7 +619,7 @@ class Node {
         return false;
     }
 
-    bool canBePerformedAsScaleShift(const Node *parentNode = nullptr) const;
+    bool canBePerformedAsScaleShift(const Node* parentNode = nullptr) const;
 
     bool isDynamicNode() const {
         return isDynamic;
@@ -613,14 +644,14 @@ class Node {
     }
 
     /**
-    * @brief Return scales and shift if nodes can be executed as ScaleShift, else raise exception
-    * If node has only scale or shift value, fill missing value with default values
-    * i.e. EltwiseAdd: fill shifts from constant, fill scales with default values = 1.0f
-    * @param parentNode
-    * node from which data comes
-    * @return pair of scales and shifts
-    */
-    std::pair<std::vector<float>, std::vector<float>> getScalesAndShifts(const Node *parentNode) const;
+     * @brief Return scales and shift if nodes can be executed as ScaleShift, else raise exception
+     * If node has only scale or shift value, fill missing value with default values
+     * i.e. EltwiseAdd: fill shifts from constant, fill scales with default values = 1.0f
+     * @param parentNode
+     * node from which data comes
+     * @return pair of scales and shifts
+     */
+    std::pair<std::vector<float>, std::vector<float>> getScalesAndShifts(const Node* parentNode) const;
 
     void fuseDQScales(const float* scaleData, const size_t scaleSize);
     const std::vector<float>& getDQScales() const {
@@ -631,8 +662,14 @@ class Node {
      * Seed node should call this routine and pass its post operations list as parameter.
      * @param ops List of fused post operations
      */
-    virtual void appendPostOps(dnnl::post_ops& ops, const VectorDims& postOpDims, std::unordered_map<int, MemoryPtr>& postOpsMem, const int channelAxis = 1);
-    virtual void appendPostOps(dnnl::post_ops& ops, const VectorDims& postOpDims, std::vector<const void*>& postOpsMem, const int channelAxis = 1);
+    virtual void appendPostOps(dnnl::post_ops& ops,
+                               const VectorDims& postOpDims,
+                               std::unordered_map<int, MemoryPtr>& postOpsMem,
+                               const int channelAxis = 1);
+    virtual void appendPostOps(dnnl::post_ops& ops,
+                               const VectorDims& postOpDims,
+                               std::vector<const void*>& postOpsMem,
+                               const int channelAxis = 1);
     virtual bool canBeExecutedInInt8() const {
         OPENVINO_THROW_NOT_IMPLEMENTED("canBeExecutedInInt8 not implemented for node with type ",
                                        NameFromType(getType()));
@@ -649,22 +686,24 @@ class Node {
         this->type = type;
     }
 
-    virtual PortDescBasePtr getConsistentInputDesc(const NodeConfig &config, size_t idx) const;
-    virtual PortDescBasePtr getConsistentOutputDesc(const NodeConfig &config, size_t idx) const;
-    virtual MemoryDescPtr getSrcMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const;
-    virtual MemoryDescPtr getDstMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const;
+    virtual PortDescBasePtr getConsistentInputDesc(const NodeConfig& config, size_t idx) const;
+    virtual PortDescBasePtr getConsistentOutputDesc(const NodeConfig& config, size_t idx) const;
+    virtual MemoryDescPtr getSrcMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const;
+    virtual MemoryDescPtr getDstMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const;
 
-    virtual AttrPtr initPrimitiveAttr() { return nullptr; }
+    virtual AttrPtr initPrimitiveAttr() {
+        return nullptr;
+    }
 
-    typedef std::function<DnnlMemoryDescPtr (dnnl::primitive_desc& primitive_desc_it, size_t idx)>
-            GetPrimitiveMemoryFormatFunc;
+    typedef std::function<DnnlMemoryDescPtr(dnnl::primitive_desc& primitive_desc_it, size_t idx)>
+        GetPrimitiveMemoryFormatFunc;
     std::vector<GetPrimitiveMemoryFormatFunc> internalBlobDesc;
 
     std::vector<Shape> inputShapes;
     std::vector<Shape> outputShapes;
 
-    std::vector <NodePtr> fusedWith;
-    std::vector <NodePtr> mergedWith;
+    std::vector<NodePtr> fusedWith;
+    std::vector<NodePtr> mergedWith;
 
     int curNumaNode = -1;
 
@@ -672,11 +711,11 @@ class Node {
     virtual void toNumaNodeImpl(int numaID);
 
     std::string primitivesPriority;
-    std::vector <impl_desc_type> customImplPriorities;
-    std::vector <dnnl::memory::format_tag> inputMemoryFormatsFilter;
-    std::vector <dnnl::memory::format_tag> outputMemoryFormatsFilter;
+    std::vector<impl_desc_type> customImplPriorities;
+    std::vector<dnnl::memory::format_tag> inputMemoryFormatsFilter;
+    std::vector<dnnl::memory::format_tag> outputMemoryFormatsFilter;
     bool enforceBF16evenForGraphTail = false;
-    bool keepOriginalPrecision  = false;
+    bool keepOriginalPrecision = false;
 
     std::string originalLayers;  // contains names of the original layers separated by comma
     std::string parallelDomain;
@@ -692,11 +731,7 @@ class Node {
 
     int selectedPrimitiveDescriptorIndex = -1;
 
-    enum class InPlaceType {
-        Unknown,
-        InPlace,
-        NoInPlace
-    };
+    enum class InPlaceType { Unknown, InPlace, NoInPlace };
     mutable InPlaceType inplace = InPlaceType::Unknown;
     ConstantType constant = ConstantType::NoConst;
     std::vector<MemoryPtr> internalBlobs;
@@ -718,7 +753,7 @@ class Node {
     void selectPreferPrimitiveDescriptorWithShape(const std::vector<impl_desc_type>& priority, bool ignoreConstInputs);
     bool isOneDimShape(const ov::PartialShape& pshape);
     bool isReorderRequired(ov::intel_cpu::MemoryDescPtr desc1, ov::intel_cpu::MemoryDescPtr desc2);
-    bool isConfigDefined(const NodeConfig &config) const;
+    bool isConfigDefined(const NodeConfig& config) const;
     virtual bool canBeInPlace() const;
 
     /* returns default implementaion prioirity */
@@ -733,13 +768,15 @@ class Node {
 
     /**
      * @brief Auxiliary function to get node input precisions
-     * @return Vector of precisions based on information from node input edges. Return empty vector in case edges are not initialized yet.
+     * @return Vector of precisions based on information from node input edges. Return empty vector in case edges are
+     * not initialized yet.
      */
     virtual std::vector<ov::element::Type> getInputPrecisions() const;
 
     /**
      * @brief Auxiliary function to get node output precisions
-     * @return Vector of precisions based on information from node output edges. Return empty vector in case edges are not initialized yet.
+     * @return Vector of precisions based on information from node output edges. Return empty vector in case edges are
+     * not initialized yet.
      */
     virtual std::vector<ov::element::Type> getOutputPrecisions() const;
 
@@ -803,13 +840,14 @@ class Node {
     //     is still under control of strong references outside of cache.
     // privateWeightCache is for holding strong references to constant weight
     // copies of same content with different layouts.
-    std::shared_ptr<std::unordered_map<std::string, MemoryPtr>> privateWeightCache
-    = std::make_shared<std::unordered_map<std::string, MemoryPtr>>();
+    std::shared_ptr<std::unordered_map<std::string, MemoryPtr>> privateWeightCache =
+        std::make_shared<std::unordered_map<std::string, MemoryPtr>>();
 
 private:
-    static void removeEdge(const EdgePtr edge, std::vector<EdgeWeakPtr> &edges) {
-        edges.erase(std::remove_if(edges.begin(), edges.end(),
-                                   [&edge] (EdgeWeakPtr _edge) {
+    static void removeEdge(const EdgePtr edge, std::vector<EdgeWeakPtr>& edges) {
+        edges.erase(std::remove_if(edges.begin(),
+                                   edges.end(),
+                                   [&edge](EdgeWeakPtr _edge) {
                                        return _edge.lock() == edge;
                                    }),
                     edges.end());
@@ -856,22 +894,20 @@ constexpr uint64_t PortMask(T... rest) {
     return util::bit::mask(rest...);
 }
 
-class Node::NodesFactory : public openvino::cc::Factory<Type,
-                                            Node*(const std::shared_ptr<ov::Node>& op,
-                                                  const GraphContext::CPtr)> {
+class Node::NodesFactory
+    : public openvino::cc::Factory<Type, Node*(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr)> {
 public:
     NodesFactory();
 
     Node* create(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 };
 
-template<typename NodeType>
+template <typename NodeType>
 struct NodeImpl : public NodeType {
-    NodeImpl(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
-        : NodeType(op, context) {
+    NodeImpl(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) : NodeType(op, context) {
         NodeType::perfCounters().template buildClassCounters<NodeType>(NameFromType(NodeType::getType()));
     }
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/adaptive_pooling.cpp b/src/plugins/intel_cpu/src/nodes/adaptive_pooling.cpp
index f4e7f6217a8dec..f4af11b0f2362a 100644
--- a/src/plugins/intel_cpu/src/nodes/adaptive_pooling.cpp
+++ b/src/plugins/intel_cpu/src/nodes/adaptive_pooling.cpp
@@ -3,18 +3,21 @@
 //
 
 #include "adaptive_pooling.h"
-#include "openvino/core/parallel.hpp"
-#include "cpu/x64/cpu_isa_traits.hpp"
+
 #include <math.h>
-#include "onednn/dnnl.h"
-#include "dnnl_extension_utils.h"
-#include "selective_build.h"
+
 #include <openvino/opsets/opset8.hpp>
 #include <string>
 #include <utils/bfloat16.hpp>
-#include "utils/general_utils.h"
 #include <vector>
+
+#include "cpu/x64/cpu_isa_traits.hpp"
+#include "dnnl_extension_utils.h"
+#include "onednn/dnnl.h"
+#include "openvino/core/parallel.hpp"
+#include "selective_build.h"
 #include "shape_inference/custom/adaptive_pooling.hpp"
+#include "utils/general_utils.h"
 
 using namespace dnnl;
 using namespace dnnl::impl::cpu::x64;
@@ -23,7 +26,8 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 
-bool AdaptivePooling::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool AdaptivePooling::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                           std::string& errorMessage) noexcept {
     try {
         if (one_of(op->get_type_info(), ov::op::v8::AdaptiveAvgPool::get_type_info_static())) {
             auto adaPool = std::dynamic_pointer_cast<const ov::opset8::AdaptiveAvgPool>(op);
@@ -51,9 +55,9 @@ AdaptivePooling::AdaptivePooling(const std::shared_ptr<ov::Node>& op, const Grap
     : Node(op, context, AdaptivePoolingShapeInferFactory(op)) {
     std::string errorMessage;
     if (isSupportedOperation(op, errorMessage)) {
-      errorPrefix = "Adaptive Pooling layer with name '" + getName() + "' ";
+        errorPrefix = "Adaptive Pooling layer with name '" + getName() + "' ";
     } else {
-      OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
+        OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
     }
     if (one_of(op->get_type_info(), ov::op::v8::AdaptiveAvgPool::get_type_info_static())) {
         algorithm = Algorithm::AdaptivePoolingAvg;
@@ -104,14 +108,14 @@ void AdaptivePooling::initSupportedPrimitiveDescriptors() {
     // we supports only fp32 currently
     precision = ov::element::f32;
 
-    std::vector<LayoutType> dataFormats{ LayoutType::ncsp };
-    const auto &inDims = getInputShapeAtPort(0).getDims();
+    std::vector<LayoutType> dataFormats{LayoutType::ncsp};
+    const auto& inDims = getInputShapeAtPort(0).getDims();
     if (inDims[1] != Shape::UNDEFINED_DIM && inDims[1] != 1) {
         dataFormats.push_back(LayoutType::nspc);
         dataFormats.push_back(LayoutType::nCsp16c);
         dataFormats.push_back(LayoutType::nCsp8c);
     }
-    for (const auto &df : dataFormats) {
+    for (const auto& df : dataFormats) {
         if (algorithm == Algorithm::AdaptivePoolingAvg) {
             addSupportedPrimDesc({{df, precision}, {LayoutType::ncsp, ov::element::i32}},
                                  {{df, precision}},
@@ -134,9 +138,9 @@ void AdaptivePooling::execute(dnnl::stream strm) {
     if (!(inputPrec == dnnl_f32 && outputPrec == dnnl_f32))
         OPENVINO_THROW(errorPrefix, "doesn't support demanded precisions");
 
-    auto &srcMemory0 = getParentEdgeAt(0)->getMemory();
-    auto &srcMemory1 = getParentEdgeAt(1)->getMemory();
-    int *indexDst = nullptr;
+    auto& srcMemory0 = getParentEdgeAt(0)->getMemory();
+    auto& srcMemory1 = getParentEdgeAt(1)->getMemory();
+    int* indexDst = nullptr;
 
     if (algorithm == Algorithm::AdaptivePoolingMax) {
         indexDst = getDstDataAtPortAs<int>(1);
@@ -144,14 +148,15 @@ void AdaptivePooling::execute(dnnl::stream strm) {
 
     auto isPlainFmt = srcMemory0.getDesc().hasLayoutType(LayoutType::ncsp);
     auto isTailCFmt = srcMemory0.getDesc().hasLayoutType(LayoutType::nspc);
-    auto isBlkFmt = srcMemory0.getDesc().hasLayoutType(LayoutType::nCsp16c) || srcMemory0.getDesc().hasLayoutType(LayoutType::nCsp8c);
+    auto isBlkFmt = srcMemory0.getDesc().hasLayoutType(LayoutType::nCsp16c) ||
+                    srcMemory0.getDesc().hasLayoutType(LayoutType::nCsp8c);
 
     auto srcBlockDesc = srcMemory0.getDescWithType<BlockedMemoryDesc>();
     int blockSize = isBlkFmt ? srcBlockDesc->getBlockDims().back() : 1;
 
-    const auto *src = getSrcDataAtPortAs<const float>(0);
-    const auto *srcPooledSpatialShapes = getSrcDataAtPortAs<const int>(1);
-    auto *dst = getDstDataAtPortAs<float>(0);
+    const auto* src = getSrcDataAtPortAs<const float>(0);
+    const auto* srcPooledSpatialShapes = getSrcDataAtPortAs<const int>(1);
+    auto* dst = getDstDataAtPortAs<float>(0);
 
     if (static_cast<int>(srcMemory1.getShape().getElementsCount()) != spatialDimsCount)
         OPENVINO_THROW(errorPrefix,
@@ -175,8 +180,9 @@ void AdaptivePooling::execute(dnnl::stream strm) {
     const int iHW = IH * IW;
     const int oDHW = OD * OH * OW, oHW = OH * OW;
 
-    const int chPadding = blockSize * (isBlkFmt ? srcBlockDesc->getBlockDims()[1] : srcMemory0.getShape().getStaticDims()[1]);
-    const int blockCount = (isTailCFmt ? 1 :  chPadding / blockSize);
+    const int chPadding =
+        blockSize * (isBlkFmt ? srcBlockDesc->getBlockDims()[1] : srcMemory0.getShape().getStaticDims()[1]);
+    const int blockCount = (isTailCFmt ? 1 : chPadding / blockSize);
     auto selectedPrimitiveDescriptor = getSelectedPrimitiveDescriptor();
     if (!selectedPrimitiveDescriptor)
         OPENVINO_THROW(errorPrefix, "doesn't have primitive descriptors.");
@@ -186,27 +192,26 @@ void AdaptivePooling::execute(dnnl::stream strm) {
 
     // unified strides array
     const size_t tailDimsOffset = (isTailCFmt ? -1 : 0);
-    const size_t inStrides[5] = {
-            srcStrides[0],
-            (isTailCFmt ? 1 : srcStrides[1]),
-            (spatialDimsCount == 3 ? srcStrides[2 + tailDimsOffset] : 0),
-            (spatialDimsCount >= 2 ? srcStrides[spatialDimsCount + tailDimsOffset] : 0),
-            srcStrides[spatialDimsCount + 1 + tailDimsOffset] };
-    const size_t outStrides[5] = {
-            dstStrides[0],
-            (isTailCFmt ? 1 : dstStrides[1]),
-            (spatialDimsCount == 3 ? dstStrides[2 + tailDimsOffset] : 0),
-            (spatialDimsCount >= 2 ? dstStrides[spatialDimsCount + tailDimsOffset] : 0),
-            dstStrides[spatialDimsCount + 1 + tailDimsOffset] };
-
-    std::function<void(const float *, float *, int, int, int, size_t)> pool;
-    auto poolMax = [&] (const float *srcData, float *dstData, int od, int oh, int ow, size_t spatIndOff) {
+    const size_t inStrides[5] = {srcStrides[0],
+                                 (isTailCFmt ? 1 : srcStrides[1]),
+                                 (spatialDimsCount == 3 ? srcStrides[2 + tailDimsOffset] : 0),
+                                 (spatialDimsCount >= 2 ? srcStrides[spatialDimsCount + tailDimsOffset] : 0),
+                                 srcStrides[spatialDimsCount + 1 + tailDimsOffset]};
+    const size_t outStrides[5] = {dstStrides[0],
+                                  (isTailCFmt ? 1 : dstStrides[1]),
+                                  (spatialDimsCount == 3 ? dstStrides[2 + tailDimsOffset] : 0),
+                                  (spatialDimsCount >= 2 ? dstStrides[spatialDimsCount + tailDimsOffset] : 0),
+                                  dstStrides[spatialDimsCount + 1 + tailDimsOffset]};
+
+    std::function<void(const float*, float*, int, int, int, size_t)> pool;
+    auto poolMax = [&](const float* srcData, float* dstData, int od, int oh, int ow, size_t spatIndOff) {
         size_t dStart, dEnd, hStart, hEnd, wStart, wEnd;
         setBinBorders(&dStart, &dEnd, od, ID, OD);
         setBinBorders(&hStart, &hEnd, oh, IH, OH);
         setBinBorders(&wStart, &wEnd, ow, IW, OW);
-        float res = srcData[dStart * inStrides[2] + hStart * inStrides[3] + wStart * inStrides[4]];  // initial max value
-        int resIndex = dStart * iHW + hStart * IW + wStart;  // initial max index
+        float res =
+            srcData[dStart * inStrides[2] + hStart * inStrides[3] + wStart * inStrides[4]];  // initial max value
+        int resIndex = dStart * iHW + hStart * IW + wStart;                                  // initial max index
         for (size_t pixD = dStart; pixD < dEnd; pixD++) {
             for (size_t pixH = hStart; pixH < hEnd; pixH++) {
                 for (size_t pixW = wStart; pixW < wEnd; pixW++) {
@@ -219,7 +224,7 @@ void AdaptivePooling::execute(dnnl::stream strm) {
         *dstData = res;
         indexDst[spatIndOff * oDHW + od * oHW + oh * OW + ow] = resIndex;
     };
-    auto poolAvg = [&] (const float *srcData, float *dstData, int od, int oh, int ow, size_t spatIndOff) {
+    auto poolAvg = [&](const float* srcData, float* dstData, int od, int oh, int ow, size_t spatIndOff) {
         size_t dStart, dEnd, hStart, hEnd, wStart, wEnd;
         setBinBorders(&dStart, &dEnd, od, ID, OD);
         setBinBorders(&hStart, &hEnd, oh, IH, OH);
@@ -245,11 +250,10 @@ void AdaptivePooling::execute(dnnl::stream strm) {
         pool = poolAvg;
     }
 
-    parallel_for5d(N, blockCount, OD, OH, OW,
-        [&](int n, int blkIdx, int od, int oh, int ow) {
+    parallel_for5d(N, blockCount, OD, OH, OW, [&](int n, int blkIdx, int od, int oh, int ow) {
         auto srcData = src + n * inStrides[0] + blkIdx * inStrides[1];
-        auto dstData = dst + n * outStrides[0] + blkIdx * outStrides[1] +
-                       od * outStrides[2] + oh * outStrides[3] + ow * outStrides[4];
+        auto dstData = dst + n * outStrides[0] + blkIdx * outStrides[1] + od * outStrides[2] + oh * outStrides[3] +
+                       ow * outStrides[4];
         int cStart = 0, cEnd = C, inResidual = 0, outResidual = 0;
         if (!isTailCFmt) {
             cStart = blkIdx * blockSize;
@@ -263,18 +267,23 @@ void AdaptivePooling::execute(dnnl::stream strm) {
                 inResidual = outResidual = c % blockSize;
             }
             pool(srcData + inResidual, dstData + outResidual, od, oh, ow, n * C + c);
-        }});
+        }
+    });
 }
 
 bool AdaptivePooling::created() const {
     return getType() == Type::AdaptivePooling;
 }
 
-inline void AdaptivePooling::setBinBorders(size_t *startPtr, size_t *endPtr, size_t idx, size_t inputLength, size_t outputLength) {
+inline void AdaptivePooling::setBinBorders(size_t* startPtr,
+                                           size_t* endPtr,
+                                           size_t idx,
+                                           size_t inputLength,
+                                           size_t outputLength) {
     *(startPtr) = idx * inputLength / outputLength;
     *(endPtr) = ceil(static_cast<float>((idx + 1) * inputLength) / outputLength);
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/adaptive_pooling.h b/src/plugins/intel_cpu/src/nodes/adaptive_pooling.h
index c88c9b5989aef9..04b628a5da5cee 100644
--- a/src/plugins/intel_cpu/src/nodes/adaptive_pooling.h
+++ b/src/plugins/intel_cpu/src/nodes/adaptive_pooling.h
@@ -5,9 +5,11 @@
 #pragma once
 
 #include <node.h>
-#include <string>
+
 #include <memory>
+#include <string>
 #include <vector>
+
 #include "dnnl_extension_utils.h"
 
 namespace ov {
@@ -29,16 +31,18 @@ class AdaptivePooling : public Node {
     int spatialDimsCount;
     mutable std::vector<Dim> spatialDimsValue = {};
     ov::element::Type precision = ov::element::f32;
-    inline void setBinBorders(size_t *startPtr, size_t *endPtr, size_t idx, size_t inputLength, size_t outputLength);
+    inline void setBinBorders(size_t* startPtr, size_t* endPtr, size_t idx, size_t inputLength, size_t outputLength);
 
     std::string errorPrefix;
 
 protected:
     bool needShapeInfer() const override;
-    bool needPrepareParams() const override { return false; };
+    bool needPrepareParams() const override {
+        return false;
+    };
     void executeDynamicImpl(dnnl::stream strm) override;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/batch_to_space.cpp b/src/plugins/intel_cpu/src/nodes/batch_to_space.cpp
index 80713e90750e2d..50665c083ec930 100644
--- a/src/plugins/intel_cpu/src/nodes/batch_to_space.cpp
+++ b/src/plugins/intel_cpu/src/nodes/batch_to_space.cpp
@@ -2,14 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <vector>
+#include "batch_to_space.h"
+
+#include <openvino/opsets/opset2.hpp>
 #include <string>
+#include <vector>
+
 #include "dnnl_types.h"
+#include "nodes/common/blocked_desc_creator.h"
 #include "openvino/core/parallel.hpp"
 #include "selective_build.h"
-#include "batch_to_space.h"
-#include "nodes/common/blocked_desc_creator.h"
-#include <openvino/opsets/opset2.hpp>
 
 namespace ov {
 namespace intel_cpu {
@@ -40,8 +42,8 @@ BatchToSpace::BatchToSpace(const std::shared_ptr<ov::Node>& op, const GraphConte
     if (inputShapes.size() != 4 || outputShapes.size() != 1)
         OPENVINO_THROW(errorPrefix, " has incorrect number of input or output edges!");
 
-    const auto &inDims = getInputShapeAtPort(0).getDims();
-    const auto &outDims = getOutputShapeAtPort(0).getDims();
+    const auto& inDims = getInputShapeAtPort(0).getDims();
+    const auto& outDims = getOutputShapeAtPort(0).getDims();
     if (inDims.size() < 4 || inDims.size() > 5)
         OPENVINO_THROW(errorPrefix, " has unsupported 'data' input rank: ", inDims.size());
     if (inDims.size() != outDims.size())
@@ -52,7 +54,7 @@ void BatchToSpace::initSupportedPrimitiveDescriptors() {
     if (!supportedPrimitiveDescriptors.empty())
         return;
 
-    const auto &inDims = getInputShapeAtPort(0).getDims();
+    const auto& inDims = getInputShapeAtPort(0).getDims();
     const auto precision = getOriginalInputPrecisionAtPort(0);
     const std::set<size_t> supported_precision_sizes = {1, 2, 4, 8};
     if (supported_precision_sizes.find(precision.size()) == supported_precision_sizes.end())
@@ -88,7 +90,7 @@ void BatchToSpace::initSupportedPrimitiveDescriptors() {
     }
 }
 
-static std::vector<size_t> getShape5D(const VectorDims &shape) {
+static std::vector<size_t> getShape5D(const VectorDims& shape) {
     std::vector<size_t> shape5D(5, 1);
     for (int i = 0; i < 2; i++) {
         shape5D[i] = shape[i];
@@ -98,26 +100,26 @@ static std::vector<size_t> getShape5D(const VectorDims &shape) {
     return shape5D;
 }
 
-template<typename T>
+template <typename T>
 void BatchToSpace::batchToSpaceKernel() {
-    const auto *srcData = getSrcDataAtPortAs<const T>(0);
-    const auto *blockShapesPtr = getSrcDataAtPortAs<int>(1);
+    const auto* srcData = getSrcDataAtPortAs<const T>(0);
+    const auto* blockShapesPtr = getSrcDataAtPortAs<int>(1);
     size_t dataRank = getSrcMemoryAtPort(0)->getShape().getRank();
     blockShapeIn.clear();
     for (size_t i = 0; i < dataRank; i++) {
         blockShapeIn.push_back(*(blockShapesPtr + i));
     }
 
-    const auto *padsBeginPtr = getSrcDataAtPortAs<int>(2);
+    const auto* padsBeginPtr = getSrcDataAtPortAs<int>(2);
     cropsBeginIn.clear();
     for (size_t i = 0; i < dataRank; i++) {
         cropsBeginIn.push_back(*(padsBeginPtr + i));
     }
 
-    auto *dstData = getDstDataAtPortAs<T>(0);
+    auto* dstData = getDstDataAtPortAs<T>(0);
 
-    const auto &inDims = getParentEdgeAt(0)->getMemory().getStaticDims();
-    const auto &outDims = getChildEdgeAt(0)->getMemory().getStaticDims();
+    const auto& inDims = getParentEdgeAt(0)->getMemory().getStaticDims();
+    const auto& outDims = getChildEdgeAt(0)->getMemory().getStaticDims();
 
     auto srcDesc = getParentEdgeAt(0)->getMemory().getDescWithType<BlockedMemoryDesc>();
 
@@ -193,8 +195,8 @@ void BatchToSpace::batchToSpaceKernel() {
             const int64_t addTmpOC = blocked ? 0lu : oAdd[1];
             const int64_t addTmpOc = blocked ? oAdd[1] : 0lu;
 
-            const size_t firstI1 = i0 == 0 ?          std::max(begin[1], indxStart[1])    : begin[1];
-            const size_t lastI1  = i0 == indxEnd[0] ? std::min(indxEnd[1] + 1, finish[1]) : finish[1];
+            const size_t firstI1 = i0 == 0 ? std::max(begin[1], indxStart[1]) : begin[1];
+            const size_t lastI1 = i0 == indxEnd[0] ? std::min(indxEnd[1] + 1, finish[1]) : finish[1];
 
             for (size_t i1 = firstI1; i1 < lastI1; ++i1) {
                 const size_t block = i1 == finish[1] ? lastBlock : blockSize;
@@ -216,12 +218,13 @@ void BatchToSpace::batchToSpaceKernel() {
                             const size_t dstIdx4 = dstIdx3 + tmpOw * blockSize;
                             for (size_t it = 0; it < itEnd + 1; ++it) {
                                 const size_t i5Begin = it == 0 ? 0 : (it * blockSize - 1 - oAdd[1]) / blockShape[1] + 1;
-                                const size_t i5End = it == itEnd ? (block - 1) : ((it + 1) * blockSize - 1 - oAdd[1]) / blockShape[1];
+                                const size_t i5End =
+                                    it == itEnd ? (block - 1) : ((it + 1) * blockSize - 1 - oAdd[1]) / blockShape[1];
                                 for (size_t i5 = i5Begin; i5 < i5End + 1; ++i5) {
                                     const int64_t tmpOc = i5 * blockShape[1] + addTmpOc;
                                     const size_t srcIdx5 = srcIdx4 + i5;
                                     const size_t dstIdx5 =
-                                            dstIdx4 + it * outSpatialStep * blockSize + (tmpOc - it * blockSize);
+                                        dstIdx4 + it * outSpatialStep * blockSize + (tmpOc - it * blockSize);
                                     dstData[dstIdx5] = srcData[srcIdx5];
                                 }
                             }
@@ -239,13 +242,19 @@ void BatchToSpace::executeDynamicImpl(dnnl::stream strm) {
 
 void BatchToSpace::execute(dnnl::stream strm) {
     switch (getParentEdgeAt(0)->getMemory().getDesc().getPrecision().size()) {
-        case 1: batchToSpaceKernel<element_type_traits<ov::element::u8>::value_type>();  break;
-        case 2: batchToSpaceKernel<element_type_traits<ov::element::u16>::value_type>(); break;
-        case 4: batchToSpaceKernel<element_type_traits<ov::element::i32>::value_type>(); break;
-        default:
-            OPENVINO_THROW("BatchToSpace layer does not support precision '",
-                           std::string(getParentEdgeAt(0)->getMemory().getDesc().getPrecision().get_type_name()),
-                           "'");
+    case 1:
+        batchToSpaceKernel<element_type_traits<ov::element::u8>::value_type>();
+        break;
+    case 2:
+        batchToSpaceKernel<element_type_traits<ov::element::u16>::value_type>();
+        break;
+    case 4:
+        batchToSpaceKernel<element_type_traits<ov::element::i32>::value_type>();
+        break;
+    default:
+        OPENVINO_THROW("BatchToSpace layer does not support precision '",
+                       std::string(getParentEdgeAt(0)->getMemory().getDesc().getPrecision().get_type_name()),
+                       "'");
     }
 }
 
@@ -253,6 +262,6 @@ bool BatchToSpace::created() const {
     return getType() == Type::BatchToSpace;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/batch_to_space.h b/src/plugins/intel_cpu/src/nodes/batch_to_space.h
index 1b583f74bd7905..5211e0c0b5dd10 100644
--- a/src/plugins/intel_cpu/src/nodes/batch_to_space.h
+++ b/src/plugins/intel_cpu/src/nodes/batch_to_space.h
@@ -14,7 +14,7 @@ class BatchToSpace : public Node {
 public:
     BatchToSpace(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
 
     // output shape can potentially be empty
@@ -25,14 +25,18 @@ class BatchToSpace : public Node {
     void execute(dnnl::stream strm) override;
     bool created() const override;
 
-    bool needPrepareParams() const override { return false; };
-    bool needShapeInfer() const override {return true;};
+    bool needPrepareParams() const override {
+        return false;
+    };
+    bool needShapeInfer() const override {
+        return true;
+    };
     void executeDynamicImpl(dnnl::stream strm) override;
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
 private:
-    template<typename T>
+    template <typename T>
     void batchToSpaceKernel();
 
 private:
@@ -42,6 +46,6 @@ class BatchToSpace : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/bin_conv.cpp b/src/plugins/intel_cpu/src/nodes/bin_conv.cpp
index d1e82235ba9bb1..336a370374a9f9 100644
--- a/src/plugins/intel_cpu/src/nodes/bin_conv.cpp
+++ b/src/plugins/intel_cpu/src/nodes/bin_conv.cpp
@@ -3,34 +3,35 @@
 //
 
 #include "bin_conv.h"
-#include "eltwise.h"
-#include "fake_quantize.h"
-#include "conv.h"
+
 #include <memory>
 #include <string>
 #include <vector>
-#include "dnnl_types.h"
+
+#include "conv.h"
+#include "cpu/x64/cpu_isa_traits.hpp"
+#include "cpu/x64/injectors/jit_uni_depthwise_injector.hpp"
+#include "cpu/x64/injectors/jit_uni_eltwise_injector.hpp"
+#include "cpu/x64/jit_generator.hpp"
 #include "dnnl_extension_utils.h"
+#include "dnnl_types.h"
+#include "eltwise.h"
+#include "fake_quantize.h"
 #include "openvino/core/parallel.hpp"
-#include "cpu/x64/jit_generator.hpp"
-#include "cpu/x64/injectors/jit_uni_eltwise_injector.hpp"
-#include "cpu/x64/injectors/jit_uni_depthwise_injector.hpp"
-#include "cpu/x64/cpu_isa_traits.hpp"
-#include "utils/general_utils.h"
 #include "openvino/opsets/opset1.hpp"
+#include "utils/general_utils.h"
 #include "utils/ngraph_utils.hpp"
 
 // WA for xbyak.h
 #ifdef _WIN32
-# ifndef _WINSOCKAPI_
-#  define _WINSOCKAPI_
-# endif
-# ifndef _WINSOCK2API_
-#  define _WINSOCK2API_
-# endif
+#    ifndef _WINSOCKAPI_
+#        define _WINSOCKAPI_
+#    endif
+#    ifndef _WINSOCK2API_
+#        define _WINSOCK2API_
+#    endif
 #endif
 
-
 using namespace dnnl;
 using namespace dnnl::impl;
 using namespace dnnl::impl::cpu;
@@ -42,14 +43,17 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 #if defined(OPENVINO_ARCH_X86_64)
-#define GET_OFF(field) offsetof(jit_bin_conv_call_args, field)
+#    define GET_OFF(field) offsetof(jit_bin_conv_call_args, field)
 
 template <cpu_isa_t isa>
 struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_bin_conv_kernel_f32)
 
-    explicit jit_uni_bin_conv_kernel_f32(jit_bin_conv_params jcp, jit_dw_conv_params jcp_dw_conv, const dnnl_primitive_attr &attr) :
-        jit_uni_bin_conv_kernel(jcp, jcp_dw_conv, attr), jit_generator(jit_name())  {}
+    explicit jit_uni_bin_conv_kernel_f32(jit_bin_conv_params jcp,
+                                         jit_dw_conv_params jcp_dw_conv,
+                                         const dnnl_primitive_attr& attr)
+        : jit_uni_bin_conv_kernel(jcp, jcp_dw_conv, attr),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -57,16 +61,19 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
     }
 
     void generate() override {
-        const auto &p = attr_.post_ops_;
+        const auto& p = attr_.post_ops_;
         int end_idx = jcp_.with_dw_conv ? p.find(primitive_kind::convolution) : p.len();
         for (int i = 0; i < end_idx; i++) {
-            auto &post_op = p.entry_[i];
+            auto& post_op = p.entry_[i];
             if (post_op.is_eltwise()) {
-                eltwise_injectors.push_back(std::make_shared<jit_uni_eltwise_injector_f32<isa>>(
-                        this, post_op.eltwise, true, eltwise_reserved, mask_post_op_reserved));
+                eltwise_injectors.push_back(std::make_shared<jit_uni_eltwise_injector_f32<isa>>(this,
+                                                                                                post_op.eltwise,
+                                                                                                true,
+                                                                                                eltwise_reserved,
+                                                                                                mask_post_op_reserved));
             } else if (post_op.is_depthwise()) {
-                depthwise_injectors.push_back(std::make_shared<jit_uni_depthwise_injector_f32<isa>>(
-                        this, post_op, mask_post_op_reserved));
+                depthwise_injectors.push_back(
+                    std::make_shared<jit_uni_depthwise_injector_f32<isa>>(this, post_op, mask_post_op_reserved));
             }
         }
 
@@ -80,7 +87,7 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
         mov(reg_oc_work, ptr[this->param1 + GET_OFF(oc_work)]);
         mov(reg_post_ops_data, ptr[this->param1 + GET_OFF(post_op_data)]);
 
-        mov(reg_oc_off,  ptr[param1 + GET_OFF(oc_off)]);
+        mov(reg_oc_off, ptr[param1 + GET_OFF(oc_off)]);
         mov(reg_table, l_table);
 
         Label main_loop_label;
@@ -98,14 +105,16 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
 
         int nbits = 8;
 
-        L(main_loop_label); {
+        L(main_loop_label);
+        {
             cmp(reg_oc_work, jcp_.oc_block);
             jl(tail_label, T_NEAR);
 
             solve_common(1, jcp_.oc_block);
 
             sub(reg_oc_work, jcp_.oc_block);
-            add(reg_kernel_base, jcp_.oc_block * jcp_.nb_ic * jcp_.kh * jcp_.kw * div_up(jcp_.ic_block, nbits) * jcp_.typesize_in);
+            add(reg_kernel_base,
+                jcp_.oc_block * jcp_.nb_ic * jcp_.kh * jcp_.kw * div_up(jcp_.ic_block, nbits) * jcp_.typesize_in);
 
             if (jcp_.with_dw_conv) {
                 add(reg_output_base, jcp_.oc_block * jcp_dw_conv_.kh * jcp_.ow * jcp_.typesize_out);
@@ -137,8 +146,7 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
     }
 
 private:
-    using Vmm = typename conditional3<isa == x64::sse41, Xbyak::Xmm, isa == x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm = typename conditional3<isa == x64::sse41, Xbyak::Xmm, isa == x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
 
     using Ymm = const Xbyak::Ymm;
     using reg8_t = const Xbyak::Reg8;
@@ -212,100 +220,108 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
     nstl::vector<std::shared_ptr<jit_uni_eltwise_injector_f32<isa>>> eltwise_injectors;
     nstl::vector<std::shared_ptr<jit_uni_depthwise_injector_f32<isa>>> depthwise_injectors;
 
-    void cvt2ps(dnnl::memory::data_type type_in, Vmm vmm_in, const Xbyak::Operand &op, bool scalar_load) {
+    void cvt2ps(dnnl::memory::data_type type_in, Vmm vmm_in, const Xbyak::Operand& op, bool scalar_load) {
         Xmm xmm_in = Xmm(vmm_in.getIdx());
 
         switch (type_in) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                if (scalar_load) {
-                    mov(reg_tmp_32, op);
-                    uni_vmovq(xmm_in, reg_tmp_64);
-                } else {
-                    uni_vmovups(vmm_in, op);
-                }
-                break;
-            case memory::data_type::s8:
-                if (scalar_load) {
-                    movsx(reg_tmp_32, op);
-                    uni_vmovq(xmm_in, reg_tmp_64);
-                } else {
-                    uni_vpmovsxbd(vmm_in, op);
-                }
-                break;
-            case memory::data_type::u8:
-                if (scalar_load) {
-                    movzx(reg_tmp_32, op);
-                    uni_vmovq(xmm_in, reg_tmp_64);
-                } else {
-                    uni_vpmovzxbd(vmm_in, op);
-                }
-                break;
-            default: assert(!"unsupported data type");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            if (scalar_load) {
+                mov(reg_tmp_32, op);
+                uni_vmovq(xmm_in, reg_tmp_64);
+            } else {
+                uni_vmovups(vmm_in, op);
+            }
+            break;
+        case memory::data_type::s8:
+            if (scalar_load) {
+                movsx(reg_tmp_32, op);
+                uni_vmovq(xmm_in, reg_tmp_64);
+            } else {
+                uni_vpmovsxbd(vmm_in, op);
+            }
+            break;
+        case memory::data_type::u8:
+            if (scalar_load) {
+                movzx(reg_tmp_32, op);
+                uni_vmovq(xmm_in, reg_tmp_64);
+            } else {
+                uni_vpmovzxbd(vmm_in, op);
+            }
+            break;
+        default:
+            assert(!"unsupported data type");
         }
 
         if (type_in != data_type::f32)
             uni_vcvtdq2ps(vmm_in, vmm_in);
     }
 
-    void store_dst(const Xbyak::Address &op, Vmm vmm_dst, bool scalar_store) {
+    void store_dst(const Xbyak::Address& op, Vmm vmm_dst, bool scalar_store) {
         Ymm ymm_dst = Ymm(vmm_dst.getIdx());
         Xmm xmm_dst = Xmm(vmm_dst.getIdx());
 
         switch (jcp_.dst_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                if (scalar_store) {
-                    movq(reg_tmp_64, xmm_dst);
-                    mov(op, reg_tmp_32);
-                } else {
-                    uni_vmovups(op, vmm_dst);
-                }
-                break;
-            case memory::data_type::s8:
-                uni_vpackssdw(vmm_dst, vmm_dst, vmm_dst);
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            if (scalar_store) {
+                movq(reg_tmp_64, xmm_dst);
+                mov(op, reg_tmp_32);
+            } else {
+                uni_vmovups(op, vmm_dst);
+            }
+            break;
+        case memory::data_type::s8:
+            uni_vpackssdw(vmm_dst, vmm_dst, vmm_dst);
 
-                if (isa != x64::sse41 && !scalar_store)
-                    vpermq(ymm_dst, ymm_dst, 0x08);
+            if (isa != x64::sse41 && !scalar_store)
+                vpermq(ymm_dst, ymm_dst, 0x08);
 
-                uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
 
-                if (scalar_store) {
-                    movq(reg_tmp_64, xmm_dst);
-                    mov(op, reg_tmp_8);
-                } else {
-                    if (isa != x64::sse41)
-                        vmovq(op, xmm_dst);
-                    else
-                        movd(op, xmm_dst);
-                }
-                break;
-            case memory::data_type::u8:
-            case memory::data_type::bin:
-                uni_vpackusdw(vmm_dst, vmm_dst, vmm_dst);
+            if (scalar_store) {
+                movq(reg_tmp_64, xmm_dst);
+                mov(op, reg_tmp_8);
+            } else {
+                if (isa != x64::sse41)
+                    vmovq(op, xmm_dst);
+                else
+                    movd(op, xmm_dst);
+            }
+            break;
+        case memory::data_type::u8:
+        case memory::data_type::bin:
+            uni_vpackusdw(vmm_dst, vmm_dst, vmm_dst);
 
-                if (isa != x64::sse41 && !scalar_store)
-                    vpermq(ymm_dst, ymm_dst, 0x08);
+            if (isa != x64::sse41 && !scalar_store)
+                vpermq(ymm_dst, ymm_dst, 0x08);
 
-                uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
 
-                if (scalar_store) {
-                    movq(reg_tmp_64, xmm_dst);
-                    mov(op, reg_tmp_8);
-                } else {
-                    if (isa != x64::sse41)
-                        vmovq(op, xmm_dst);
-                    else
-                        movd(op, xmm_dst);
-                }
+            if (scalar_store) {
+                movq(reg_tmp_64, xmm_dst);
+                mov(op, reg_tmp_8);
+            } else {
+                if (isa != x64::sse41)
+                    vmovq(op, xmm_dst);
+                else
+                    movd(op, xmm_dst);
+            }
 
-                break;
-            default:
-                assert(!"unknown dst_dt");
+            break;
+        default:
+            assert(!"unknown dst_dt");
         }
     }
 
-    void apply_filter(int ur_w, int pad_l, int pad_r, int oc_blocks, int oc_step, int ic_blocks, bool last_icb, bool h_padded) {
+    void apply_filter(int ur_w,
+                      int pad_l,
+                      int pad_r,
+                      int oc_blocks,
+                      int oc_step,
+                      int ic_blocks,
+                      bool last_icb,
+                      bool h_padded) {
         int kw = jcp_.kw;
         int kh = jcp_.kh;
         int stride_w = jcp_.stride_w;
@@ -318,15 +334,16 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
 
         for (int ki = 0; ki < kw; ki++) {
             int jj_start = nstl::max(0, div_up(pad_l - ki * dilate_w, stride_w));
-            int jj_end = ur_w  - nstl::max(0, div_up(ki*dilate_w+pad_r-(kw-1)*dilate_w, stride_w));
+            int jj_end = ur_w - nstl::max(0, div_up(ki * dilate_w + pad_r - (kw - 1) * dilate_w, stride_w));
 
             int _start = (!jcp_.exclude_pad) ? 0 : jj_start;
             int _end = (!jcp_.exclude_pad) ? ur_w : jj_end;
 
             for (int ifm2 = 0; ifm2 < ic_blocks; ifm2++) {
                 for (int jj = _start; jj < _end; jj++) {
-                    int inp_off = ((ki*dilate_w + jj*stride_w - pad_l)*div_up(jcp_.ic, nbits) +
-                                   ifm2 * div_up(ic_blk, nbits)) * jcp_.typesize_in;
+                    int inp_off = ((ki * dilate_w + jj * stride_w - pad_l) * div_up(jcp_.ic, nbits) +
+                                   ifm2 * div_up(ic_blk, nbits)) *
+                                  jcp_.typesize_in;
 
                     if (h_padded || jj < jj_start || jj >= jj_end) {
                         uni_vmovups(vmm_src, ptr[reg_table + 8 * vlen]);
@@ -336,10 +353,11 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
 
                     for (int r = 0; r < repeats; r++) {
                         for (int ii = 0; ii < oc_blocks; ii++) {
-                            int ker_off = (ifm2 * kh * kw * div_up(ic_blk, nbits) * oc_blk
-                                           + ii * jcp_.nb_ic * div_up(ic_blk, nbits) * kh * kw * oc_blk
-                                           + ki * div_up(ic_blk, nbits) * oc_blk
-                                           + r * div_up(ic_blk, nbits) * (oc_blk / 2)) * jcp_.typesize_in;
+                            int ker_off =
+                                (ifm2 * kh * kw * div_up(ic_blk, nbits) * oc_blk +
+                                 ii * jcp_.nb_ic * div_up(ic_blk, nbits) * kh * kw * oc_blk +
+                                 ki * div_up(ic_blk, nbits) * oc_blk + r * div_up(ic_blk, nbits) * (oc_blk / 2)) *
+                                jcp_.typesize_in;
 
                             uni_vmovups(vmm_tmp, ptr[aux1_reg_kernel + ker_off]);
 
@@ -350,7 +368,8 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
                             if (mayiuse(x64::avx512_vpopcnt)) {
                                 vpopcntd(vmm_tmp, vmm_tmp);
                                 uni_vpaddd(Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj),
-                                           Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj), vmm_tmp);
+                                           Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj),
+                                           vmm_tmp);
                             } else {
                                 if (isa == x64::sse41) {
                                     movups(vmm_tmp1, vmm_tmp);
@@ -375,12 +394,15 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
                                 }
 
                                 if (mayiuse(avx512_core_vnni)) {
-                                    vpdpbusd(Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj), vmm_tmp, vmm_one_u8);
+                                    vpdpbusd(Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj),
+                                             vmm_tmp,
+                                             vmm_one_u8);
                                 } else {
                                     uni_vpmaddubsw(vmm_tmp, vmm_tmp, vmm_one_u8);
                                     uni_vpmaddwd(vmm_tmp, vmm_tmp, vmm_one_s16);
                                     uni_vpaddd(Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj),
-                                               Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj), vmm_tmp);
+                                               Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj),
+                                               vmm_tmp);
                                 }
                             }
                         }
@@ -431,22 +453,22 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
         int nbits = 8;
         const int inp_mult = dilate_h * div_up(jcp_.ic, nbits);
 
-        Label t_overflow_label, no_t_overflow_label,
-                b_overflow_label, no_b_overflow_label;
+        Label t_overflow_label, no_t_overflow_label, b_overflow_label, no_b_overflow_label;
 
         mov(aux_reg_input, reg_input);
         mov(aux_reg_kernel, reg_kernel_base);
 
-        uni_vmovups(vmm_lookup,  ptr[reg_table + 0 * vlen]);
-        uni_vmovups(vmm_mask,    ptr[reg_table + 1 * vlen]);
-        uni_vmovups(vmm_one_u8,  ptr[reg_table + 5 * vlen]);
+        uni_vmovups(vmm_lookup, ptr[reg_table + 0 * vlen]);
+        uni_vmovups(vmm_mask, ptr[reg_table + 1 * vlen]);
+        uni_vmovups(vmm_one_u8, ptr[reg_table + 5 * vlen]);
         uni_vmovups(vmm_one_s16, ptr[reg_table + 6 * vlen]);
 
         if (!jcp_.exclude_pad) {
-            mov(reg_overflow,  ptr[param1 + GET_OFF(t_overflow)]);
+            mov(reg_overflow, ptr[param1 + GET_OFF(t_overflow)]);
             cmp(reg_overflow, 0);
             je(no_t_overflow_label, T_NEAR);
-            L(t_overflow_label); {
+            L(t_overflow_label);
+            {
                 oh_step_unroll_kw(ur_w, pad_l, pad_r, oc_blocks, oc_step, true);
 
                 add(aux_reg_kernel, jcp_.typesize_in * kw * jcp_.oc_block * div_up(jcp_.ic_block, nbits));
@@ -459,8 +481,8 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
 
         Label skip_kh_loop;
         mov(reg_kh, ptr[this->param1 + GET_OFF(kh_padding)]);
-        if (!jcp_.exclude_pad || (jcp_.exclude_pad &&
-                                  (jcp_.kh - 1) * (jcp_.dilate_h + 1) < nstl::max(jcp_.t_pad, jcp_.b_pad))) {
+        if (!jcp_.exclude_pad ||
+            (jcp_.exclude_pad && (jcp_.kh - 1) * (jcp_.dilate_h + 1) < nstl::max(jcp_.t_pad, jcp_.b_pad))) {
             cmp(reg_kh, 0);
             je(skip_kh_loop, T_NEAR);
         }
@@ -481,10 +503,11 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
         L(skip_kh_loop);
 
         if (!jcp_.exclude_pad) {
-            mov(reg_overflow,  ptr[param1 + GET_OFF(b_overflow)]);
+            mov(reg_overflow, ptr[param1 + GET_OFF(b_overflow)]);
             cmp(reg_overflow, 0);
             je(no_b_overflow_label, T_NEAR);
-            L(b_overflow_label); {
+            L(b_overflow_label);
+            {
                 oh_step_unroll_kw(ur_w, pad_l, pad_r, oc_blocks, oc_step, true);
 
                 add(aux_reg_kernel, jcp_.typesize_in * kw * jcp_.oc_block * div_up(jcp_.ic_block, nbits));
@@ -515,7 +538,7 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
             kmovw(ktail_mask, reg_tmp_32);
         }
 
-        const auto &p = attr_.post_ops_;
+        const auto& p = attr_.post_ops_;
         for (int r = 0; r < repeats; r++) {
             int tail_size = isa == x64::sse41 ? nstl::min(jcp_.oc_block / 2, oc_step - r * jcp_.oc_block / 2) : oc_step;
             bool is_scalar_store = isa == x64::sse41 ? tail_size < jcp_.oc_block / 2 : tail_size < jcp_.oc_block;
@@ -524,15 +547,17 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
 
             if (jcp_.exclude_pad) {
                 mov(reg_tmp_32, jcp_.ic);
-                imul(reg_tmp_32,  ptr[param1 + GET_OFF(kh_padding)]);
+                imul(reg_tmp_32, ptr[param1 + GET_OFF(kh_padding)]);
 
                 for (int jj = 0; jj < ur_w; jj++)
                     kw_padding[jj] = 0;
 
                 for (int ki = 0; ki < jcp_.kw; ki++) {
                     int jj_start = nstl::max(0, div_up(pad_l - ki * (jcp_.dilate_w + 1), jcp_.stride_w));
-                    int jj_end = ur_w - nstl::max(0, div_up(ki * (jcp_.dilate_w + 1) + pad_r -
-                                                                          (jcp_.kw - 1) * (jcp_.dilate_w + 1), jcp_.stride_w));
+                    int jj_end =
+                        ur_w - nstl::max(0,
+                                         div_up(ki * (jcp_.dilate_w + 1) + pad_r - (jcp_.kw - 1) * (jcp_.dilate_w + 1),
+                                                jcp_.stride_w));
                     for (int jj = jj_start; jj < jj_end; jj++) {
                         kw_padding[jj]++;
                     }
@@ -552,8 +577,11 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
                 }
 
                 for (int ii = 0; ii < oc_blocks; ii++) {
-                    uni_vcvtdq2ps(Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj), Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj));
-                    uni_vfmadd213ps(Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj), vmm_scale, vmm_shift);
+                    uni_vcvtdq2ps(Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj),
+                                  Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj));
+                    uni_vfmadd213ps(Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj),
+                                    vmm_scale,
+                                    vmm_shift);
                 }
             }
 
@@ -580,7 +608,9 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
 
                     for (int ii = 0; ii < oc_blocks; ii++) {
                         depthwise_injectors[depthwise_inj_idx]->compute_vector_range(start_idx + ur_w * ii,
-                                                                                     start_idx + ur_w * ii + ur_w, reg_d_weights, reg_d_weights);
+                                                                                     start_idx + ur_w * ii + ur_w,
+                                                                                     reg_d_weights,
+                                                                                     reg_d_weights);
 
                         add(reg_d_weights, jcp_.oc_block * sizeof(float));
                     }
@@ -596,7 +626,7 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
 
                             if (is_scalar_store) {
                                 if (isa == x64::avx512_core) {
-                                    int o_off =  jj * jcp_.oc * jcp_.ngroups;
+                                    int o_off = jj * jcp_.oc * jcp_.ngroups;
 
                                     Vmm vmm_in = vmm_sum | ktail_mask | T_z;
 
@@ -604,7 +634,7 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
                                     uni_vaddps(vmm_dst, vmm_dst, vmm_sum);
                                 } else {
                                     for (int oc = 0; oc < tail_size; oc++) {
-                                        int o_off =  jj * jcp_.oc * jcp_.ngroups + r * (jcp_.oc_block / 2) + oc;
+                                        int o_off = jj * jcp_.oc * jcp_.ngroups + r * (jcp_.oc_block / 2) + oc;
 
                                         uni_vpxor(vmm_sum, vmm_sum, vmm_sum);
                                         cvt2ps(jcp_.dst_dt, vmm_sum, ptr[reg_output + o_off * jcp_.typesize_out], true);
@@ -621,7 +651,8 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
                                     }
                                 }
                             } else {
-                                size_t o_off = ii * jcp_.oc_block + jj * jcp_.oc * jcp_.ngroups + r * (jcp_.oc_block / 2);
+                                size_t o_off =
+                                    ii * jcp_.oc_block + jj * jcp_.oc * jcp_.ngroups + r * (jcp_.oc_block / 2);
 
                                 cvt2ps(jcp_.dst_dt, vmm_sum, ptr[reg_output + o_off * jcp_.typesize_out], false);
                                 uni_vaddps(vmm_dst, vmm_dst, vmm_sum);
@@ -649,10 +680,15 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
             for (int ii = 0; ii < oc_blocks; ii++) {
                 for (int jj = 0; jj < ur_w; jj++) {
                     for (int r = 0; r < repeats; r++) {
-                        int tail_size = isa == x64::sse41 ? nstl::min(jcp_.oc_block / 2, oc_step - r * jcp_.oc_block / 2) : oc_step;
+                        int tail_size =
+                            isa == x64::sse41 ? nstl::min(jcp_.oc_block / 2, oc_step - r * jcp_.oc_block / 2) : oc_step;
                         mov(reg_b_mask, (1 << tail_size) - 1);
-                        uni_vmovups(vmm_thr, ptr[reg_b_weights + (ii * jcp_.oc_block + r * (jcp_.oc_block / 2)) * sizeof(float)]);
-                        uni_vmovups(vmm_out_mask, ptr[reg_b_out_mask + (ii * jcp_.oc_block + r * (jcp_.oc_block / 2)) * sizeof(float)]);
+                        uni_vmovups(
+                            vmm_thr,
+                            ptr[reg_b_weights + (ii * jcp_.oc_block + r * (jcp_.oc_block / 2)) * sizeof(float)]);
+                        uni_vmovups(
+                            vmm_out_mask,
+                            ptr[reg_b_out_mask + (ii * jcp_.oc_block + r * (jcp_.oc_block / 2)) * sizeof(float)]);
 
                         Vmm vmm_dst = Vmm(1 + r * jcp_.ur_w * jcp_.nb_oc_blocking + ur_w * ii + jj);
 
@@ -693,7 +729,8 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
             }
         } else {
             for (int r = 0; r < repeats; r++) {
-                int tail_size = isa == x64::sse41 ? nstl::min(jcp_.oc_block / 2, oc_step - r * jcp_.oc_block / 2) : oc_step;
+                int tail_size =
+                    isa == x64::sse41 ? nstl::min(jcp_.oc_block / 2, oc_step - r * jcp_.oc_block / 2) : oc_step;
                 bool is_scalar_store = isa == x64::sse41 ? tail_size < jcp_.oc_block / 2 : tail_size < jcp_.oc_block;
                 if (is_scalar_store) {
                     for (int jj = 0; jj < ur_w; jj++) {
@@ -735,7 +772,7 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
 
                             size_t o_off;
                             if (jcp_.with_dw_conv)
-                                o_off = ((size_t) ii * jcp_dw_conv_.kh * jcp_.ow + jj) * jcp_.oc_block +
+                                o_off = ((size_t)ii * jcp_dw_conv_.kh * jcp_.ow + jj) * jcp_.oc_block +
                                         r * (jcp_.oc_block / 2);
                             else
                                 o_off = ii * jcp_.oc_block + jj * jcp_.oc * jcp_.ngroups + r * (jcp_.oc_block / 2);
@@ -759,14 +796,15 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
 
         int nbits = 8;
         const int inp_mult = div_up(jcp_.ic, nbits);
-        const int out_mult = jcp_.with_dw_conv ? jcp_.oc_block : jcp_.with_binarization ? div_up(jcp_.oc, nbits) : jcp_.oc;
+        const int out_mult = jcp_.with_dw_conv        ? jcp_.oc_block
+                             : jcp_.with_binarization ? div_up(jcp_.oc, nbits)
+                                                      : jcp_.oc;
 
         int l_pad = jcp_.l_pad;
-        int r_pad = nstl::max(0, (jcp_.ow - 1) * str_w + (kw - 1) * dilate_w
-                                 - (iw + l_pad - 1));
-        int r_pad1 = (ur_w * n_oi - 1) * str_w + (kw - 1) * dilate_w
-                     - (iw + l_pad - 1);
-        if (r_pad1 > 0) n_oi--;
+        int r_pad = nstl::max(0, (jcp_.ow - 1) * str_w + (kw - 1) * dilate_w - (iw + l_pad - 1));
+        int r_pad1 = (ur_w * n_oi - 1) * str_w + (kw - 1) * dilate_w - (iw + l_pad - 1);
+        if (r_pad1 > 0)
+            n_oi--;
 
         mov(reg_input, reg_input_base);
         mov(reg_output, reg_output_base);
@@ -779,9 +817,9 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
         if (l_pad > 0) {
             n_oi--;
             if (n_oi < 0 && r_pad1 > 0)
-                width_blk_step(ur_w, l_pad, r_pad1, oc_blocks, oc_step); // "lrpad"
+                width_blk_step(ur_w, l_pad, r_pad1, oc_blocks, oc_step);  // "lrpad"
             else
-                width_blk_step(ur_w, l_pad, 0, oc_blocks, oc_step); // "lpad"
+                width_blk_step(ur_w, l_pad, 0, oc_blocks, oc_step);  // "lpad"
             add(reg_input, jcp_.typesize_in * (ur_w * str_w - l_pad) * inp_mult);
             add(reg_output, jcp_.typesize_out * ur_w * out_mult);
         }
@@ -792,7 +830,7 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
         if (n_oi > 0) {
             L(ow_loop_label);
 
-            width_blk_step(ur_w, 0, 0, oc_blocks, oc_step); // "middle"
+            width_blk_step(ur_w, 0, 0, oc_blocks, oc_step);  // "middle"
             add(reg_input, jcp_.typesize_in * ur_w * str_w * inp_mult);
             add(reg_output, jcp_.typesize_out * ur_w * out_mult);
 
@@ -801,14 +839,14 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
             jl(ow_loop_label, T_NEAR);
         }
 
-        if (r_pad1 > 0 && n_oi >=0) {
-            width_blk_step(ur_w, 0, r_pad1, oc_blocks, oc_step); // "rpad"
+        if (r_pad1 > 0 && n_oi >= 0) {
+            width_blk_step(ur_w, 0, r_pad1, oc_blocks, oc_step);  // "rpad"
             add(reg_input, jcp_.typesize_in * ur_w * str_w * inp_mult);
             add(reg_output, jcp_.typesize_out * ur_w * out_mult);
         }
 
         if (ur_w_tail != 0)
-            width_blk_step(ur_w_tail, 0, r_pad, oc_blocks, oc_step); // "tail"
+            width_blk_step(ur_w_tail, 0, r_pad, oc_blocks, oc_step);  // "tail"
 
         pop(reg_oc_off);
         pop(reg_oc_work);
@@ -817,17 +855,15 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
     }
 
     void prepare_table() {
-        const unsigned int cvals[] = {
-                0x02010100, // 0 1 1 2
-                0x03020201, // 1 2 2 3
-                0x03020201, // 1 2 2 3
-                0x04030302,  // 2 3 3 4
-                0x0f0f0f0f,
-                0x000000ff,
-                0xc0000000, // -2.0f
-                0x01010101,
-                0x00010001
-        };
+        const unsigned int cvals[] = {0x02010100,  // 0 1 1 2
+                                      0x03020201,  // 1 2 2 3
+                                      0x03020201,  // 1 2 2 3
+                                      0x04030302,  // 2 3 3 4
+                                      0x0f0f0f0f,
+                                      0x000000ff,
+                                      0xc0000000,  // -2.0f
+                                      0x01010101,
+                                      0x00010001};
 
         size_t simd_w = vlen / sizeof(int32_t);
 
@@ -876,7 +912,8 @@ struct jit_uni_bin_conv_kernel_f32 : public jit_uni_bin_conv_kernel, public jit_
     }
 };
 #endif
-bool BinaryConvolution::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool BinaryConvolution::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                             std::string& errorMessage) noexcept {
     try {
         if (isDynamicNgraphNode(op)) {
             errorMessage = "Doesn't support op with dynamic shapes";
@@ -934,7 +971,7 @@ void BinaryConvolution::getSupportedDescriptors() {
     withSum = false;
     size_t expectedInputEdgesNum = 2;
     for (size_t i = 0; i < fusedWith.size(); i++) {
-        auto *eltwiseNode = dynamic_cast<Eltwise *>(fusedWith[i].get());
+        auto* eltwiseNode = dynamic_cast<Eltwise*>(fusedWith[i].get());
         if (eltwiseNode && eltwiseNode->isSpecialConvolutionAddFusing()) {
             withSum = true;
             expectedInputEdgesNum++;
@@ -979,22 +1016,30 @@ void BinaryConvolution::initSupportedPrimitiveDescriptors() {
 
     if (implType != impl_desc_type::ref) {
         // optimzed implementation
-//        auto weiFormat = implType == impl_desc_type::jit_avx512 ? memory::format_tag::OhIw16o32i : memory::format_tag::OhIw8o32i;
+        //        auto weiFormat = implType == impl_desc_type::jit_avx512 ? memory::format_tag::OhIw16o32i :
+        //        memory::format_tag::OhIw8o32i;
 
-        //activation
+        // activation
         auto nspcCreator = BlockedDescCreator::getCommonCreators().at(LayoutType::nspc);
         config.inConfs[0].setMemDesc(nspcCreator->createSharedDesc(ov::element::u1, getInputShapeAtPort(0)));
 
-        //weights
-        size_t weiFirstDimBlockSize = implType == impl_desc_type::jit_avx512 ? 16 : 8; //memory::format_tag::OIhw16o32i : memory::format_tag::OIhw8o32i;
+        // weights
+        size_t weiFirstDimBlockSize = implType == impl_desc_type::jit_avx512
+                                          ? 16
+                                          : 8;  // memory::format_tag::OIhw16o32i : memory::format_tag::OIhw8o32i;
         auto weiDims = getInputShapeAtPort(1).getStaticDims();
-        std::vector<size_t> weiBlockDims = {div_up(weiDims[0], weiFirstDimBlockSize), div_up(weiDims[1], 32),
-                                            weiDims[2], weiDims[3], weiFirstDimBlockSize, 32};
+        std::vector<size_t> weiBlockDims = {div_up(weiDims[0], weiFirstDimBlockSize),
+                                            div_up(weiDims[1], 32),
+                                            weiDims[2],
+                                            weiDims[3],
+                                            weiFirstDimBlockSize,
+                                            32};
         std::vector<size_t> weiOrder = {0, 1, 2, 3, 0, 1};
 
-        config.inConfs[1].setMemDesc(std::make_shared<CpuBlockedMemoryDesc>(ov::element::u1, Shape(weiDims), weiBlockDims, weiOrder));
+        config.inConfs[1].setMemDesc(
+            std::make_shared<CpuBlockedMemoryDesc>(ov::element::u1, Shape(weiDims), weiBlockDims, weiOrder));
 
-        //result
+        // result
         auto outputPrecision = withBinarization ? ov::element::u1 : ov::element::f32;
         config.outConfs[0].setMemDesc(nspcCreator->createSharedDesc(outputPrecision, getOutputShapeAtPort(0)));
         if (withSum) {
@@ -1056,14 +1101,15 @@ void BinaryConvolution::createPrimitive() {
     jcp.with_dw_conv = false;
     jcp.with_binarization = withBinarization;
 
-    const auto &p = (*attr.get()).post_ops_;
+    const auto& p = (*attr.get()).post_ops_;
     jcp.with_sum = p.find(primitive_kind::sum) != -1;
     jcp.with_binarization = p.find(primitive_kind::binarization) != -1;
 
     int simd_w = implType == impl_desc_type::jit_avx512 ? 16 : 8;
 
     jcp.ur_w = implType == impl_desc_type::jit_avx512 ? 4 : 2;
-    if (jcp.ow < jcp.ur_w) jcp.ur_w = jcp.ow;
+    if (jcp.ow < jcp.ur_w)
+        jcp.ur_w = jcp.ow;
     jcp.ur_w_tail = jcp.ow % jcp.ur_w;
 
     jcp.ic_block = 32;
@@ -1073,7 +1119,10 @@ void BinaryConvolution::createPrimitive() {
     jcp.oc_block = simd_w;
     jcp.nb_oc = div_up(jcp.oc, jcp.oc_block);
 
-    jcp.nb_oc_blocking = nstl::min(implType == impl_desc_type::jit_sse42 ? 2 : implType == impl_desc_type::jit_avx2 ? 4 : 6, jcp.nb_oc);
+    jcp.nb_oc_blocking = nstl::min(implType == impl_desc_type::jit_sse42  ? 2
+                                   : implType == impl_desc_type::jit_avx2 ? 4
+                                                                          : 6,
+                                   jcp.nb_oc);
 
     auto srcPrecision = getParentEdgeAt(0)->getMemory().getDesc().getPrecision();
     auto dstPrecision = getChildEdgeAt(0)->getMemory().getDesc().getPrecision();
@@ -1082,11 +1131,13 @@ void BinaryConvolution::createPrimitive() {
     jcp.typesize_in = srcPrecision == ov::element::u1 ? 1 : srcPrecision.size();
     jcp.typesize_out = dstPrecision == ov::element::u1 ? 1 : dstPrecision.size();
 
-    int r_pad_no_tail = nstl::max(0, (jcp.ow - jcp.ur_w_tail - 1) * jcp.stride_w
-                                     + (jcp.kw - 1) * (jcp.dilate_w + 1) - (jcp.iw + jcp.l_pad - 1));
+    int r_pad_no_tail = nstl::max(
+        0,
+        (jcp.ow - jcp.ur_w_tail - 1) * jcp.stride_w + (jcp.kw - 1) * (jcp.dilate_w + 1) - (jcp.iw + jcp.l_pad - 1));
 
-    bool args_ok = (jcp.l_pad <= jcp.ur_w) && (r_pad_no_tail <= jcp.ur_w) &&
-                   IMPLICATION(jcp.kw > 7, (jcp.t_pad == 0 && jcp.l_pad == 0) || (jcp.stride_w == 1 && jcp.stride_h == 1));
+    bool args_ok =
+        (jcp.l_pad <= jcp.ur_w) && (r_pad_no_tail <= jcp.ur_w) &&
+        IMPLICATION(jcp.kw > 7, (jcp.t_pad == 0 && jcp.l_pad == 0) || (jcp.stride_w == 1 && jcp.stride_h == 1));
     if (!args_ok)
         OPENVINO_THROW("BinaryConvolution with name '", getName(), "' has unsupported parameters");
 #if defined(OPENVINO_ARCH_X86_64)
@@ -1122,12 +1173,12 @@ bool BinaryConvolution::canFuse(const NodePtr& node) const {
     }
 }
 
-void BinaryConvolution::setPostOps(dnnl::primitive_attr &attr) {
+void BinaryConvolution::setPostOps(dnnl::primitive_attr& attr) {
     dnnl::post_ops ops;
 
     postOpsDataPtrs.clear();
-    for (auto &node : fusedWith) {
-        auto* eltwiseNode = dynamic_cast<Eltwise *>(node.get());
+    for (auto& node : fusedWith) {
+        auto* eltwiseNode = dynamic_cast<Eltwise*>(node.get());
         if (eltwiseNode) {
             if (eltwiseNode->isSpecialConvolutionAddFusing()) {
                 ops.append_sum(1.0);
@@ -1138,7 +1189,7 @@ void BinaryConvolution::setPostOps(dnnl::primitive_attr &attr) {
             continue;
         }
 
-        auto* fakeQuantizeNode = dynamic_cast<FakeQuantize *>(node.get());
+        auto* fakeQuantizeNode = dynamic_cast<FakeQuantize*>(node.get());
         if (fakeQuantizeNode) {
             fakeQuantizeNode->appendPostOps(ops, getOutputShapeAtPort(0).getStaticDims(), postOpsDataPtrs);
             continue;
@@ -1154,9 +1205,13 @@ void BinaryConvolution::setPostOps(dnnl::primitive_attr &attr) {
     attr.set_post_ops(ops);
 }
 
-void BinaryConvolution::executeOptimized(const uint8_t* src, const uint8_t* weights, uint8_t* dst,
-                                         const std::vector<size_t>& s_str, const std::vector<size_t>& w_str, const std::vector<size_t>& d_str) {
-    auto dst_f32 = reinterpret_cast<float *>(dst);
+void BinaryConvolution::executeOptimized(const uint8_t* src,
+                                         const uint8_t* weights,
+                                         uint8_t* dst,
+                                         const std::vector<size_t>& s_str,
+                                         const std::vector<size_t>& w_str,
+                                         const std::vector<size_t>& d_str) {
+    auto dst_f32 = reinterpret_cast<float*>(dst);
 
     const int MB = jcp.mb;
 
@@ -1170,26 +1225,28 @@ void BinaryConvolution::executeOptimized(const uint8_t* src, const uint8_t* weig
         auto par_conv = jit_bin_conv_call_args();
 
         const int ij = oh * jcp.stride_h;
-        const int i_t_overflow = nstl::min(jcp.kh, div_up(nstl::max(0, jcp.t_pad - ij), (jcp.dilate_h+1)));
-        const int i_b_overflow = nstl::min(jcp.kh, div_up(nstl::max(jcp.ih, ij + (jcp.kh-1) * (jcp.dilate_h+1) -
-                                                                                          jcp.t_pad+1) - jcp.ih, (jcp.dilate_h + 1)));
+        const int i_t_overflow = nstl::min(jcp.kh, div_up(nstl::max(0, jcp.t_pad - ij), (jcp.dilate_h + 1)));
+        const int i_b_overflow =
+            nstl::min(jcp.kh,
+                      div_up(nstl::max(jcp.ih, ij + (jcp.kh - 1) * (jcp.dilate_h + 1) - jcp.t_pad + 1) - jcp.ih,
+                             (jcp.dilate_h + 1)));
 
         const size_t _oc = g * jcp.nb_oc + ocb;
         const size_t _ic = g * jcp.nb_ic;
 
         const int ih = nstl::max(ij - jcp.t_pad + i_t_overflow * (jcp.dilate_h + 1), 0);
-        par_conv.src = &src[(n * s_str[0] + _ic*jcp.ic_block * s_str[1] + ih * s_str[2]) / nbits];
+        par_conv.src = &src[(n * s_str[0] + _ic * jcp.ic_block * s_str[1] + ih * s_str[2]) / nbits];
 
         if (jcp.with_binarization) {
-            par_conv.dst = &dst[(n * d_str[0] + _oc*jcp.oc_block * d_str[1] + oh * d_str[2]) / nbits];
+            par_conv.dst = &dst[(n * d_str[0] + _oc * jcp.oc_block * d_str[1] + oh * d_str[2]) / nbits];
         } else {
-            par_conv.dst = &dst_f32[n * d_str[0] + _oc*jcp.oc_block * d_str[1] + oh * d_str[2]];
+            par_conv.dst = &dst_f32[n * d_str[0] + _oc * jcp.oc_block * d_str[1] + oh * d_str[2]];
         }
 
         const int wh = jcp.exclude_pad ? i_t_overflow : 0;
         par_conv.filt = &weights[(ocb * w_str[0] + wh * w_str[2]) / nbits];
 
-        par_conv.oc_work = nstl::min((ocb + ocb_num) * jcp.oc_block, jcp.oc) - ocb*jcp.oc_block;
+        par_conv.oc_work = nstl::min((ocb + ocb_num) * jcp.oc_block, jcp.oc) - ocb * jcp.oc_block;
 
         par_conv.kw_padding = 0;
         const int kh_padding = jcp.kh - i_t_overflow - i_b_overflow;
@@ -1204,9 +1261,13 @@ void BinaryConvolution::executeOptimized(const uint8_t* src, const uint8_t* weig
     });
 }
 
-void BinaryConvolution::executeReference(const uint8_t* src, const uint8_t* weights, uint8_t* dst,
-                                                   const std::vector<size_t>& s_str, const std::vector<size_t>& w_str, const std::vector<size_t>& d_str) {
-    auto dst_fp = reinterpret_cast<float *>(dst);
+void BinaryConvolution::executeReference(const uint8_t* src,
+                                         const uint8_t* weights,
+                                         uint8_t* dst,
+                                         const std::vector<size_t>& s_str,
+                                         const std::vector<size_t>& w_str,
+                                         const std::vector<size_t>& d_str) {
+    auto dst_fp = reinterpret_cast<float*>(dst);
 
     const bool with_groups = jcp.ngroups > 1;
 
@@ -1240,7 +1301,7 @@ void BinaryConvolution::executeReference(const uint8_t* src, const uint8_t* weig
         return (uint8_t)((val >> bit) & 0x0001);
     };
 
-    auto ker = [=](int32_t &d, int g, int mb, int oc, int oh, int ow) {
+    auto ker = [=](int32_t& d, int g, int mb, int oc, int oh, int ow) {
         for (int ic = 0; ic < IC; ++ic) {
             for (int kh = 0; kh < KH; ++kh) {
                 for (int kw = 0; kw < KW; ++kw) {
@@ -1259,14 +1320,14 @@ void BinaryConvolution::executeReference(const uint8_t* src, const uint8_t* weig
                         if (pad_value == 0)
                             continue;
                         else
-                            s = pad_value == 1.0f ? (uint8_t) 1 : (uint8_t) 0;
+                            s = pad_value == 1.0f ? (uint8_t)1 : (uint8_t)0;
                     } else {
-                        s = extract_bit(src[iidx / nbits], (uint8_t) (iidx % nbits));
+                        s = extract_bit(src[iidx / nbits], (uint8_t)(iidx % nbits));
                     }
 
-                    uint8_t w = extract_bit(weights[widx / nbits], (uint8_t) (widx % nbits));
+                    uint8_t w = extract_bit(weights[widx / nbits], (uint8_t)(widx % nbits));
 
-                    d += (int32_t) (s ^ w);
+                    d += (int32_t)(s ^ w);
                 }
             }
         }
@@ -1280,13 +1341,11 @@ void BinaryConvolution::executeReference(const uint8_t* src, const uint8_t* weig
         if (pad_value == 0.0f) {
             const int i_left_overflow = nstl::max(0, (padL - ow * KSW));
             const int i_right_overflow = nstl::max(IW, (ow * KSW + (KW - 1) * (KDW + 1) - padL + 1)) - IW;
-            const int kw_padding =
-                    KW - div_up(i_left_overflow, (KDW + 1)) - div_up(i_right_overflow, (KDW + 1));
+            const int kw_padding = KW - div_up(i_left_overflow, (KDW + 1)) - div_up(i_right_overflow, (KDW + 1));
 
             const int i_top_overflow = nstl::max(0, (padT - oh * KSH));
             const int i_bottom_overflow = nstl::max(IH, (oh * KSH + (KH - 1) * (KDH + 1) - padT + 1)) - IH;
-            const int kh_padding =
-                    KH - div_up(i_top_overflow, (KDH + 1)) - div_up(i_bottom_overflow, (KDH + 1));
+            const int kh_padding = KH - div_up(i_top_overflow, (KDH + 1)) - div_up(i_bottom_overflow, (KDH + 1));
 
             base_value = IC * kh_padding * kw_padding;
         } else {
@@ -1295,7 +1354,7 @@ void BinaryConvolution::executeReference(const uint8_t* src, const uint8_t* weig
 
         float a_fp = base_value - static_cast<float>(2 * a);
 
-        dst_fp[mb * d_str[0] + (g*OC + oc) * d_str[1] + oh * d_str[2] + ow * d_str[3]] = a_fp;
+        dst_fp[mb * d_str[0] + (g * OC + oc) * d_str[1] + oh * d_str[2] + ow * d_str[3]] = a_fp;
     });
 }
 
@@ -1342,6 +1401,6 @@ bool BinaryConvolution::created() const {
     return getType() == Type::BinaryConvolution;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/bin_conv.h b/src/plugins/intel_cpu/src/nodes/bin_conv.h
index 86b5cb41b2bf6d..661e075b680ec7 100644
--- a/src/plugins/intel_cpu/src/nodes/bin_conv.h
+++ b/src/plugins/intel_cpu/src/nodes/bin_conv.h
@@ -39,9 +39,9 @@ struct jit_dw_conv_params {
 };
 
 struct jit_bin_conv_call_args {
-    const void *src;
-    const void *dst;
-    const void *filt;
+    const void* src;
+    const void* dst;
+    const void* filt;
     size_t kh_padding;
     size_t kw_padding;
     size_t oc_work;
@@ -52,15 +52,20 @@ struct jit_bin_conv_call_args {
 };
 
 struct jit_uni_bin_conv_kernel {
-    void (*ker_)(const jit_bin_conv_call_args *);
+    void (*ker_)(const jit_bin_conv_call_args*);
 
-    void operator()(const jit_bin_conv_call_args *args) {
+    void operator()(const jit_bin_conv_call_args* args) {
         assert(ker_);
         ker_(args);
     }
 
-    explicit jit_uni_bin_conv_kernel(jit_bin_conv_params jcp, jit_dw_conv_params jcp_dw_conv, const dnnl_primitive_attr &attr) :
-        ker_(nullptr), jcp_(jcp), jcp_dw_conv_(jcp_dw_conv), attr_(attr) {}
+    explicit jit_uni_bin_conv_kernel(jit_bin_conv_params jcp,
+                                     jit_dw_conv_params jcp_dw_conv,
+                                     const dnnl_primitive_attr& attr)
+        : ker_(nullptr),
+          jcp_(jcp),
+          jcp_dw_conv_(jcp_dw_conv),
+          attr_(attr) {}
     virtual ~jit_uni_bin_conv_kernel() {}
 
     virtual void create_ker() = 0;
@@ -68,7 +73,7 @@ struct jit_uni_bin_conv_kernel {
     jit_bin_conv_params jcp_;
     jit_dw_conv_params jcp_dw_conv_;
 
-    const dnnl_primitive_attr &attr_;
+    const dnnl_primitive_attr& attr_;
 };
 
 class BinaryConvolution : public Node {
@@ -83,12 +88,14 @@ class BinaryConvolution : public Node {
     bool canBeInPlace() const override {
         return false;
     }
-    void setPostOps(dnnl::primitive_attr &attr);
+    void setPostOps(dnnl::primitive_attr& attr);
     bool canFuse(const NodePtr& node) const override;
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
-    impl_desc_type getImplType() { return implType; }
+    impl_desc_type getImplType() {
+        return implType;
+    }
 
 private:
     bool withSum = false;
@@ -110,14 +117,22 @@ class BinaryConvolution : public Node {
 
     impl_desc_type implType = impl_desc_type::ref;
 
-    void executeOptimized(const uint8_t* src, const uint8_t* weights, uint8_t* dst,
-                          const std::vector<size_t>& s_str, const std::vector<size_t>& w_str, const std::vector<size_t>& d_str);
-    void executeReference(const uint8_t* src, const uint8_t* weights, uint8_t* dst,
-                          const std::vector<size_t>& s_str, const std::vector<size_t>& w_str, const std::vector<size_t>& d_str);
+    void executeOptimized(const uint8_t* src,
+                          const uint8_t* weights,
+                          uint8_t* dst,
+                          const std::vector<size_t>& s_str,
+                          const std::vector<size_t>& w_str,
+                          const std::vector<size_t>& d_str);
+    void executeReference(const uint8_t* src,
+                          const uint8_t* weights,
+                          uint8_t* dst,
+                          const std::vector<size_t>& s_str,
+                          const std::vector<size_t>& w_str,
+                          const std::vector<size_t>& d_str);
 
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/broadcast.cpp b/src/plugins/intel_cpu/src/nodes/broadcast.cpp
index c88803e07de601..646e186922b397 100644
--- a/src/plugins/intel_cpu/src/nodes/broadcast.cpp
+++ b/src/plugins/intel_cpu/src/nodes/broadcast.cpp
@@ -2,15 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <vector>
+#include "broadcast.h"
+
+#include <selective_build.h>
+
 #include <string>
+#include <vector>
+
+#include "common/cpu_memcpy.h"
 #include "dnnl_types.h"
-#include "openvino/core/parallel.hpp"
-#include <selective_build.h>
-#include "broadcast.h"
 #include "nodes/common/blocked_desc_creator.h"
+#include "openvino/core/parallel.hpp"
 #include "openvino/opsets/opset1.hpp"
-#include "common/cpu_memcpy.h"
 #include "utils/ngraph_utils.hpp"
 
 namespace ov {
@@ -24,19 +27,20 @@ bool Broadcast::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
             return false;
         }
         if (!one_of(ov::as_type_ptr<const ov::op::v1::Broadcast>(op)->get_broadcast_spec().m_type,
-                ov::op::AutoBroadcastType::NUMPY, ov::op::AutoBroadcastType::EXPLICIT)) {
+                    ov::op::AutoBroadcastType::NUMPY,
+                    ov::op::AutoBroadcastType::EXPLICIT)) {
             errorMessage = "Only NUMPY and EXPLICIT broadcast types are supported.";
             return false;
         }
         if (op->get_input_partial_shape(TARGET_SHAPE_IDX).is_dynamic() ||
-                (op->get_input_size() > AXES_MAPPING_IDX && op->get_input_partial_shape(AXES_MAPPING_IDX).is_dynamic())) {
+            (op->get_input_size() > AXES_MAPPING_IDX && op->get_input_partial_shape(AXES_MAPPING_IDX).is_dynamic())) {
             errorMessage = "Only static shapes are supported for target shape and axes mapping inputs.";
             return false;
         }
         if (!isDynamicNgraphNode(op) &&
-                (!ov::is_type<ov::op::v0::Constant>(op->get_input_node_ptr(TARGET_SHAPE_IDX)) ||
-                 (op->get_input_size() > AXES_MAPPING_IDX &&
-                 !ov::is_type<ov::op::v0::Constant>(op->get_input_node_ptr(AXES_MAPPING_IDX))))) {
+            (!ov::is_type<ov::op::v0::Constant>(op->get_input_node_ptr(TARGET_SHAPE_IDX)) ||
+             (op->get_input_size() > AXES_MAPPING_IDX &&
+              !ov::is_type<ov::op::v0::Constant>(op->get_input_node_ptr(AXES_MAPPING_IDX))))) {
             errorMessage = "Only constant target shapes and axis mapping inputs are supported for static shapes.";
             return false;
         }
@@ -72,12 +76,13 @@ Broadcast::Broadcast(const std::shared_ptr<ov::Node>& op, const GraphContext::CP
 
     if (ov::is_type<ov::op::v0::Constant>(op->get_input_node_ptr(TARGET_SHAPE_IDX))) {
         constMap[TARGET_SHAPE_IDX] = true;
-        targetShape = (ov::as_type<ov::op::v0::Constant>(op->get_input_node_ptr(TARGET_SHAPE_IDX)))->get_vector<int32_t>();
+        targetShape =
+            (ov::as_type<ov::op::v0::Constant>(op->get_input_node_ptr(TARGET_SHAPE_IDX)))->get_vector<int32_t>();
     }
-    if (broadcastType == EXPLICIT &&
-                ov::is_type<ov::op::v0::Constant>(op->get_input_node_ptr(AXES_MAPPING_IDX))) {
+    if (broadcastType == EXPLICIT && ov::is_type<ov::op::v0::Constant>(op->get_input_node_ptr(AXES_MAPPING_IDX))) {
         constMap[AXES_MAPPING_IDX] = true;
-        axesMapping = ov::as_type<ov::op::v0::Constant>(op->get_input_node_ptr(AXES_MAPPING_IDX))->get_vector<int32_t>();
+        axesMapping =
+            ov::as_type<ov::op::v0::Constant>(op->get_input_node_ptr(AXES_MAPPING_IDX))->get_vector<int32_t>();
     }
 }
 
@@ -126,7 +131,8 @@ void Broadcast::prepareParams() {
     repeats.assign(targetShape.begin(), targetShape.end());
     const auto ndims = repeats.size();
 
-    auto srcBlockedDims = getParentEdgeAt(INPUT_DATA_IDX)->getMemory().getDescWithType<BlockedMemoryDesc>()->getBlockDims();
+    auto srcBlockedDims =
+        getParentEdgeAt(INPUT_DATA_IDX)->getMemory().getDescWithType<BlockedMemoryDesc>()->getBlockDims();
     auto dstBlockedDims = getChildEdgeAt(0)->getMemory().getDescWithType<BlockedMemoryDesc>()->getBlockDims();
 
     if (broadcastType == NUMPY) {
@@ -227,8 +233,8 @@ void Broadcast::plainExecute(dnnl::stream strm) {
     }
 
     const size_t workAmountDst = dstStrides[0] * dstDims[0];
-    const auto *srcData = getSrcDataAtPortAs<const uint8_t>(INPUT_DATA_IDX);
-    auto *dstData = getDstDataAtPortAs<uint8_t>(0);
+    const auto* srcData = getSrcDataAtPortAs<const uint8_t>(INPUT_DATA_IDX);
+    auto* dstData = getDstDataAtPortAs<uint8_t>(0);
 
     parallel_nt(0, [&](const int ithr, const int nthr) {
         size_t i = 0lu, srcIdx = 0lu, start = 0lu, end = 0lu;
@@ -246,7 +252,8 @@ void Broadcast::plainExecute(dnnl::stream strm) {
 
             for (int j = dataDstRank - 1; j >= 0; j--) {
                 counters[j] = (counters[j] + 1) % dstDims[j];
-                if (counters[j] != 0) break;
+                if (counters[j] != 0)
+                    break;
             }
         }
     });
@@ -256,6 +263,6 @@ bool Broadcast::created() const {
     return getType() == Type::Broadcast;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/broadcast.h b/src/plugins/intel_cpu/src/nodes/broadcast.h
index 1435314ee08776..df9ad4614e311d 100644
--- a/src/plugins/intel_cpu/src/nodes/broadcast.h
+++ b/src/plugins/intel_cpu/src/nodes/broadcast.h
@@ -4,12 +4,12 @@
 
 #pragma once
 
-#include "common/tile_broadcast_utils.h"
-
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "common/tile_broadcast_utils.h"
+
 namespace ov {
 namespace intel_cpu {
 namespace node {
@@ -35,10 +35,7 @@ class Broadcast : public Node, public TileBroadcastCommon {
 private:
     void plainExecute(dnnl::stream strm);
 
-    enum AutoBroadcastType {
-        NUMPY,
-        EXPLICIT
-    };
+    enum AutoBroadcastType { NUMPY, EXPLICIT };
     AutoBroadcastType broadcastType = NUMPY;
 
     static constexpr size_t INPUT_DATA_IDX = 0;
@@ -51,6 +48,6 @@ class Broadcast : public Node, public TileBroadcastCommon {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/bucketize.cpp b/src/plugins/intel_cpu/src/nodes/bucketize.cpp
index a71255c0d531e4..cfa4bb031501ef 100644
--- a/src/plugins/intel_cpu/src/nodes/bucketize.cpp
+++ b/src/plugins/intel_cpu/src/nodes/bucketize.cpp
@@ -2,14 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "bucketize.h"
+
+#include <algorithm>
+#include <shape_inference/shape_inference_pass_through.hpp>
 #include <string>
 #include <vector>
-#include <algorithm>
 
-#include "openvino/opsets/opset3.hpp"
-#include <shape_inference/shape_inference_pass_through.hpp>
 #include "openvino/core/parallel.hpp"
-#include "bucketize.h"
+#include "openvino/opsets/opset3.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -70,16 +71,15 @@ void Bucketize::initSupportedPrimitiveDescriptors() {
         output_precision = ov::element::i32;
     }
 
-    addSupportedPrimDesc({{LayoutType::ncsp, input_precision},
-                          {LayoutType::ncsp, boundaries_precision}},
+    addSupportedPrimDesc({{LayoutType::ncsp, input_precision}, {LayoutType::ncsp, boundaries_precision}},
                          {{LayoutType::ncsp, output_precision}},
                          impl_desc_type::ref_any);
 }
 
 inline constexpr uint32_t getElementsMask(ov::element::Type precision1,
-                                ov::element::Type precision2,
-                                ov::element::Type precision3 = ov::element::undefined,
-                                ov::element::Type precision4 = ov::element::undefined) {
+                                          ov::element::Type precision2,
+                                          ov::element::Type precision3 = ov::element::undefined,
+                                          ov::element::Type precision4 = ov::element::undefined) {
     return static_cast<uint32_t>(ov::element::Type_t(precision1)) |
            (static_cast<uint32_t>(ov::element::Type_t(precision2)) << 8) |
            (static_cast<uint32_t>(ov::element::Type_t(precision3)) << 16) |
@@ -90,98 +90,98 @@ void Bucketize::execute(dnnl::stream strm) {
     auto precision_mask = getElementsMask(input_precision, boundaries_precision, output_precision);
 
     switch (precision_mask) {
-        case getElementsMask(ov::element::f32, ov::element::f32, ov::element::i32):
-            bucketize<element_type_traits<ov::element::f32>::value_type,
-                    element_type_traits<ov::element::f32>::value_type,
-                    element_type_traits<ov::element::i32>::value_type>();
-            break;
-        case getElementsMask(ov::element::f32, ov::element::f32, ov::element::i64):
-            bucketize<element_type_traits<ov::element::f32>::value_type,
-                    element_type_traits<ov::element::f32>::value_type,
-                    element_type_traits<ov::element::i64>::value_type>();
-            break;
-        case getElementsMask(ov::element::f32, ov::element::i32, ov::element::i32):
-            bucketize<element_type_traits<ov::element::f32>::value_type,
-                    element_type_traits<ov::element::i32>::value_type,
-                    element_type_traits<ov::element::i32>::value_type>();
-            break;
-        case getElementsMask(ov::element::f32, ov::element::i32, ov::element::i64):
-            bucketize<element_type_traits<ov::element::f32>::value_type,
-                    element_type_traits<ov::element::i32>::value_type,
-                    element_type_traits<ov::element::i64>::value_type>();
-            break;
-        case getElementsMask(ov::element::f32, ov::element::i64, ov::element::i32):
-            bucketize<element_type_traits<ov::element::f32>::value_type,
-                    element_type_traits<ov::element::i64>::value_type,
-                    element_type_traits<ov::element::i32>::value_type>();
-            break;
-        case getElementsMask(ov::element::f32, ov::element::i64, ov::element::i64):
-            bucketize<element_type_traits<ov::element::f32>::value_type,
-                    element_type_traits<ov::element::i64>::value_type,
-                    element_type_traits<ov::element::i64>::value_type>();
-            break;
-        case getElementsMask(ov::element::i32, ov::element::f32, ov::element::i32):
-            bucketize<element_type_traits<ov::element::i32>::value_type,
-                    element_type_traits<ov::element::f32>::value_type,
-                    element_type_traits<ov::element::i32>::value_type>();
-            break;
-        case getElementsMask(ov::element::i32, ov::element::f32, ov::element::i64):
-            bucketize<element_type_traits<ov::element::i32>::value_type,
-                    element_type_traits<ov::element::f32>::value_type,
-                    element_type_traits<ov::element::i64>::value_type>();
-            break;
-        case getElementsMask(ov::element::i32, ov::element::i32, ov::element::i32):
-            bucketize<element_type_traits<ov::element::i32>::value_type,
-                    element_type_traits<ov::element::i32>::value_type,
-                    element_type_traits<ov::element::i32>::value_type>();
-            break;
-        case getElementsMask(ov::element::i32, ov::element::i32, ov::element::i64):
-            bucketize<element_type_traits<ov::element::i32>::value_type,
-                    element_type_traits<ov::element::i32>::value_type,
-                    element_type_traits<ov::element::i64>::value_type>();
-            break;
-        case getElementsMask(ov::element::i32, ov::element::i64, ov::element::i32):
-            bucketize<element_type_traits<ov::element::i32>::value_type,
-                    element_type_traits<ov::element::i64>::value_type,
-                    element_type_traits<ov::element::i32>::value_type>();
-            break;
-        case getElementsMask(ov::element::i32, ov::element::i64, ov::element::i64):
-            bucketize<element_type_traits<ov::element::i32>::value_type,
-                    element_type_traits<ov::element::i64>::value_type,
-                    element_type_traits<ov::element::i64>::value_type>();
-            break;
-        case getElementsMask(ov::element::i64, ov::element::f32, ov::element::i32):
-            bucketize<element_type_traits<ov::element::i64>::value_type,
-                    element_type_traits<ov::element::f32>::value_type,
-                    element_type_traits<ov::element::i32>::value_type>();
-            break;
-        case getElementsMask(ov::element::i64, ov::element::f32, ov::element::i64):
-            bucketize<element_type_traits<ov::element::i64>::value_type,
-                    element_type_traits<ov::element::f32>::value_type,
-                    element_type_traits<ov::element::i64>::value_type>();
-            break;
-        case getElementsMask(ov::element::i64, ov::element::i32, ov::element::i32):
-            bucketize<element_type_traits<ov::element::i64>::value_type,
-                    element_type_traits<ov::element::i32>::value_type,
-                    element_type_traits<ov::element::i32>::value_type>();
-            break;
-        case getElementsMask(ov::element::i64, ov::element::i32, ov::element::i64):
-            bucketize<element_type_traits<ov::element::i64>::value_type,
-                    element_type_traits<ov::element::i32>::value_type,
-                    element_type_traits<ov::element::i64>::value_type>();
-            break;
-        case getElementsMask(ov::element::i64, ov::element::i64, ov::element::i32):
-            bucketize<element_type_traits<ov::element::i64>::value_type,
-                    element_type_traits<ov::element::i64>::value_type,
-                    element_type_traits<ov::element::i32>::value_type>();
-            break;
-        case getElementsMask(ov::element::i64, ov::element::i64, ov::element::i64):
-            bucketize<element_type_traits<ov::element::i64>::value_type,
-                    element_type_traits<ov::element::i64>::value_type,
-                    element_type_traits<ov::element::i64>::value_type>();
-            break;
-        default:
-            OPENVINO_THROW(errorPrefix, " has unsupported precision: ", precision_mask);
+    case getElementsMask(ov::element::f32, ov::element::f32, ov::element::i32):
+        bucketize<element_type_traits<ov::element::f32>::value_type,
+                  element_type_traits<ov::element::f32>::value_type,
+                  element_type_traits<ov::element::i32>::value_type>();
+        break;
+    case getElementsMask(ov::element::f32, ov::element::f32, ov::element::i64):
+        bucketize<element_type_traits<ov::element::f32>::value_type,
+                  element_type_traits<ov::element::f32>::value_type,
+                  element_type_traits<ov::element::i64>::value_type>();
+        break;
+    case getElementsMask(ov::element::f32, ov::element::i32, ov::element::i32):
+        bucketize<element_type_traits<ov::element::f32>::value_type,
+                  element_type_traits<ov::element::i32>::value_type,
+                  element_type_traits<ov::element::i32>::value_type>();
+        break;
+    case getElementsMask(ov::element::f32, ov::element::i32, ov::element::i64):
+        bucketize<element_type_traits<ov::element::f32>::value_type,
+                  element_type_traits<ov::element::i32>::value_type,
+                  element_type_traits<ov::element::i64>::value_type>();
+        break;
+    case getElementsMask(ov::element::f32, ov::element::i64, ov::element::i32):
+        bucketize<element_type_traits<ov::element::f32>::value_type,
+                  element_type_traits<ov::element::i64>::value_type,
+                  element_type_traits<ov::element::i32>::value_type>();
+        break;
+    case getElementsMask(ov::element::f32, ov::element::i64, ov::element::i64):
+        bucketize<element_type_traits<ov::element::f32>::value_type,
+                  element_type_traits<ov::element::i64>::value_type,
+                  element_type_traits<ov::element::i64>::value_type>();
+        break;
+    case getElementsMask(ov::element::i32, ov::element::f32, ov::element::i32):
+        bucketize<element_type_traits<ov::element::i32>::value_type,
+                  element_type_traits<ov::element::f32>::value_type,
+                  element_type_traits<ov::element::i32>::value_type>();
+        break;
+    case getElementsMask(ov::element::i32, ov::element::f32, ov::element::i64):
+        bucketize<element_type_traits<ov::element::i32>::value_type,
+                  element_type_traits<ov::element::f32>::value_type,
+                  element_type_traits<ov::element::i64>::value_type>();
+        break;
+    case getElementsMask(ov::element::i32, ov::element::i32, ov::element::i32):
+        bucketize<element_type_traits<ov::element::i32>::value_type,
+                  element_type_traits<ov::element::i32>::value_type,
+                  element_type_traits<ov::element::i32>::value_type>();
+        break;
+    case getElementsMask(ov::element::i32, ov::element::i32, ov::element::i64):
+        bucketize<element_type_traits<ov::element::i32>::value_type,
+                  element_type_traits<ov::element::i32>::value_type,
+                  element_type_traits<ov::element::i64>::value_type>();
+        break;
+    case getElementsMask(ov::element::i32, ov::element::i64, ov::element::i32):
+        bucketize<element_type_traits<ov::element::i32>::value_type,
+                  element_type_traits<ov::element::i64>::value_type,
+                  element_type_traits<ov::element::i32>::value_type>();
+        break;
+    case getElementsMask(ov::element::i32, ov::element::i64, ov::element::i64):
+        bucketize<element_type_traits<ov::element::i32>::value_type,
+                  element_type_traits<ov::element::i64>::value_type,
+                  element_type_traits<ov::element::i64>::value_type>();
+        break;
+    case getElementsMask(ov::element::i64, ov::element::f32, ov::element::i32):
+        bucketize<element_type_traits<ov::element::i64>::value_type,
+                  element_type_traits<ov::element::f32>::value_type,
+                  element_type_traits<ov::element::i32>::value_type>();
+        break;
+    case getElementsMask(ov::element::i64, ov::element::f32, ov::element::i64):
+        bucketize<element_type_traits<ov::element::i64>::value_type,
+                  element_type_traits<ov::element::f32>::value_type,
+                  element_type_traits<ov::element::i64>::value_type>();
+        break;
+    case getElementsMask(ov::element::i64, ov::element::i32, ov::element::i32):
+        bucketize<element_type_traits<ov::element::i64>::value_type,
+                  element_type_traits<ov::element::i32>::value_type,
+                  element_type_traits<ov::element::i32>::value_type>();
+        break;
+    case getElementsMask(ov::element::i64, ov::element::i32, ov::element::i64):
+        bucketize<element_type_traits<ov::element::i64>::value_type,
+                  element_type_traits<ov::element::i32>::value_type,
+                  element_type_traits<ov::element::i64>::value_type>();
+        break;
+    case getElementsMask(ov::element::i64, ov::element::i64, ov::element::i32):
+        bucketize<element_type_traits<ov::element::i64>::value_type,
+                  element_type_traits<ov::element::i64>::value_type,
+                  element_type_traits<ov::element::i32>::value_type>();
+        break;
+    case getElementsMask(ov::element::i64, ov::element::i64, ov::element::i64):
+        bucketize<element_type_traits<ov::element::i64>::value_type,
+                  element_type_traits<ov::element::i64>::value_type,
+                  element_type_traits<ov::element::i64>::value_type>();
+        break;
+    default:
+        OPENVINO_THROW(errorPrefix, " has unsupported precision: ", precision_mask);
     }
 }
 
@@ -222,9 +222,9 @@ bool Bucketize::isExecutable() const {
 
 template <typename T, typename T_BOUNDARIES, typename T_IND>
 void Bucketize::bucketize() {
-    const auto *input_data = getSrcDataAtPortAs<const T>(0);
-    const auto *boundaries_data = getSrcDataAtPortAs<const T_BOUNDARIES>(1);
-    auto *output_data = getDstDataAtPortAs<T_IND>(0);
+    const auto* input_data = getSrcDataAtPortAs<const T>(0);
+    const auto* boundaries_data = getSrcDataAtPortAs<const T_BOUNDARIES>(1);
+    auto* output_data = getDstDataAtPortAs<T_IND>(0);
 
     if (!with_bins) {
         memset(output_data, 0, num_values * sizeof(T_IND));
@@ -248,6 +248,6 @@ bool Bucketize::created() const {
     return getType() == Type::Bucketize;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/bucketize.h b/src/plugins/intel_cpu/src/nodes/bucketize.h
index c834921a38ce54..0ecdd633838950 100644
--- a/src/plugins/intel_cpu/src/nodes/bucketize.h
+++ b/src/plugins/intel_cpu/src/nodes/bucketize.h
@@ -14,7 +14,7 @@ class Bucketize : public Node {
 public:
     Bucketize(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -46,6 +46,6 @@ class Bucketize : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/causal_mask_preprocess.cpp b/src/plugins/intel_cpu/src/nodes/causal_mask_preprocess.cpp
index 674d77265c9219..fd015a372ed1db 100644
--- a/src/plugins/intel_cpu/src/nodes/causal_mask_preprocess.cpp
+++ b/src/plugins/intel_cpu/src/nodes/causal_mask_preprocess.cpp
@@ -4,16 +4,16 @@
 
 #include "causal_mask_preprocess.h"
 
+#include <chrono>
+#include <string>
+#include <vector>
+
 #include "common/bfloat16.hpp"
 #include "common/cpu_memcpy.h"
 #include "cpu/x64/cpu_isa_traits.hpp"
 #include "shape_inference/shape_inference_internal_dyn.hpp"
 #include "utils/plain_tensor.hpp"
 
-#include <chrono>
-#include <string>
-#include <vector>
-
 namespace ov {
 namespace intel_cpu {
 namespace node {
@@ -48,7 +48,7 @@ The functionality is equivalent to following python code:
 template <typename T>
 struct CausalMaskPreprocess::ExecutorCausalMaskPreprocess : public CausalMaskPreprocess::Executor {
     void execute(dnnl::stream strm,
-                 intel_cpu::Node * pnode,
+                 intel_cpu::Node* pnode,
                  const intel_cpu::CausalMaskPreprocessNode::Config& config) override {
         ov::intel_cpu::PlainTensor t_attention_mask(pnode->getSrcMemoryAtPort(0));
         ov::intel_cpu::PlainTensor t_batch_size(pnode->getSrcMemoryAtPort(1));
@@ -64,7 +64,14 @@ struct CausalMaskPreprocess::ExecutorCausalMaskPreprocess : public CausalMaskPre
         pnode->redefineOutputMemory({newDims});
         ov::intel_cpu::PlainTensor t_dst(pnode->getDstMemoryAtPort(0));
 
-        DEBUG_LOG("CausalMaskPreprocess::execute", config.type, "  batch_size=", batch_size, " qLen=", qLen, " kvLen=", kvLen);
+        DEBUG_LOG("CausalMaskPreprocess::execute",
+                  config.type,
+                  "  batch_size=",
+                  batch_size,
+                  " qLen=",
+                  qLen,
+                  " kvLen=",
+                  kvLen);
         DEBUG_LOG("CausalMaskPreprocess::execute  attention_mask=", t_attention_mask);
         DEBUG_LOG("CausalMaskPreprocess::execute  cache_positions=", t_cache_positions);
 
@@ -81,7 +88,7 @@ struct CausalMaskPreprocess::ExecutorCausalMaskPreprocess : public CausalMaskPre
                 bool cmask_eq0 = (j <= row);
                 bool amask_eq0 = (pamask[j] == 0);
                 bool padding_mask = (cmask_eq0 && amask_eq0);
-                pdst[j] = (padding_mask | (!cmask_eq0))? min_dtype : T(0);
+                pdst[j] = (padding_mask | (!cmask_eq0)) ? min_dtype : T(0);
             }
             for (; j < kvLen; j++) {
                 bool cmask_eq0 = (j <= row);
@@ -103,7 +110,8 @@ CausalMaskPreprocess::CausalMaskPreprocess(const std::shared_ptr<ov::Node>& op,
     m_config = node->get_config();
 }
 
-bool CausalMaskPreprocess::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool CausalMaskPreprocess::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                                std::string& errorMessage) noexcept {
     try {
         const auto node = std::dynamic_pointer_cast<const intel_cpu::CausalMaskPreprocessNode>(op);
         if (!node) {
@@ -133,7 +141,8 @@ void CausalMaskPreprocess::initSupportedPrimitiveDescriptors() {
             oprecs[0] = ov::element::f32;
         }
         // all input precisions must be int32
-        for (auto& prec : iprecs) prec = ov::element::i32;
+        for (auto& prec : iprecs)
+            prec = ov::element::i32;
     } else {
         OPENVINO_THROW("CPU: CausalMaskPreprocess type not supported : " + m_config.type);
     }
diff --git a/src/plugins/intel_cpu/src/nodes/causal_mask_preprocess.h b/src/plugins/intel_cpu/src/nodes/causal_mask_preprocess.h
index eeb997c4cefb9f..444f242b0597a7 100644
--- a/src/plugins/intel_cpu/src/nodes/causal_mask_preprocess.h
+++ b/src/plugins/intel_cpu/src/nodes/causal_mask_preprocess.h
@@ -32,7 +32,7 @@ class CausalMaskPreprocess : public Node {
 private:
     struct Executor {
         virtual void execute(dnnl::stream strm,
-                             intel_cpu::Node * pnode,
+                             intel_cpu::Node* pnode,
                              const intel_cpu::CausalMaskPreprocessNode::Config& config) = 0;
         virtual ~Executor() = default;
     };
diff --git a/src/plugins/intel_cpu/src/nodes/col2im.cpp b/src/plugins/intel_cpu/src/nodes/col2im.cpp
index 4b83e78fd82505..409607ea6bb89c 100644
--- a/src/plugins/intel_cpu/src/nodes/col2im.cpp
+++ b/src/plugins/intel_cpu/src/nodes/col2im.cpp
@@ -3,8 +3,9 @@
 //
 
 #include "col2im.h"
-#include "openvino/reference/col2im.hpp"
+
 #include "openvino/op/col2im.hpp"
+#include "openvino/reference/col2im.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -62,42 +63,42 @@ void Col2Im::executeDynamicImpl(dnnl::stream strm) {
 
 template <class T, class T_idx>
 void Col2Im::executeImpl() {
-    ov::reference::col2im<T, T_idx>(
-        getSrcDataAtPortAs<const T>(0),
-        ov::Shape{getSrcMemoryAtPort(0)->getStaticDims()},
-        getSrcDataAtPortAs<const T_idx>(1),
-        getSrcDataAtPortAs<const T_idx>(2),
-        getDstDataAtPortAs<T>(0),
-        strides,
-        dilations,
-        padsBegin,
-        padsEnd);
+    ov::reference::col2im<T, T_idx>(getSrcDataAtPortAs<const T>(0),
+                                    ov::Shape{getSrcMemoryAtPort(0)->getStaticDims()},
+                                    getSrcDataAtPortAs<const T_idx>(1),
+                                    getSrcDataAtPortAs<const T_idx>(2),
+                                    getDstDataAtPortAs<T>(0),
+                                    strides,
+                                    dilations,
+                                    padsBegin,
+                                    padsEnd);
 }
 
 namespace {
 struct Col2ImContext {
-    Col2Im &node;
+    Col2Im& node;
 };
-}
+}  // namespace
 
-template<typename T>
+template <typename T>
 struct Col2Im::Col2ImExecute {
     using TData = typename std::tuple_element<0, T>::type;
     using TIndex = typename std::tuple_element<1, T>::type;
 
-    void operator()(Col2ImContext & ctx) {
-            ctx.node.executeImpl<TData, TIndex>();
-        }
+    void operator()(Col2ImContext& ctx) {
+        ctx.node.executeImpl<TData, TIndex>();
+    }
 };
 void Col2Im::execute(dnnl::stream strm) {
     auto dataPrecision = getParentEdgeAt(0)->getMemory().getDesc().getPrecision();
     auto indexPrecision = getParentEdgeAt(1)->getMemory().getDesc().getPrecision();
 
-    Col2ImContext ctx = {
-            *this
-    };
+    Col2ImContext ctx = {*this};
 
-    OV_SWITCH(intel_cpu, Col2ImExecute, ctx, std::tie(dataPrecision, indexPrecision),
+    OV_SWITCH(intel_cpu,
+              Col2ImExecute,
+              ctx,
+              std::tie(dataPrecision, indexPrecision),
               OV_CASE2(ov::element::f32, ov::element::i32, float, int32_t),
               OV_CASE2(ov::element::f16, ov::element::i32, ov::float16, int32_t),
               OV_CASE2(ov::element::bf16, ov::element::i32, ov::bfloat16, int32_t),
diff --git a/src/plugins/intel_cpu/src/nodes/col2im.h b/src/plugins/intel_cpu/src/nodes/col2im.h
index 9904689e53be0f..b56b4bb78469aa 100644
--- a/src/plugins/intel_cpu/src/nodes/col2im.h
+++ b/src/plugins/intel_cpu/src/nodes/col2im.h
@@ -26,7 +26,7 @@ class Col2Im : public Node {
     template <class OV_DATA_TYPE, class OV_INDEX_TYPE>
     void executeImpl();
 
-    template<typename T>
+    template <typename T>
     struct Col2ImExecute;
 
     ov::Strides strides;
diff --git a/src/plugins/intel_cpu/src/nodes/color_convert.cpp b/src/plugins/intel_cpu/src/nodes/color_convert.cpp
index ea3c8e2c774944..a06214b768d6b4 100644
--- a/src/plugins/intel_cpu/src/nodes/color_convert.cpp
+++ b/src/plugins/intel_cpu/src/nodes/color_convert.cpp
@@ -3,14 +3,17 @@
 //
 
 #include "color_convert.h"
+
 #include <memory_desc/dnnl_blocked_memory_desc.h>
-#include <openvino/op/nv12_to_rgb.hpp>
-#include <openvino/op/nv12_to_bgr.hpp>
-#include <openvino/op/i420_to_rgb.hpp>
-#include <openvino/op/i420_to_bgr.hpp>
+
 #include <openvino/core/type.hpp>
-#include "openvino/core/parallel.hpp"
+#include <openvino/op/i420_to_bgr.hpp>
+#include <openvino/op/i420_to_rgb.hpp>
+#include <openvino/op/nv12_to_bgr.hpp>
+#include <openvino/op/nv12_to_rgb.hpp>
+
 #include "kernels/x64/jit_kernel.hpp"
+#include "openvino/core/parallel.hpp"
 #include "shape_inference/custom/color_convert.hpp"
 
 using namespace dnnl::impl;
@@ -39,7 +42,7 @@ class Converter : public ColorConvert::Converter {
     using Base = ColorConvert::Converter;
 
 public:
-    Converter(Node *node);
+    Converter(Node* node);
 
     bool singlePlane() const;
 
@@ -47,12 +50,12 @@ class Converter : public ColorConvert::Converter {
     std::tuple<T, T, T> yuv_to_rgb(float y, float u, float v);
 };
 
-Converter::Converter(Node *node)
-    : Base(node, node->getAlgorithm() == Algorithm::ColorConvertNV12toRGB
-                    || node->getAlgorithm() == Algorithm::ColorConvertI420toRGB
-                        ? ColorFormat { { 0, 1, 2 } }
-                        : ColorFormat { { 2, 1, 0 } }) {
-}
+Converter::Converter(Node* node)
+    : Base(node,
+           node->getAlgorithm() == Algorithm::ColorConvertNV12toRGB ||
+                   node->getAlgorithm() == Algorithm::ColorConvertI420toRGB
+               ? ColorFormat{{0, 1, 2}}
+               : ColorFormat{{2, 1, 0}}) {}
 
 bool Converter::singlePlane() const {
     return _node->getOriginalInputsNumber() == 1;
@@ -81,46 +84,43 @@ struct jit_uni_converter : public jit_kernel {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_converter)
 
     struct Params {
-        const void * y;
-        const void * u;
-        const void * v;
-        void * dst;
+        const void* y;
+        const void* u;
+        const void* v;
+        void* dst;
         size_t width;
-        uint8_t colorFormat;    // RGB: 0, BGR: !=0
+        uint8_t colorFormat;  // RGB: 0, BGR: !=0
     };
 
-    typedef void (*function_t)(const Params *);
+    typedef void (*function_t)(const Params*);
 
     void init();
 
-    void operator()(const Params & args) const {
+    void operator()(const Params& args) const {
         _fn(&args);
     }
 
 protected:
     jit_uni_converter();
 
-    template<size_t N>
-    void yuv_to_rgb(const variable<float[N]> & y,
-                    const variable<float[N]> & u,
-                    const variable<float[N]> & v,
-                    const variable<uint8_t> & color_format,
+    template <size_t N>
+    void yuv_to_rgb(const variable<float[N]>& y,
+                    const variable<float[N]>& u,
+                    const variable<float[N]>& v,
+                    const variable<uint8_t>& color_format,
                     bool round);
-    template<typename T, size_t N>
-    void store_tail(const variable<T*> & dst,
-                    const variable<float[N]> & a,
-                    const variable<float[N]> & b,
-                    const variable<float[N]> & c,
-                    const variable<size_t> & size);
+    template <typename T, size_t N>
+    void store_tail(const variable<T*>& dst,
+                    const variable<float[N]>& a,
+                    const variable<float[N]>& b,
+                    const variable<float[N]>& c,
+                    const variable<size_t>& size);
 
     function_t _fn;
     variable<const float*> _consts;
 };
 
-jit_uni_converter::jit_uni_converter()
-    : jit_kernel(jit_name()),
-      _consts(*this) {
-}
+jit_uni_converter::jit_uni_converter() : jit_kernel(jit_name()), _consts(*this) {}
 
 void jit_uni_converter::init() {
     if (create_kernel() != status::success)
@@ -128,15 +128,13 @@ void jit_uni_converter::init() {
     _fn = (function_t)jit_ker();
 }
 
-template<size_t N>
-void jit_uni_converter::yuv_to_rgb(const variable<float[N]> & y,
-                                   const variable<float[N]> & u,
-                                   const variable<float[N]> & v,
-                                   const variable<uint8_t> & color_format,
+template <size_t N>
+void jit_uni_converter::yuv_to_rgb(const variable<float[N]>& y,
+                                   const variable<float[N]>& u,
+                                   const variable<float[N]>& v,
+                                   const variable<uint8_t>& color_format,
                                    bool round) {
-    auto clip = [&](const variable<float[N]> & op,
-                    const variable<float[N]> & a,
-                    const variable<float[N]> & b) {
+    auto clip = [&](const variable<float[N]>& op, const variable<float[N]>& a, const variable<float[N]>& b) {
         if (round)
             uni_vroundps(op, op, 0);
         uni_vmaxps(op, op, a);
@@ -144,8 +142,12 @@ void jit_uni_converter::yuv_to_rgb(const variable<float[N]> & y,
     };
 
     // blend r,g,b and put to r0,r1,r2
-    auto blend = [&](const variable<float[N]> & r, const variable<float[N]> & g, const variable<float[N]> & b,
-                     const variable<float[N]> & r0, const variable<float[N]> & r1, const variable<float[N]> & r2) {
+    auto blend = [&](const variable<float[N]>& r,
+                     const variable<float[N]>& g,
+                     const variable<float[N]>& b,
+                     const variable<float[N]>& r0,
+                     const variable<float[N]>& r1,
+                     const variable<float[N]>& r2) {
         /*
             Input:
             r0,r1,r2,r3,r4,r5,r6,r7
@@ -174,7 +176,7 @@ void jit_uni_converter::yuv_to_rgb(const variable<float[N]> & y,
         */
 
         auto genPermutationMask = [&](int offset) {
-            std::array<uint8_t, N> mask {};
+            std::array<uint8_t, N> mask{};
             for (uint8_t i = 0; i < mask.size(); ++i)
                 mask[(i * 3 + offset) % mask.size()] = i;
             return mask;
@@ -184,11 +186,8 @@ void jit_uni_converter::yuv_to_rgb(const variable<float[N]> & y,
         g.permute(genPermutationMask(1));
         b.permute(genPermutationMask(2));
 
-        auto blendWithMask = [&](int offset, const variable<float[N]> & result) {
-            static const uint32_t blendMasks[2] = {
-                0x92492492,
-                0x24924924
-            };
+        auto blendWithMask = [&](int offset, const variable<float[N]>& result) {
+            static const uint32_t blendMasks[2] = {0x92492492, 0x24924924};
             const uint16_t mask0 = static_cast<const uint16_t>(blendMasks[0] >> ((offset * N) % 3));
             const uint16_t mask1 = static_cast<const uint16_t>(blendMasks[1] >> ((offset * N) % 3));
 
@@ -208,29 +207,29 @@ void jit_uni_converter::yuv_to_rgb(const variable<float[N]> & y,
     auto b = var<float[N]>();
     auto tmp = var<float[N]>();
 
-    uni_vbroadcastss(tmp, ptr[_consts + 0 * sizeof(float)]);    // tmp = [16.0f,16.0f,...]
-    uni_vsubps(y, y, tmp);                                      // y = y - tmp
-    uni_vbroadcastss(tmp, ptr[_consts + 1 * sizeof(float)]);    // tmp = [128.f,128.f,...]
-    uni_vsubps(u, u, tmp);                                      // u = u - tmp
-    uni_vsubps(v, v, tmp);                                      // v = v - tmp
+    uni_vbroadcastss(tmp, ptr[_consts + 0 * sizeof(float)]);  // tmp = [16.0f,16.0f,...]
+    uni_vsubps(y, y, tmp);                                    // y = y - tmp
+    uni_vbroadcastss(tmp, ptr[_consts + 1 * sizeof(float)]);  // tmp = [128.f,128.f,...]
+    uni_vsubps(u, u, tmp);                                    // u = u - tmp
+    uni_vsubps(v, v, tmp);                                    // v = v - tmp
 
-    uni_vbroadcastss(tmp, ptr[_consts + 2 * sizeof(float)]);    // tmp = [1.164f,1.164f,...]
-    uni_vmulps(y, y, tmp);                                      // y = y * tmp
+    uni_vbroadcastss(tmp, ptr[_consts + 2 * sizeof(float)]);  // tmp = [1.164f,1.164f,...]
+    uni_vmulps(y, y, tmp);                                    // y = y * tmp
 
-    uni_vbroadcastss(r, ptr[_consts + 3 * sizeof(float)]);      // r = [1.596f,1.596f,...]
-    uni_vmulps(r, r, v);                                        // r = r * v
-    uni_vaddps(r, r, y);                                        // r = r + y
+    uni_vbroadcastss(r, ptr[_consts + 3 * sizeof(float)]);  // r = [1.596f,1.596f,...]
+    uni_vmulps(r, r, v);                                    // r = r * v
+    uni_vaddps(r, r, y);                                    // r = r + y
 
-    uni_vbroadcastss(g, ptr[_consts + 4 * sizeof(float)]);      // g = [0.391f,0.391f,...]
-    uni_vmulps(g, g, u);                                        // g = g * u
-    uni_vsubps(g, y, g);                                        // g = y - g
-    uni_vbroadcastss(tmp, ptr[_consts + 6 * sizeof(float)]);    // tmp = [0.813f,0.813f,...]
-    uni_vmulps(tmp, tmp, v);                                    // tmp = tmp * v
-    uni_vsubps(g, g, tmp);                                      // g = g - tmp
+    uni_vbroadcastss(g, ptr[_consts + 4 * sizeof(float)]);    // g = [0.391f,0.391f,...]
+    uni_vmulps(g, g, u);                                      // g = g * u
+    uni_vsubps(g, y, g);                                      // g = y - g
+    uni_vbroadcastss(tmp, ptr[_consts + 6 * sizeof(float)]);  // tmp = [0.813f,0.813f,...]
+    uni_vmulps(tmp, tmp, v);                                  // tmp = tmp * v
+    uni_vsubps(g, g, tmp);                                    // g = g - tmp
 
-    uni_vbroadcastss(b, ptr[_consts + 5 * sizeof(float)]);      // b = [2.018f,2.018f,...]
-    uni_vmulps(b, b, u);                                        // b = b * u
-    uni_vaddps(b, b, y);                                        // b = b + y
+    uni_vbroadcastss(b, ptr[_consts + 5 * sizeof(float)]);  // b = [2.018f,2.018f,...]
+    uni_vmulps(b, b, u);                                    // b = b * u
+    uni_vaddps(b, b, y);                                    // b = b + y
 
     // clip
     uni_vxorps(y, y, y);
@@ -241,24 +240,30 @@ void jit_uni_converter::yuv_to_rgb(const variable<float[N]> & y,
     clip(b, y, u);
 
     _if(color_format == 0)
-    ._then([&]{ blend(r, g, b, y, u, v); })
-    ._else([&]{ blend(b, g, r, y, u, v); });
+        ._then([&] {
+            blend(r, g, b, y, u, v);
+        })
+        ._else([&] {
+            blend(b, g, r, y, u, v);
+        });
 }
 
-template<typename T, size_t N>
-void jit_uni_converter::store_tail(const variable<T*> & dst,
-                                   const variable<float[N]> & a,
-                                   const variable<float[N]> & b,
-                                   const variable<float[N]> & c,
-                                   const variable<size_t> & size) {
+template <typename T, size_t N>
+void jit_uni_converter::store_tail(const variable<T*>& dst,
+                                   const variable<float[N]>& a,
+                                   const variable<float[N]>& b,
+                                   const variable<float[N]>& c,
+                                   const variable<size_t>& size) {
     const size_t step = N * sizeof(T);
     auto s = stack(3 * step);
 
     auto sptr = var<T*>();
     sptr = s.pointer();
 
-    store(sptr, a); sptr += step;
-    store(sptr, b); sptr += step;
+    store(sptr, a);
+    sptr += step;
+    store(sptr, b);
+    sptr += step;
     store(sptr, c);
 
     auto copy_size = size * size_t(3u);
@@ -269,36 +274,33 @@ void jit_uni_converter::store_tail(const variable<T*> & dst,
 
 namespace nv12 {
 
-ColorConvert::Converter::PrimitiveDescs supportedPrimitiveDescs(Node *node) {
-    const LayoutType layout = LayoutType::ncsp; // 0,1,2,3
+ColorConvert::Converter::PrimitiveDescs supportedPrimitiveDescs(Node* node) {
+    const LayoutType layout = LayoutType::ncsp;  // 0,1,2,3
 
-    const ov::element::Type precision = node->getOriginalInputPrecisionAtPort(0) == ov::element::u8
-                                    ? ov::element::u8
-                                    : ov::element::f32;
+    const ov::element::Type precision =
+        node->getOriginalInputPrecisionAtPort(0) == ov::element::u8 ? ov::element::u8 : ov::element::f32;
 
     ColorConvert::Converter::PrimitiveDescs descs;
 
-    descs.emplace_back(std::vector<PortConfigurator> { node->getOriginalInputsNumber(), { layout, precision } },
-                        std::vector<PortConfigurator> { { layout, precision } },
-                        mayiuse(cpu_isa_t::sse41)
-                            ? impl_desc_type::jit_uni
-                            : impl_desc_type::ref,
-                        true);
+    descs.emplace_back(std::vector<PortConfigurator>{node->getOriginalInputsNumber(), {layout, precision}},
+                       std::vector<PortConfigurator>{{layout, precision}},
+                       mayiuse(cpu_isa_t::sse41) ? impl_desc_type::jit_uni : impl_desc_type::ref,
+                       true);
 
     return descs;
 }
 
-template<typename T, impl_desc_type I>
+template <typename T, impl_desc_type I>
 class SinglePlaneConvert;
-template<typename T, impl_desc_type I>
+template <typename T, impl_desc_type I>
 class TwoPlaneConvert;
 
 class RefConverter : public Converter {
 public:
-    RefConverter(Node *node);
+    RefConverter(Node* node);
 
 protected:
-    template<typename T>
+    template <typename T>
     void convert(const T* y,
                  const T* uv,
                  T* dst,
@@ -309,15 +311,14 @@ class RefConverter : public Converter {
                  size_t stride_uv);
 };
 
-RefConverter::RefConverter(Node *node)
-    : Converter(node) {
+RefConverter::RefConverter(Node* node) : Converter(node) {
     if (node->getOriginalInputsNumber() != (singlePlane() ? 1 : 2))
         OPENVINO_THROW("NV12Converter node has incorrect number of inputs");
     if (!node->getOriginalOutputsNumber())
         OPENVINO_THROW("NV12Converter node has incorrect number of outputs");
 }
 
-template<typename T>
+template <typename T>
 void RefConverter::convert(const T* y,
                            const T* uv,
                            T* dst,
@@ -346,13 +347,13 @@ void RefConverter::convert(const T* y,
     });
 }
 
-template<typename T>
+template <typename T>
 class SinglePlaneConvert<T, impl_desc_type::ref> : public RefConverter {
 public:
     using RefConverter::RefConverter;
 
     void execute(dnnl::stream strm) override {
-        const auto & dims = inputDims(0);
+        const auto& dims = inputDims(0);
 
         const size_t batch_size = dims[N_DIM];
         const size_t height = dims[H_DIM] * 2 / 3;
@@ -362,22 +363,17 @@ class SinglePlaneConvert<T, impl_desc_type::ref> : public RefConverter {
         const T* uv = y + width * height;
         T* dst = static_cast<T*>(output(0));
 
-        convert<T>(y, uv, dst,
-                   batch_size,
-                   height,
-                   width,
-                   height * width * 3 / 2,
-                   height * width * 3 / 2);
+        convert<T>(y, uv, dst, batch_size, height, width, height * width * 3 / 2, height * width * 3 / 2);
     }
 };
 
-template<typename T>
+template <typename T>
 class TwoPlaneConvert<T, impl_desc_type::ref> : public RefConverter {
 public:
     using RefConverter::RefConverter;
 
     void execute(dnnl::stream strm) override {
-        const auto & dims = inputDims(0);
+        const auto& dims = inputDims(0);
 
         const T* y = static_cast<const T*>(input(0));
         const T* uv = static_cast<const T*>(input(1));
@@ -387,34 +383,24 @@ class TwoPlaneConvert<T, impl_desc_type::ref> : public RefConverter {
         const size_t height = dims[H_DIM];
         const size_t width = dims[W_DIM];
 
-        convert<T>(y, uv, dst,
-                   batch_size,
-                   height,
-                   width,
-                   height * width,
-                   height * width / 2);
+        convert<T>(y, uv, dst, batch_size, height, width, height * width, height * width / 2);
     }
 };
 
 #if defined(OPENVINO_ARCH_X86_64)
-template<typename T>
+template <typename T>
 class JitConverter;
 
-template<typename T, size_t N>
+template <typename T, size_t N>
 class JitConverter<T[N]> : public jit_uni_converter {
 private:
     void generate() override;
-    std::tuple<variable<float[N]>,
-               variable<float[N]>,
-               variable<float[N]>>
-    load_yuv(const variable<const T *> & src_y,
-             const variable<const T *> & src_uv);
-    std::tuple<variable<float[N]>,
-               variable<float[N]>>
-    unpack_uv(const variable<float[N]> & uv);
+    std::tuple<variable<float[N]>, variable<float[N]>, variable<float[N]>> load_yuv(const variable<const T*>& src_y,
+                                                                                    const variable<const T*>& src_uv);
+    std::tuple<variable<float[N]>, variable<float[N]>> unpack_uv(const variable<float[N]>& uv);
 };
 
-template<typename T, size_t N>
+template <typename T, size_t N>
 void JitConverter<T[N]>::generate() {
     preamble();
 
@@ -425,7 +411,7 @@ void JitConverter<T[N]>::generate() {
     auto width = arg(&Params::width);
     auto colorFormat = arg(&Params::colorFormat);
 
-    static const float data[8] = { 16.f, 128.f, 1.164f, 1.596f, 0.391f, 2.018f, 0.813f, 255.f };
+    static const float data[8] = {16.f, 128.f, 1.164f, 1.596f, 0.391f, 2.018f, 0.813f, 255.f};
     _consts = data;
 
     const size_t reg_capacity_log = static_cast<size_t>(std::logb(N));
@@ -433,26 +419,29 @@ void JitConverter<T[N]>::generate() {
 
     width >>= reg_capacity_log;
 
-    foreach(0, width, [&](const Reg64 & idx) {
+    foreach (0, width, [&](const Reg64& idx) {
         auto yuv = load_yuv(src_y, src_uv);
 
         // Aliases
-        const auto & y = std::get<0>(yuv);
-        const auto & u = std::get<1>(yuv);
-        const auto & v = std::get<2>(yuv);
+        const auto& y = std::get<0>(yuv);
+        const auto& u = std::get<1>(yuv);
+        const auto& v = std::get<2>(yuv);
 
         yuv_to_rgb(y, u, v, colorFormat, std::is_integral<T>::value);
 
-        store(dst, y);  dst += step;
-        store(dst, u);  dst += step;
-        store(dst, v);  dst += step;
-    });
+        store(dst, y);
+        dst += step;
+        store(dst, u);
+        dst += step;
+        store(dst, v);
+        dst += step;
+    })
+        ;
 
     mov(width, argPtr(&Params::width));
     width &= N - 1;
 
-    _if(width != 0)
-    ._then([&] {
+    _if(width != 0)._then([&] {
         auto y = var<float[N]>();
         auto uv = var<float[N]>();
 
@@ -462,8 +451,8 @@ void JitConverter<T[N]>::generate() {
         auto uv_pair = unpack_uv(uv);
 
         // Aliases
-        const auto & u = std::get<0>(uv_pair);
-        const auto & v = std::get<1>(uv_pair);
+        const auto& u = std::get<0>(uv_pair);
+        const auto& v = std::get<1>(uv_pair);
 
         yuv_to_rgb(y, u, v, colorFormat, std::is_integral<T>::value);
 
@@ -473,12 +462,9 @@ void JitConverter<T[N]>::generate() {
     postamble();
 }
 
-template<typename T, size_t N>
-std::tuple<jit_kernel::variable<float[N]>,
-           jit_kernel::variable<float[N]>,
-           jit_kernel::variable<float[N]>>
-JitConverter<T[N]>::load_yuv(const variable<const T *> & src_y,
-                             const variable<const T *> & src_uv) {
+template <typename T, size_t N>
+std::tuple<jit_kernel::variable<float[N]>, jit_kernel::variable<float[N]>, jit_kernel::variable<float[N]>>
+JitConverter<T[N]>::load_yuv(const variable<const T*>& src_y, const variable<const T*>& src_uv) {
     auto y = var<float[N]>();
     auto uv = var<float[N]>();
 
@@ -490,29 +476,26 @@ JitConverter<T[N]>::load_yuv(const variable<const T *> & src_y,
     src_y += N * sizeof(T);
     src_uv += N * sizeof(T);
 
-    return std::make_tuple(std::move(y),
-                           std::move(std::get<0>(uv_pair)),
-                           std::move(std::get<1>(uv_pair)));
+    return std::make_tuple(std::move(y), std::move(std::get<0>(uv_pair)), std::move(std::get<1>(uv_pair)));
 }
 
-template<typename T, size_t N>
-std::tuple<jit_kernel::variable<float[N]>,
-           jit_kernel::variable<float[N]>>
-JitConverter<T[N]>::unpack_uv(const variable<float[N]> & uv) {
+template <typename T, size_t N>
+std::tuple<jit_kernel::variable<float[N]>, jit_kernel::variable<float[N]>> JitConverter<T[N]>::unpack_uv(
+    const variable<float[N]>& uv) {
     auto u = var<float[N]>();
     auto v = var<float[N]>();
 
-    const uint8_t even_mask = 0xA0;         // 0b10100000
-    const uint8_t odd_mask = 0xF5;          // 0b11110101
+    const uint8_t even_mask = 0xA0;  // 0b10100000
+    const uint8_t odd_mask = 0xF5;   // 0b11110101
 
-    uni_vshufps(u, uv, uv, even_mask);      // u = uv[0,0,2,2,4,4,6,6]
-    uni_vshufps(v, uv, uv, odd_mask);       // v = uv[1,1,3,3,5,5,7,7]
+    uni_vshufps(u, uv, uv, even_mask);  // u = uv[0,0,2,2,4,4,6,6]
+    uni_vshufps(v, uv, uv, odd_mask);   // v = uv[1,1,3,3,5,5,7,7]
 
     return std::make_tuple(std::move(u), std::move(v));
 }
 
-template<typename T>
-const jit_uni_converter & jit_converter_create() {
+template <typename T>
+const jit_uni_converter& jit_converter_create() {
     auto createKernel = []() {
         std::unique_ptr<jit_uni_converter> kernel;
 
@@ -540,22 +523,21 @@ const jit_uni_converter & jit_converter_create() {
     return *kernel;
 }
 
-template<typename T>
-const jit_uni_converter & jit_converter_get() {
+template <typename T>
+const jit_uni_converter& jit_converter_get() {
     return jit_converter_create<T>();
 }
 
-template<typename T>
+template <typename T>
 class SinglePlaneConvert<T, impl_desc_type::jit_uni> : public Converter {
 public:
-    SinglePlaneConvert(Node *node)
-        : Converter(node) {
+    SinglePlaneConvert(Node* node) : Converter(node) {
         jit_converter_create<T>();
     }
 
     void execute(dnnl::stream strm) override {
-        const auto & kernel = jit_converter_get<T>();
-        const auto & dims = inputDims(0);
+        const auto& kernel = jit_converter_get<T>();
+        const auto& dims = inputDims(0);
 
         const size_t batch_size = dims[N_DIM];
         const size_t height = dims[H_DIM] * 2 / 3;
@@ -574,23 +556,22 @@ class SinglePlaneConvert<T, impl_desc_type::jit_uni> : public Converter {
             args.u = args.v = uv + batch * stride_uv + (h / 2) * width;
             args.dst = dst + (batch * width * height + h * width) * 3;
             args.width = width;
-            args.colorFormat = _colorFormat[0]; // The first byte is enough to determine the RGB or BGR format.
+            args.colorFormat = _colorFormat[0];  // The first byte is enough to determine the RGB or BGR format.
             kernel(args);
         });
     }
 };
 
-template<typename T>
+template <typename T>
 class TwoPlaneConvert<T, impl_desc_type::jit_uni> : public Converter {
 public:
-    TwoPlaneConvert(Node *node)
-        : Converter(node) {
+    TwoPlaneConvert(Node* node) : Converter(node) {
         jit_converter_create<T>();
     }
 
     void execute(dnnl::stream strm) override {
-        const auto & kernel = jit_converter_get<T>();
-        const auto & dims = inputDims(0);
+        const auto& kernel = jit_converter_get<T>();
+        const auto& dims = inputDims(0);
 
         const size_t batch_size = dims[N_DIM];
         const size_t height = dims[H_DIM];
@@ -609,46 +590,43 @@ class TwoPlaneConvert<T, impl_desc_type::jit_uni> : public Converter {
             args.u = args.v = uv + batch * stride_uv + (h / 2) * width;
             args.dst = dst + (batch * width * height + h * width) * 3;
             args.width = width;
-            args.colorFormat = _colorFormat[0]; // The first byte is enough to determine the RGB or BGR format.
+            args.colorFormat = _colorFormat[0];  // The first byte is enough to determine the RGB or BGR format.
             kernel(args);
         });
     }
 };
 #endif
-}   // namespace nv12
+}  // namespace nv12
 
 namespace i420 {
 
-ColorConvert::Converter::PrimitiveDescs supportedPrimitiveDescs(Node *node) {
-    const LayoutType layout = LayoutType::ncsp; // 0,1,2,3
+ColorConvert::Converter::PrimitiveDescs supportedPrimitiveDescs(Node* node) {
+    const LayoutType layout = LayoutType::ncsp;  // 0,1,2,3
 
-    const ov::element::Type precision = node->getOriginalInputPrecisionAtPort(0) == ov::element::u8
-                                    ? ov::element::u8
-                                    : ov::element::f32;
+    const ov::element::Type precision =
+        node->getOriginalInputPrecisionAtPort(0) == ov::element::u8 ? ov::element::u8 : ov::element::f32;
 
     ColorConvert::Converter::PrimitiveDescs descs;
 
-    descs.emplace_back(std::vector<PortConfigurator> { node->getOriginalInputsNumber(), { layout, precision } },
-                        std::vector<PortConfigurator> { { layout, precision } },
-                        mayiuse(cpu_isa_t::sse41)
-                            ? impl_desc_type::jit_uni
-                            : impl_desc_type::ref,
-                        true);
+    descs.emplace_back(std::vector<PortConfigurator>{node->getOriginalInputsNumber(), {layout, precision}},
+                       std::vector<PortConfigurator>{{layout, precision}},
+                       mayiuse(cpu_isa_t::sse41) ? impl_desc_type::jit_uni : impl_desc_type::ref,
+                       true);
 
     return descs;
 }
 
-template<typename T, impl_desc_type I>
+template <typename T, impl_desc_type I>
 class SinglePlaneConvert;
-template<typename T, impl_desc_type I>
+template <typename T, impl_desc_type I>
 class ThreePlaneConvert;
 
 class RefConverter : public Converter {
 public:
-    RefConverter(Node *node);
+    RefConverter(Node* node);
 
 protected:
-    template<typename T>
+    template <typename T>
     void convert(const T* y,
                  const T* u,
                  const T* v,
@@ -660,15 +638,14 @@ class RefConverter : public Converter {
                  size_t stride_uv);
 };
 
-RefConverter::RefConverter(Node *node)
-    : Converter(node) {
-    if (node->getOriginalInputsNumber() != (singlePlane() ? 1: 3))
+RefConverter::RefConverter(Node* node) : Converter(node) {
+    if (node->getOriginalInputsNumber() != (singlePlane() ? 1 : 3))
         OPENVINO_THROW("I420Converter node has incorrect number of inputs");
     if (!node->getOriginalOutputsNumber())
         OPENVINO_THROW("I420Converter node has incorrect number of outputs");
 }
 
-template<typename T>
+template <typename T>
 void RefConverter::convert(const T* y,
                            const T* u,
                            const T* v,
@@ -699,13 +676,13 @@ void RefConverter::convert(const T* y,
     });
 }
 
-template<typename T>
+template <typename T>
 class SinglePlaneConvert<T, impl_desc_type::ref> : public RefConverter {
 public:
     using RefConverter::RefConverter;
 
     void execute(dnnl::stream strm) override {
-        const auto & dims = inputDims(0);
+        const auto& dims = inputDims(0);
 
         const size_t batch_size = dims[N_DIM];
         const size_t height = dims[H_DIM] * 2 / 3;
@@ -716,22 +693,17 @@ class SinglePlaneConvert<T, impl_desc_type::ref> : public RefConverter {
         const T* v = y + 5 * width * height / 4;
         T* dst = static_cast<T*>(output(0));
 
-        convert<T>(y, u, v, dst,
-                   batch_size,
-                   height,
-                   width,
-                   height * width * 3 / 2,
-                   height * width * 3 / 2);
+        convert<T>(y, u, v, dst, batch_size, height, width, height * width * 3 / 2, height * width * 3 / 2);
     }
 };
 
-template<typename T>
+template <typename T>
 class ThreePlaneConvert<T, impl_desc_type::ref> : public RefConverter {
 public:
     using RefConverter::RefConverter;
 
     void execute(dnnl::stream strm) override {
-        const auto & dims = inputDims(0);
+        const auto& dims = inputDims(0);
 
         const T* y = static_cast<const T*>(input(0));
         const T* u = static_cast<const T*>(input(1));
@@ -742,34 +714,25 @@ class ThreePlaneConvert<T, impl_desc_type::ref> : public RefConverter {
         const size_t height = dims[H_DIM];
         const size_t width = dims[W_DIM];
 
-        convert<T>(y, u, v, dst,
-                   batch_size,
-                   height,
-                   width,
-                   height * width,
-                   height * width / 4);
+        convert<T>(y, u, v, dst, batch_size, height, width, height * width, height * width / 4);
     }
 };
 
 #if defined(OPENVINO_ARCH_X86_64)
-template<typename T>
+template <typename T>
 class JitConverter;
 
-template<typename T, size_t N>
+template <typename T, size_t N>
 class JitConverter<T[N]> : public jit_uni_converter {
 private:
     void generate() override;
-    std::tuple<variable<float[N]>,
-               variable<float[N]>,
-               variable<float[N]>>
-    load_yuv(const variable<const T *> & src_y,
-             const variable<const T *> & src_u,
-             const variable<const T *> & src_v);
-    void unpack_uv(const variable<float[N]> & u,
-                   const variable<float[N]> & v);
+    std::tuple<variable<float[N]>, variable<float[N]>, variable<float[N]>> load_yuv(const variable<const T*>& src_y,
+                                                                                    const variable<const T*>& src_u,
+                                                                                    const variable<const T*>& src_v);
+    void unpack_uv(const variable<float[N]>& u, const variable<float[N]>& v);
 };
 
-template<typename T, size_t N>
+template <typename T, size_t N>
 void JitConverter<T[N]>::generate() {
     preamble();
 
@@ -781,7 +744,7 @@ void JitConverter<T[N]>::generate() {
     auto width = arg(&Params::width);
     auto colorFormat = arg(&Params::colorFormat);
 
-    static const float data[8] = { 16.f, 128.f, 1.164f, 1.596f, 0.391f, 2.018f, 0.813f, 255.f };
+    static const float data[8] = {16.f, 128.f, 1.164f, 1.596f, 0.391f, 2.018f, 0.813f, 255.f};
     _consts = data;
 
     const size_t reg_capacity_log = static_cast<size_t>(std::logb(N));
@@ -789,26 +752,29 @@ void JitConverter<T[N]>::generate() {
 
     width >>= reg_capacity_log;
 
-    foreach(0, width, [&](const Reg64 & idx) {
+    foreach (0, width, [&](const Reg64& idx) {
         auto yuv = load_yuv(src_y, src_u, src_v);
 
         // Aliases
-        const auto & y = std::get<0>(yuv);
-        const auto & u = std::get<1>(yuv);
-        const auto & v = std::get<2>(yuv);
+        const auto& y = std::get<0>(yuv);
+        const auto& u = std::get<1>(yuv);
+        const auto& v = std::get<2>(yuv);
 
         yuv_to_rgb(y, u, v, colorFormat, std::is_integral<T>::value);
 
-        store(dst, y);  dst += step;
-        store(dst, u);  dst += step;
-        store(dst, v);  dst += step;
-    });
+        store(dst, y);
+        dst += step;
+        store(dst, u);
+        dst += step;
+        store(dst, v);
+        dst += step;
+    })
+        ;
 
     mov(width, argPtr(&Params::width));
     width &= N - 1;
 
-    _if(width != 0)
-    ._then([&] {
+    _if(width != 0)._then([&] {
         auto y = var<float[N]>();
         auto u = var<float[N]>();
         auto v = var<float[N]>();
@@ -829,13 +795,11 @@ void JitConverter<T[N]>::generate() {
     postamble();
 }
 
-template<typename T, size_t N>
-std::tuple<jit_kernel::variable<float[N]>,
-           jit_kernel::variable<float[N]>,
-           jit_kernel::variable<float[N]>>
-JitConverter<T[N]>::load_yuv(const variable<const T *> & src_y,
-                             const variable<const T *> & src_u,
-                             const variable<const T *> & src_v) {
+template <typename T, size_t N>
+std::tuple<jit_kernel::variable<float[N]>, jit_kernel::variable<float[N]>, jit_kernel::variable<float[N]>>
+JitConverter<T[N]>::load_yuv(const variable<const T*>& src_y,
+                             const variable<const T*>& src_u,
+                             const variable<const T*>& src_v) {
     auto y = var<float[N]>();
     auto u = var<float[N]>();
     auto v = var<float[N]>();
@@ -853,16 +817,15 @@ JitConverter<T[N]>::load_yuv(const variable<const T *> & src_y,
     return std::make_tuple(std::move(y), std::move(u), std::move(v));
 }
 
-template<typename T, size_t N>
-void JitConverter<T[N]>::unpack_uv(const variable<float[N]> & u,
-                                   const variable<float[N]> & v) {
-    static const uint8_t order[] = { 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7 };
+template <typename T, size_t N>
+void JitConverter<T[N]>::unpack_uv(const variable<float[N]>& u, const variable<float[N]>& v) {
+    static const uint8_t order[] = {0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7};
     u.permute(order);
     v.permute(order);
 }
 
-template<typename T>
-const jit_uni_converter & jit_converter_create() {
+template <typename T>
+const jit_uni_converter& jit_converter_create() {
     auto createKernel = []() {
         std::unique_ptr<jit_uni_converter> kernel;
 
@@ -890,22 +853,21 @@ const jit_uni_converter & jit_converter_create() {
     return *kernel;
 }
 
-template<typename T>
-const jit_uni_converter & jit_converter_get() {
+template <typename T>
+const jit_uni_converter& jit_converter_get() {
     return jit_converter_create<T>();
 }
 
-template<typename T>
+template <typename T>
 class SinglePlaneConvert<T, impl_desc_type::jit_uni> : public Converter {
 public:
-    SinglePlaneConvert(Node *node)
-        : Converter(node) {
+    SinglePlaneConvert(Node* node) : Converter(node) {
         jit_converter_create<T>();
     }
 
     void execute(dnnl::stream strm) override {
-        const auto & kernel = jit_converter_get<T>();
-        const auto & dims = inputDims(0);
+        const auto& kernel = jit_converter_get<T>();
+        const auto& dims = inputDims(0);
 
         const size_t batch_size = dims[N_DIM];
         const size_t height = dims[H_DIM] * 2 / 3;
@@ -926,23 +888,22 @@ class SinglePlaneConvert<T, impl_desc_type::jit_uni> : public Converter {
             args.v = v + batch * stride_uv + (h / 2) * (width / 2);
             args.dst = dst + (batch * width * height + h * width) * 3;
             args.width = width;
-            args.colorFormat = _colorFormat[0]; // The first byte is enough to determine the RGB or BGR format.
+            args.colorFormat = _colorFormat[0];  // The first byte is enough to determine the RGB or BGR format.
             kernel(args);
         });
     }
 };
 
-template<typename T>
+template <typename T>
 class ThreePlaneConvert<T, impl_desc_type::jit_uni> : public Converter {
 public:
-    ThreePlaneConvert(Node *node)
-        : Converter(node) {
+    ThreePlaneConvert(Node* node) : Converter(node) {
         jit_converter_create<T>();
     }
 
     void execute(dnnl::stream strm) override {
-        const auto & kernel = jit_converter_get<T>();
-        const auto & dims = inputDims(0);
+        const auto& kernel = jit_converter_get<T>();
+        const auto& dims = inputDims(0);
 
         const T* y = static_cast<const T*>(input(0));
         const T* u = static_cast<const T*>(input(1));
@@ -963,20 +924,19 @@ class ThreePlaneConvert<T, impl_desc_type::jit_uni> : public Converter {
             args.v = v + batch * stride_uv + (h / 2) * (width / 2);
             args.dst = dst + (batch * width * height + h * width) * 3;
             args.width = width;
-            args.colorFormat = _colorFormat[0]; // The first byte is enough to determine the RGB or BGR format.
+            args.colorFormat = _colorFormat[0];  // The first byte is enough to determine the RGB or BGR format.
             kernel(args);
         });
     }
 };
 #endif
-}   // namespace i420
+}  // namespace i420
 
-}   // namespace
+}  // namespace
 
-ColorConvert::Converter::Converter(Node *node, const ColorFormat & colorFormat)
-    : _node(node)
-    , _colorFormat(colorFormat) {
-}
+ColorConvert::Converter::Converter(Node* node, const ColorFormat& colorFormat)
+    : _node(node),
+      _colorFormat(colorFormat) {}
 
 ov::element::Type ColorConvert::Converter::inputPrecision(size_t idx) const {
     return _node->getParentEdgeAt(idx)->getMemory().getDesc().getPrecision();
@@ -986,15 +946,15 @@ ov::element::Type ColorConvert::Converter::outputPrecision(size_t idx) const {
     return _node->getChildEdgeAt(idx)->getMemory().getDesc().getPrecision();
 }
 
-const void * ColorConvert::Converter::input(size_t idx) const {
+const void* ColorConvert::Converter::input(size_t idx) const {
     return _node->getSrcDataAtPort(idx);
 }
 
-void * ColorConvert::Converter::output(size_t idx) const {
+void* ColorConvert::Converter::output(size_t idx) const {
     return _node->getDstDataAtPort(idx);
 }
 
-const VectorDims & ColorConvert::Converter::inputDims(size_t idx) const {
+const VectorDims& ColorConvert::Converter::inputDims(size_t idx) const {
     return _node->getParentEdgeAt(idx)->getMemory().getStaticDims();
 }
 
@@ -1019,42 +979,42 @@ void ColorConvert::initSupportedPrimitiveDescriptors() {
         return;
 
     switch (algorithm) {
-        case Algorithm::ColorConvertNV12toRGB:
-        case Algorithm::ColorConvertNV12toBGR: {
-            for (const auto &desc : nv12::supportedPrimitiveDescs(this)) {
-                const auto & inPortConfigs = std::get<0>(desc);
-                const auto & outPortConfigs = std::get<1>(desc);
-                const auto implType = std::get<2>(desc);
-                addSupportedPrimDesc(inPortConfigs, outPortConfigs, implType);
-            }
-            initSupportedNV12Impls();
-            break;
+    case Algorithm::ColorConvertNV12toRGB:
+    case Algorithm::ColorConvertNV12toBGR: {
+        for (const auto& desc : nv12::supportedPrimitiveDescs(this)) {
+            const auto& inPortConfigs = std::get<0>(desc);
+            const auto& outPortConfigs = std::get<1>(desc);
+            const auto implType = std::get<2>(desc);
+            addSupportedPrimDesc(inPortConfigs, outPortConfigs, implType);
         }
-        case Algorithm::ColorConvertI420toRGB:
-        case Algorithm::ColorConvertI420toBGR: {
-            for (const auto &desc : i420::supportedPrimitiveDescs(this)) {
-                const auto & inPortConfigs = std::get<0>(desc);
-                const auto & outPortConfigs = std::get<1>(desc);
-                const auto implType = std::get<2>(desc);
-                addSupportedPrimDesc(inPortConfigs, outPortConfigs, implType);
-            }
-            initSupportedI420Impls();
-            break;
+        initSupportedNV12Impls();
+        break;
+    }
+    case Algorithm::ColorConvertI420toRGB:
+    case Algorithm::ColorConvertI420toBGR: {
+        for (const auto& desc : i420::supportedPrimitiveDescs(this)) {
+            const auto& inPortConfigs = std::get<0>(desc);
+            const auto& outPortConfigs = std::get<1>(desc);
+            const auto implType = std::get<2>(desc);
+            addSupportedPrimDesc(inPortConfigs, outPortConfigs, implType);
         }
-        default:
-            break;
+        initSupportedI420Impls();
+        break;
+    }
+    default:
+        break;
     }
 }
 
 void ColorConvert::initSupportedNV12Impls() {
-    #define SUPPORTED_IMPL(Impl, type, desc_type)                           \
-        [](Node *node) {                                              \
-            return new nv12::Impl<type, impl_desc_type::desc_type>(node);   \
-        };
+#define SUPPORTED_IMPL(Impl, type, desc_type)                         \
+    [](Node* node) {                                                  \
+        return new nv12::Impl<type, impl_desc_type::desc_type>(node); \
+    };
 
     // ref
     {
-        auto &impls = _supportedImpls[impl_desc_type::ref][algorithm];
+        auto& impls = _supportedImpls[impl_desc_type::ref][algorithm];
         impls[ov::element::Type_t::u8][true] = SUPPORTED_IMPL(SinglePlaneConvert, uint8_t, ref);
         impls[ov::element::Type_t::u8][false] = SUPPORTED_IMPL(TwoPlaneConvert, uint8_t, ref);
         impls[ov::element::Type_t::f32][true] = SUPPORTED_IMPL(SinglePlaneConvert, float, ref);
@@ -1064,25 +1024,25 @@ void ColorConvert::initSupportedNV12Impls() {
 #if defined(OPENVINO_ARCH_X86_64)
     // jit_uni
     {
-        auto &impls = _supportedImpls[impl_desc_type::jit_uni][algorithm];
+        auto& impls = _supportedImpls[impl_desc_type::jit_uni][algorithm];
         impls[ov::element::Type_t::u8][true] = SUPPORTED_IMPL(SinglePlaneConvert, uint8_t, jit_uni);
         impls[ov::element::Type_t::u8][false] = SUPPORTED_IMPL(TwoPlaneConvert, uint8_t, jit_uni);
         impls[ov::element::Type_t::f32][true] = SUPPORTED_IMPL(SinglePlaneConvert, float, jit_uni);
         impls[ov::element::Type_t::f32][false] = SUPPORTED_IMPL(TwoPlaneConvert, float, jit_uni);
     }
 #endif
-    #undef SUPPORTED_IMPL
+#undef SUPPORTED_IMPL
 }
 
 void ColorConvert::initSupportedI420Impls() {
-    #define SUPPORTED_IMPL(Impl, type, desc_type)                           \
-        [](Node *node) {                                              \
-            return new i420::Impl<type, impl_desc_type::desc_type>(node);   \
-        };
+#define SUPPORTED_IMPL(Impl, type, desc_type)                         \
+    [](Node* node) {                                                  \
+        return new i420::Impl<type, impl_desc_type::desc_type>(node); \
+    };
 
     // ref
     {
-        auto &impls = _supportedImpls[impl_desc_type::ref][algorithm];
+        auto& impls = _supportedImpls[impl_desc_type::ref][algorithm];
         impls[ov::element::Type_t::u8][true] = SUPPORTED_IMPL(SinglePlaneConvert, uint8_t, ref);
         impls[ov::element::Type_t::u8][false] = SUPPORTED_IMPL(ThreePlaneConvert, uint8_t, ref);
         impls[ov::element::Type_t::f32][true] = SUPPORTED_IMPL(SinglePlaneConvert, float, ref);
@@ -1092,32 +1052,29 @@ void ColorConvert::initSupportedI420Impls() {
 #if defined(OPENVINO_ARCH_X86_64)
     // jit_uni
     {
-        auto &impls = _supportedImpls[impl_desc_type::jit_uni][algorithm];
+        auto& impls = _supportedImpls[impl_desc_type::jit_uni][algorithm];
         impls[ov::element::Type_t::u8][true] = SUPPORTED_IMPL(SinglePlaneConvert, uint8_t, jit_uni);
         impls[ov::element::Type_t::u8][false] = SUPPORTED_IMPL(ThreePlaneConvert, uint8_t, jit_uni);
         impls[ov::element::Type_t::f32][true] = SUPPORTED_IMPL(SinglePlaneConvert, float, jit_uni);
         impls[ov::element::Type_t::f32][false] = SUPPORTED_IMPL(ThreePlaneConvert, float, jit_uni);
     }
 #endif
-    #undef SUPPORTED_IMPL
+#undef SUPPORTED_IMPL
 }
 
 void ColorConvert::createPrimitive() {
-    const NodeDesc *desc = getSelectedPrimitiveDescriptor();
+    const NodeDesc* desc = getSelectedPrimitiveDescriptor();
     if (!desc)
         OPENVINO_THROW(getTypeStr() + " node with name '" + getName() + "' ",
                        "no optimal primitive descriptor selected");
 
     if (!_impl) {
-        const auto & cfg = desc->getConfig();
+        const auto& cfg = desc->getConfig();
         const auto precision = cfg.inConfs[0].getMemDesc()->getPrecision();
         const bool isSinglePlane = cfg.inConfs.size() == 1;
 
-        _impl = std::unique_ptr<Converter>(_supportedImpls
-                                            .at(desc->getImplementationType())
-                                            .at(algorithm)
-                                            .at(precision)
-                                            .at(isSinglePlane)(this));
+        _impl = std::unique_ptr<Converter>(
+            _supportedImpls.at(desc->getImplementationType()).at(algorithm).at(precision).at(isSinglePlane)(this));
     }
 }
 
@@ -1139,6 +1096,6 @@ void ColorConvert::executeDynamicImpl(dnnl::stream strm) {
     execute(strm);
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/color_convert.h b/src/plugins/intel_cpu/src/nodes/color_convert.h
index 19df1209dd4bab..9bd27c7cf9dffa 100644
--- a/src/plugins/intel_cpu/src/nodes/color_convert.h
+++ b/src/plugins/intel_cpu/src/nodes/color_convert.h
@@ -5,10 +5,11 @@
 #pragma once
 
 #include <node.h>
-#include <utils/multidim_map.hpp>
+
+#include <array>
 #include <functional>
 #include <tuple>
-#include <array>
+#include <utils/multidim_map.hpp>
 
 namespace ov {
 namespace intel_cpu {
@@ -35,11 +36,11 @@ class ColorConvert : public Node {
     void initSupportedI420Impls();
 
 private:
-    using ConverterBuilder = std::function<Converter*(Node *)>;
-    using SupportedImpls = multidim_map<impl_desc_type,                             // Implementation type
-                                        Algorithm,                                  // Algorithm: ColorConvertXXX
-                                        ov::element::Type_t,                        // element type: f32/u8
-                                        bool,                                       // true - SinglePlaneConvert, false - TwoPlaneConvert/ThreePlaneConvert
+    using ConverterBuilder = std::function<Converter*(Node*)>;
+    using SupportedImpls = multidim_map<impl_desc_type,       // Implementation type
+                                        Algorithm,            // Algorithm: ColorConvertXXX
+                                        ov::element::Type_t,  // element type: f32/u8
+                                        bool,  // true - SinglePlaneConvert, false - TwoPlaneConvert/ThreePlaneConvert
                                         ConverterBuilder>;
 
     std::unique_ptr<Converter> _impl;
@@ -48,10 +49,11 @@ class ColorConvert : public Node {
 
 class ColorConvert::Converter {
 public:
-    using PrimitiveDescs = std::vector<std::tuple<std::vector<PortConfigurator>,    // Input port configurator
-                                                  std::vector<PortConfigurator>,    // Output port configurator
-                                                  impl_desc_type,                   // Implementation type
-                                                  bool>>;                           // // true - SinglePlaneConvert, false - TwoPlaneConvert/ThreePlaneConvert
+    using PrimitiveDescs =
+        std::vector<std::tuple<std::vector<PortConfigurator>,  // Input port configurator
+                               std::vector<PortConfigurator>,  // Output port configurator
+                               impl_desc_type,                 // Implementation type
+                               bool>>;  // // true - SinglePlaneConvert, false - TwoPlaneConvert/ThreePlaneConvert
     using Shapes = std::vector<VectorDims>;
 
     static constexpr size_t N_DIM = 0;
@@ -61,20 +63,20 @@ class ColorConvert::Converter {
 
     using ColorFormat = std::array<uint8_t, 3>;
 
-    Converter(Node *node, const ColorFormat & colorFormat);
+    Converter(Node* node, const ColorFormat& colorFormat);
     virtual ~Converter() = default;
     ov::element::Type inputPrecision(size_t idx) const;
     ov::element::Type outputPrecision(size_t idx) const;
-    const void * input(size_t idx) const;
-    void * output(size_t idx) const;
-    const VectorDims & inputDims(size_t idx) const;
+    const void* input(size_t idx) const;
+    void* output(size_t idx) const;
+    const VectorDims& inputDims(size_t idx) const;
     virtual void execute(dnnl::stream strm) = 0;
 
 protected:
-    Node *_node;
-    ColorFormat _colorFormat;   // RGB: {0,1,2}, BGR: {2,1,0}
+    Node* _node;
+    ColorFormat _colorFormat;  // RGB: {0,1,2}, BGR: {2,1,0}
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/arbitrary_order_desc_creator.cpp b/src/plugins/intel_cpu/src/nodes/common/arbitrary_order_desc_creator.cpp
index a7d3adc50d62e3..5887900ce8fa9e 100644
--- a/src/plugins/intel_cpu/src/nodes/common/arbitrary_order_desc_creator.cpp
+++ b/src/plugins/intel_cpu/src/nodes/common/arbitrary_order_desc_creator.cpp
@@ -3,26 +3,26 @@
 //
 
 #include "arbitrary_order_desc_creator.h"
+
 #include "utils/general_utils.h"
 
 namespace ov {
 namespace intel_cpu {
 
-ArbitraryOrderDescCreator::ArbitraryOrderDescCreator(VectorDims order) :
-    m_order(std::move(order)) {
+ArbitraryOrderDescCreator::ArbitraryOrderDescCreator(VectorDims order) : m_order(std::move(order)) {
     OPENVINO_ASSERT(std::adjacent_find(m_order.begin(), m_order.end()) == m_order.end(),
-        "Can't construct ArbitraryOrderDescCreator, order vector contains repetitive elements",
-        vec2str(m_order));
+                    "Can't construct ArbitraryOrderDescCreator, order vector contains repetitive elements",
+                    vec2str(m_order));
 }
 
-CpuBlockedMemoryDesc
-ArbitraryOrderDescCreator::createDesc(const ov::element::Type& precision, const Shape& srcShape) const {
+CpuBlockedMemoryDesc ArbitraryOrderDescCreator::createDesc(const ov::element::Type& precision,
+                                                           const Shape& srcShape) const {
     auto&& dims = srcShape.getDims();
     OPENVINO_ASSERT(dims.size() == m_order.size(),
-        "Couldn't create a tensor descriptor, shape and order size mismatch. Shape: ",
-        vec2str(dims),
-        " order: ",
-        vec2str(m_order));
+                    "Couldn't create a tensor descriptor, shape and order size mismatch. Shape: ",
+                    vec2str(dims),
+                    " order: ",
+                    vec2str(m_order));
 
     VectorDims blkDims(dims.size());
     for (size_t i = 0; i < dims.size(); ++i) {
@@ -36,5 +36,5 @@ size_t ArbitraryOrderDescCreator::getMinimalRank() const {
     return m_order.size();
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/arbitrary_order_desc_creator.h b/src/plugins/intel_cpu/src/nodes/common/arbitrary_order_desc_creator.h
index aaf5a7d5560799..c7341169fd9187 100644
--- a/src/plugins/intel_cpu/src/nodes/common/arbitrary_order_desc_creator.h
+++ b/src/plugins/intel_cpu/src/nodes/common/arbitrary_order_desc_creator.h
@@ -20,5 +20,5 @@ class ArbitraryOrderDescCreator : public BlockedDescCreator {
     VectorDims m_order;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/blocked_desc_creator.cpp b/src/plugins/intel_cpu/src/nodes/common/blocked_desc_creator.cpp
index 88c351ecafbdc1..a7398cac1e9940 100644
--- a/src/plugins/intel_cpu/src/nodes/common/blocked_desc_creator.cpp
+++ b/src/plugins/intel_cpu/src/nodes/common/blocked_desc_creator.cpp
@@ -3,9 +3,8 @@
 //
 
 #include "blocked_desc_creator.h"
-#include <numeric>
-
 
+#include <numeric>
 
 namespace ov {
 namespace intel_cpu {
@@ -15,17 +14,19 @@ constexpr size_t channelsPos = 1lu;
 
 class PlainFormatCreator : public BlockedDescCreator {
 public:
-    CpuBlockedMemoryDesc createDesc(const ov::element::Type &precision, const Shape& srcShape) const override {
+    CpuBlockedMemoryDesc createDesc(const ov::element::Type& precision, const Shape& srcShape) const override {
         VectorDims order(srcShape.getRank());
         std::iota(order.begin(), order.end(), 0);
         return CpuBlockedMemoryDesc(precision, srcShape, srcShape.getDims(), order);
     }
-    size_t getMinimalRank() const override { return 0lu; }
+    size_t getMinimalRank() const override {
+        return 0lu;
+    }
 };
 
 class PerChannelCreator : public BlockedDescCreator {
 public:
-    CpuBlockedMemoryDesc createDesc(const ov::element::Type &precision, const Shape& srcShape) const override {
+    CpuBlockedMemoryDesc createDesc(const ov::element::Type& precision, const Shape& srcShape) const override {
         VectorDims order(srcShape.getRank());
         std::iota(order.begin(), order.end(), 0);
         VectorDims blkDims = srcShape.getDims();
@@ -41,7 +42,9 @@ class PerChannelCreator : public BlockedDescCreator {
 
         return CpuBlockedMemoryDesc(precision, srcShape, blkDims, order);
     }
-    size_t getMinimalRank() const override { return 3lu; }
+    size_t getMinimalRank() const override {
+        return 3lu;
+    }
 };
 
 class ChannelBlockedCreator : public BlockedDescCreator {
@@ -64,24 +67,27 @@ class ChannelBlockedCreator : public BlockedDescCreator {
 
         return CpuBlockedMemoryDesc(precision, srcShape, blkDims, order);
     }
-    size_t getMinimalRank() const override { return 3lu; }
+    size_t getMinimalRank() const override {
+        return 3lu;
+    }
 
 private:
     size_t _blockSize;
 };
 
-} // namespace
+}  // namespace
 
 const BlockedDescCreator::CreatorsMap& BlockedDescCreator::getCommonCreators() {
-    static const CreatorsMap map{ { LayoutType::nspc, CreatorConstPtr(new PerChannelCreator) },
-                                { LayoutType::nCsp8c, CreatorConstPtr(new ChannelBlockedCreator(8)) },
-                                { LayoutType::nCsp16c, CreatorConstPtr(new ChannelBlockedCreator(16)) },
-                                { LayoutType::ncsp, CreatorConstPtr(new PlainFormatCreator) } };
+    static const CreatorsMap map{{LayoutType::nspc, CreatorConstPtr(new PerChannelCreator)},
+                                 {LayoutType::nCsp8c, CreatorConstPtr(new ChannelBlockedCreator(8))},
+                                 {LayoutType::nCsp16c, CreatorConstPtr(new ChannelBlockedCreator(16))},
+                                 {LayoutType::ncsp, CreatorConstPtr(new PlainFormatCreator)}};
     return map;
 }
 
-std::pair<CreatorsMapFilterConstIterator, CreatorsMapFilterConstIterator>
-BlockedDescCreator::makeFilteredRange(const CreatorsMap &map, unsigned int rank) {
+std::pair<CreatorsMapFilterConstIterator, CreatorsMapFilterConstIterator> BlockedDescCreator::makeFilteredRange(
+    const CreatorsMap& map,
+    unsigned int rank) {
     auto rankFilter = [rank](const CreatorsMap::value_type& item) {
         if (item.second->getMinimalRank() > rank) {
             return false;
@@ -94,8 +100,10 @@ BlockedDescCreator::makeFilteredRange(const CreatorsMap &map, unsigned int rank)
     return std::make_pair(first, last);
 }
 
-std::pair<CreatorsMapFilterConstIterator, CreatorsMapFilterConstIterator>
-BlockedDescCreator::makeFilteredRange(const CreatorsMap& map, unsigned rank, const std::vector<LayoutType>& supportedTypes) {
+std::pair<CreatorsMapFilterConstIterator, CreatorsMapFilterConstIterator> BlockedDescCreator::makeFilteredRange(
+    const CreatorsMap& map,
+    unsigned rank,
+    const std::vector<LayoutType>& supportedTypes) {
     unsigned bitMask = 0ul;
     for (auto& item : supportedTypes) {
         bitMask |= 1 << static_cast<unsigned>(item);
@@ -116,12 +124,13 @@ BlockedDescCreator::makeFilteredRange(const CreatorsMap& map, unsigned rank, con
     return std::make_pair(first, last);
 }
 
-std::pair<CreatorsMapFilterConstIterator, CreatorsMapFilterConstIterator>
-BlockedDescCreator::makeFilteredRange(const CreatorsMap &map, BlockedDescCreator::Predicate predicate) {
+std::pair<CreatorsMapFilterConstIterator, CreatorsMapFilterConstIterator> BlockedDescCreator::makeFilteredRange(
+    const CreatorsMap& map,
+    BlockedDescCreator::Predicate predicate) {
     auto first = CreatorsMapFilterConstIterator(std::move(predicate), map.begin(), map.end());
     auto last = first.end();
     return std::make_pair(first, last);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/blocked_desc_creator.h b/src/plugins/intel_cpu/src/nodes/common/blocked_desc_creator.h
index 1fd7a02dff984b..9f8b15b430c727 100644
--- a/src/plugins/intel_cpu/src/nodes/common/blocked_desc_creator.h
+++ b/src/plugins/intel_cpu/src/nodes/common/blocked_desc_creator.h
@@ -5,6 +5,7 @@
 #pragma once
 
 #include <functional>
+
 #include "cpu_shape.h"
 #include "memory_desc/cpu_blocked_memory_desc.h"
 
@@ -22,15 +23,18 @@ class BlockedDescCreator {
 
 public:
     static const CreatorsMap& getCommonCreators();
-    static std::pair<CreatorsMapFilterConstIterator, CreatorsMapFilterConstIterator>
-    makeFilteredRange(const CreatorsMap &map, unsigned rank);
+    static std::pair<CreatorsMapFilterConstIterator, CreatorsMapFilterConstIterator> makeFilteredRange(
+        const CreatorsMap& map,
+        unsigned rank);
     static std::pair<CreatorsMapFilterConstIterator, CreatorsMapFilterConstIterator>
     makeFilteredRange(const CreatorsMap& map, unsigned rank, const std::vector<LayoutType>& supportedTypes);
-    static std::pair<CreatorsMapFilterConstIterator, CreatorsMapFilterConstIterator>
-    makeFilteredRange(const CreatorsMap& map, Predicate predicate);
+    static std::pair<CreatorsMapFilterConstIterator, CreatorsMapFilterConstIterator> makeFilteredRange(
+        const CreatorsMap& map,
+        Predicate predicate);
     virtual CpuBlockedMemoryDesc createDesc(const ov::element::Type& precision, const Shape& srcShape) const = 0;
 
-    std::shared_ptr<CpuBlockedMemoryDesc> createSharedDesc(const ov::element::Type& precision, const Shape& srcShape) const {
+    std::shared_ptr<CpuBlockedMemoryDesc> createSharedDesc(const ov::element::Type& precision,
+                                                           const Shape& srcShape) const {
         return std::make_shared<CpuBlockedMemoryDesc>(createDesc(precision, srcShape));
     }
 
@@ -49,7 +53,10 @@ class CreatorsMapFilterConstIterator {
     typedef std::function<bool(const value_type&)> predicate_type;
 
 public:
-    CreatorsMapFilterConstIterator(predicate_type filter, Iterator begin, Iterator end) : _iter(begin), _end(end), _filter(std::move(filter))  {
+    CreatorsMapFilterConstIterator(predicate_type filter, Iterator begin, Iterator end)
+        : _iter(begin),
+          _end(end),
+          _filter(std::move(filter)) {
         while (_iter != _end && !_filter(*_iter)) {
             ++_iter;
         }
@@ -93,5 +100,5 @@ class CreatorsMapFilterConstIterator {
     predicate_type _filter;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/cpu_convert.cpp b/src/plugins/intel_cpu/src/nodes/common/cpu_convert.cpp
index ad0738e9d57558..a0590827006eb4 100644
--- a/src/plugins/intel_cpu/src/nodes/common/cpu_convert.cpp
+++ b/src/plugins/intel_cpu/src/nodes/common/cpu_convert.cpp
@@ -5,16 +5,16 @@
 #include "cpu_convert.h"
 
 #include "cpu_memcpy.h"
-#include "utils/bfloat16.hpp"
 #include "openvino/core/type/nf4.hpp"
+#include "utils/bfloat16.hpp"
 
 #if defined(OPENVINO_ARCH_X86_64)
-#include "nodes/kernels/x64/jit_kernel.hpp"
+#    include "nodes/kernels/x64/jit_kernel.hpp"
 #else
-#include "cpu_memory.h"
-#include "openvino/core/type/element_type_traits.hpp"
-#include "selective_build.h"
-#include "utils/general_utils.h"
+#    include "cpu_memory.h"
+#    include "openvino/core/type/element_type_traits.hpp"
+#    include "selective_build.h"
+#    include "utils/general_utils.h"
 #endif
 
 namespace ov {
@@ -28,16 +28,12 @@ using namespace dnnl::impl::cpu::x64;
 using namespace Xbyak;
 
 template <typename src_t, typename dst_t>
-void convert_vec(jit_generator & gen,
-                 const RegExp & src,
-                 const RegExp & dst);
+void convert_vec(jit_generator& gen, const RegExp& src, const RegExp& dst);
 
 template <>
-void convert_vec<ov::float16, float>(jit_generator & gen,
-                                     const RegExp & src,
-                                     const RegExp & dst) {
-    auto const & f16vec = gen.xmm3;
-    auto const & f32vec = gen.ymm4;
+void convert_vec<ov::float16, float>(jit_generator& gen, const RegExp& src, const RegExp& dst) {
+    auto const& f16vec = gen.xmm3;
+    auto const& f32vec = gen.ymm4;
 
     gen.movdqu(f16vec, gen.xword[src]);
     gen.vcvtph2ps(f32vec, f16vec);
@@ -45,11 +41,9 @@ void convert_vec<ov::float16, float>(jit_generator & gen,
 }
 
 template <>
-void convert_vec<float, ov::float16>(jit_generator & gen,
-                                     const RegExp & src,
-                                     const RegExp & dst) {
-    auto const & f16vec = gen.xmm3;
-    auto const & f32vec = gen.ymm4;
+void convert_vec<float, ov::float16>(jit_generator& gen, const RegExp& src, const RegExp& dst) {
+    auto const& f16vec = gen.xmm3;
+    auto const& f32vec = gen.ymm4;
 
     gen.vmovups(f32vec, gen.yword[src]);
     gen.vcvtps2ph(f16vec, f32vec, 0);
@@ -72,18 +66,18 @@ class jit_convert_array : public jit_kernel {
 
         size >>= vlen_log2;
 
-        foreach(0, size, [&, this](const Xbyak::Reg64& idx) {
+        foreach (0, size, [&, this](const Xbyak::Reg64& idx) {
             _convert_vec(*this, src, dst);
             src += _src_size * vlen;
             dst += _dst_size * vlen;
-        });
+        })
+            ;
 
         mov(size, argPtr(&args_t::count));
         size &= vlen - 1;
 
         // Tail conversion
-        _if(size != 0)
-        ._then([&] {
+        _if(size != 0)._then([&] {
             auto tmp = stack(vlen * sizeof(float));
             tmp.clear();
 
@@ -112,24 +106,19 @@ class jit_convert_array : public jit_kernel {
 
     typedef void (*fn_t)(const args_t*);
 
-    typedef void (*convert_vec_t)(jit_generator &,
-                                  const RegExp &,
-                                  const RegExp &);
+    typedef void (*convert_vec_t)(jit_generator&, const RegExp&, const RegExp&);
 
-    jit_convert_array(convert_vec_t convert_vec,
-                      size_t src_size,
-                      size_t dst_size)
-        : jit_kernel(jit_name())
-        , _convert_vec(convert_vec)
-        , _src_size(src_size)
-        , _dst_size(dst_size) {}
+    jit_convert_array(convert_vec_t convert_vec, size_t src_size, size_t dst_size)
+        : jit_kernel(jit_name()),
+          _convert_vec(convert_vec),
+          _src_size(src_size),
+          _dst_size(dst_size) {}
 
-    template<typename src_t, typename dst_t>
+    template <typename src_t, typename dst_t>
     static fn_t get() {
-        if (mayiuse(cpu_isa_t::avx2)
-            && dnnl::impl::cpu::x64::cpu().has(Xbyak::util::Cpu::tF16C)) {
+        if (mayiuse(cpu_isa_t::avx2) && dnnl::impl::cpu::x64::cpu().has(Xbyak::util::Cpu::tF16C)) {
             static jit_convert_array converter(convert_vec<src_t, dst_t>, sizeof(src_t), sizeof(dst_t));
-            auto & generator = static_cast<jit_generator&>(converter);
+            auto& generator = static_cast<jit_generator&>(converter);
             generator.create_kernel();
             return (fn_t)generator.jit_ker();
         }
@@ -148,7 +137,7 @@ void jit_convert(const TI* arg, TO* out, size_t count) {
     static auto converter = jit_impl::get<TI, TO>();
 
     if (converter) {
-        typename jit_impl::args_t args = { arg, out, count };
+        typename jit_impl::args_t args = {arg, out, count};
         converter(&args);
     } else {
         for (size_t i = 0; i < count; ++i) {
@@ -179,44 +168,41 @@ struct PrecisionInfo<ov::element::boolean> {
     using value_type = uint8_t;
 };
 
-template<typename T,
-         typename U = typename std::conditional<
-                        std::is_same<ov::float16, T>::value
-                        || std::is_same<ov::intel_cpu::bfloat16_t, T>::value,
-                        float, T>::type>
+template <typename T,
+          typename U = typename std::conditional<std::is_same<ov::float16, T>::value ||
+                                                     std::is_same<ov::intel_cpu::bfloat16_t, T>::value,
+                                                 float,
+                                                 T>::type>
 struct Range {
-    const std::tuple<U, U> & fit(const ov::element::Type & prec);
+    const std::tuple<U, U>& fit(const ov::element::Type& prec);
 
 private:
-    std::tuple<U, U> _range {
-        std::numeric_limits<T>::lowest(),
-        std::numeric_limits<T>::max()
-    };
+    std::tuple<U, U> _range{std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max()};
 };
 
-template<typename T, typename U>
-const std::tuple<U, U> & Range<T, U>::fit(const ov::element::Type & prec) {
+template <typename T, typename U>
+const std::tuple<U, U>& Range<T, U>::fit(const ov::element::Type& prec) {
     if (prec.is_real()) {
         double lbound, ubound;
         switch (prec) {
-            case ov::element::bf16:
-                lbound = static_cast<double>(std::numeric_limits<ov::intel_cpu::bfloat16_t>::lowest());
-                ubound = static_cast<double>(std::numeric_limits<ov::intel_cpu::bfloat16_t>::max());
-                break;
-            case ov::element::f16:
-                lbound = static_cast<double>(std::numeric_limits<ov::float16>::lowest());
-                ubound = static_cast<double>(std::numeric_limits<ov::float16>::max());
-                break;
-            case ov::element::f32:
-                lbound = static_cast<double>(std::numeric_limits<float>::lowest());
-                ubound = static_cast<double>(std::numeric_limits<float>::max());
-                break;
-            case ov::element::f64:
-                lbound = std::numeric_limits<double>::lowest();
-                ubound = std::numeric_limits<double>::max();
-                break;
-            default:
-                OPENVINO_THROW("Unsupported precision");
+        case ov::element::bf16:
+            lbound = static_cast<double>(std::numeric_limits<ov::intel_cpu::bfloat16_t>::lowest());
+            ubound = static_cast<double>(std::numeric_limits<ov::intel_cpu::bfloat16_t>::max());
+            break;
+        case ov::element::f16:
+            lbound = static_cast<double>(std::numeric_limits<ov::float16>::lowest());
+            ubound = static_cast<double>(std::numeric_limits<ov::float16>::max());
+            break;
+        case ov::element::f32:
+            lbound = static_cast<double>(std::numeric_limits<float>::lowest());
+            ubound = static_cast<double>(std::numeric_limits<float>::max());
+            break;
+        case ov::element::f64:
+            lbound = std::numeric_limits<double>::lowest();
+            ubound = std::numeric_limits<double>::max();
+            break;
+        default:
+            OPENVINO_THROW("Unsupported precision");
         }
         // If U is integral, its range always less than float, so not need update _range
         // Else it will be overflow, for example static_cast double to int64_t:
@@ -224,73 +210,71 @@ const std::tuple<U, U> & Range<T, U>::fit(const ov::element::Type & prec) {
         //         double  dd_ubound = static_cast<double>(ubbound)
         //         static_cast<int64_t>(dd_ubound) will return -9223372036854775808
         if (!std::is_integral<U>::value) {
-                std::get<0>(_range) = static_cast<U>(std::max(static_cast<double>(std::get<0>(_range)), lbound));
-                std::get<1>(_range) = static_cast<U>(std::min(static_cast<double>(std::get<1>(_range)), ubound));
+            std::get<0>(_range) = static_cast<U>(std::max(static_cast<double>(std::get<0>(_range)), lbound));
+            std::get<1>(_range) = static_cast<U>(std::min(static_cast<double>(std::get<1>(_range)), ubound));
         }
     } else {
         int64_t lbound;
         uint64_t ubound;
         switch (prec) {
-            case ov::element::boolean:
-                lbound = static_cast<int64_t>(std::numeric_limits<bool>::lowest());
-                ubound = static_cast<uint64_t>(std::numeric_limits<bool>::max());
-                break;
-            case ov::element::u8:
-                lbound = static_cast<int64_t>(std::numeric_limits<uint8_t>::lowest());
-                ubound = static_cast<uint64_t>(std::numeric_limits<uint8_t>::max());
-                break;
-            case ov::element::i8:
-                lbound = static_cast<int64_t>(std::numeric_limits<int8_t>::lowest());
-                ubound = static_cast<uint64_t>(std::numeric_limits<int8_t>::max());
-                break;
-            case ov::element::u16:
-                lbound = static_cast<int64_t>(std::numeric_limits<uint16_t>::lowest());
-                ubound = static_cast<uint64_t>(std::numeric_limits<uint16_t>::max());
-                break;
-            case ov::element::i16:
-                lbound = static_cast<int64_t>(std::numeric_limits<int16_t>::lowest());
-                ubound = static_cast<uint64_t>(std::numeric_limits<int16_t>::max());
-                break;
-            case ov::element::u32:
-                lbound = static_cast<int64_t>(std::numeric_limits<uint32_t>::lowest());
-                ubound = static_cast<uint64_t>(std::numeric_limits<uint32_t>::max());
-                break;
-            case ov::element::i32:
-                lbound = static_cast<int64_t>(std::numeric_limits<int32_t>::lowest());
-                ubound = static_cast<uint64_t>(std::numeric_limits<int32_t>::max());
-                break;
-            case ov::element::u64:
-                lbound = static_cast<int64_t>(std::numeric_limits<uint64_t>::lowest());
-                ubound = static_cast<uint64_t>(std::numeric_limits<uint64_t>::max());
-                break;
-            case ov::element::i64:
-                lbound = static_cast<int64_t>(std::numeric_limits<int64_t>::lowest());
-                ubound = static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
-                break;
-            default:
-                OPENVINO_THROW("Unsupported precision");
+        case ov::element::boolean:
+            lbound = static_cast<int64_t>(std::numeric_limits<bool>::lowest());
+            ubound = static_cast<uint64_t>(std::numeric_limits<bool>::max());
+            break;
+        case ov::element::u8:
+            lbound = static_cast<int64_t>(std::numeric_limits<uint8_t>::lowest());
+            ubound = static_cast<uint64_t>(std::numeric_limits<uint8_t>::max());
+            break;
+        case ov::element::i8:
+            lbound = static_cast<int64_t>(std::numeric_limits<int8_t>::lowest());
+            ubound = static_cast<uint64_t>(std::numeric_limits<int8_t>::max());
+            break;
+        case ov::element::u16:
+            lbound = static_cast<int64_t>(std::numeric_limits<uint16_t>::lowest());
+            ubound = static_cast<uint64_t>(std::numeric_limits<uint16_t>::max());
+            break;
+        case ov::element::i16:
+            lbound = static_cast<int64_t>(std::numeric_limits<int16_t>::lowest());
+            ubound = static_cast<uint64_t>(std::numeric_limits<int16_t>::max());
+            break;
+        case ov::element::u32:
+            lbound = static_cast<int64_t>(std::numeric_limits<uint32_t>::lowest());
+            ubound = static_cast<uint64_t>(std::numeric_limits<uint32_t>::max());
+            break;
+        case ov::element::i32:
+            lbound = static_cast<int64_t>(std::numeric_limits<int32_t>::lowest());
+            ubound = static_cast<uint64_t>(std::numeric_limits<int32_t>::max());
+            break;
+        case ov::element::u64:
+            lbound = static_cast<int64_t>(std::numeric_limits<uint64_t>::lowest());
+            ubound = static_cast<uint64_t>(std::numeric_limits<uint64_t>::max());
+            break;
+        case ov::element::i64:
+            lbound = static_cast<int64_t>(std::numeric_limits<int64_t>::lowest());
+            ubound = static_cast<uint64_t>(std::numeric_limits<int64_t>::max());
+            break;
+        default:
+            OPENVINO_THROW("Unsupported precision");
         }
-        using ltype = typename std::conditional<
-                            std::is_floating_point<U>::value,
-                            double, int64_t>::type;
-        using utype = typename std::conditional<
-                            std::is_floating_point<U>::value,
-                            double, uint64_t>::type;
-        std::get<0>(_range) = static_cast<U>(std::max(static_cast<ltype>(std::get<0>(_range)), static_cast<ltype>(lbound)));
-        std::get<1>(_range) = static_cast<U>(std::min(static_cast<utype>(std::get<1>(_range)), static_cast<utype>(ubound)));
+        using ltype = typename std::conditional<std::is_floating_point<U>::value, double, int64_t>::type;
+        using utype = typename std::conditional<std::is_floating_point<U>::value, double, uint64_t>::type;
+        std::get<0>(_range) =
+            static_cast<U>(std::max(static_cast<ltype>(std::get<0>(_range)), static_cast<ltype>(lbound)));
+        std::get<1>(_range) =
+            static_cast<U>(std::min(static_cast<utype>(std::get<1>(_range)), static_cast<utype>(ubound)));
     }
     return _range;
 }
 
 struct ConvertContext {
-    const void *srcPtr;
-    void *dstPtr;
+    const void* srcPtr;
+    void* dstPtr;
     size_t size;
     ov::element::Type interimPrc;
     ov::element::Type dstPrc;
     bool converted;
 
-    template<typename T>
+    template <typename T>
     std::tuple<T, T> range() const {
         Range<T> r;
         r.fit(interimPrc);
@@ -298,20 +282,18 @@ struct ConvertContext {
     }
 };
 
-template<typename T>
+template <typename T>
 struct ConvertPrecision;
 
-template<typename src_t, typename dst_t>
+template <typename src_t, typename dst_t>
 struct ConvertPrecision<std::tuple<src_t, dst_t>> {
-    void operator()(ConvertContext & ctx) {
-        auto src = static_cast<const src_t *>(ctx.srcPtr);
-        auto dst = static_cast<dst_t *>(ctx.dstPtr);
+    void operator()(ConvertContext& ctx) {
+        auto src = static_cast<const src_t*>(ctx.srcPtr);
+        auto dst = static_cast<dst_t*>(ctx.dstPtr);
         src_t lbound, ubound;
         std::tie(lbound, ubound) = ctx.range<src_t>();
 
-        if (std::is_integral<src_t>::value
-            || ctx.interimPrc.is_real()
-            || std::is_integral<dst_t>::value) {
+        if (std::is_integral<src_t>::value || ctx.interimPrc.is_real() || std::is_integral<dst_t>::value) {
             parallel_for(ctx.size, [&](size_t i) {
                 dst[i] = static_cast<dst_t>(std::max(std::min(src[i], ubound), lbound));
             });
@@ -325,11 +307,11 @@ struct ConvertPrecision<std::tuple<src_t, dst_t>> {
     }
 };
 
-template<>
+template <>
 struct ConvertPrecision<std::tuple<float, ov::intel_cpu::bfloat16_t>> {
-    void operator()(ConvertContext & ctx) {
-        auto src = static_cast<const float *>(ctx.srcPtr);
-        auto dst = static_cast<ov::intel_cpu::bfloat16_t *>(ctx.dstPtr);
+    void operator()(ConvertContext& ctx) {
+        auto src = static_cast<const float*>(ctx.srcPtr);
+        auto dst = static_cast<ov::intel_cpu::bfloat16_t*>(ctx.dstPtr);
 
         if (ctx.interimPrc.is_real()) {
             parallel_for(ctx.size, [&](size_t i) {
@@ -347,11 +329,11 @@ struct ConvertPrecision<std::tuple<float, ov::intel_cpu::bfloat16_t>> {
     }
 };
 
-template<>
+template <>
 struct ConvertPrecision<std::tuple<ov::intel_cpu::bfloat16_t, float>> {
-    void operator()(ConvertContext & ctx) {
-        auto src = static_cast<const ov::intel_cpu::bfloat16_t *>(ctx.srcPtr);
-        auto dst = static_cast<float *>(ctx.dstPtr);
+    void operator()(ConvertContext& ctx) {
+        auto src = static_cast<const ov::intel_cpu::bfloat16_t*>(ctx.srcPtr);
+        auto dst = static_cast<float*>(ctx.dstPtr);
 
         if (ctx.interimPrc.is_real()) {
             parallel_for(ctx.size, [&](size_t i) {
@@ -370,11 +352,11 @@ struct ConvertPrecision<std::tuple<ov::intel_cpu::bfloat16_t, float>> {
 };
 
 #if defined(OPENVINO_ARCH_X86_64)
-template<typename src_t>
+template <typename src_t>
 struct ConvertPrecision<std::tuple<src_t, ov::float16>> {
-    void operator()(ConvertContext & ctx) {
-        auto src = static_cast<const src_t *>(ctx.srcPtr);
-        auto dst = static_cast<ov::float16 *>(ctx.dstPtr);
+    void operator()(ConvertContext& ctx) {
+        auto src = static_cast<const src_t*>(ctx.srcPtr);
+        auto dst = static_cast<ov::float16*>(ctx.dstPtr);
 
         constexpr size_t batch = 64;
         const size_t iterations = ov::intel_cpu::div_up(ctx.size, batch);
@@ -388,16 +370,16 @@ struct ConvertPrecision<std::tuple<src_t, ov::float16>> {
                 batch_type tmp;
                 const size_t offset = i * batch;
                 const size_t current_batch_size = std::min(ctx.size - offset, batch);
-                for (size_t j = 0; j < current_batch_size; ++j)         // src_t -> fp32
+                for (size_t j = 0; j < current_batch_size; ++j)  // src_t -> fp32
                     tmp[j] = static_cast<float>(std::max(std::min(src[offset + j], ubound), lbound));
-                jit_convert(tmp, dst + offset, current_batch_size);     // fp32 -> fp16
+                jit_convert(tmp, dst + offset, current_batch_size);  // fp32 -> fp16
             });
         } else if (ctx.interimPrc.is_real()) {
             parallel_for(iterations, [&](size_t i) {
                 const size_t offset = i * batch;
                 const size_t current_batch_size = std::min(ctx.size - offset, batch);
                 if (std::is_same<typename std::remove_cv<src_t>::type, float>::value) {  // fp32 -> fp16
-                    jit_convert(reinterpret_cast<const float *>(src) + offset, dst + offset, current_batch_size);
+                    jit_convert(reinterpret_cast<const float*>(src) + offset, dst + offset, current_batch_size);
                 } else {
                     batch_type tmp;
                     for (size_t j = 0; j < current_batch_size; ++j)  // src_t -> fp32
@@ -410,9 +392,9 @@ struct ConvertPrecision<std::tuple<src_t, ov::float16>> {
                 batch_type tmp;
                 const size_t offset = i * batch;
                 const size_t current_batch_size = std::min(ctx.size - offset, batch);
-                for (size_t j = 0; j < current_batch_size; ++j)         // src_t -> fp32
+                for (size_t j = 0; j < current_batch_size; ++j)  // src_t -> fp32
                     tmp[j] = static_cast<float>(std::trunc(std::max(std::min(src[offset + j], ubound), lbound)));
-                jit_convert(tmp, dst + offset, current_batch_size);     // fp32 -> fp16
+                jit_convert(tmp, dst + offset, current_batch_size);  // fp32 -> fp16
             });
         }
 
@@ -420,11 +402,11 @@ struct ConvertPrecision<std::tuple<src_t, ov::float16>> {
     }
 };
 
-template<typename dst_t>
+template <typename dst_t>
 struct ConvertPrecision<std::tuple<ov::float16, dst_t>> {
-    void operator()(ConvertContext & ctx) {
-        auto src = static_cast<const ov::float16 *>(ctx.srcPtr);
-        auto dst = static_cast<dst_t *>(ctx.dstPtr);
+    void operator()(ConvertContext& ctx) {
+        auto src = static_cast<const ov::float16*>(ctx.srcPtr);
+        auto dst = static_cast<dst_t*>(ctx.dstPtr);
 
         constexpr size_t batch = 64;
         const size_t iterations = ov::intel_cpu::div_up(ctx.size, batch);
@@ -438,8 +420,8 @@ struct ConvertPrecision<std::tuple<ov::float16, dst_t>> {
                 batch_type tmp;
                 const size_t offset = i * batch;
                 const size_t current_batch_size = std::min(ctx.size - offset, batch);
-                jit_convert(src + offset, tmp, current_batch_size);     // fp16 -> fp32
-                for (size_t j = 0; j < current_batch_size; ++j)         // fp32 -> dst_t
+                jit_convert(src + offset, tmp, current_batch_size);  // fp16 -> fp32
+                for (size_t j = 0; j < current_batch_size; ++j)      // fp32 -> dst_t
                     dst[offset + j] = static_cast<dst_t>(std::max(std::min(tmp[j], ubound), lbound));
             });
         } else if (ctx.interimPrc.is_real()) {
@@ -447,7 +429,7 @@ struct ConvertPrecision<std::tuple<ov::float16, dst_t>> {
                 const size_t offset = i * batch;
                 const size_t current_batch_size = std::min(ctx.size - offset, batch);
                 if (std::is_same<typename std::remove_cv<dst_t>::type, float>::value) {  // fp16 -> fp32
-                    jit_convert(src + offset, reinterpret_cast<float *>(dst) + offset, current_batch_size);
+                    jit_convert(src + offset, reinterpret_cast<float*>(dst) + offset, current_batch_size);
                 } else {
                     batch_type tmp;
                     jit_convert(src + offset, tmp, current_batch_size);  // fp16 -> fp32
@@ -460,8 +442,8 @@ struct ConvertPrecision<std::tuple<ov::float16, dst_t>> {
                 batch_type tmp;
                 const size_t offset = i * batch;
                 const size_t current_batch_size = std::min(ctx.size - offset, batch);
-                jit_convert(src + offset, tmp, current_batch_size);     // fp16 -> fp32
-                for (size_t j = 0; j < current_batch_size; ++j)         // fp32 -> dst_t
+                jit_convert(src + offset, tmp, current_batch_size);  // fp16 -> fp32
+                for (size_t j = 0; j < current_batch_size; ++j)      // fp32 -> dst_t
                     dst[offset + j] = static_cast<dst_t>(std::trunc(std::max(std::min(tmp[j], ubound), lbound)));
             });
         }
@@ -470,11 +452,11 @@ struct ConvertPrecision<std::tuple<ov::float16, dst_t>> {
     }
 };
 
-template<>
+template <>
 struct ConvertPrecision<std::tuple<ov::float16, ov::float16>> {
-    void operator()(ConvertContext & ctx) {
-        auto src = static_cast<const ov::float16 *>(ctx.srcPtr);
-        auto dst = static_cast<ov::float16 *>(ctx.dstPtr);
+    void operator()(ConvertContext& ctx) {
+        auto src = static_cast<const ov::float16*>(ctx.srcPtr);
+        auto dst = static_cast<ov::float16*>(ctx.dstPtr);
 
         constexpr size_t batch = 64;
         const size_t iterations = ov::intel_cpu::div_up(ctx.size, batch);
@@ -490,10 +472,10 @@ struct ConvertPrecision<std::tuple<ov::float16, ov::float16>> {
                 batch_type tmp;
                 const size_t offset = i * batch;
                 const size_t current_batch_size = std::min(ctx.size - offset, batch);
-                jit_convert(src + offset, tmp, current_batch_size);     // fp16 -> fp32
-                for (size_t j = 0; j < current_batch_size; ++j)         // truncate fp32
+                jit_convert(src + offset, tmp, current_batch_size);  // fp16 -> fp32
+                for (size_t j = 0; j < current_batch_size; ++j)      // truncate fp32
                     tmp[j] = std::trunc(std::max(std::min(tmp[j], ubound), lbound));
-                jit_convert(tmp, dst + offset, current_batch_size);     // fp32 -> fp16
+                jit_convert(tmp, dst + offset, current_batch_size);  // fp32 -> fp16
             });
         }
 
@@ -502,7 +484,7 @@ struct ConvertPrecision<std::tuple<ov::float16, ov::float16>> {
 };
 #endif
 
-}   // namespace
+}  // namespace
 
 #define INTEL_CPU_CVT(ST, DT)                            \
     OV_CASE2(ov::element::ST,                            \
@@ -510,74 +492,72 @@ struct ConvertPrecision<std::tuple<ov::float16, ov::float16>> {
              PrecisionInfo<ov::element::ST>::value_type, \
              PrecisionInfo<ov::element::DT>::value_type)
 
-#define INTEL_CPU_CVT_LIST                                                                                         \
-    INTEL_CPU_CVT(u8, i8), INTEL_CPU_CVT(u8, u16), INTEL_CPU_CVT(u8, i16), INTEL_CPU_CVT(u8, u32),                 \
-    INTEL_CPU_CVT(u8, i32), INTEL_CPU_CVT(u8, u64), INTEL_CPU_CVT(u8, i64), INTEL_CPU_CVT(u8, f32),                \
-    INTEL_CPU_CVT(u8, f16), INTEL_CPU_CVT(u8, bf16), INTEL_CPU_CVT(u8, f64), INTEL_CPU_CVT(u8, boolean),           \
-    INTEL_CPU_CVT(i8, u8), INTEL_CPU_CVT(i8, u16), INTEL_CPU_CVT(i8, i16), INTEL_CPU_CVT(i8, u32),                 \
-    INTEL_CPU_CVT(i8, i32), INTEL_CPU_CVT(i8, u64), INTEL_CPU_CVT(i8, i64), INTEL_CPU_CVT(i8, f32),                \
-    INTEL_CPU_CVT(i8, f16), INTEL_CPU_CVT(i8, bf16), INTEL_CPU_CVT(i8, f64), INTEL_CPU_CVT(i8, boolean),           \
-    INTEL_CPU_CVT(u16, u8), INTEL_CPU_CVT(u16, i8), INTEL_CPU_CVT(u16, i16), INTEL_CPU_CVT(u16, u32),              \
-    INTEL_CPU_CVT(u16, i32), INTEL_CPU_CVT(u16, u64), INTEL_CPU_CVT(u16, i64), INTEL_CPU_CVT(u16, f32),            \
-    INTEL_CPU_CVT(u16, f16), INTEL_CPU_CVT(u16, bf16), INTEL_CPU_CVT(u16, f64), INTEL_CPU_CVT(u16, boolean),       \
-    INTEL_CPU_CVT(i16, u8), INTEL_CPU_CVT(i16, i8), INTEL_CPU_CVT(i16, u16), INTEL_CPU_CVT(i16, u32),              \
-    INTEL_CPU_CVT(i16, i32), INTEL_CPU_CVT(i16, u64), INTEL_CPU_CVT(i16, i64), INTEL_CPU_CVT(i16, f32),            \
-    INTEL_CPU_CVT(i16, f16), INTEL_CPU_CVT(i16, bf16), INTEL_CPU_CVT(i16, f64), INTEL_CPU_CVT(i16, boolean),       \
-    INTEL_CPU_CVT(u32, u8), INTEL_CPU_CVT(u32, i8), INTEL_CPU_CVT(u32, u16), INTEL_CPU_CVT(u32, i16),              \
-    INTEL_CPU_CVT(u32, i32), INTEL_CPU_CVT(u32, u64), INTEL_CPU_CVT(u32, i64), INTEL_CPU_CVT(u32, f32),            \
-    INTEL_CPU_CVT(u32, f16), INTEL_CPU_CVT(u32, bf16), INTEL_CPU_CVT(u32, f64), INTEL_CPU_CVT(u32, boolean),       \
-    INTEL_CPU_CVT(i32, u8), INTEL_CPU_CVT(i32, i8), INTEL_CPU_CVT(i32, u16), INTEL_CPU_CVT(i32, i16),              \
-    INTEL_CPU_CVT(i32, u32), INTEL_CPU_CVT(i32, u64), INTEL_CPU_CVT(i32, i64), INTEL_CPU_CVT(i32, f32),            \
-    INTEL_CPU_CVT(i32, f16), INTEL_CPU_CVT(i32, bf16), INTEL_CPU_CVT(i32, f64), INTEL_CPU_CVT(i32, boolean),       \
-    INTEL_CPU_CVT(u64, u8), INTEL_CPU_CVT(u64, i8), INTEL_CPU_CVT(u64, u16), INTEL_CPU_CVT(u64, i16),              \
-    INTEL_CPU_CVT(u64, u32), INTEL_CPU_CVT(u64, i32), INTEL_CPU_CVT(u64, i64), INTEL_CPU_CVT(u64, f32),            \
-    INTEL_CPU_CVT(u64, f16), INTEL_CPU_CVT(u64, bf16), INTEL_CPU_CVT(u64, f64), INTEL_CPU_CVT(u64, boolean),       \
-    INTEL_CPU_CVT(i64, u8), INTEL_CPU_CVT(i64, i8), INTEL_CPU_CVT(i64, u16), INTEL_CPU_CVT(i64, i16),              \
-    INTEL_CPU_CVT(i64, u32), INTEL_CPU_CVT(i64, i32), INTEL_CPU_CVT(i64, u64), INTEL_CPU_CVT(i64, f32),            \
-    INTEL_CPU_CVT(i64, f16), INTEL_CPU_CVT(i64, bf16), INTEL_CPU_CVT(i64, f64), INTEL_CPU_CVT(i64, boolean),       \
-    INTEL_CPU_CVT(f32, u8), INTEL_CPU_CVT(f32, i8), INTEL_CPU_CVT(f32, u16), INTEL_CPU_CVT(f32, i16),              \
-    INTEL_CPU_CVT(f32, u32), INTEL_CPU_CVT(f32, i32), INTEL_CPU_CVT(f32, u64), INTEL_CPU_CVT(f32, i64),            \
-    INTEL_CPU_CVT(f32, f16), INTEL_CPU_CVT(f32, bf16), INTEL_CPU_CVT(f32, f64), INTEL_CPU_CVT(f32, boolean),       \
-    INTEL_CPU_CVT(f16, u8), INTEL_CPU_CVT(f16, i8), INTEL_CPU_CVT(f16, u16), INTEL_CPU_CVT(f16, i16),              \
-    INTEL_CPU_CVT(f16, u32), INTEL_CPU_CVT(f16, i32), INTEL_CPU_CVT(f16, u64), INTEL_CPU_CVT(f16, i64),            \
-    INTEL_CPU_CVT(f16, f32), INTEL_CPU_CVT(f16, bf16), INTEL_CPU_CVT(f16, f64), INTEL_CPU_CVT(f16, boolean),       \
-    INTEL_CPU_CVT(bf16, u8), INTEL_CPU_CVT(bf16, i8), INTEL_CPU_CVT(bf16, u16), INTEL_CPU_CVT(bf16, i16),          \
-    INTEL_CPU_CVT(bf16, u32), INTEL_CPU_CVT(bf16, i32), INTEL_CPU_CVT(bf16, u64), INTEL_CPU_CVT(bf16, i64),        \
-    INTEL_CPU_CVT(bf16, f32), INTEL_CPU_CVT(bf16, f16), INTEL_CPU_CVT(bf16, f64), INTEL_CPU_CVT(bf16, boolean),    \
-    INTEL_CPU_CVT(f64, u8), INTEL_CPU_CVT(f64, i8), INTEL_CPU_CVT(f64, u16), INTEL_CPU_CVT(f64, i16),              \
-    INTEL_CPU_CVT(f64, u32), INTEL_CPU_CVT(f64, i32), INTEL_CPU_CVT(f64, u64), INTEL_CPU_CVT(f64, i64),            \
-    INTEL_CPU_CVT(f64, f32), INTEL_CPU_CVT(f64, f16), INTEL_CPU_CVT(f64, bf16), INTEL_CPU_CVT(f64, boolean),       \
-    INTEL_CPU_CVT(boolean, u8), INTEL_CPU_CVT(boolean, i8), INTEL_CPU_CVT(boolean, u16),                           \
-    INTEL_CPU_CVT(boolean, i16), INTEL_CPU_CVT(boolean, u32), INTEL_CPU_CVT(boolean, i32),                         \
-    INTEL_CPU_CVT(boolean, u64), INTEL_CPU_CVT(boolean, i64), INTEL_CPU_CVT(boolean, f32),                         \
-    INTEL_CPU_CVT(boolean, f16), INTEL_CPU_CVT(boolean, bf16), INTEL_CPU_CVT(boolean, f64), INTEL_CPU_CVT(u8, u8), \
-    INTEL_CPU_CVT(i8, i8), INTEL_CPU_CVT(u16, u16), INTEL_CPU_CVT(i16, i16), INTEL_CPU_CVT(u32, u32),              \
-    INTEL_CPU_CVT(i32, i32), INTEL_CPU_CVT(u64, u64), INTEL_CPU_CVT(i64, i64), INTEL_CPU_CVT(f32, f32),            \
-    INTEL_CPU_CVT(f16, f16), INTEL_CPU_CVT(bf16, bf16), INTEL_CPU_CVT(f64, f64), INTEL_CPU_CVT(boolean, boolean)
-
-
-#define INTEL_CPU_CVT_FROM_BIN_LIST                                          \
-    INTEL_CPU_CVT(u1, f32), INTEL_CPU_CVT(u1, f16), INTEL_CPU_CVT(u1, bf16), \
-    INTEL_CPU_CVT(u1, f64), INTEL_CPU_CVT(u1, i16), INTEL_CPU_CVT(u1, u8),   \
-    INTEL_CPU_CVT(u1, i8), INTEL_CPU_CVT(u1, u16), INTEL_CPU_CVT(u1, i32),   \
-    INTEL_CPU_CVT(u1, u32), INTEL_CPU_CVT(u1, i64), INTEL_CPU_CVT(u1, u64),  \
-    INTEL_CPU_CVT(u1, boolean)
+#define INTEL_CPU_CVT_LIST                                                                                             \
+    INTEL_CPU_CVT(u8, i8), INTEL_CPU_CVT(u8, u16), INTEL_CPU_CVT(u8, i16), INTEL_CPU_CVT(u8, u32),                     \
+        INTEL_CPU_CVT(u8, i32), INTEL_CPU_CVT(u8, u64), INTEL_CPU_CVT(u8, i64), INTEL_CPU_CVT(u8, f32),                \
+        INTEL_CPU_CVT(u8, f16), INTEL_CPU_CVT(u8, bf16), INTEL_CPU_CVT(u8, f64), INTEL_CPU_CVT(u8, boolean),           \
+        INTEL_CPU_CVT(i8, u8), INTEL_CPU_CVT(i8, u16), INTEL_CPU_CVT(i8, i16), INTEL_CPU_CVT(i8, u32),                 \
+        INTEL_CPU_CVT(i8, i32), INTEL_CPU_CVT(i8, u64), INTEL_CPU_CVT(i8, i64), INTEL_CPU_CVT(i8, f32),                \
+        INTEL_CPU_CVT(i8, f16), INTEL_CPU_CVT(i8, bf16), INTEL_CPU_CVT(i8, f64), INTEL_CPU_CVT(i8, boolean),           \
+        INTEL_CPU_CVT(u16, u8), INTEL_CPU_CVT(u16, i8), INTEL_CPU_CVT(u16, i16), INTEL_CPU_CVT(u16, u32),              \
+        INTEL_CPU_CVT(u16, i32), INTEL_CPU_CVT(u16, u64), INTEL_CPU_CVT(u16, i64), INTEL_CPU_CVT(u16, f32),            \
+        INTEL_CPU_CVT(u16, f16), INTEL_CPU_CVT(u16, bf16), INTEL_CPU_CVT(u16, f64), INTEL_CPU_CVT(u16, boolean),       \
+        INTEL_CPU_CVT(i16, u8), INTEL_CPU_CVT(i16, i8), INTEL_CPU_CVT(i16, u16), INTEL_CPU_CVT(i16, u32),              \
+        INTEL_CPU_CVT(i16, i32), INTEL_CPU_CVT(i16, u64), INTEL_CPU_CVT(i16, i64), INTEL_CPU_CVT(i16, f32),            \
+        INTEL_CPU_CVT(i16, f16), INTEL_CPU_CVT(i16, bf16), INTEL_CPU_CVT(i16, f64), INTEL_CPU_CVT(i16, boolean),       \
+        INTEL_CPU_CVT(u32, u8), INTEL_CPU_CVT(u32, i8), INTEL_CPU_CVT(u32, u16), INTEL_CPU_CVT(u32, i16),              \
+        INTEL_CPU_CVT(u32, i32), INTEL_CPU_CVT(u32, u64), INTEL_CPU_CVT(u32, i64), INTEL_CPU_CVT(u32, f32),            \
+        INTEL_CPU_CVT(u32, f16), INTEL_CPU_CVT(u32, bf16), INTEL_CPU_CVT(u32, f64), INTEL_CPU_CVT(u32, boolean),       \
+        INTEL_CPU_CVT(i32, u8), INTEL_CPU_CVT(i32, i8), INTEL_CPU_CVT(i32, u16), INTEL_CPU_CVT(i32, i16),              \
+        INTEL_CPU_CVT(i32, u32), INTEL_CPU_CVT(i32, u64), INTEL_CPU_CVT(i32, i64), INTEL_CPU_CVT(i32, f32),            \
+        INTEL_CPU_CVT(i32, f16), INTEL_CPU_CVT(i32, bf16), INTEL_CPU_CVT(i32, f64), INTEL_CPU_CVT(i32, boolean),       \
+        INTEL_CPU_CVT(u64, u8), INTEL_CPU_CVT(u64, i8), INTEL_CPU_CVT(u64, u16), INTEL_CPU_CVT(u64, i16),              \
+        INTEL_CPU_CVT(u64, u32), INTEL_CPU_CVT(u64, i32), INTEL_CPU_CVT(u64, i64), INTEL_CPU_CVT(u64, f32),            \
+        INTEL_CPU_CVT(u64, f16), INTEL_CPU_CVT(u64, bf16), INTEL_CPU_CVT(u64, f64), INTEL_CPU_CVT(u64, boolean),       \
+        INTEL_CPU_CVT(i64, u8), INTEL_CPU_CVT(i64, i8), INTEL_CPU_CVT(i64, u16), INTEL_CPU_CVT(i64, i16),              \
+        INTEL_CPU_CVT(i64, u32), INTEL_CPU_CVT(i64, i32), INTEL_CPU_CVT(i64, u64), INTEL_CPU_CVT(i64, f32),            \
+        INTEL_CPU_CVT(i64, f16), INTEL_CPU_CVT(i64, bf16), INTEL_CPU_CVT(i64, f64), INTEL_CPU_CVT(i64, boolean),       \
+        INTEL_CPU_CVT(f32, u8), INTEL_CPU_CVT(f32, i8), INTEL_CPU_CVT(f32, u16), INTEL_CPU_CVT(f32, i16),              \
+        INTEL_CPU_CVT(f32, u32), INTEL_CPU_CVT(f32, i32), INTEL_CPU_CVT(f32, u64), INTEL_CPU_CVT(f32, i64),            \
+        INTEL_CPU_CVT(f32, f16), INTEL_CPU_CVT(f32, bf16), INTEL_CPU_CVT(f32, f64), INTEL_CPU_CVT(f32, boolean),       \
+        INTEL_CPU_CVT(f16, u8), INTEL_CPU_CVT(f16, i8), INTEL_CPU_CVT(f16, u16), INTEL_CPU_CVT(f16, i16),              \
+        INTEL_CPU_CVT(f16, u32), INTEL_CPU_CVT(f16, i32), INTEL_CPU_CVT(f16, u64), INTEL_CPU_CVT(f16, i64),            \
+        INTEL_CPU_CVT(f16, f32), INTEL_CPU_CVT(f16, bf16), INTEL_CPU_CVT(f16, f64), INTEL_CPU_CVT(f16, boolean),       \
+        INTEL_CPU_CVT(bf16, u8), INTEL_CPU_CVT(bf16, i8), INTEL_CPU_CVT(bf16, u16), INTEL_CPU_CVT(bf16, i16),          \
+        INTEL_CPU_CVT(bf16, u32), INTEL_CPU_CVT(bf16, i32), INTEL_CPU_CVT(bf16, u64), INTEL_CPU_CVT(bf16, i64),        \
+        INTEL_CPU_CVT(bf16, f32), INTEL_CPU_CVT(bf16, f16), INTEL_CPU_CVT(bf16, f64), INTEL_CPU_CVT(bf16, boolean),    \
+        INTEL_CPU_CVT(f64, u8), INTEL_CPU_CVT(f64, i8), INTEL_CPU_CVT(f64, u16), INTEL_CPU_CVT(f64, i16),              \
+        INTEL_CPU_CVT(f64, u32), INTEL_CPU_CVT(f64, i32), INTEL_CPU_CVT(f64, u64), INTEL_CPU_CVT(f64, i64),            \
+        INTEL_CPU_CVT(f64, f32), INTEL_CPU_CVT(f64, f16), INTEL_CPU_CVT(f64, bf16), INTEL_CPU_CVT(f64, boolean),       \
+        INTEL_CPU_CVT(boolean, u8), INTEL_CPU_CVT(boolean, i8), INTEL_CPU_CVT(boolean, u16),                           \
+        INTEL_CPU_CVT(boolean, i16), INTEL_CPU_CVT(boolean, u32), INTEL_CPU_CVT(boolean, i32),                         \
+        INTEL_CPU_CVT(boolean, u64), INTEL_CPU_CVT(boolean, i64), INTEL_CPU_CVT(boolean, f32),                         \
+        INTEL_CPU_CVT(boolean, f16), INTEL_CPU_CVT(boolean, bf16), INTEL_CPU_CVT(boolean, f64), INTEL_CPU_CVT(u8, u8), \
+        INTEL_CPU_CVT(i8, i8), INTEL_CPU_CVT(u16, u16), INTEL_CPU_CVT(i16, i16), INTEL_CPU_CVT(u32, u32),              \
+        INTEL_CPU_CVT(i32, i32), INTEL_CPU_CVT(u64, u64), INTEL_CPU_CVT(i64, i64), INTEL_CPU_CVT(f32, f32),            \
+        INTEL_CPU_CVT(f16, f16), INTEL_CPU_CVT(bf16, bf16), INTEL_CPU_CVT(f64, f64), INTEL_CPU_CVT(boolean, boolean)
+
+#define INTEL_CPU_CVT_FROM_BIN_LIST                                                                     \
+    INTEL_CPU_CVT(u1, f32), INTEL_CPU_CVT(u1, f16), INTEL_CPU_CVT(u1, bf16), INTEL_CPU_CVT(u1, f64),    \
+        INTEL_CPU_CVT(u1, i16), INTEL_CPU_CVT(u1, u8), INTEL_CPU_CVT(u1, i8), INTEL_CPU_CVT(u1, u16),   \
+        INTEL_CPU_CVT(u1, i32), INTEL_CPU_CVT(u1, u32), INTEL_CPU_CVT(u1, i64), INTEL_CPU_CVT(u1, u64), \
+        INTEL_CPU_CVT(u1, boolean)
 
 struct ConvertFromBinContext {
-    const void *srcPtr;
-    void *dstPtr;
+    const void* srcPtr;
+    void* dstPtr;
     size_t size;
     bool converted;
 };
 
-template<typename T>
+template <typename T>
 struct ConvertFromBinPrecision;
 
-template<typename src_t, typename dst_t>
+template <typename src_t, typename dst_t>
 struct ConvertFromBinPrecision<std::tuple<src_t, dst_t>> {
-    void operator()(ConvertFromBinContext &ctx) {
-        auto src = static_cast<const uint8_t *>(ctx.srcPtr);
-        auto dst = static_cast<dst_t *>(ctx.dstPtr);
+    void operator()(ConvertFromBinContext& ctx) {
+        auto src = static_cast<const uint8_t*>(ctx.srcPtr);
+        auto dst = static_cast<dst_t*>(ctx.dstPtr);
         const size_t nBits = 8;
         const size_t nBytes = rnd_up(ctx.size, nBits);
         parallel_for(nBytes, [&](size_t byteIndex) {
@@ -590,16 +570,17 @@ struct ConvertFromBinPrecision<std::tuple<src_t, dst_t>> {
     }
 };
 
-#define INTEL_CPU_CVT_FROM_4BIT_LIST                                                                                       \
-    INTEL_CPU_CVT(u4, f32), INTEL_CPU_CVT(u4, bf16), INTEL_CPU_CVT(u4, f16), INTEL_CPU_CVT(u4, i8), INTEL_CPU_CVT(u4, u8), \
-    INTEL_CPU_CVT(i4, f32), INTEL_CPU_CVT(i4, bf16), INTEL_CPU_CVT(i4, f16), INTEL_CPU_CVT(i4, i8), INTEL_CPU_CVT(i4, u8), \
-    INTEL_CPU_CVT(nf4, f32), INTEL_CPU_CVT(nf4, bf16), INTEL_CPU_CVT(nf4, f16), INTEL_CPU_CVT(nf4, i8), INTEL_CPU_CVT(nf4, u8), \
-    INTEL_CPU_CVT(f4e2m1, f32), INTEL_CPU_CVT(f4e2m1, bf16), INTEL_CPU_CVT(f4e2m1, f16), INTEL_CPU_CVT(f4e2m1, i8), INTEL_CPU_CVT(f4e2m1, u8)
+#define INTEL_CPU_CVT_FROM_4BIT_LIST                                                                         \
+    INTEL_CPU_CVT(u4, f32), INTEL_CPU_CVT(u4, bf16), INTEL_CPU_CVT(u4, f16), INTEL_CPU_CVT(u4, i8),          \
+        INTEL_CPU_CVT(u4, u8), INTEL_CPU_CVT(i4, f32), INTEL_CPU_CVT(i4, bf16), INTEL_CPU_CVT(i4, f16),      \
+        INTEL_CPU_CVT(i4, i8), INTEL_CPU_CVT(i4, u8), INTEL_CPU_CVT(nf4, f32), INTEL_CPU_CVT(nf4, bf16),     \
+        INTEL_CPU_CVT(nf4, f16), INTEL_CPU_CVT(nf4, i8), INTEL_CPU_CVT(nf4, u8), INTEL_CPU_CVT(f4e2m1, f32), \
+        INTEL_CPU_CVT(f4e2m1, bf16), INTEL_CPU_CVT(f4e2m1, f16), INTEL_CPU_CVT(f4e2m1, i8), INTEL_CPU_CVT(f4e2m1, u8)
 
 struct ConvertFrom4BitContext {
     ov::element::Type_t inType;
-    const void *srcPtr;
-    void *dstPtr;
+    const void* srcPtr;
+    void* dstPtr;
     size_t size;
     bool converted;
 };
@@ -624,12 +605,12 @@ static int8_t get_u4(const uint8_t& val, bool high) {
     return high ? (val >> 4) : (val & 0xF);
 }
 
-template<typename T>
+template <typename T>
 struct ConvertFrom4BitPrecision;
 
-template<typename src_t, typename dst_t>
+template <typename src_t, typename dst_t>
 struct ConvertFrom4BitPrecision<std::tuple<src_t, dst_t>> {
-    void operator()(ConvertFrom4BitContext &ctx) {
+    void operator()(ConvertFrom4BitContext& ctx) {
         auto src = static_cast<const uint8_t*>(ctx.srcPtr);
         auto dst = static_cast<dst_t*>(ctx.dstPtr);
         if (ctx.inType == ov::element::nf4) {
@@ -655,23 +636,23 @@ struct ConvertFrom4BitPrecision<std::tuple<src_t, dst_t>> {
     }
 };
 
-#define INTEL_CPU_CVT_FROM_BYTE_FP_LIST                                                           \
+#define INTEL_CPU_CVT_FROM_BYTE_FP_LIST \
     INTEL_CPU_CVT(f8e8m0, f32), INTEL_CPU_CVT(f8e8m0, bf16), INTEL_CPU_CVT(f8e8m0, f16)
 
 struct ConvertFromByteFPContext {
     ov::element::Type_t inType;
-    const void *srcPtr;
-    void *dstPtr;
+    const void* srcPtr;
+    void* dstPtr;
     size_t size;
     bool converted;
 };
 
-template<typename T>
+template <typename T>
 struct ConvertFromByteFPPrecision;
 
-template<typename src_t, typename dst_t>
+template <typename src_t, typename dst_t>
 struct ConvertFromByteFPPrecision<std::tuple<src_t, dst_t>> {
-    void operator()(ConvertFromByteFPContext &ctx) {
+    void operator()(ConvertFromByteFPContext& ctx) {
         auto src = static_cast<const uint8_t*>(ctx.srcPtr);
         auto dst = static_cast<dst_t*>(ctx.dstPtr);
         if (ctx.inType == ov::element::f8e8m0) {
@@ -685,12 +666,16 @@ struct ConvertFromByteFPPrecision<std::tuple<src_t, dst_t>> {
     }
 };
 
-void cpu_convert(const void *srcPtr, void *dstPtr, ov::element::Type srcPrc, ov::element::Type dstPrc, const size_t size) {
+void cpu_convert(const void* srcPtr,
+                 void* dstPtr,
+                 ov::element::Type srcPrc,
+                 ov::element::Type dstPrc,
+                 const size_t size) {
     cpu_convert(srcPtr, dstPtr, srcPrc, dstPrc, dstPrc, size);
 }
 
-void cpu_convert(const void *srcPtr,
-                 void *dstPtr,
+void cpu_convert(const void* srcPtr,
+                 void* dstPtr,
                  ov::element::Type srcPrc,
                  ov::element::Type interimPrc,
                  ov::element::Type dstPrc,
@@ -705,12 +690,12 @@ void cpu_convert(const void *srcPtr,
         const size_t L2_cache_size = dnnl::utils::get_cache_size(2, true);
         const size_t totalSize = size * dstPrc.size();
         if (srcPrc == element::string) {
-            auto str_src = reinterpret_cast<const StringMemory::OvString *>(srcPtr);
-            auto str_dst = reinterpret_cast<StringMemory::OvString *>(dstPtr);
+            auto str_src = reinterpret_cast<const StringMemory::OvString*>(srcPtr);
+            auto str_dst = reinterpret_cast<StringMemory::OvString*>(dstPtr);
             std::copy(str_src, str_src + size, str_dst);
         } else if (totalSize >= L2_cache_size) {
-            auto src = static_cast<const uint8_t *>(srcPtr);
-            auto dst = static_cast<uint8_t *>(dstPtr);
+            auto src = static_cast<const uint8_t*>(srcPtr);
+            auto dst = static_cast<uint8_t*>(dstPtr);
             parallel_nt(0, [&](const size_t ithr, const size_t nthr) {
                 size_t start = 0, end = 0;
                 splitter(totalSize, nthr, ithr, start, end);
@@ -728,12 +713,7 @@ void cpu_convert(const void *srcPtr,
                            "> precision to: ",
                            dstPrc,
                            ". Not implemented.");
-        ConvertFromBinContext ctx {
-                srcPtr,
-                dstPtr,
-                size,
-                false
-        };
+        ConvertFromBinContext ctx{srcPtr, dstPtr, size, false};
         OV_SWITCH(intel_cpu, ConvertFromBinPrecision, ctx, std::tie(srcPrc, dstPrc), INTEL_CPU_CVT_FROM_BIN_LIST);
         if (!ctx.converted)
             OPENVINO_THROW("cpu_convert can't convert from: ",
@@ -749,18 +729,15 @@ void cpu_convert(const void *srcPtr,
             OPENVINO_THROW("cpu_convert can't convert from: ", srcPrc, " precision to: ", dstPrc);
     } else if (srcPrc.bitwidth() == 8u && srcPrc.is_real()) {
         ConvertFromByteFPContext ctx{srcPrc, srcPtr, dstPtr, size, false};
-        OV_SWITCH(intel_cpu, ConvertFromByteFPPrecision, ctx, std::tie(srcPrc, dstPrc), INTEL_CPU_CVT_FROM_BYTE_FP_LIST);
+        OV_SWITCH(intel_cpu,
+                  ConvertFromByteFPPrecision,
+                  ctx,
+                  std::tie(srcPrc, dstPrc),
+                  INTEL_CPU_CVT_FROM_BYTE_FP_LIST);
         if (!ctx.converted)
             OPENVINO_THROW("cpu_convert can't convert from: ", srcPrc, " precision to: ", dstPrc);
     } else {
-        ConvertContext ctx {
-            srcPtr,
-            dstPtr,
-            size,
-            interimPrc,
-            dstPrc,
-            false
-        };
+        ConvertContext ctx{srcPtr, dstPtr, size, interimPrc, dstPrc, false};
         OV_SWITCH(intel_cpu, ConvertPrecision, ctx, std::tie(srcPrc, dstPrc), INTEL_CPU_CVT_LIST);
         if (!ctx.converted)
             OPENVINO_THROW("cpu_convert can't convert from: ", srcPrc, " precision to: ", dstPrc);
@@ -773,7 +750,7 @@ struct isSupportedContext {
 
 template <typename DT>
 struct isSupported {
-    void operator()(isSupportedContext &ctx) {
+    void operator()(isSupportedContext& ctx) {
         ctx.isSupported = true;
     }
 };
@@ -790,5 +767,5 @@ bool is_supported_convert(ov::element::Type srcPrc, ov::element::Type dstPrc) {
 #undef INTEL_CPU_CVT
 #undef INTEL_CPU_CVT_LIST
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/cpu_convert.h b/src/plugins/intel_cpu/src/nodes/common/cpu_convert.h
index 8390849ff8adc7..11228dbd1dcfdb 100644
--- a/src/plugins/intel_cpu/src/nodes/common/cpu_convert.h
+++ b/src/plugins/intel_cpu/src/nodes/common/cpu_convert.h
@@ -22,8 +22,8 @@ namespace intel_cpu {
  * number of elements in buffers to be converted
  * @return none.
  */
-void cpu_convert(const void *srcPtr,
-                 void *dstPtr,
+void cpu_convert(const void* srcPtr,
+                 void* dstPtr,
                  ov::element::Type srcPrc,
                  ov::element::Type dstPrc,
                  const size_t size);
@@ -45,14 +45,14 @@ void cpu_convert(const void *srcPtr,
  * number of elements in buffers to be converted
  * @return none.
  */
-void cpu_convert(const void *srcPtr,
-                 void *dstPtr,
+void cpu_convert(const void* srcPtr,
+                 void* dstPtr,
                  ov::element::Type srcPrc,
                  ov::element::Type interimPrc,
                  ov::element::Type dstPrc,
                  const size_t size);
 
- bool is_supported_convert(ov::element::Type srcPrc, ov::element::Type dstPrc);
+bool is_supported_convert(ov::element::Type srcPrc, ov::element::Type dstPrc);
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/cpu_memcpy.h b/src/plugins/intel_cpu/src/nodes/common/cpu_memcpy.h
old mode 100755
new mode 100644
index 95b0267bd4757c..e827d35a11c2ad
--- a/src/plugins/intel_cpu/src/nodes/common/cpu_memcpy.h
+++ b/src/plugins/intel_cpu/src/nodes/common/cpu_memcpy.h
@@ -5,8 +5,9 @@
 #pragma once
 
 #include <cstring>
-#include "openvino/core/parallel.hpp"
+
 #include "onednn/dnnl.h"
+#include "openvino/core/parallel.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -36,8 +37,7 @@ inline void cpu_memcpy(void* dst, const void* src, size_t count) {
 }
 
 inline int cpu_memcpy_s(void* dst, size_t dst_size, const void* src, size_t count) {
-    if (!src ||
-        count > dst_size ||
+    if (!src || count > dst_size ||
         count > (dst > src ? ((uintptr_t)dst - (uintptr_t)src) : ((uintptr_t)src - (uintptr_t)dst))) {
         // zero out dest if error detected
         std::memset(dst, 0, dst_size);
@@ -55,8 +55,8 @@ inline int cpu_memcpy_s(void* dst, size_t dst_size, const void* src, size_t coun
 inline void cpu_parallel_memcpy(void* dst, const void* src, size_t count) {
     const size_t l2_cache_size = dnnl::utils::get_cache_size(2, true);
     if (count >= l2_cache_size) {
-        auto src_int8 = static_cast<const uint8_t *>(src);
-        auto dst_int8 = static_cast<uint8_t *>(dst);
+        auto src_int8 = static_cast<const uint8_t*>(src);
+        auto dst_int8 = static_cast<uint8_t*>(dst);
         parallel_nt(0, [&](const size_t ithr, const size_t nthr) {
             size_t start = 0, end = 0;
             splitter(count, nthr, ithr, start, end);
@@ -67,5 +67,5 @@ inline void cpu_parallel_memcpy(void* dst, const void* src, size_t count) {
     }
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/defs.h b/src/plugins/intel_cpu/src/nodes/common/defs.h
index 6d8574de0939a4..a8a07a2cc8942a 100644
--- a/src/plugins/intel_cpu/src/nodes/common/defs.h
+++ b/src/plugins/intel_cpu/src/nodes/common/defs.h
@@ -4,10 +4,10 @@
 
 #pragma once
 
-#if defined (HAVE_SSE) || defined (HAVE_AVX2)
-# if defined (_WIN32)
-#  include <emmintrin.h>
-# else
-#  include <x86intrin.h>
-# endif
+#if defined(HAVE_SSE) || defined(HAVE_AVX2)
+#    if defined(_WIN32)
+#        include <emmintrin.h>
+#    else
+#        include <x86intrin.h>
+#    endif
 #endif
diff --git a/src/plugins/intel_cpu/src/nodes/common/dnnl_executor.cpp b/src/plugins/intel_cpu/src/nodes/common/dnnl_executor.cpp
index 51aa54c2f50463..695fdbe823ea15 100644
--- a/src/plugins/intel_cpu/src/nodes/common/dnnl_executor.cpp
+++ b/src/plugins/intel_cpu/src/nodes/common/dnnl_executor.cpp
@@ -18,7 +18,9 @@ DnnlExecutor::DnnlExecutor(const dnnl::primitive_desc& pd) {
 
 DnnlExecutor::IntermReorder::IntermReorder(const dnnl::memory::desc& descSrc,
                                            const dnnl::memory::desc& descDst,
-                                           const dnnl::engine& engine) : m_descSrc(descSrc), m_descDst(descDst) {
+                                           const dnnl::engine& engine)
+    : m_descSrc(descSrc),
+      m_descDst(descDst) {
     auto reorderPd = dnnl::reorder::primitive_desc(engine, descSrc, engine, descDst);
     m_reorder = dnnl::reorder(reorderPd);
 }
@@ -36,7 +38,7 @@ void DnnlExecutor::exec(const std::unordered_map<int, dnnl::memory>& primArgs, d
 }
 
 void DnnlExecutor::reorder_exec(std::unordered_map<int, dnnl::memory> primArgs, dnnl::stream strm) {
-    for (auto &inReorder : inputReorders) {
+    for (auto& inReorder : inputReorders) {
         if (primArgs.count(inReorder.first)) {
             dnnl::memory memDst(inReorder.second.getDstDesc(), strm.get_engine());
             inReorder.second.exec(primArgs[inReorder.first], memDst, strm);
@@ -46,17 +48,19 @@ void DnnlExecutor::reorder_exec(std::unordered_map<int, dnnl::memory> primArgs,
         }
     }
     std::unordered_map<int, dnnl::memory> outputMem;
-    for (auto &outReorder : outputReorders) {
+    for (auto& outReorder : outputReorders) {
         if (primArgs.count(outReorder.first)) {
             dnnl::memory memSrc(outReorder.second.getSrcDesc(), strm.get_engine());
             outputMem[outReorder.first] = primArgs[outReorder.first];
             primArgs[outReorder.first] = memSrc;
         } else {
-            OPENVINO_THROW("DnnlExecutor has reorder for output ", outReorder.first, ", but doesn't have destination memory");
+            OPENVINO_THROW("DnnlExecutor has reorder for output ",
+                           outReorder.first,
+                           ", but doesn't have destination memory");
         }
     }
     execPrim.execute(strm, primArgs);
-    for (auto &outReorder : outputReorders) {
+    for (auto& outReorder : outputReorders) {
         outReorder.second.exec(primArgs[outReorder.first], outputMem[outReorder.first], strm);
     }
 }
@@ -79,4 +83,4 @@ impl_desc_type DnnlExecutor::getImplementationType() const {
 }
 
 }  // namespace intel_cpu
-}   // namespace ov
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/dnnl_executor.h b/src/plugins/intel_cpu/src/nodes/common/dnnl_executor.h
index 3cc6749857816c..32739a38d37028 100644
--- a/src/plugins/intel_cpu/src/nodes/common/dnnl_executor.h
+++ b/src/plugins/intel_cpu/src/nodes/common/dnnl_executor.h
@@ -6,74 +6,79 @@
 
 #include <cpu_memory.h>
 #include <onednn/iml_type_mapper.h>
+
 #include "memory_desc/dnnl_memory_desc.h"
 
 namespace ov {
 namespace intel_cpu {
 
 class DnnlExecutor {
-    protected:
-        class IntermReorder {
-            public:
-                IntermReorder(const dnnl::memory::desc& descSrc, const dnnl::memory::desc& descDst, const dnnl::engine& engine);
-                void exec(dnnl::memory& memSrc, dnnl::memory& memDst, dnnl::stream strm);
-                const dnnl::memory::desc& getSrcDesc() const { return m_descSrc; }
-                const dnnl::memory::desc& getDstDesc() const { return m_descDst; }
-
-            private:
-                dnnl::reorder m_reorder;
-                dnnl::memory::desc m_descSrc;
-                dnnl::memory::desc m_descDst;
-        };
-
+protected:
+    class IntermReorder {
     public:
-        explicit DnnlExecutor(const dnnl::primitive_desc& pd);
-        void exec(const std::unordered_map<int, dnnl::memory>& primArgs, dnnl::stream strm);
-        bool needReordering() const;
-        virtual ~DnnlExecutor() = default;
-        dnnl::primitive getExecPrim() const;
-        const_dnnl_primitive_desc_t getPrimitiveDesc() const;
-        impl_desc_type getImplementationType() const;
-
-        DnnlMemoryDescPtr getSrcDesc() const {
-            return src_md;
+        IntermReorder(const dnnl::memory::desc& descSrc, const dnnl::memory::desc& descDst, const dnnl::engine& engine);
+        void exec(dnnl::memory& memSrc, dnnl::memory& memDst, dnnl::stream strm);
+        const dnnl::memory::desc& getSrcDesc() const {
+            return m_descSrc;
         }
-        DnnlMemoryDescPtr getWeightDesc() const {
-            return wghts_md;
-        }
-        DnnlMemoryDescPtr getDstDesc() const {
-            return dst_md;
-        }
-        DnnlMemoryDescPtr getScratchPadDesc() const {
-            return scrch_md;
+        const dnnl::memory::desc& getDstDesc() const {
+            return m_descDst;
         }
 
-        const dnnl::memory::desc& getDnnlSrcDesc() const {
-            return src_md->getDnnlDesc();
-        }
-        const dnnl::memory::desc& getDnnlWeightDesc() const {
-            return wghts_md->getDnnlDesc();
-        }
-        const dnnl::memory::desc& getDnnlDstDesc() const {
-            return dst_md->getDnnlDesc();
-        }
-        const dnnl::memory::desc& getDnnlScratchPadDesc() const {
-            return scrch_md->getDnnlDesc();
-        }
+    private:
+        dnnl::reorder m_reorder;
+        dnnl::memory::desc m_descSrc;
+        dnnl::memory::desc m_descDst;
+    };
+
+public:
+    explicit DnnlExecutor(const dnnl::primitive_desc& pd);
+    void exec(const std::unordered_map<int, dnnl::memory>& primArgs, dnnl::stream strm);
+    bool needReordering() const;
+    virtual ~DnnlExecutor() = default;
+    dnnl::primitive getExecPrim() const;
+    const_dnnl_primitive_desc_t getPrimitiveDesc() const;
+    impl_desc_type getImplementationType() const;
+
+    DnnlMemoryDescPtr getSrcDesc() const {
+        return src_md;
+    }
+    DnnlMemoryDescPtr getWeightDesc() const {
+        return wghts_md;
+    }
+    DnnlMemoryDescPtr getDstDesc() const {
+        return dst_md;
+    }
+    DnnlMemoryDescPtr getScratchPadDesc() const {
+        return scrch_md;
+    }
+
+    const dnnl::memory::desc& getDnnlSrcDesc() const {
+        return src_md->getDnnlDesc();
+    }
+    const dnnl::memory::desc& getDnnlWeightDesc() const {
+        return wghts_md->getDnnlDesc();
+    }
+    const dnnl::memory::desc& getDnnlDstDesc() const {
+        return dst_md->getDnnlDesc();
+    }
+    const dnnl::memory::desc& getDnnlScratchPadDesc() const {
+        return scrch_md->getDnnlDesc();
+    }
 
-    protected:
-        virtual void reorder_exec(std::unordered_map<int, dnnl::memory> primArgs, dnnl::stream strm);
+protected:
+    virtual void reorder_exec(std::unordered_map<int, dnnl::memory> primArgs, dnnl::stream strm);
 
-    protected:
-        dnnl::primitive execPrim;
-        // key is the port number for the primitive that needs memory reordering
-        std::unordered_map<int, IntermReorder> inputReorders;
-        std::unordered_map<int, IntermReorder> outputReorders;
-        DnnlMemoryDescPtr src_md;
-        DnnlMemoryDescPtr wghts_md;
-        DnnlMemoryDescPtr dst_md;
-        DnnlMemoryDescPtr scrch_md;
+protected:
+    dnnl::primitive execPrim;
+    // key is the port number for the primitive that needs memory reordering
+    std::unordered_map<int, IntermReorder> inputReorders;
+    std::unordered_map<int, IntermReorder> outputReorders;
+    DnnlMemoryDescPtr src_md;
+    DnnlMemoryDescPtr wghts_md;
+    DnnlMemoryDescPtr dst_md;
+    DnnlMemoryDescPtr scrch_md;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/fp16_utils.h b/src/plugins/intel_cpu/src/nodes/common/fp16_utils.h
index daedcc4bf23ca4..b6622f7ae54d0b 100644
--- a/src/plugins/intel_cpu/src/nodes/common/fp16_utils.h
+++ b/src/plugins/intel_cpu/src/nodes/common/fp16_utils.h
@@ -13,7 +13,7 @@ typedef short ie_fp16;
 // F32: exp_bias:127 SEEEEEEE EMMMMMMM MMMMMMMM MMMMMMMM.
 // F16: exp_bias:15  SEEEEEMM MMMMMMMM
 #define EXP_MASK_F32 0x7F800000U
-#define EXP_MASK_F16     0x7C00U
+#define EXP_MASK_F16 0x7C00U
 
 // small helper function to represent uint32_t value as float32
 inline float asfloat(uint32_t v) {
@@ -83,5 +83,5 @@ inline float f16tof32(ie_fp16 x) {
     return asfloat(u);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/permute_kernel.cpp b/src/plugins/intel_cpu/src/nodes/common/permute_kernel.cpp
index 396cebc1ba82e1..60bd675d726e4a 100644
--- a/src/plugins/intel_cpu/src/nodes/common/permute_kernel.cpp
+++ b/src/plugins/intel_cpu/src/nodes/common/permute_kernel.cpp
@@ -6,15 +6,14 @@
 
 #include <vector>
 
-#include "dnnl_types.h"
-#include "dnnl_extension_utils.h"
-#include "cpu_memcpy.h"
-#include "utils/bfloat16.hpp"
-
-#include "cpu/x64/jit_generator.hpp"
 #include "common/primitive_hashing_utils.hpp"
-#include "nodes/executors/transpose.hpp"
+#include "cpu/x64/jit_generator.hpp"
+#include "cpu_memcpy.h"
+#include "dnnl_extension_utils.h"
+#include "dnnl_types.h"
 #include "nodes/executors/common/ref_transpose.hpp"
+#include "nodes/executors/transpose.hpp"
+#include "utils/bfloat16.hpp"
 
 using namespace dnnl;
 using namespace dnnl::impl;
@@ -33,7 +32,9 @@ template <cpu_isa_t isa>
 struct jit_uni_permute_kernel_f32 : public jit_uni_permute_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_permute_kernel_f32)
 
-    explicit jit_uni_permute_kernel_f32(jit_permute_config_params jcp_) : jit_uni_permute_kernel(jcp_), jit_generator(jit_name()) {}
+    explicit jit_uni_permute_kernel_f32(jit_permute_config_params jcp_)
+        : jit_uni_permute_kernel(jcp_),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -51,23 +52,43 @@ struct jit_uni_permute_kernel_f32 : public jit_uni_permute_kernel, public jit_ge
         this->postamble();
     }
 
-    void load(const Xbyak::Xmm &xmm, const Xbyak::Address &addr) {
+    void load(const Xbyak::Xmm& xmm, const Xbyak::Address& addr) {
         switch (jcp.data_size) {
-            case 16: uni_vmovups(xmm, addr); break;
-            case 8: uni_vmovsd(xmm, addr); break;
-            case 4: uni_vmovss(xmm, addr); break;
-            case 2: uni_vpinsrw(xmm, xmm, addr, 0x0); break;
-            case 1: uni_vpinsrb(xmm, xmm, addr, 0x0); break;
+        case 16:
+            uni_vmovups(xmm, addr);
+            break;
+        case 8:
+            uni_vmovsd(xmm, addr);
+            break;
+        case 4:
+            uni_vmovss(xmm, addr);
+            break;
+        case 2:
+            uni_vpinsrw(xmm, xmm, addr, 0x0);
+            break;
+        case 1:
+            uni_vpinsrb(xmm, xmm, addr, 0x0);
+            break;
         }
     }
 
-    void store(const Xbyak::Address &addr, const Xbyak::Xmm &xmm) {
+    void store(const Xbyak::Address& addr, const Xbyak::Xmm& xmm) {
         switch (jcp.data_size) {
-            case 16: uni_vmovups(addr, xmm); break;
-            case 8: uni_vmovsd(addr, xmm); break;
-            case 4: uni_vmovss(addr, xmm); break;
-            case 2: uni_vpextrw(addr, xmm, 0x0); break;
-            case 1: uni_vpextrb(addr, xmm, 0x0); break;
+        case 16:
+            uni_vmovups(addr, xmm);
+            break;
+        case 8:
+            uni_vmovsd(addr, xmm);
+            break;
+        case 4:
+            uni_vmovss(addr, xmm);
+            break;
+        case 2:
+            uni_vpextrw(addr, xmm, 0x0);
+            break;
+        case 1:
+            uni_vpextrb(addr, xmm, 0x0);
+            break;
         }
     }
 
@@ -99,7 +120,8 @@ struct jit_uni_permute_kernel_f32 : public jit_uni_permute_kernel, public jit_ge
             }
         }
 
-        L(tail_loop_label); {
+        L(tail_loop_label);
+        {
             cmp(reg_work_amount, 0);
             je(exit_label, T_NEAR);
 
@@ -129,7 +151,8 @@ struct jit_uni_permute_kernel_f32 : public jit_uni_permute_kernel, public jit_ge
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
     uint32_t vlen = cpu_isa_traits<isa>::vlen;
 
     Xbyak::Reg64 reg_src = r8;
@@ -144,7 +167,7 @@ struct jit_uni_permute_kernel_f32 : public jit_uni_permute_kernel, public jit_ge
     Xbyak::Xmm xmm = Xbyak::Xmm(1);
 };
 
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
 PermuteKernel::PermuteKernel(const PermuteParams& params) : params(params) {
     jcp = TransposeExecutor::prepareParams(params);
@@ -156,7 +179,7 @@ PermuteKernel::PermuteKernel(const PermuteParams& params) : params(params) {
     } else if (mayiuse(cpu::x64::sse41)) {
         permute_kernel.reset(new jit_uni_permute_kernel_f32<cpu::x64::sse41>(jcp));
     }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
     if (permute_kernel)
         permute_kernel->create_ker();
@@ -178,7 +201,7 @@ void PermuteKernel::execute(const uint8_t* src_data, uint8_t* dst_data) {
         return;
     }
 
-    RefTransposeExecutor::referenceExecute(src_data, dst_data, jcp,  dst_dims[0]);
+    RefTransposeExecutor::referenceExecute(src_data, dst_data, jcp, dst_dims[0]);
 }
 
 void PermuteKernel::optimizedExecute(const uint8_t* src_data, uint8_t* dst_data, const int mb) {
@@ -190,42 +213,42 @@ void PermuteKernel::optimizedExecute(const uint8_t* src_data, uint8_t* dst_data,
         dst_dims[0] = mb;
 
     switch (jcp.n) {
-        case 1:
-            parallel_for(dst_dims[0], [&](int i0) {
-                auto arg = jit_args_permute();
-
-                size_t dst_off = i0 * dst_strides[0];
-                size_t src_off = i0 * src_strides[0];
-                arg.src = &src_data[src_off * jcp.data_size];
-                arg.dst = &dst_data[dst_off * jcp.data_size];
-
-                (*permute_kernel)(&arg);
-            });
-            break;
-        case 2:
-            parallel_for2d(dst_dims[0], dst_dims[1], [&](int i0, int i1) {
-                auto arg = jit_args_permute();
-
-                size_t dst_off = i0 * dst_strides[0] + i1 * dst_strides[1];
-                size_t src_off = i0 * src_strides[0] + i1 * src_strides[1];
-                arg.src = &src_data[src_off * jcp.data_size];
-                arg.dst = &dst_data[dst_off * jcp.data_size];
-
-                (*permute_kernel)(&arg);
-            });
-            break;
-        case 3:
-            parallel_for3d(dst_dims[0], dst_dims[1], dst_dims[2], [&](int i0, int i1, int i2) {
-                auto arg = jit_args_permute();
-
-                size_t dst_off = i0 * dst_strides[0] + i1 * dst_strides[1] + i2 * dst_strides[2];
-                size_t src_off = i0 * src_strides[0] + i1 * src_strides[1] + i2 * src_strides[2];
-                arg.src = &src_data[src_off * jcp.data_size];
-                arg.dst = &dst_data[dst_off * jcp.data_size];
-
-                (*permute_kernel)(&arg);
-            });
-            break;
+    case 1:
+        parallel_for(dst_dims[0], [&](int i0) {
+            auto arg = jit_args_permute();
+
+            size_t dst_off = i0 * dst_strides[0];
+            size_t src_off = i0 * src_strides[0];
+            arg.src = &src_data[src_off * jcp.data_size];
+            arg.dst = &dst_data[dst_off * jcp.data_size];
+
+            (*permute_kernel)(&arg);
+        });
+        break;
+    case 2:
+        parallel_for2d(dst_dims[0], dst_dims[1], [&](int i0, int i1) {
+            auto arg = jit_args_permute();
+
+            size_t dst_off = i0 * dst_strides[0] + i1 * dst_strides[1];
+            size_t src_off = i0 * src_strides[0] + i1 * src_strides[1];
+            arg.src = &src_data[src_off * jcp.data_size];
+            arg.dst = &dst_data[dst_off * jcp.data_size];
+
+            (*permute_kernel)(&arg);
+        });
+        break;
+    case 3:
+        parallel_for3d(dst_dims[0], dst_dims[1], dst_dims[2], [&](int i0, int i1, int i2) {
+            auto arg = jit_args_permute();
+
+            size_t dst_off = i0 * dst_strides[0] + i1 * dst_strides[1] + i2 * dst_strides[2];
+            size_t src_off = i0 * src_strides[0] + i1 * src_strides[1] + i2 * src_strides[2];
+            arg.src = &src_data[src_off * jcp.data_size];
+            arg.dst = &dst_data[dst_off * jcp.data_size];
+
+            (*permute_kernel)(&arg);
+        });
+        break;
     }
     return;
 }
@@ -245,12 +268,10 @@ size_t PermuteParams::hash() const {
 }
 
 bool PermuteParams::operator==(const PermuteParams& rhs) const {
-    return (src_block_dims == rhs.src_block_dims) &&
-           (dst_block_dims == rhs.dst_block_dims) &&
-           (src_block_order == rhs.src_block_order) &&
-           (dst_block_order == rhs.dst_block_order) && (order == rhs.order) &&
-           (data_size == rhs.data_size);
+    return (src_block_dims == rhs.src_block_dims) && (dst_block_dims == rhs.dst_block_dims) &&
+           (src_block_order == rhs.src_block_order) && (dst_block_order == rhs.dst_block_order) &&
+           (order == rhs.order) && (data_size == rhs.data_size);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/permute_kernel.h b/src/plugins/intel_cpu/src/nodes/common/permute_kernel.h
index ac665efb4f0bb6..ba7a89d746d945 100644
--- a/src/plugins/intel_cpu/src/nodes/common/permute_kernel.h
+++ b/src/plugins/intel_cpu/src/nodes/common/permute_kernel.h
@@ -38,9 +38,9 @@ struct jit_args_permute {
 };
 
 struct jit_uni_permute_kernel {
-    void (*ker_)(const jit_args_permute *);
+    void (*ker_)(const jit_args_permute*);
 
-    void operator()(const jit_args_permute *args) {
+    void operator()(const jit_args_permute* args) {
         assert(ker_);
         ker_(args);
     }
@@ -71,5 +71,5 @@ class PermuteKernel {
     PermuteParams params;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/reorder_prim.cpp b/src/plugins/intel_cpu/src/nodes/common/reorder_prim.cpp
index 93e145b25b9e95..dd07a721260aac 100644
--- a/src/plugins/intel_cpu/src/nodes/common/reorder_prim.cpp
+++ b/src/plugins/intel_cpu/src/nodes/common/reorder_prim.cpp
@@ -4,15 +4,14 @@
 
 #include "reorder_prim.h"
 
-#include "dnnl_extension_utils.h"
-#include "dnnl_types.h"
-
 #include <algorithm>
-#include "common/primitive_hashing_utils.hpp"
-#include "cpu/x64/cpu_isa_traits.hpp"
 #include <memory>
 #include <string>
 
+#include "common/primitive_hashing_utils.hpp"
+#include "cpu/x64/cpu_isa_traits.hpp"
+#include "dnnl_extension_utils.h"
+#include "dnnl_types.h"
 #include "utils/general_utils.h"
 
 namespace ov {
diff --git a/src/plugins/intel_cpu/src/nodes/common/softmax.cpp b/src/plugins/intel_cpu/src/nodes/common/softmax.cpp
index 66a6ca9c1b6f53..0fcc87f8978752 100644
--- a/src/plugins/intel_cpu/src/nodes/common/softmax.cpp
+++ b/src/plugins/intel_cpu/src/nodes/common/softmax.cpp
@@ -4,17 +4,17 @@
 
 #include "softmax.h"
 
-#include "openvino/core/parallel.hpp"
-#include "cpu/x64/jit_generator.hpp"
-#include "cpu/x64/injectors/jit_uni_eltwise_injector.hpp"
-#include "onednn/dnnl.h"
-#include "utils/bfloat16.hpp"
-#include "emitters/plugin/x64/jit_bf16_emitters.hpp"
-
 #include <algorithm>
 #include <cassert>
 #include <vector>
 
+#include "cpu/x64/injectors/jit_uni_eltwise_injector.hpp"
+#include "cpu/x64/jit_generator.hpp"
+#include "emitters/plugin/x64/jit_bf16_emitters.hpp"
+#include "onednn/dnnl.h"
+#include "openvino/core/parallel.hpp"
+#include "utils/bfloat16.hpp"
+
 using namespace dnnl;
 using namespace dnnl::impl::cpu;
 using namespace dnnl::impl::cpu::x64;
@@ -38,11 +38,13 @@ struct jit_softmax_config_params {
     ov::element::Type dst_dt;
 };
 
-
 struct jit_uni_softmax_kernel {
-    void (*ker_)(const jit_args_softmax *);
+    void (*ker_)(const jit_args_softmax*);
 
-    void operator()(const jit_args_softmax *args) { assert(ker_); ker_(args); }
+    void operator()(const jit_args_softmax* args) {
+        assert(ker_);
+        ker_(args);
+    }
 
     jit_uni_softmax_kernel() : ker_(nullptr) {}
     virtual ~jit_uni_softmax_kernel() {}
@@ -54,7 +56,10 @@ template <cpu_isa_t isa>
 struct jit_uni_softmax_kernel_f32 : public jit_uni_softmax_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_softmax_kernel_f32)
 
-    jit_uni_softmax_kernel_f32(jit_softmax_config_params jcp) : jit_uni_softmax_kernel(), jit_generator(jit_name()), jcp_(jcp) {}
+    jit_uni_softmax_kernel_f32(jit_softmax_config_params jcp)
+        : jit_uni_softmax_kernel(),
+          jit_generator(jit_name()),
+          jcp_(jcp) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -62,14 +67,14 @@ struct jit_uni_softmax_kernel_f32 : public jit_uni_softmax_kernel, public jit_ge
     }
 
     void generate() override {
-        exp_injector.reset(new jit_uni_eltwise_injector_f32<isa>(this, dnnl::impl::alg_kind::eltwise_exp, 0.f, 0.f, 1.0f));
+        exp_injector.reset(
+            new jit_uni_eltwise_injector_f32<isa>(this, dnnl::impl::alg_kind::eltwise_exp, 0.f, 0.f, 1.0f));
 
         if (mayiuse(avx512_core))
             uni_vcvtneps2bf16.reset(new jit_uni_vcvtneps2bf16(this, isa));
 
         this->preamble();
 
-
         mov(reg_src, ptr[reg_params + GET_OFF(src)]);
         mov(reg_dst, ptr[reg_params + GET_OFF(dst)]);
         mov(reg_src_stride, ptr[reg_params + GET_OFF(src_stride)]);
@@ -86,7 +91,8 @@ struct jit_uni_softmax_kernel_f32 : public jit_uni_softmax_kernel, public jit_ge
         mov(aux_reg_work_amount, reg_work_amount);
         mov(aux_reg_src, reg_src);
         load_vector(vmm_max, ptr[aux_reg_src], jcp_.src_dt);
-        L(max_loop_label); {
+        L(max_loop_label);
+        {
             cmp(aux_reg_work_amount, 0);
             jle(max_loop_end_label, T_NEAR);
 
@@ -120,7 +126,8 @@ struct jit_uni_softmax_kernel_f32 : public jit_uni_softmax_kernel, public jit_ge
         mov(aux_reg_src, reg_src);
         mov(aux_reg_dst, reg_dst);
         uni_vpxor(vmm_exp_sum, vmm_exp_sum, vmm_exp_sum);
-        L(exp_loop_label); {
+        L(exp_loop_label);
+        {
             cmp(aux_reg_work_amount, 0);
             jle(exp_loop_end_label, T_NEAR);
 
@@ -143,7 +150,8 @@ struct jit_uni_softmax_kernel_f32 : public jit_uni_softmax_kernel, public jit_ge
 
         mov(aux_reg_work_amount, reg_work_amount);
         mov(aux_reg_dst, reg_dst);
-        L(div_loop_label); {
+        L(div_loop_label);
+        {
             cmp(aux_reg_work_amount, 0);
             jle(div_loop_end_label, T_NEAR);
 
@@ -196,38 +204,40 @@ struct jit_uni_softmax_kernel_f32 : public jit_uni_softmax_kernel, public jit_ge
 
     jit_softmax_config_params jcp_;
 
-    inline void load_vector(Vmm vmm_src, const Xbyak::Address &op, ov::element::Type src_dt) {
+    inline void load_vector(Vmm vmm_src, const Xbyak::Address& op, ov::element::Type src_dt) {
         switch (src_dt) {
-            case ov::element::f32:
-                uni_vmovups(vmm_src, op);
-                break;
-            case ov::element::bf16:
-                vpmovzxwd(vmm_src, op);
-                uni_vpslld(vmm_src, vmm_src, 16);
-                break;
-            default:
-                assert(!"unknown src_dt");
+        case ov::element::f32:
+            uni_vmovups(vmm_src, op);
+            break;
+        case ov::element::bf16:
+            vpmovzxwd(vmm_src, op);
+            uni_vpslld(vmm_src, vmm_src, 16);
+            break;
+        default:
+            assert(!"unknown src_dt");
         }
     }
-    inline void store_vector(const Xbyak::Address &op, Vmm vmm_dst, ov::element::Type dst_dt) {
+    inline void store_vector(const Xbyak::Address& op, Vmm vmm_dst, ov::element::Type dst_dt) {
         Xbyak::Ymm ymm_dst = Xbyak::Ymm(vmm_dst.getIdx());
 
         switch (dst_dt) {
-            case ov::element::f32:
-                uni_vmovups(op, vmm_dst);
-                break;
-            case ov::element::bf16:
-                uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())}, {static_cast<size_t>(ymm_dst.getIdx())});
-                vmovdqu16(op, ymm_dst);
-                break;
-            default:
-                assert(!"unknown dst_dt");
+        case ov::element::f32:
+            uni_vmovups(op, vmm_dst);
+            break;
+        case ov::element::bf16:
+            uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
+                                         {static_cast<size_t>(ymm_dst.getIdx())});
+            vmovdqu16(op, ymm_dst);
+            break;
+        default:
+            assert(!"unknown dst_dt");
         }
     }
 };
 #endif
 SoftmaxGeneric::SoftmaxGeneric(ov::element::Type inpPrc, ov::element::Type outPrc)
-    : input_prec(inpPrc), output_prec(outPrc) {
+    : input_prec(inpPrc),
+      output_prec(outPrc) {
     if (ov::element::bf16 == output_prec) {
         if (!mayiuse(avx512_core)) {
             OPENVINO_THROW("SoftmaxGeneric doesn't support BF16 precision on this target.");
@@ -255,27 +265,27 @@ SoftmaxGeneric::SoftmaxGeneric(ov::element::Type inpPrc, ov::element::Type outPr
 #endif
 }
 
-template<typename in_data_t, typename out_data_t>
-void SoftmaxGeneric::calculate(const in_data_t *src_data, out_data_t *dst_data, int B, int C, int H, int W) {
+template <typename in_data_t, typename out_data_t>
+void SoftmaxGeneric::calculate(const in_data_t* src_data, out_data_t* dst_data, int B, int C, int H, int W) {
     for (int b = 0; b < B; b++) {
         int tail_start = 0;
 
         if (softmax_kernel) {
-            int blocks_num = H*W / block_size;
+            int blocks_num = H * W / block_size;
 
             parallel_for(blocks_num, [&](int ib) {
                 auto arg = jit_args_softmax();
 
                 arg.src = src_data + b * C * H * W + ib * block_size;
                 arg.dst = dst_data + b * C * H * W + ib * block_size;
-                arg.src_stride = static_cast<size_t>((size_t)(H) * W * sizeof(in_data_t));
-                arg.dst_stride = static_cast<size_t>((size_t)(H) * W * sizeof(out_data_t));
+                arg.src_stride = static_cast<size_t>((size_t)(H)*W * sizeof(in_data_t));
+                arg.dst_stride = static_cast<size_t>((size_t)(H)*W * sizeof(out_data_t));
                 arg.work_amount = static_cast<size_t>(C);
 
                 (*softmax_kernel)(&arg);
             });
 
-            tail_start = (H*W / block_size) * block_size;
+            tail_start = (H * W / block_size) * block_size;
         }
 
         parallel_for(H * W - tail_start, [&](int i) {
@@ -283,7 +293,8 @@ void SoftmaxGeneric::calculate(const in_data_t *src_data, out_data_t *dst_data,
             float max = src_data[b * C * H * W + offset];
             for (int c = 0; c < C; c++) {
                 float val = src_data[b * C * H * W + c * H * W + offset];
-                if (val > max) max = val;
+                if (val > max)
+                    max = val;
             }
 
             float expSum = 0;
@@ -299,7 +310,7 @@ void SoftmaxGeneric::calculate(const in_data_t *src_data, out_data_t *dst_data,
     }
 }
 
-void SoftmaxGeneric::execute(const uint8_t *src_data, uint8_t *dst_data, int B, int C, int H, int W) {
+void SoftmaxGeneric::execute(const uint8_t* src_data, uint8_t* dst_data, int B, int C, int H, int W) {
     if (ov::element::f32 == input_prec) {
         auto float_src_data = reinterpret_cast<const float*>(src_data);
         if (ov::element::f32 == output_prec) {
@@ -327,5 +338,5 @@ void SoftmaxGeneric::execute(const uint8_t *src_data, uint8_t *dst_data, int B,
     }
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/softmax.h b/src/plugins/intel_cpu/src/nodes/common/softmax.h
index 2e3d5caa4becee..bb450c2ac5a303 100644
--- a/src/plugins/intel_cpu/src/nodes/common/softmax.h
+++ b/src/plugins/intel_cpu/src/nodes/common/softmax.h
@@ -4,27 +4,28 @@
 
 #pragma once
 
-#include <memory>
 #include <cmath>
-#include "openvino/core/type/element_type.hpp"
+#include <memory>
+
 #include "defs.h"
 #include "openvino/core/parallel.hpp"
+#include "openvino/core/type/element_type.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
 struct jit_uni_softmax_kernel;
 
-static inline
-void softmax_many_batches(const float *src_data, float *dst_data, int B, int C, int H, int W) {
+static inline void softmax_many_batches(const float* src_data, float* dst_data, int B, int C, int H, int W) {
     ov::parallel_for(B * H * W, [&](size_t i) {
-        const float *psrc = src_data + (i / (H * W)) * C * H * W - (i / (H * W)) * H * W;
-        float *pdst = dst_data + (i / (H * W)) * C * H * W - (i / (H * W)) * H * W;
+        const float* psrc = src_data + (i / (H * W)) * C * H * W - (i / (H * W)) * H * W;
+        float* pdst = dst_data + (i / (H * W)) * C * H * W - (i / (H * W)) * H * W;
 
         float max = psrc[i];
         for (int c = 0; c < C; c++) {
             float val = psrc[c * H * W + i];
-            if (val > max) max = val;
+            if (val > max)
+                max = val;
         }
 
         float expSum = 0;
@@ -43,9 +44,10 @@ class SoftmaxGeneric {
 public:
     SoftmaxGeneric(ov::element::Type inpPrc, ov::element::Type outPrc);
 
-    void execute(const uint8_t *src_data, uint8_t *dst_data, int B, int C, int H, int W);
+    void execute(const uint8_t* src_data, uint8_t* dst_data, int B, int C, int H, int W);
+
 private:
-    template<typename in_data_t, typename out_data_t>
+    template <typename in_data_t, typename out_data_t>
     void calculate(const in_data_t* src_data, out_data_t* dst_data, int B, int C, int H, int W);
 
 private:
@@ -54,5 +56,5 @@ class SoftmaxGeneric {
     std::shared_ptr<jit_uni_softmax_kernel> softmax_kernel;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/tile_broadcast_utils.cpp b/src/plugins/intel_cpu/src/nodes/common/tile_broadcast_utils.cpp
index 6c62304ab22da7..f482b0876b3f4c 100644
--- a/src/plugins/intel_cpu/src/nodes/common/tile_broadcast_utils.cpp
+++ b/src/plugins/intel_cpu/src/nodes/common/tile_broadcast_utils.cpp
@@ -4,18 +4,17 @@
 
 #include "tile_broadcast_utils.h"
 
+#include <memory_desc/cpu_memory_desc_utils.h>
+
 #include "cpu_convert.h"
 #include "cpu_memcpy.h"
-#include "openvino/core/parallel.hpp"
-#include <memory_desc/cpu_memory_desc_utils.h>
 #include "memory_desc/dnnl_blocked_memory_desc.h"
-
-
+#include "openvino/core/parallel.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
-VectorDims TileBroadcastCommon::calculateDenseStrides(const VectorDims &dims) {
+VectorDims TileBroadcastCommon::calculateDenseStrides(const VectorDims& dims) {
     VectorDims strides(dims.size(), 1);
 
     for (int i = strides.size() - 2; i >= 0; i--) {
@@ -25,8 +24,10 @@ VectorDims TileBroadcastCommon::calculateDenseStrides(const VectorDims &dims) {
     return strides;
 }
 
-void TileBroadcastCommon::fillOptimizedDimsAndSrcStrides(const VectorDims& srcBlockedDims, const VectorDims& blockedRepeats,
-        VectorDims& optimizedDims, VectorDims& optimizedSrcStrides) {
+void TileBroadcastCommon::fillOptimizedDimsAndSrcStrides(const VectorDims& srcBlockedDims,
+                                                         const VectorDims& blockedRepeats,
+                                                         VectorDims& optimizedDims,
+                                                         VectorDims& optimizedSrcStrides) {
     optimizedDims.clear();
     optimizedSrcStrides.clear();
     VectorDims srcBlockedStrides = calculateDenseStrides(srcBlockedDims);
@@ -60,10 +61,11 @@ void TileBroadcastCommon::fillOptimizedDimsAndSrcStrides(const VectorDims& srcBl
     }
 }
 
-bool TileBroadcastCommon::canBeExecutedInBlockedLayout(VectorDims srcBlockedDims, VectorDims blockedRepeats,
-        const size_t elemsInBlock) {
-    if (srcBlockedDims.empty() || blockedRepeats.empty() || elemsInBlock == 0lu || srcBlockedDims[1] == Shape::UNDEFINED_DIM ||
-            (blockedRepeats[1] != 1 && srcBlockedDims[1] % elemsInBlock != 0))
+bool TileBroadcastCommon::canBeExecutedInBlockedLayout(VectorDims srcBlockedDims,
+                                                       VectorDims blockedRepeats,
+                                                       const size_t elemsInBlock) {
+    if (srcBlockedDims.empty() || blockedRepeats.empty() || elemsInBlock == 0lu ||
+        srcBlockedDims[1] == Shape::UNDEFINED_DIM || (blockedRepeats[1] != 1 && srcBlockedDims[1] % elemsInBlock != 0))
         return false;
 
     srcBlockedDims[1] = div_up(srcBlockedDims[1], elemsInBlock);
@@ -90,7 +92,7 @@ bool TileBroadcastCommon::canBeExecutedInNSPCLayout(VectorDims srcBlockedDims, V
     return optimizedDims.size() <= maxNDims;
 }
 
-std::vector<NodeDesc> TileBroadcastCommon::getSupportedConfigs(const Node *node, size_t outSize) {
+std::vector<NodeDesc> TileBroadcastCommon::getSupportedConfigs(const Node* node, size_t outSize) {
     std::vector<NodeDesc> supportedPrimitiveDescriptors;
     auto precision = node->getOriginalInputPrecisionAtPort(0);
     auto dataType = DnnlExtensionUtils::ElementTypeToDataType(precision);
@@ -115,26 +117,31 @@ std::vector<NodeDesc> TileBroadcastCommon::getSupportedConfigs(const Node *node,
     config.inConfs[0].constant(constMap[0]);
     config.inConfs[1].inPlace(-1);
     config.inConfs[1].constant(constMap[1]);
-    config.inConfs[1].setMemDesc(std::make_shared<CpuBlockedMemoryDesc>(ov::element::i32, node->getInputShapeAtPort(1)));
+    config.inConfs[1].setMemDesc(
+        std::make_shared<CpuBlockedMemoryDesc>(ov::element::i32, node->getInputShapeAtPort(1)));
     if (config.inConfs.size() == 3) {
         config.inConfs[2].inPlace(-1);
         config.inConfs[2].constant(constMap[2]);
-        config.inConfs[2].setMemDesc(std::make_shared<CpuBlockedMemoryDesc>(ov::element::i32, node->getInputShapeAtPort(2)));
+        config.inConfs[2].setMemDesc(
+            std::make_shared<CpuBlockedMemoryDesc>(ov::element::i32, node->getInputShapeAtPort(2)));
     }
 
     config.outConfs.resize(outSize);
 
     auto pushDesc = [&](dnnl::memory::format_tag inFormat, dnnl::memory::format_tag outFormat) {
-        config.inConfs[0].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(node->getInputShapeAtPort(0), dataType, inFormat));
+        config.inConfs[0].setMemDesc(
+            std::make_shared<DnnlBlockedMemoryDesc>(node->getInputShapeAtPort(0), dataType, inFormat));
         for (size_t i = 0; i < config.outConfs.size(); i++) {
             config.outConfs[i].inPlace(-1);
             config.outConfs[i].constant(false);
-            config.outConfs[i].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(node->getOutputShapeAtPort(0), dataType, outFormat));
+            config.outConfs[i].setMemDesc(
+                std::make_shared<DnnlBlockedMemoryDesc>(node->getOutputShapeAtPort(0), dataType, outFormat));
         }
         supportedPrimitiveDescriptors.push_back({config, impl_desc_type::ref});
     };
 
-    if (!repeats.empty() && inDataShape.getRank() == outDataShapeRank && (outDataShapeRank == 4 || outDataShapeRank == 5)) {
+    if (!repeats.empty() && inDataShape.getRank() == outDataShapeRank &&
+        (outDataShapeRank == 4 || outDataShapeRank == 5)) {
         if (canBeExecutedInBlockedLayout(srcDims, repeats, 16)) {
             if (outDataShapeRank == 4) {
                 pushDesc(dnnl::memory::format_tag::nChw16c, dnnl::memory::format_tag::nChw16c);
@@ -165,7 +172,8 @@ std::vector<NodeDesc> TileBroadcastCommon::getSupportedConfigs(const Node *node,
         for (size_t i = 0; i < config.outConfs.size(); i++) {
             config.outConfs[i].inPlace(-1);
             config.outConfs[i].constant(false);
-            config.outConfs[i].setMemDesc(std::make_shared<CpuBlockedMemoryDesc>(precision, node->getOutputShapeAtPort(i)));
+            config.outConfs[i].setMemDesc(
+                std::make_shared<CpuBlockedMemoryDesc>(precision, node->getOutputShapeAtPort(i)));
         }
         supportedPrimitiveDescriptors.push_back({config, impl_desc_type::ref});
     } else {
@@ -175,7 +183,9 @@ std::vector<NodeDesc> TileBroadcastCommon::getSupportedConfigs(const Node *node,
     return supportedPrimitiveDescriptors;
 }
 
-bool TileBroadcastCommon::prepareOptimizedParams(const Node *node, VectorDims& srcBlockedDims, VectorDims& dstBlockedDims) {
+bool TileBroadcastCommon::prepareOptimizedParams(const Node* node,
+                                                 VectorDims& srcBlockedDims,
+                                                 VectorDims& dstBlockedDims) {
     while (srcBlockedDims.size() < dstBlockedDims.size()) {
         srcBlockedDims.insert(srcBlockedDims.begin(), 1);
     }
@@ -186,7 +196,8 @@ bool TileBroadcastCommon::prepareOptimizedParams(const Node *node, VectorDims& s
         blockedRepeats.push_back(1);
     }
     // for NSPC layouts
-    if (node->getBaseMemDescAtInputPort(0)->hasLayoutType(LayoutType::nspc) && one_of(node->getBaseMemDescAtInputPort(0)->getShape().getRank(), 4u, 5u)) {
+    if (node->getBaseMemDescAtInputPort(0)->hasLayoutType(LayoutType::nspc) &&
+        one_of(node->getBaseMemDescAtInputPort(0)->getShape().getRank(), 4u, 5u)) {
         blockedRepeats.push_back(blockedRepeats[1]);
         blockedRepeats.erase(blockedRepeats.begin() + 1);
     }
@@ -205,7 +216,8 @@ bool TileBroadcastCommon::prepareOptimizedParams(const Node *node, VectorDims& s
 
     VectorDims optimizedDstStrides = calculateDenseStrides(optimizedDims);
 
-    size_t dataSize = node->getSelectedPrimitiveDescriptor()->getConfig().inConfs[0].getMemDesc()->getPrecision().size();
+    size_t dataSize =
+        node->getSelectedPrimitiveDescriptor()->getConfig().inConfs[0].getMemDesc()->getPrecision().size();
     for (size_t i = 0; i < optimizedDims.size(); i++) {
         optimizedSrcStrides[i] *= dataSize;
         optimizedDstStrides[i] *= dataSize;
@@ -221,9 +233,9 @@ bool TileBroadcastCommon::prepareOptimizedParams(const Node *node, VectorDims& s
 
 // Broadcast 1 element to N continuous elements based on cpu_memcpy
 // Step 1: Get the binary format of the number N
-// Step 2: Use cpu_memcpy to form fragments containing pow(2, k) (ie. 2, 4, 8, ...) elements, based on the given 1 element
-// Step 3: Form N continuous elements, who's a combination of those fragments, demonstrated by its binary format
-void TileBroadcastCommon::broadcastScalar(const char *srcData, char *dstData, size_t elt_cnt, size_t data_size) {
+// Step 2: Use cpu_memcpy to form fragments containing pow(2, k) (ie. 2, 4, 8, ...) elements, based on the given 1
+// element Step 3: Form N continuous elements, who's a combination of those fragments, demonstrated by its binary format
+void TileBroadcastCommon::broadcastScalar(const char* srcData, char* dstData, size_t elt_cnt, size_t data_size) {
     std::vector<size_t> binary_digits;
 
     binary_digits.clear();
@@ -275,32 +287,44 @@ void TileBroadcastCommon::optimizedExecute(const MemoryPtr& srcMemory, const Mem
                 broadcastScalar(srcData, dstData, elt_cnt, data_size);
             }
         } else {
-            parallel_for5d(optimizedParams.dims[0], optimizedParams.dims[1], optimizedParams.dims[2], optimizedParams.dims[3], optimizedParams.dims[4],
-                    [&](int i0, int i1, int i2, int i3, int i4) {
-                auto srcData2 = srcData + (i0 * optimizedParams.srcStrides[0] + i1 * optimizedParams.srcStrides[1] +
-                        i2 * optimizedParams.srcStrides[2] + i3 * optimizedParams.srcStrides[3] +
-                        i4 * optimizedParams.srcStrides[4]);
-                auto dstData2 = dstData + (i0 * optimizedParams.dstStrides[0] + i1 * optimizedParams.dstStrides[1] +
-                        i2 * optimizedParams.dstStrides[2] + i3 * optimizedParams.dstStrides[3] +
-                        i4 * optimizedParams.dstStrides[4]);
-                for (size_t i = 0; i < optimizedParams.dims[5]; i++) {
-                    cpu_memcpy(dstData2 + i * optimizedParams.dstStrides[5], srcData2, optimizedParams.dstStrides[5]);
-                }
-            });
+            parallel_for5d(
+                optimizedParams.dims[0],
+                optimizedParams.dims[1],
+                optimizedParams.dims[2],
+                optimizedParams.dims[3],
+                optimizedParams.dims[4],
+                [&](int i0, int i1, int i2, int i3, int i4) {
+                    auto srcData2 = srcData + (i0 * optimizedParams.srcStrides[0] + i1 * optimizedParams.srcStrides[1] +
+                                               i2 * optimizedParams.srcStrides[2] + i3 * optimizedParams.srcStrides[3] +
+                                               i4 * optimizedParams.srcStrides[4]);
+                    auto dstData2 = dstData + (i0 * optimizedParams.dstStrides[0] + i1 * optimizedParams.dstStrides[1] +
+                                               i2 * optimizedParams.dstStrides[2] + i3 * optimizedParams.dstStrides[3] +
+                                               i4 * optimizedParams.dstStrides[4]);
+                    for (size_t i = 0; i < optimizedParams.dims[5]; i++) {
+                        cpu_memcpy(dstData2 + i * optimizedParams.dstStrides[5],
+                                   srcData2,
+                                   optimizedParams.dstStrides[5]);
+                    }
+                });
         }
     } else {
-        parallel_for5d(optimizedParams.dims[0], optimizedParams.dims[1], optimizedParams.dims[2], optimizedParams.dims[3], optimizedParams.dims[4],
-                [&](int i0, int i1, int i2, int i3, int i4) {
-            auto srcData2 = srcData + (i0 * optimizedParams.srcStrides[0] + i1 * optimizedParams.srcStrides[1] +
-                                                 i2 * optimizedParams.srcStrides[2] + i3 * optimizedParams.srcStrides[3] +
-                                                 i4 * optimizedParams.srcStrides[4]);
-            auto dstData2 = dstData + (i0 * optimizedParams.dstStrides[0] + i1 * optimizedParams.dstStrides[1] +
+        parallel_for5d(
+            optimizedParams.dims[0],
+            optimizedParams.dims[1],
+            optimizedParams.dims[2],
+            optimizedParams.dims[3],
+            optimizedParams.dims[4],
+            [&](int i0, int i1, int i2, int i3, int i4) {
+                auto srcData2 = srcData + (i0 * optimizedParams.srcStrides[0] + i1 * optimizedParams.srcStrides[1] +
+                                           i2 * optimizedParams.srcStrides[2] + i3 * optimizedParams.srcStrides[3] +
+                                           i4 * optimizedParams.srcStrides[4]);
+                auto dstData2 = dstData + (i0 * optimizedParams.dstStrides[0] + i1 * optimizedParams.dstStrides[1] +
                                            i2 * optimizedParams.dstStrides[2] + i3 * optimizedParams.dstStrides[3] +
                                            i4 * optimizedParams.dstStrides[4]);
-            cpu_memcpy(dstData2, srcData2, optimizedParams.copySize);
-        });
+                cpu_memcpy(dstData2, srcData2, optimizedParams.copySize);
+            });
     }
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/tile_broadcast_utils.h b/src/plugins/intel_cpu/src/nodes/common/tile_broadcast_utils.h
index 7ae0eacbccd373..6638eba7f88a39 100644
--- a/src/plugins/intel_cpu/src/nodes/common/tile_broadcast_utils.h
+++ b/src/plugins/intel_cpu/src/nodes/common/tile_broadcast_utils.h
@@ -9,27 +9,28 @@
 #include <memory>
 #include <vector>
 
-
 namespace ov {
 namespace intel_cpu {
 
 class TileBroadcastCommon {
 protected:
-    static VectorDims calculateDenseStrides(const VectorDims &dims);
-    std::vector<NodeDesc> getSupportedConfigs(const Node *node, size_t outSize);
-    bool prepareOptimizedParams(const Node *node, VectorDims& srcBlockedDims, VectorDims& dstBlockedDims);
+    static VectorDims calculateDenseStrides(const VectorDims& dims);
+    std::vector<NodeDesc> getSupportedConfigs(const Node* node, size_t outSize);
+    bool prepareOptimizedParams(const Node* node, VectorDims& srcBlockedDims, VectorDims& dstBlockedDims);
 
     void optimizedExecute(const MemoryPtr& srcMemory, const MemoryPtr& dstMemory);
 
     VectorDims repeats;
     bool optimizedCase = false;
-    bool constMap[3] = { false };
+    bool constMap[3] = {false};
     mutable bool needPrepareParamsVar = false;
 
 private:
-    static void fillOptimizedDimsAndSrcStrides(const VectorDims &srcBlockedDims, const VectorDims &blockedRepeats,
-            VectorDims &optimizedDims, VectorDims &optimizedSrcStrides);
-    static void broadcastScalar(const char *srcData, char *dstData, size_t elt_cnt, size_t data_size);
+    static void fillOptimizedDimsAndSrcStrides(const VectorDims& srcBlockedDims,
+                                               const VectorDims& blockedRepeats,
+                                               VectorDims& optimizedDims,
+                                               VectorDims& optimizedSrcStrides);
+    static void broadcastScalar(const char* srcData, char* dstData, size_t elt_cnt, size_t data_size);
 
     static bool canBeExecutedInBlockedLayout(VectorDims srcDims, VectorDims repeats, const size_t elemsInBlock);
     static bool canBeExecutedInNSPCLayout(VectorDims srcDims, VectorDims repeats);
@@ -42,5 +43,5 @@ class TileBroadcastCommon {
     } optimizedParams;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/common/uni_simd.h b/src/plugins/intel_cpu/src/nodes/common/uni_simd.h
index 7f2cdc7bed4821..dbcec60baa7d4c 100644
--- a/src/plugins/intel_cpu/src/nodes/common/uni_simd.h
+++ b/src/plugins/intel_cpu/src/nodes/common/uni_simd.h
@@ -5,7 +5,7 @@
 #pragma once
 
 #if defined(HAVE_SSE) || defined(HAVE_AVX2) || defined(HAVE_AVX512F)
-#include <immintrin.h>
+#    include <immintrin.h>
 #endif
 
 namespace ov {
@@ -14,348 +14,350 @@ namespace Cpu {
 
 #if defined(HAVE_AVX512F)
 namespace AVX512F {
-    static inline __m512 _mm_uni_any_ps() {
-        return __m512{};
-    }
-
-    static inline __m512i _mm_uni_any_epi32() {
-        return __m512i{};
-    }
-
-    static inline __m512 _mm_uni_loadu_ps(const float* psrc) {
-        return _mm512_mask_loadu_ps(_mm_uni_any_ps(), (__mmask16)-1, psrc);
-    }
-
-    static inline void _mm_uni_storeu_ps(float* pdst, const __m512& vec) {
-        _mm512_storeu_ps(pdst, vec);
-    }
-
-    static inline void _mm_uni_storeu_si(void* pdst, const __m512i vec) {
-        _mm512_storeu_si512(pdst, vec);
-    }
-
-    static inline __m512 _mm_uni_setzero_ps() {
-        return _mm512_setzero_ps();
-    }
-
-    static inline __m512 _mm_uni_set1_ps(float value) {
-        return _mm512_set1_ps(value);
-    }
-
-    static inline __m512 _mm_uni_add_ps(__m512 vec0, __m512 vec1) {
-        return _mm512_add_ps(vec0, vec1);
-    }
-
-    static inline __m512 _mm_uni_sub_ps(__m512 vec0, __m512 vec1) {
-        return _mm512_sub_ps(vec0, vec1);
-    }
-
-    static inline __m512 _mm_uni_mul_ps(__m512 vec0, __m512 vec1) {
-        return _mm512_mul_ps(vec0, vec1);
-    }
-
-    static inline __m512 _mm_uni_div_ps(__m512 vec0, __m512 vec1) {
-        return _mm512_div_ps(vec0, vec1);
-    }
-
-    static inline __m512 _mm_uni_sqrt_ps(__m512 vec) {
-        return _mm512_sqrt_ps(vec);
-    }
-
-    static inline __m512 _mm_uni_and_ps(__m512 vec0, __m512 vec1) {
-        return _mm512_castsi512_ps(_mm512_and_epi32(_mm512_castps_si512(vec0), _mm512_castps_si512(vec1)));
-    }
-
-    static inline __m512 _mm_uni_or_ps(__m512 vec0, __m512 vec1) {
-        return _mm512_castsi512_ps(_mm512_or_epi32(_mm512_castps_si512(vec0), _mm512_castps_si512(vec1)));
-    }
-
-    static inline __m512i _mm_uni_set1_epi32(int value) {
-        return _mm512_mask_set1_epi32(_mm_uni_any_epi32(), (__mmask16)-1, value);
-    }
-
-    static inline __m512 _mm_uni_blendv_ps(__m512 vec0, __m512 vec1, __m512 vmask) {
-        return _mm512_mask_blend_ps(_mm512_cmpneq_epi32_mask(_mm512_castps_si512(vmask), _mm_uni_set1_epi32(0)), vec0, vec1);
-    }
-
-    static inline __m512 _mm_uni_blendv_ps(__m512 vec0, __m512 vec1, __mmask16 vmask) {
-        return _mm512_mask_blend_ps(vmask, vec0, vec1);
-    }
-
-    static inline __m512 _mm_uni_min_ps(__m512 vec0, __m512 vec1) {
-        return _mm512_min_ps(vec0, vec1);
-    }
-
-    static inline __m512 _mm_uni_max_ps(__m512 vec0, __m512 vec1) {
-        return _mm512_max_ps(vec0, vec1);
-    }
-
-    static inline __m512 _mm_uni_floor_ps(__m512 vec) {
-        return _mm512_floor_ps(vec);
-    }
-
-    static inline __m512i _mm_uni_cvtps_epi32(__m512 vec) {
-        return _mm512_cvtps_epi32(vec);
-    }
-
-    static inline __m512i _mm_uni_add_epi32(__m512i vec0, __m512i vec1) {
-        return _mm512_add_epi32(vec0, vec1);
-    }
-
-    static inline __m512i _mm_uni_slli_epi32(__m512i vec, int value) {
-        return _mm512_sll_epi32(vec, _mm_set1_epi64x(value));
-    }
-
-    static inline __m512 _mm_uni_castsi_ps(__m512i vec) {
-        return _mm512_castsi512_ps(vec);
-    }
-
-    static inline __m512i _mm_uni_setzero_si() {
-        return _mm512_setzero_si512();
-    }
-
-    static inline __mmask16 _mm_uni_cmpgt_ps(__m512 vec0, __m512 vec1) {
-        return _mm512_cmp_ps_mask(vec0, vec1, 14);
-    }
-
-    static inline __mmask16 _mm_uni_cmpgt_i32(__m512i vec0, __m512i vec1) {
-        return _mm512_cmp_epi32_mask(vec1, vec0, 1);
-    }
-
-    static inline __m512i _mm_uni_castps_si(__m512 vec) {
-        return _mm512_castps_si512(vec);
-    }
-
-    static inline __m512 _mm_uni_cvtepi32_ps(__m512i vec) {
-        return _mm512_mask_cvtepi32_ps(_mm_uni_any_ps(), (__mmask16)-1, vec);
-    }
+static inline __m512 _mm_uni_any_ps() {
+    return __m512{};
+}
+
+static inline __m512i _mm_uni_any_epi32() {
+    return __m512i{};
+}
+
+static inline __m512 _mm_uni_loadu_ps(const float* psrc) {
+    return _mm512_mask_loadu_ps(_mm_uni_any_ps(), (__mmask16)-1, psrc);
+}
+
+static inline void _mm_uni_storeu_ps(float* pdst, const __m512& vec) {
+    _mm512_storeu_ps(pdst, vec);
+}
+
+static inline void _mm_uni_storeu_si(void* pdst, const __m512i vec) {
+    _mm512_storeu_si512(pdst, vec);
+}
+
+static inline __m512 _mm_uni_setzero_ps() {
+    return _mm512_setzero_ps();
+}
+
+static inline __m512 _mm_uni_set1_ps(float value) {
+    return _mm512_set1_ps(value);
+}
+
+static inline __m512 _mm_uni_add_ps(__m512 vec0, __m512 vec1) {
+    return _mm512_add_ps(vec0, vec1);
+}
+
+static inline __m512 _mm_uni_sub_ps(__m512 vec0, __m512 vec1) {
+    return _mm512_sub_ps(vec0, vec1);
+}
+
+static inline __m512 _mm_uni_mul_ps(__m512 vec0, __m512 vec1) {
+    return _mm512_mul_ps(vec0, vec1);
+}
+
+static inline __m512 _mm_uni_div_ps(__m512 vec0, __m512 vec1) {
+    return _mm512_div_ps(vec0, vec1);
+}
+
+static inline __m512 _mm_uni_sqrt_ps(__m512 vec) {
+    return _mm512_sqrt_ps(vec);
+}
+
+static inline __m512 _mm_uni_and_ps(__m512 vec0, __m512 vec1) {
+    return _mm512_castsi512_ps(_mm512_and_epi32(_mm512_castps_si512(vec0), _mm512_castps_si512(vec1)));
+}
+
+static inline __m512 _mm_uni_or_ps(__m512 vec0, __m512 vec1) {
+    return _mm512_castsi512_ps(_mm512_or_epi32(_mm512_castps_si512(vec0), _mm512_castps_si512(vec1)));
+}
+
+static inline __m512i _mm_uni_set1_epi32(int value) {
+    return _mm512_mask_set1_epi32(_mm_uni_any_epi32(), (__mmask16)-1, value);
+}
+
+static inline __m512 _mm_uni_blendv_ps(__m512 vec0, __m512 vec1, __m512 vmask) {
+    return _mm512_mask_blend_ps(_mm512_cmpneq_epi32_mask(_mm512_castps_si512(vmask), _mm_uni_set1_epi32(0)),
+                                vec0,
+                                vec1);
+}
+
+static inline __m512 _mm_uni_blendv_ps(__m512 vec0, __m512 vec1, __mmask16 vmask) {
+    return _mm512_mask_blend_ps(vmask, vec0, vec1);
+}
+
+static inline __m512 _mm_uni_min_ps(__m512 vec0, __m512 vec1) {
+    return _mm512_min_ps(vec0, vec1);
+}
+
+static inline __m512 _mm_uni_max_ps(__m512 vec0, __m512 vec1) {
+    return _mm512_max_ps(vec0, vec1);
+}
+
+static inline __m512 _mm_uni_floor_ps(__m512 vec) {
+    return _mm512_floor_ps(vec);
+}
+
+static inline __m512i _mm_uni_cvtps_epi32(__m512 vec) {
+    return _mm512_cvtps_epi32(vec);
+}
+
+static inline __m512i _mm_uni_add_epi32(__m512i vec0, __m512i vec1) {
+    return _mm512_add_epi32(vec0, vec1);
+}
+
+static inline __m512i _mm_uni_slli_epi32(__m512i vec, int value) {
+    return _mm512_sll_epi32(vec, _mm_set1_epi64x(value));
+}
+
+static inline __m512 _mm_uni_castsi_ps(__m512i vec) {
+    return _mm512_castsi512_ps(vec);
+}
+
+static inline __m512i _mm_uni_setzero_si() {
+    return _mm512_setzero_si512();
+}
+
+static inline __mmask16 _mm_uni_cmpgt_ps(__m512 vec0, __m512 vec1) {
+    return _mm512_cmp_ps_mask(vec0, vec1, 14);
+}
+
+static inline __mmask16 _mm_uni_cmpgt_i32(__m512i vec0, __m512i vec1) {
+    return _mm512_cmp_epi32_mask(vec1, vec0, 1);
+}
+
+static inline __m512i _mm_uni_castps_si(__m512 vec) {
+    return _mm512_castps_si512(vec);
+}
+
+static inline __m512 _mm_uni_cvtepi32_ps(__m512i vec) {
+    return _mm512_mask_cvtepi32_ps(_mm_uni_any_ps(), (__mmask16)-1, vec);
+}
 }  // namespace AVX512F
 #elif defined(HAVE_AVX2)
 namespace AVX2 {
-    static inline __m256 _mm_uni_loadu_ps(const float* psrc) {
-        return _mm256_loadu_ps(psrc);
-    }
+static inline __m256 _mm_uni_loadu_ps(const float* psrc) {
+    return _mm256_loadu_ps(psrc);
+}
 
-    static inline void _mm_uni_storeu_ps(float* pdst, const __m256 vec) {
-        _mm256_storeu_ps(pdst, vec);
-    }
+static inline void _mm_uni_storeu_ps(float* pdst, const __m256 vec) {
+    _mm256_storeu_ps(pdst, vec);
+}
 
-    static inline void _mm_uni_storeu_si(__m256i* pdst, const __m256i vec) {
-        _mm256_storeu_si256(pdst, vec);
-    }
+static inline void _mm_uni_storeu_si(__m256i* pdst, const __m256i vec) {
+    _mm256_storeu_si256(pdst, vec);
+}
 
-    static inline __m256 _mm_uni_setzero_ps() {
-        return _mm256_setzero_ps();
-    }
+static inline __m256 _mm_uni_setzero_ps() {
+    return _mm256_setzero_ps();
+}
 
-    static inline __m256 _mm_uni_set1_ps(float value) {
-        return _mm256_set1_ps(value);
-    }
+static inline __m256 _mm_uni_set1_ps(float value) {
+    return _mm256_set1_ps(value);
+}
 
-    static inline __m256 _mm_uni_add_ps(__m256 vec0, __m256 vec1) {
-        return _mm256_add_ps(vec0, vec1);
-    }
+static inline __m256 _mm_uni_add_ps(__m256 vec0, __m256 vec1) {
+    return _mm256_add_ps(vec0, vec1);
+}
 
-    static inline __m256 _mm_uni_sub_ps(__m256 vec0, __m256 vec1) {
-        return _mm256_sub_ps(vec0, vec1);
-    }
+static inline __m256 _mm_uni_sub_ps(__m256 vec0, __m256 vec1) {
+    return _mm256_sub_ps(vec0, vec1);
+}
 
-    static inline __m256 _mm_uni_mul_ps(__m256 vec0, __m256 vec1) {
-        return _mm256_mul_ps(vec0, vec1);
-    }
+static inline __m256 _mm_uni_mul_ps(__m256 vec0, __m256 vec1) {
+    return _mm256_mul_ps(vec0, vec1);
+}
 
-    static inline __m256 _mm_uni_div_ps(__m256 vec0, __m256 vec1) {
-        return _mm256_div_ps(vec0, vec1);
-    }
+static inline __m256 _mm_uni_div_ps(__m256 vec0, __m256 vec1) {
+    return _mm256_div_ps(vec0, vec1);
+}
 
-    static inline __m256 _mm_uni_sqrt_ps(__m256 vec) {
-        return _mm256_sqrt_ps(vec);
-    }
+static inline __m256 _mm_uni_sqrt_ps(__m256 vec) {
+    return _mm256_sqrt_ps(vec);
+}
 
-    static inline __m256 _mm_uni_and_ps(__m256 vec0, __m256 vec1) {
-        return _mm256_and_ps(vec0, vec1);
-    }
+static inline __m256 _mm_uni_and_ps(__m256 vec0, __m256 vec1) {
+    return _mm256_and_ps(vec0, vec1);
+}
 
-    static inline __m256 _mm_uni_or_ps(__m256 vec0, __m256 vec1) {
-        return _mm256_or_ps(vec0, vec1);
-    }
+static inline __m256 _mm_uni_or_ps(__m256 vec0, __m256 vec1) {
+    return _mm256_or_ps(vec0, vec1);
+}
 
-    static inline __m256 _mm_uni_blendv_ps(__m256 vec0, __m256 vec1, __m256 vmask) {
-        return _mm256_blendv_ps(vec0, vec1, vmask);
-    }
+static inline __m256 _mm_uni_blendv_ps(__m256 vec0, __m256 vec1, __m256 vmask) {
+    return _mm256_blendv_ps(vec0, vec1, vmask);
+}
 
-    static inline __m256 _mm_uni_min_ps(__m256 vec0, __m256 vec1) {
-        return _mm256_min_ps(vec0, vec1);
-    }
+static inline __m256 _mm_uni_min_ps(__m256 vec0, __m256 vec1) {
+    return _mm256_min_ps(vec0, vec1);
+}
 
-    static inline __m256 _mm_uni_max_ps(__m256 vec0, __m256 vec1) {
-        return _mm256_max_ps(vec0, vec1);
-    }
+static inline __m256 _mm_uni_max_ps(__m256 vec0, __m256 vec1) {
+    return _mm256_max_ps(vec0, vec1);
+}
 
-    static inline __m256 _mm_uni_floor_ps(__m256 vec) {
-        return _mm256_floor_ps(vec);
-    }
+static inline __m256 _mm_uni_floor_ps(__m256 vec) {
+    return _mm256_floor_ps(vec);
+}
 
-    static inline __m256i _mm_uni_cvtps_epi32(__m256 vec) {
-        return _mm256_cvtps_epi32(vec);
-    }
+static inline __m256i _mm_uni_cvtps_epi32(__m256 vec) {
+    return _mm256_cvtps_epi32(vec);
+}
 
-    static inline __m256i _mm_uni_add_epi32(__m256i vec0, __m256i vec1) {
-        return _mm256_add_epi32(vec0, vec1);
-    }
+static inline __m256i _mm_uni_add_epi32(__m256i vec0, __m256i vec1) {
+    return _mm256_add_epi32(vec0, vec1);
+}
 
-    static inline __m256i _mm_uni_set1_epi32(int value) {
-        return _mm256_set1_epi32(value);
-    }
+static inline __m256i _mm_uni_set1_epi32(int value) {
+    return _mm256_set1_epi32(value);
+}
 
-    static inline __m256i _mm_uni_slli_epi32(__m256i vec, int value) {
-        return _mm256_slli_epi32(vec, value);
-    }
+static inline __m256i _mm_uni_slli_epi32(__m256i vec, int value) {
+    return _mm256_slli_epi32(vec, value);
+}
 
-    static inline __m256 _mm_uni_castsi_ps(__m256i vec) {
-        return _mm256_castsi256_ps(vec);
-    }
+static inline __m256 _mm_uni_castsi_ps(__m256i vec) {
+    return _mm256_castsi256_ps(vec);
+}
 
-    static inline __m256i _mm_uni_setzero_si() {
-        return _mm256_setzero_si256();
-    }
+static inline __m256i _mm_uni_setzero_si() {
+    return _mm256_setzero_si256();
+}
 
-    static inline __m256 _mm_uni_cmpgt_ps(__m256 vec0, __m256 vec1) {
-        return _mm256_cmp_ps(vec0, vec1, 14);
-    }
+static inline __m256 _mm_uni_cmpgt_ps(__m256 vec0, __m256 vec1) {
+    return _mm256_cmp_ps(vec0, vec1, 14);
+}
 
-    static inline __m256 _mm_uni_cmpgt_i32(__m256i vec0, __m256i vec1) {
-        return _mm256_cvtepi32_ps(_mm256_cmpgt_epi32(vec0, vec1));
-    }
+static inline __m256 _mm_uni_cmpgt_i32(__m256i vec0, __m256i vec1) {
+    return _mm256_cvtepi32_ps(_mm256_cmpgt_epi32(vec0, vec1));
+}
 
-    static inline __m256i _mm_uni_blendv_epi8(__m256i vec0, __m256i vec1, __m256i vmask) {
-        return _mm256_blendv_epi8(vec0, vec1, vmask);
-    }
+static inline __m256i _mm_uni_blendv_epi8(__m256i vec0, __m256i vec1, __m256i vmask) {
+    return _mm256_blendv_epi8(vec0, vec1, vmask);
+}
 
-    static inline __m256i _mm_uni_castps_si(__m256 vec) {
-        return _mm256_castps_si256(vec);
-    }
+static inline __m256i _mm_uni_castps_si(__m256 vec) {
+    return _mm256_castps_si256(vec);
+}
 
-    static inline __m256 _mm_uni_cvtepi32_ps(__m256i vec) {
-        return _mm256_cvtepi32_ps(vec);
-    }
+static inline __m256 _mm_uni_cvtepi32_ps(__m256i vec) {
+    return _mm256_cvtepi32_ps(vec);
+}
 
-    static inline int _mm_uni_movemask_ps(__m256 vec) {
-        return _mm256_movemask_ps(vec);
-    }
+static inline int _mm_uni_movemask_ps(__m256 vec) {
+    return _mm256_movemask_ps(vec);
+}
 }  // namespace AVX2
 #elif defined(HAVE_SSE42)
 namespace SSE42 {
-    static inline __m128 _mm_uni_loadu_ps(const float* psrc) {
-        return _mm_loadu_ps(psrc);
-    }
+static inline __m128 _mm_uni_loadu_ps(const float* psrc) {
+    return _mm_loadu_ps(psrc);
+}
 
-    static inline void _mm_uni_storeu_ps(float* pdst, const __m128 vec) {
-        _mm_storeu_ps(pdst, vec);
-    }
-
-    static inline void _mm_uni_storeu_si(__m128i* pdst, const __m128i vec) {
-        _mm_storeu_si128(pdst, vec);
-    }
-
-    static inline __m128 _mm_uni_setzero_ps() {
-        return _mm_setzero_ps();
-    }
-
-    static inline __m128 _mm_uni_set1_ps(float value) {
-        return _mm_set1_ps(value);
-    }
-
-    static inline __m128 _mm_uni_add_ps(__m128 vec0, __m128 vec1) {
-        return _mm_add_ps(vec0, vec1);
-    }
-
-    static inline __m128 _mm_uni_sub_ps(__m128 vec0, __m128 vec1) {
-        return _mm_sub_ps(vec0, vec1);
-    }
-
-    static inline __m128 _mm_uni_mul_ps(__m128 vec0, __m128 vec1) {
-        return _mm_mul_ps(vec0, vec1);
-    }
-
-    static inline __m128 _mm_uni_div_ps(__m128 vec0, __m128 vec1) {
-        return _mm_div_ps(vec0, vec1);
-    }
-
-    static inline __m128 _mm_uni_sqrt_ps(__m128 vec) {
-        return _mm_sqrt_ps(vec);
-    }
-
-    static inline __m128 _mm_uni_and_ps(__m128 vec0, __m128 vec1) {
-        return _mm_and_ps(vec0, vec1);
-    }
-
-    static inline __m128 _mm_uni_or_ps(__m128 vec0, __m128 vec1) {
-        return _mm_or_ps(vec0, vec1);
-    }
-
-    static inline __m128 _mm_uni_blendv_ps(__m128 vec0, __m128 vec1, __m128 vmask) {
-        return _mm_blendv_ps(vec0, vec1, vmask);
-    }
-
-    static inline __m128 _mm_uni_min_ps(__m128 vec0, __m128 vec1) {
-        return _mm_min_ps(vec0, vec1);
-    }
-
-    static inline __m128 _mm_uni_max_ps(__m128 vec0, __m128 vec1) {
-        return _mm_max_ps(vec0, vec1);
-    }
-
-    static inline __m128 _mm_uni_floor_ps(__m128 vec) {
-        return _mm_floor_ps(vec);
-    }
-
-    static inline __m128i _mm_uni_cvtps_epi32(__m128 vec) {
-        return _mm_cvtps_epi32(vec);
-    }
-
-    static inline __m128i _mm_uni_add_epi32(__m128i vec0, __m128i vec1) {
-        return _mm_add_epi32(vec0, vec1);
-    }
-
-    static inline __m128i _mm_uni_set1_epi32(int value) {
-        return _mm_set1_epi32(value);
-    }
-
-    static inline __m128i _mm_uni_slli_epi32(__m128i vec, int value) {
-        return _mm_slli_epi32(vec, value);
-    }
-
-    static inline __m128 _mm_uni_castsi_ps(__m128i vec) {
-        return _mm_castsi128_ps(vec);
-    }
-
-    static inline __m128i _mm_uni_setzero_si() {
-        return _mm_setzero_si128();
-    }
-
-    static inline __m128 _mm_uni_cmpgt_ps(__m128 vec0, __m128 vec1) {
-        return _mm_cmpgt_ps(vec0, vec1);
-    }
-
-    static inline __m128 _mm_uni_cmpgt_i32(__m128i vec0, __m128i vec1) {
-        return _mm_cvtepi32_ps(_mm_cmpgt_epi32(vec0, vec1));
-    }
-
-    static inline __m128i _mm_uni_blendv_epi8(__m128i vec0, __m128i vec1, __m128i vmask) {
-        return _mm_blendv_epi8(vec0, vec1, vmask);
-    }
-
-    static inline __m128i _mm_uni_castps_si(__m128 vec) {
-        return _mm_castps_si128(vec);
-    }
+static inline void _mm_uni_storeu_ps(float* pdst, const __m128 vec) {
+    _mm_storeu_ps(pdst, vec);
+}
+
+static inline void _mm_uni_storeu_si(__m128i* pdst, const __m128i vec) {
+    _mm_storeu_si128(pdst, vec);
+}
+
+static inline __m128 _mm_uni_setzero_ps() {
+    return _mm_setzero_ps();
+}
+
+static inline __m128 _mm_uni_set1_ps(float value) {
+    return _mm_set1_ps(value);
+}
+
+static inline __m128 _mm_uni_add_ps(__m128 vec0, __m128 vec1) {
+    return _mm_add_ps(vec0, vec1);
+}
+
+static inline __m128 _mm_uni_sub_ps(__m128 vec0, __m128 vec1) {
+    return _mm_sub_ps(vec0, vec1);
+}
+
+static inline __m128 _mm_uni_mul_ps(__m128 vec0, __m128 vec1) {
+    return _mm_mul_ps(vec0, vec1);
+}
+
+static inline __m128 _mm_uni_div_ps(__m128 vec0, __m128 vec1) {
+    return _mm_div_ps(vec0, vec1);
+}
+
+static inline __m128 _mm_uni_sqrt_ps(__m128 vec) {
+    return _mm_sqrt_ps(vec);
+}
+
+static inline __m128 _mm_uni_and_ps(__m128 vec0, __m128 vec1) {
+    return _mm_and_ps(vec0, vec1);
+}
+
+static inline __m128 _mm_uni_or_ps(__m128 vec0, __m128 vec1) {
+    return _mm_or_ps(vec0, vec1);
+}
+
+static inline __m128 _mm_uni_blendv_ps(__m128 vec0, __m128 vec1, __m128 vmask) {
+    return _mm_blendv_ps(vec0, vec1, vmask);
+}
+
+static inline __m128 _mm_uni_min_ps(__m128 vec0, __m128 vec1) {
+    return _mm_min_ps(vec0, vec1);
+}
+
+static inline __m128 _mm_uni_max_ps(__m128 vec0, __m128 vec1) {
+    return _mm_max_ps(vec0, vec1);
+}
+
+static inline __m128 _mm_uni_floor_ps(__m128 vec) {
+    return _mm_floor_ps(vec);
+}
+
+static inline __m128i _mm_uni_cvtps_epi32(__m128 vec) {
+    return _mm_cvtps_epi32(vec);
+}
+
+static inline __m128i _mm_uni_add_epi32(__m128i vec0, __m128i vec1) {
+    return _mm_add_epi32(vec0, vec1);
+}
+
+static inline __m128i _mm_uni_set1_epi32(int value) {
+    return _mm_set1_epi32(value);
+}
+
+static inline __m128i _mm_uni_slli_epi32(__m128i vec, int value) {
+    return _mm_slli_epi32(vec, value);
+}
+
+static inline __m128 _mm_uni_castsi_ps(__m128i vec) {
+    return _mm_castsi128_ps(vec);
+}
+
+static inline __m128i _mm_uni_setzero_si() {
+    return _mm_setzero_si128();
+}
+
+static inline __m128 _mm_uni_cmpgt_ps(__m128 vec0, __m128 vec1) {
+    return _mm_cmpgt_ps(vec0, vec1);
+}
+
+static inline __m128 _mm_uni_cmpgt_i32(__m128i vec0, __m128i vec1) {
+    return _mm_cvtepi32_ps(_mm_cmpgt_epi32(vec0, vec1));
+}
+
+static inline __m128i _mm_uni_blendv_epi8(__m128i vec0, __m128i vec1, __m128i vmask) {
+    return _mm_blendv_epi8(vec0, vec1, vmask);
+}
+
+static inline __m128i _mm_uni_castps_si(__m128 vec) {
+    return _mm_castps_si128(vec);
+}
 
-    static inline __m128 _mm_uni_cvtepi32_ps(__m128i vec) {
-        return _mm_cvtepi32_ps(vec);
-    }
-    static inline int _mm_uni_movemask_ps(__m128 vec) {
-        return _mm_movemask_ps(vec);
-    }
+static inline __m128 _mm_uni_cvtepi32_ps(__m128i vec) {
+    return _mm_cvtepi32_ps(vec);
+}
+static inline int _mm_uni_movemask_ps(__m128 vec) {
+    return _mm_movemask_ps(vec);
+}
 }  // namespace SSE42
 #endif
 
diff --git a/src/plugins/intel_cpu/src/nodes/composite.cpp b/src/plugins/intel_cpu/src/nodes/composite.cpp
index a1ceabd6942db1..616d3df6950e9a 100644
--- a/src/plugins/intel_cpu/src/nodes/composite.cpp
+++ b/src/plugins/intel_cpu/src/nodes/composite.cpp
@@ -4,11 +4,11 @@
 
 #include "composite.h"
 
-#include "nodes/input.h"
 #include "cpu_memory.h"
+#include "nodes/input.h"
+#include "shape_inference/shape_inference_internal_dyn.hpp"
 #include "transformations/cpu_opset/common/op/submodel.hpp"
 #include "utils/debug_capabilities.h"
-#include "shape_inference/shape_inference_internal_dyn.hpp"
 
 namespace ov {
 namespace intel_cpu {
diff --git a/src/plugins/intel_cpu/src/nodes/concat.cpp b/src/plugins/intel_cpu/src/nodes/concat.cpp
index 635f37b2d05b3a..ef621947d723a7 100644
--- a/src/plugins/intel_cpu/src/nodes/concat.cpp
+++ b/src/plugins/intel_cpu/src/nodes/concat.cpp
@@ -4,29 +4,29 @@
 
 #include "concat.h"
 
-#include "openvino/op/concat.hpp"
+#include <cpu_memory.h>
+#include <edge.h>
+#include <memory_desc/cpu_memory_desc_utils.h>
+#include <onednn/iml_type_mapper.h>
+#include <partitioned_mem_blk.h>
 
 #include <map>
 #include <utility>
 #include <vector>
-#include "dnnl_extension_utils.h"
 
+#include "common/blocked_desc_creator.h"
+#include "common/cpu_memcpy.h"
+#include "dnnl_extension_utils.h"
 #include "onednn/dnnl.h"
-#include <onednn/iml_type_mapper.h>
-#include <edge.h>
-#include <cpu_memory.h>
 #include "openvino/core/parallel.hpp"
-#include "common/cpu_memcpy.h"
-#include "common/blocked_desc_creator.h"
-#include <memory_desc/cpu_memory_desc_utils.h>
-#include <partitioned_mem_blk.h>
+#include "openvino/op/concat.hpp"
 using namespace dnnl;
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 namespace {
-    constexpr size_t channelAxis = 1lu;
+constexpr size_t channelAxis = 1lu;
 }
 
 bool Concat::isExecutable() const {
@@ -86,11 +86,14 @@ void Concat::getSupportedDescriptors() {
         }
     }
 
-    // we need the first dims before axis to be 1 to avoid the reorder in the edge between the first parent and this concat
+    // we need the first dims before axis to be 1 to avoid the reorder in the edge between the first parent and this
+    // concat
 
     const auto& childDims = outputShapes[0].getDims();
     if (childDims[axis] != Shape::UNDEFINED_DIM &&
-        std::all_of(childDims.begin(), childDims.begin() + axis, [](size_t dim) { return  dim == 1; }))
+        std::all_of(childDims.begin(), childDims.begin() + axis, [](size_t dim) {
+            return dim == 1;
+        }))
         canBeInPlace = true;
 }
 
@@ -118,11 +121,11 @@ void Concat::initSupportedPrimitiveDescriptors() {
     const auto& dstShape = getOutputShapeAtPort(0);
     std::vector<LayoutType> tdCreatorTypes = {LayoutType::ncsp, LayoutType::nspc};
 
-    // check if blocked layouts are available the channels size should be evenly divided by the block size to avoid slow oneDNN ref implementation and allow
-    // inPlace memory usage if possible
+    // check if blocked layouts are available the channels size should be evenly divided by the block size to avoid slow
+    // oneDNN ref implementation and allow inPlace memory usage if possible
     if (dstShape.getRank() > channelAxis) {
-        for (auto& item : { std::make_pair(8lu, LayoutType::nCsp8c), std::make_pair(16lu, LayoutType::nCsp16c)}) {
-            const VectorDims &blkDims = dstShape.getDims();
+        for (auto& item : {std::make_pair(8lu, LayoutType::nCsp8c), std::make_pair(16lu, LayoutType::nCsp16c)}) {
+            const VectorDims& blkDims = dstShape.getDims();
             if (blkDims[channelAxis] == Shape::UNDEFINED_DIM || blkDims[channelAxis] % item.first != 0)
                 continue;
 
@@ -144,7 +147,8 @@ void Concat::initSupportedPrimitiveDescriptors() {
 
     auto& creatorsMap = BlockedDescCreator::getCommonCreators();
 
-    auto itrRange = BlockedDescCreator::makeFilteredRange(creatorsMap, static_cast<unsigned>(dstShape.getRank()), tdCreatorTypes);
+    auto itrRange =
+        BlockedDescCreator::makeFilteredRange(creatorsMap, static_cast<unsigned>(dstShape.getRank()), tdCreatorTypes);
     for (auto itr = itrRange.first; itr != itrRange.second; ++itr) {
         NodeConfig config;
 
@@ -183,12 +187,15 @@ void Concat::initSupportedPrimitiveDescriptors() {
         }
     }
 
-    if (!canBeInPlace || std::any_of(inputShapes.begin(), inputShapes.end(), [](const Shape& shape) { return shape.hasZeroDims(); }))
+    if (!canBeInPlace || std::any_of(inputShapes.begin(), inputShapes.end(), [](const Shape& shape) {
+            return shape.hasZeroDims();
+        }))
         return;
 
     // Optimized inplace case
     for (auto refPdIndex : pdIndexesToReuse) {
-        auto config = supportedPrimitiveDescriptors[refPdIndex].getConfig();;
+        auto config = supportedPrimitiveDescriptors[refPdIndex].getConfig();
+        ;
         for (size_t i = 0; i < config.inConfs.size(); i++) {
             config.inConfs[i].inPlace(0);
         }
@@ -204,12 +211,16 @@ void Concat::selectOptimalPrimitiveDescriptor() {
     // for that case.
     for (size_t i = 0; i < getParentEdges().size(); i++) {
         for (size_t j = i + 1; j < getParentEdges().size(); j++) {
-            if (getParentEdgeAt(i) == getParentEdgeAt(j)) canBeInPlace = false;
+            if (getParentEdgeAt(i) == getParentEdgeAt(j))
+                canBeInPlace = false;
         }
     }
 
     std::map<LayoutType, size_t> formatFrequency;
-    std::vector<LayoutType> supportedLayouts = {LayoutType::ncsp, LayoutType::nspc, LayoutType::nCsp8c, LayoutType::nCsp16c};
+    std::vector<LayoutType> supportedLayouts = {LayoutType::ncsp,
+                                                LayoutType::nspc,
+                                                LayoutType::nCsp8c,
+                                                LayoutType::nCsp16c};
     for (size_t i = 0; i < getParentEdges().size(); i++) {
         auto parentEdge = getParentEdgeAt(i);
         auto parent = parentEdge->getParent();
@@ -218,11 +229,11 @@ void Concat::selectOptimalPrimitiveDescriptor() {
         if (parent_pdesc == nullptr)
             continue;
 
-        const auto &parent_config = parent_pdesc->getConfig();
+        const auto& parent_config = parent_pdesc->getConfig();
         int outputIndex = parentEdge->getInputNum();
         if (outputIndex < 0 || outputIndex >= static_cast<int>(parent_config.outConfs.size()))
             OPENVINO_THROW("Cannot find index of output node");
-        const auto &port_desc = parent_config.outConfs[outputIndex].getMemDesc();
+        const auto& port_desc = parent_config.outConfs[outputIndex].getMemDesc();
         for (auto& item : supportedLayouts) {
             if (port_desc->hasLayoutType(item)) {
                 formatFrequency[item] += 1;
@@ -232,15 +243,15 @@ void Concat::selectOptimalPrimitiveDescriptor() {
     for (size_t i = 0; i < getChildEdges().size(); i++) {
         auto childEdge = getChildEdgeAt(i);
         auto child = childEdge->getChild();
-        const auto *prim_desc = child->getSelectedPrimitiveDescriptor();
+        const auto* prim_desc = child->getSelectedPrimitiveDescriptor();
         if (prim_desc == nullptr)
             continue;
 
-        const auto &config = prim_desc->getConfig();
+        const auto& config = prim_desc->getConfig();
         int inputIndex = childEdge->getOutputNum();
         if (inputIndex < 0 || inputIndex >= static_cast<int>(config.inConfs.size()))
             OPENVINO_THROW("Cannot find index of output node");
-        const auto &port_desc = config.inConfs[inputIndex].getMemDesc();
+        const auto& port_desc = config.inConfs[inputIndex].getMemDesc();
         for (auto& item : supportedLayouts) {
             if (port_desc->hasLayoutType(item)) {
                 formatFrequency[item] += 1;
@@ -249,9 +260,9 @@ void Concat::selectOptimalPrimitiveDescriptor() {
     }
 
     size_t maxCount = 0;
-    const auto &outDims = getOutputShapeAtPort(0).getDims();
+    const auto& outDims = getOutputShapeAtPort(0).getDims();
     LayoutType convertTo = LayoutType::ncsp;
-    for (auto &it : formatFrequency) {
+    for (auto& it : formatFrequency) {
         if (it.second > maxCount) {
             maxCount = it.second;
             convertTo = it.first;
@@ -264,7 +275,7 @@ void Concat::selectOptimalPrimitiveDescriptor() {
         }
     }
 
-    for (auto& item : { std::make_pair(8lu, LayoutType::nCsp8c), std::make_pair(16lu, LayoutType::nCsp16c) }) {
+    for (auto& item : {std::make_pair(8lu, LayoutType::nCsp8c), std::make_pair(16lu, LayoutType::nCsp16c)}) {
         if (convertTo == item.second) {
             if (outDims[channelAxis] == Shape::UNDEFINED_DIM || outDims[1] % item.first != 0) {
                 convertTo = LayoutType::ncsp;
@@ -282,7 +293,8 @@ void Concat::selectOptimalPrimitiveDescriptor() {
 
     for (size_t i = 0; i < supportedPrimitiveDescriptors.size(); ++i) {
         if (supportedPrimitiveDescriptors[i].getConfig().outConfs[0].getMemDesc()->hasLayoutType(convertTo)) {
-            if (IMPLICATION(supportedPrimitiveDescriptors[i].getImplementationType() == impl_desc_type::unknown, canBeInPlace)) {
+            if (IMPLICATION(supportedPrimitiveDescriptors[i].getImplementationType() == impl_desc_type::unknown,
+                            canBeInPlace)) {
                 canSelectPrimitive.push_back(i);
             }
         }
@@ -444,24 +456,26 @@ void Concat::initOptimalPrimitiveDescriptor() {
     if (selected_pd == nullptr)
         OPENVINO_THROW("Preferable primitive descriptor is not set.");
 
-   if (!isInPlace()) {
-       Node::initOptimalPrimitiveDescriptor();
+    if (!isInPlace()) {
+        Node::initOptimalPrimitiveDescriptor();
         auto config = selected_pd->getConfig();
         if (!isConfigDefined(config)) {
             for (size_t i = 0; i < config.inConfs.size(); i++) {
                 // Concat doesn't support different precision on inputs
-                config.inConfs[i].setMemDesc(getConsistentInputDesc(config, i)->getMemDesc()->cloneWithNewPrecision(inputPrecision));
+                config.inConfs[i].setMemDesc(
+                    getConsistentInputDesc(config, i)->getMemDesc()->cloneWithNewPrecision(inputPrecision));
             }
 
             for (size_t i = 0; i < config.outConfs.size(); i++) {
-                config.outConfs[i].setMemDesc(getConsistentOutputDesc(config, i)->getMemDesc()->cloneWithNewPrecision(outputPrecision));
+                config.outConfs[i].setMemDesc(
+                    getConsistentOutputDesc(config, i)->getMemDesc()->cloneWithNewPrecision(outputPrecision));
             }
 
             initDescriptor(config);
         }
     }
 
-    //block layout may have axis greater than rank, disable ref_concat
+    // block layout may have axis greater than rank, disable ref_concat
     auto primDesc = getSelectedPrimitiveDescriptor();
     auto memDesc = primDesc->getConfig().outConfs[0].getMemDesc()->as<BlockedMemoryDesc>();
     auto rank = memDesc->getShape().getRank();
@@ -474,7 +488,9 @@ void Concat::initOptimalPrimitiveDescriptor() {
         srcPtrs.resize(getParentEdges().size());
     }
     // check if selected Tensor descriptor has nspc layout and concat axis is C
-    canOptimizeNspc = axis == channelAxis && getSelectedPrimitiveDescriptor()->getConfig().outConfs.front().getMemDesc()->hasLayoutType(LayoutType::nspc);
+    canOptimizeNspc =
+        axis == channelAxis &&
+        getSelectedPrimitiveDescriptor()->getConfig().outConfs.front().getMemDesc()->hasLayoutType(LayoutType::nspc);
 }
 
 void Concat::execute(dnnl::stream strm) {
@@ -497,7 +513,7 @@ void Concat::execute(dnnl::stream strm) {
     } else {
         const auto& dst_memory = getChildEdgeAt(0)->getMemory();
         const size_t num_src = getParentEdges().size();
-        std::unordered_map<int, memory> mem_ags {{DNNL_ARG_DST, dst_memory.getPrimitive()}};
+        std::unordered_map<int, memory> mem_ags{{DNNL_ARG_DST, dst_memory.getPrimitive()}};
         size_t nonZeroInShapes = 0;
         for (size_t i = 0; i < num_src; i++) {
             const auto& srcMem = getParentEdgeAt(i)->getMemory();
@@ -580,7 +596,7 @@ void Concat::execRef() {
     }
 
     if (!hasOuterLoop) {
-        if (nelemTotal < 64*1024 || parallel_get_max_threads() == 1) {
+        if (nelemTotal < 64 * 1024 || parallel_get_max_threads() == 1) {
             for (size_t a = 0; a < srcPtrs.size(); ++a) {
                 const auto inData = srcPtrs[a];
                 auto outputData = &dstPtr[dstOffset[a]];
@@ -612,63 +628,65 @@ void Concat::execRef() {
             physDims[i] = outputShape[i];
         }
         const auto L1Size = dnnl::utils::get_cache_size(1, true);
-        UNUSED(L1Size); // for Windows
-        parallel_for6d(physDims[0], physDims[1], physDims[2], physDims[3], physDims[4], numSrc,
-                                [&](size_t n0, size_t n1, size_t n2, size_t n3, size_t n4, size_t a) {
-            // check if zero memory
-            if (srcPtrs[a] == nullptr) return;
-
-            size_t inOff = inputStrides[a][0] * n0 + inputStrides[a][1] * n1 + inputStrides[a][2] * n2
-                            + inputStrides[a][3] * n3 + inputStrides[a][4] * n4;
-            size_t outOff = outputStrides[0] * n0 + outputStrides[1] * n1 + outputStrides[2] * n2
-                             + outputStrides[3] * n3 + outputStrides[4] * n4;
-            const uint8_t *i = &srcPtrs[a][inOff];
-            uint8_t *o = &dstPtr[dstOffset[a] + outOff];
+        UNUSED(L1Size);  // for Windows
+        parallel_for6d(physDims[0],
+                       physDims[1],
+                       physDims[2],
+                       physDims[3],
+                       physDims[4],
+                       numSrc,
+                       [&](size_t n0, size_t n1, size_t n2, size_t n3, size_t n4, size_t a) {
+                           // check if zero memory
+                           if (srcPtrs[a] == nullptr)
+                               return;
+
+                           size_t inOff = inputStrides[a][0] * n0 + inputStrides[a][1] * n1 + inputStrides[a][2] * n2 +
+                                          inputStrides[a][3] * n3 + inputStrides[a][4] * n4;
+                           size_t outOff = outputStrides[0] * n0 + outputStrides[1] * n1 + outputStrides[2] * n2 +
+                                           outputStrides[3] * n3 + outputStrides[4] * n4;
+                           const uint8_t* i = &srcPtrs[a][inOff];
+                           uint8_t* o = &dstPtr[dstOffset[a] + outOff];
 
 #if defined(__GNUC__)
-            // Heuristic:
-            // memcpy works generally faster for data sizes not
-            // exceeding L1 cache.
-            if (nelemToCopy[a] > L1Size) {
-                // The code below performs data copying: o[e] = i[e]
-                // and uses a workaround to make GNU compilers optimize it
-                uint8_t *ptro = o;
-                const uint8_t *ptri = i;
-                // head part: bytes before 4 byte-align's address
-                const size_t headPart = sizeof(uint32_t)
-                                         - reinterpret_cast<uint64_t>(ptro)
-                                           % sizeof(uint32_t);
-
-                // main part: bytes in 4 byte-align
-                const size_t mainPart
-                        = (nelemToCopy[a] - headPart) / sizeof(uint32_t);
-                // tail part: bytes after 4 byte-align
-                const size_t tailPart
-                        = (nelemToCopy[a]) - headPart
-                          - (mainPart * sizeof(uint32_t));
-                // copy head part
-                for (size_t e = 0; e < headPart; ++e) {
-                    *ptro = *ptri;
-                    ++ptro;
-                    ++ptri;
-                }
-                // copy main part
-                std::memcpy(ptro, ptri, mainPart * sizeof(uint32_t));
-                ptro += mainPart * sizeof(uint32_t);
-                ptri += mainPart * sizeof(uint32_t);
-                // copy tail part
-                for (size_t e = 0; e < tailPart; ++e) {
-                    *ptro = *ptri;
-                    ++ptro;
-                    ++ptri;
-                }
-            } else {
-                std::memcpy(o, i, nelemToCopy[a]);
-            }
+                           // Heuristic:
+                           // memcpy works generally faster for data sizes not
+                           // exceeding L1 cache.
+                           if (nelemToCopy[a] > L1Size) {
+                               // The code below performs data copying: o[e] = i[e]
+                               // and uses a workaround to make GNU compilers optimize it
+                               uint8_t* ptro = o;
+                               const uint8_t* ptri = i;
+                               // head part: bytes before 4 byte-align's address
+                               const size_t headPart =
+                                   sizeof(uint32_t) - reinterpret_cast<uint64_t>(ptro) % sizeof(uint32_t);
+
+                               // main part: bytes in 4 byte-align
+                               const size_t mainPart = (nelemToCopy[a] - headPart) / sizeof(uint32_t);
+                               // tail part: bytes after 4 byte-align
+                               const size_t tailPart = (nelemToCopy[a]) - headPart - (mainPart * sizeof(uint32_t));
+                               // copy head part
+                               for (size_t e = 0; e < headPart; ++e) {
+                                   *ptro = *ptri;
+                                   ++ptro;
+                                   ++ptri;
+                               }
+                               // copy main part
+                               std::memcpy(ptro, ptri, mainPart * sizeof(uint32_t));
+                               ptro += mainPart * sizeof(uint32_t);
+                               ptri += mainPart * sizeof(uint32_t);
+                               // copy tail part
+                               for (size_t e = 0; e < tailPart; ++e) {
+                                   *ptro = *ptri;
+                                   ++ptro;
+                                   ++ptri;
+                               }
+                           } else {
+                               std::memcpy(o, i, nelemToCopy[a]);
+                           }
 #else
             std::memcpy(o, i, nelemToCopy[a]);
 #endif
-        });
+                       });
     }
 }
 
@@ -691,8 +709,10 @@ void Concat::resolveInPlaceEdges(Edge::LOOK look) {
                     " can't use inPlace memory with concatenation on dynamic dimension");
 
     auto edges = getChildEdgesAtPort(inplaceOutIndx);
-    auto itr = std::find_if(edges.begin(), edges.end(), [](const EdgePtr& edge) { return edge->getStatus() == Edge::Status::Allocated; });
-    OPENVINO_ASSERT(itr != edges.end(), " Could not find allocated child edge for concat node: " , getName());
+    auto itr = std::find_if(edges.begin(), edges.end(), [](const EdgePtr& edge) {
+        return edge->getStatus() == Edge::Status::Allocated;
+    });
+    OPENVINO_ASSERT(itr != edges.end(), " Could not find allocated child edge for concat node: ", getName());
 
     auto baseMemBlock = (*itr)->getMemory().getMemoryBlock();
     OPENVINO_ASSERT(baseMemBlock != nullptr, " NULL base memory block in concat node: ", getName());
@@ -726,6 +746,6 @@ void Concat::resolveInPlaceEdges(Edge::LOOK look) {
     }
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/concat.h b/src/plugins/intel_cpu/src/nodes/concat.h
index 9ed331bee4f16d..8b75e3839a372d 100644
--- a/src/plugins/intel_cpu/src/nodes/concat.h
+++ b/src/plugins/intel_cpu/src/nodes/concat.h
@@ -4,8 +4,8 @@
 
 #pragma once
 
-#include "node.h"
 #include "graph_context.h"
+#include "node.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -22,7 +22,9 @@ class Concat : public Node {
     void selectOptimalPrimitiveDescriptor() override;
     bool created() const override;
     void execute(dnnl::stream strm) override;
-    void executeDynamicImpl(dnnl::stream strm) override { execute(strm); }
+    void executeDynamicImpl(dnnl::stream strm) override {
+        execute(strm);
+    }
     void resolveInPlaceEdges(Edge::LOOK look) override;
 
     ov::element::Type getRuntimePrecision() const override;
@@ -42,9 +44,9 @@ class Concat : public Node {
     void execNspcSpecCase();
     void exec1DCase();
     std::vector<VectorDims> inputStrides;
-    std::vector<size_t> nelemToCopy; // byte moved in each iter
+    std::vector<size_t> nelemToCopy;  // byte moved in each iter
     size_t nelemTotal = 0;
-    std::vector<size_t> dstOffset; // dst offset for each input
+    std::vector<size_t> dstOffset;  // dst offset for each input
     std::vector<const uint8_t*> srcPtrs;
     bool hasOuterLoop = false;
     ov::element::Type inputPrecision = ov::element::f32;
@@ -54,6 +56,6 @@ class Concat : public Node {
     dnnl::primitive prim;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/conv.cpp b/src/plugins/intel_cpu/src/nodes/conv.cpp
index 53d53d093cfabf..4cb2dc9058551f 100644
--- a/src/plugins/intel_cpu/src/nodes/conv.cpp
+++ b/src/plugins/intel_cpu/src/nodes/conv.cpp
@@ -4,8 +4,11 @@
 
 #include "conv.h"
 
-#include "openvino/op/convolution.hpp"
-#include "openvino/op/group_conv.hpp"
+#include <cstdlib>
+#include <memory>
+#include <string>
+#include <vector>
+
 #include "common/c_types_map.hpp"
 #include "common/cpu_convert.h"
 #include "common/primitive_desc.hpp"
@@ -27,17 +30,14 @@
 #include "oneapi/dnnl/dnnl_common.hpp"
 #include "oneapi/dnnl/dnnl_types.h"
 #include "onednn/dnnl.h"
+#include "openvino/op/convolution.hpp"
+#include "openvino/op/group_conv.hpp"
 #include "pooling.h"
 #include "reorder.h"
 #include "utils/cpu_utils.hpp"
 #include "utils/debug_capabilities.h"
 #include "utils/general_utils.h"
 
-#include <cstdlib>
-#include <memory>
-#include <string>
-#include <vector>
-
 using namespace dnnl;
 
 namespace ov {
@@ -88,7 +88,7 @@ size_t ConvKey::hash() const {
     return seed;
 }
 
-bool ConvKey::operator==(const ConvKey &rhs) const {
+bool ConvKey::operator==(const ConvKey& rhs) const {
     bool retVal = true;
     if (inp0 != rhs.inp0) {
         retVal = retVal && inp0 && rhs.inp0 && inp0->getDnnlDesc() == rhs.inp0->getDnnlDesc();
@@ -112,11 +112,11 @@ bool ConvKey::operator==(const ConvKey &rhs) const {
     return retVal;
 }
 
-} // namespace
+}  // namespace
 
 class Convolution::FusedSubgraph {
 public:
-    FusedSubgraph(const std::vector<NodePtr> &opList, const Convolution &conv, const GraphContext::CPtr context) {
+    FusedSubgraph(const std::vector<NodePtr>& opList, const Convolution& conv, const GraphContext::CPtr context) {
         _graph = std::unique_ptr<Graph>(new Graph());
 
         std::unordered_set<NodePtr> nodesSet;
@@ -130,16 +130,16 @@ class Convolution::FusedSubgraph {
             nodesSet.insert(child);
         };
 
-        //Make inputs
-        const auto &inpMemDesc1 = conv.getBaseMemDescAtOutputPort(0);
+        // Make inputs
+        const auto& inpMemDesc1 = conv.getBaseMemDescAtOutputPort(0);
         auto inp0 = std::make_shared<Input>(inpMemDesc1, "inp0", "Parameter", context);
         inputs.push_back(inp0);
         const size_t sumPortNum = conv.getParentEdges().size() - 1;
-        const auto &inpMemDesc2 = conv.getBaseMemDescAtInputPort(sumPortNum);
+        const auto& inpMemDesc2 = conv.getBaseMemDescAtInputPort(sumPortNum);
         auto inp1 = std::make_shared<Input>(inpMemDesc2, "inp1", "Parameter", context);
         inputs.push_back(inp1);
 
-        auto itr = std::find_if(opList.begin(), opList.end(), [](const NodePtr &node) {
+        auto itr = std::find_if(opList.begin(), opList.end(), [](const NodePtr& node) {
             if (auto eltwise = std::dynamic_pointer_cast<Eltwise>(node)) {
                 return eltwise->isSpecialConvolutionAddFusing();
             }
@@ -153,7 +153,7 @@ class Convolution::FusedSubgraph {
         addEdge(inp0, sumNode, 0, 0);
         addEdge(inp1, sumNode, 0, 1);
 
-        //Replicate the rest of the subgraph
+        // Replicate the rest of the subgraph
         auto parentItr = itr;
         while (++itr != opList.end()) {
             auto parentNode = *parentItr;
@@ -173,8 +173,8 @@ class Convolution::FusedSubgraph {
             }
         }
 
-        //Make output
-        const auto &outMemDesc = conv.getBaseMemDescAtOutputPort(0);
+        // Make output
+        const auto& outMemDesc = conv.getBaseMemDescAtOutputPort(0);
         auto out = std::make_shared<Input>(outMemDesc, "out", "Result", context);
         addEdge(*parentItr, out, 0, 0);
         outputs.push_back(out);
@@ -240,9 +240,20 @@ bool Convolution::isSupportedOperation(const std::shared_ptr<const ov::Node>& op
 }
 
 Convolution::Convolution(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
-        : Node(op, context, NgraphShapeInferFactory(op)), withBiases(false), withSum(false), withDWConv(false),
-          isGrouped(false), dw_conv_oc(0), dw_conv_ih(0), dw_conv_iw(0), dw_conv_in_dt(memory::data_type::undef),
-          groupNum(1lu), IC(1), groupIC(1), groupOC(1), eltwisePrecision(ov::element::f32) {
+    : Node(op, context, NgraphShapeInferFactory(op)),
+      withBiases(false),
+      withSum(false),
+      withDWConv(false),
+      isGrouped(false),
+      dw_conv_oc(0),
+      dw_conv_ih(0),
+      dw_conv_iw(0),
+      dw_conv_in_dt(memory::data_type::undef),
+      groupNum(1lu),
+      IC(1),
+      groupIC(1),
+      groupOC(1),
+      eltwisePrecision(ov::element::f32) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
@@ -296,12 +307,12 @@ Convolution::Convolution(const std::shared_ptr<ov::Node>& op, const GraphContext
         }
         paddingL = groupConvolutionOp->get_pads_begin();
         paddingR = groupConvolutionOp->get_pads_end();
-        autoPadding = one_of(groupConvolutionOp->get_auto_pad(), ov::op::PadType::SAME_UPPER, ov::op::PadType::SAME_LOWER);
+        autoPadding =
+            one_of(groupConvolutionOp->get_auto_pad(), ov::op::PadType::SAME_UPPER, ov::op::PadType::SAME_LOWER);
     }
     // Only apply this heuristic logic on FP32 IR. IC=1 ,OC=1 would disable brgconv on avx2.
     const bool isAvx2FP32 = !dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core) &&
-                                dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2) &&
-                                    !context->isGraphQuantized();
+                            dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2) && !context->isGraphQuantized();
     useJitPlanar = ((IC == 1 && groupOC * groupNum == 1) && isAvx2FP32);
 }
 
@@ -315,7 +326,8 @@ bool Convolution::canBeExecutedInInt8() const {
     if (!legacyWeightsZeroPoints.empty())
         weightsDataType = memory::data_type::s8;
 
-    return one_of(inputDataType, memory::data_type::u8, memory::data_type::s8) && weightsDataType == memory::data_type::s8;
+    return one_of(inputDataType, memory::data_type::u8, memory::data_type::s8) &&
+           weightsDataType == memory::data_type::s8;
 }
 
 ov::element::Type Convolution::fusedEltwisePrecision(const NodePtr& fusingNode) const {
@@ -338,62 +350,63 @@ ov::element::Type Convolution::fusedEltwisePrecision(const NodePtr& fusingNode)
 
 const std::vector<impl_desc_type>& Convolution::getDefaultImplPriority() {
     static const std::vector<impl_desc_type> priorities = {
-            impl_desc_type::unknown,
-            impl_desc_type::dw_acl,
-            impl_desc_type::winograd_acl,
-            impl_desc_type::gemm_acl,
-            impl_desc_type::acl,
-            impl_desc_type::brgconv_avx512_dw,
-            impl_desc_type::brgconv_avx512_amx_1x1,
-            impl_desc_type::brgconv_avx512_amx,
-            impl_desc_type::jit_avx512_amx_dw,
-            impl_desc_type::jit_avx512_amx_1x1,
-            impl_desc_type::jit_avx512_amx,
-            impl_desc_type::brgconv_avx512_1x1,
-            impl_desc_type::brgconv_avx512,
-            impl_desc_type::jit_avx512_dw,
-            impl_desc_type::jit_avx512_1x1,
-            impl_desc_type::jit_avx512,
-            impl_desc_type::brgconv_avx2_dw,
-            impl_desc_type::brgconv_avx2_1x1,
-            impl_desc_type::brgconv_avx2,
-            impl_desc_type::jit_uni_dw,
-            impl_desc_type::jit_uni_1x1,
-            impl_desc_type::jit_uni,
-            impl_desc_type::jit_avx2_dw,
-            impl_desc_type::jit_avx2_1x1,
-            impl_desc_type::jit_avx2,
-            impl_desc_type::jit_avx_dw,
-            impl_desc_type::jit_avx_1x1,
-            impl_desc_type::jit_avx,
-            impl_desc_type::jit_sse42_dw,
-            impl_desc_type::jit_sse42_1x1,
-            impl_desc_type::jit_sse42,
-            impl_desc_type::gemm_any,
-            impl_desc_type::gemm_blas,
-            impl_desc_type::gemm_avx512,
-            impl_desc_type::gemm_avx2,
-            impl_desc_type::gemm_avx,
-            impl_desc_type::gemm_sse42,
-            impl_desc_type::jit_gemm,
-            impl_desc_type::ref_any,
-            impl_desc_type::ref,
-        };
-        if (isBrgConvAvailable())
-            return priorities;
-
-        static const std::vector<impl_desc_type> priorities_wo_brgemm = [&] {
-            std::vector<impl_desc_type>result;
-            std::copy_if(priorities.begin(), priorities.end(), std::back_inserter(result),
-                [](impl_desc_type type) { return !(type & impl_desc_type::brgconv); });
-            return result;}();
-        return priorities_wo_brgemm;
+        impl_desc_type::unknown,
+        impl_desc_type::dw_acl,
+        impl_desc_type::winograd_acl,
+        impl_desc_type::gemm_acl,
+        impl_desc_type::acl,
+        impl_desc_type::brgconv_avx512_dw,
+        impl_desc_type::brgconv_avx512_amx_1x1,
+        impl_desc_type::brgconv_avx512_amx,
+        impl_desc_type::jit_avx512_amx_dw,
+        impl_desc_type::jit_avx512_amx_1x1,
+        impl_desc_type::jit_avx512_amx,
+        impl_desc_type::brgconv_avx512_1x1,
+        impl_desc_type::brgconv_avx512,
+        impl_desc_type::jit_avx512_dw,
+        impl_desc_type::jit_avx512_1x1,
+        impl_desc_type::jit_avx512,
+        impl_desc_type::brgconv_avx2_dw,
+        impl_desc_type::brgconv_avx2_1x1,
+        impl_desc_type::brgconv_avx2,
+        impl_desc_type::jit_uni_dw,
+        impl_desc_type::jit_uni_1x1,
+        impl_desc_type::jit_uni,
+        impl_desc_type::jit_avx2_dw,
+        impl_desc_type::jit_avx2_1x1,
+        impl_desc_type::jit_avx2,
+        impl_desc_type::jit_avx_dw,
+        impl_desc_type::jit_avx_1x1,
+        impl_desc_type::jit_avx,
+        impl_desc_type::jit_sse42_dw,
+        impl_desc_type::jit_sse42_1x1,
+        impl_desc_type::jit_sse42,
+        impl_desc_type::gemm_any,
+        impl_desc_type::gemm_blas,
+        impl_desc_type::gemm_avx512,
+        impl_desc_type::gemm_avx2,
+        impl_desc_type::gemm_avx,
+        impl_desc_type::gemm_sse42,
+        impl_desc_type::jit_gemm,
+        impl_desc_type::ref_any,
+        impl_desc_type::ref,
+    };
+    if (isBrgConvAvailable())
+        return priorities;
+
+    static const std::vector<impl_desc_type> priorities_wo_brgemm = [&] {
+        std::vector<impl_desc_type> result;
+        std::copy_if(priorities.begin(), priorities.end(), std::back_inserter(result), [](impl_desc_type type) {
+            return !(type & impl_desc_type::brgconv);
+        });
+        return result;
+    }();
+    return priorities_wo_brgemm;
 }
 
 const bool Convolution::isBrgConvAvailable() {
-    //When avx2 brgconv heuristic case,  disable brgconv to WA the regression.
-    const bool isBrgConvAvailable = dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2) &&
-                                           !useJitPlanar;
+    // When avx2 brgconv heuristic case,  disable brgconv to WA the regression.
+    const bool isBrgConvAvailable = dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2) && !useJitPlanar;
     return isBrgConvAvailable;
 }
 
@@ -413,7 +426,7 @@ void Convolution::getSupportedDescriptors() {
         }
 
         if (fusedWith[i]->getAlgorithm() == Algorithm::EltwiseAdd) {
-            auto* eltwiseNode = dynamic_cast<Eltwise *>(fusedWith[i].get());
+            auto* eltwiseNode = dynamic_cast<Eltwise*>(fusedWith[i].get());
             if (eltwiseNode && eltwiseNode->isSpecialConvolutionAddFusing()) {
                 expectedInputEdgesNum++;
             }
@@ -427,17 +440,19 @@ void Convolution::getSupportedDescriptors() {
     outputDataType = DnnlExtensionUtils::ElementTypeToDataType(getOriginalOutputPrecisionAtPort(0));
     eltwisePrecision = DnnlExtensionUtils::DataTypeToElementType(outputDataType);
     if (!fusedWith.empty()) {
-        outputDataType = DnnlExtensionUtils::ElementTypeToDataType(fusedWith[fusedWith.size() - 1]->getOriginalOutputPrecisionAtPort(0));
+        outputDataType = DnnlExtensionUtils::ElementTypeToDataType(
+            fusedWith[fusedWith.size() - 1]->getOriginalOutputPrecisionAtPort(0));
         eltwisePrecision = DnnlExtensionUtils::DataTypeToElementType(outputDataType);
     }
 
     // We need to make sure that convolution output and second input of fused Eltwise operation
-    // have equal precision sizes since they use the same physical memory. In case precisions are different we upscale to FP32.
+    // have equal precision sizes since they use the same physical memory. In case precisions are different we upscale
+    // to FP32.
     if (outputDataType != memory::data_type::f32 && outputDataType != memory::data_type::bf16 &&
         outputDataType != memory::data_type::f16 && withSum) {
         for (size_t i = 0; i < fusedWith.size(); i++) {
             if (fusedWith[i]->getAlgorithm() == Algorithm::EltwiseAdd) {
-                auto* eltwiseNode = dynamic_cast<Eltwise *>(fusedWith[i].get());
+                auto* eltwiseNode = dynamic_cast<Eltwise*>(fusedWith[i].get());
                 if (eltwiseNode && eltwiseNode->isSpecialConvolutionAddFusing()) {
                     eltwisePrecision = fusedEltwisePrecision(fusedWith[i]);
                     if (DnnlExtensionUtils::DataTypeToElementType(outputDataType).size() != eltwisePrecision.size()) {
@@ -468,7 +483,7 @@ void Convolution::getSupportedDescriptors() {
     }
 
     for (size_t i = 0; i < fusedWith.size(); i++) {
-        auto *convolutionNode = dynamic_cast<Convolution *>(fusedWith[i].get());
+        auto* convolutionNode = dynamic_cast<Convolution*>(fusedWith[i].get());
         if (convolutionNode) {
             auto& inActivationDims = convolutionNode->inputShapes[0].getStaticDims();
             dw_conv_ih = inActivationDims[convolutionNode->inputShapes[0].getRank() - 2];
@@ -477,7 +492,7 @@ void Convolution::getSupportedDescriptors() {
             auto& outDims = convolutionNode->outputShapes[0].getStaticDims();
             dw_conv_oc = outDims[1];
 
-            const auto &dwWeightsDims = convolutionNode->inputShapes[1].getStaticDims();
+            const auto& dwWeightsDims = convolutionNode->inputShapes[1].getStaticDims();
             dw_conv_kernel.push_back(dwWeightsDims[dwWeightsDims.size() - 1]);
             dw_conv_kernel.push_back(dwWeightsDims[dwWeightsDims.size() - 2]);
             dw_conv_strides = convolutionNode->getStride();
@@ -486,7 +501,8 @@ void Convolution::getSupportedDescriptors() {
                 if (i == 0) {
                     dw_conv_in_dt = DnnlExtensionUtils::ElementTypeToDataType(getOriginalOutputPrecisionAtPort(0));
                 } else {
-                    dw_conv_in_dt = DnnlExtensionUtils::ElementTypeToDataType(fusedWith[i - 1]->getOriginalOutputPrecisionAtPort(0));
+                    dw_conv_in_dt = DnnlExtensionUtils::ElementTypeToDataType(
+                        fusedWith[i - 1]->getOriginalOutputPrecisionAtPort(0));
                 }
             } else {
                 dw_conv_in_dt = memory::data_type::f32;
@@ -498,7 +514,7 @@ void Convolution::getSupportedDescriptors() {
                 int src = getInputShapeAtPort(0).getStaticDims()[2 + j];
                 int dst = getOutputShapeAtPort(0).getStaticDims()[2 + j];
 
-                krn = (krn - 1)*(dilation[j] + 1) + 1;
+                krn = (krn - 1) * (dilation[j] + 1) + 1;
                 int calc_dst = (src - krn + paddingL[j]) / stride[j] + 1;
                 paddingR[j] = (dst - calc_dst) * stride[j];
             }
@@ -506,10 +522,14 @@ void Convolution::getSupportedDescriptors() {
     }
 
     MemoryDescPtr in_candidate, out_candidate;
-    memory::format_tag nspc = ndims == 3 ? memory::format_tag::nwc : (ndims == 4 ? memory::format_tag::nhwc : memory::format_tag::ndhwc);
-    memory::format_tag ncsp = ndims == 3 ? memory::format_tag::ncw : (ndims == 4 ? memory::format_tag::nchw : memory::format_tag::ncdhw);
-    memory::format_tag nCsp8c = ndims == 3 ? memory::format_tag::nCw8c : (ndims == 4 ? memory::format_tag::nChw8c : memory::format_tag::nCdhw8c);
-    memory::format_tag nCsp16c = ndims == 3 ? memory::format_tag::nCw16c : (ndims == 4 ? memory::format_tag::nChw16c : memory::format_tag::nCdhw16c);
+    memory::format_tag nspc =
+        ndims == 3 ? memory::format_tag::nwc : (ndims == 4 ? memory::format_tag::nhwc : memory::format_tag::ndhwc);
+    memory::format_tag ncsp =
+        ndims == 3 ? memory::format_tag::ncw : (ndims == 4 ? memory::format_tag::nchw : memory::format_tag::ncdhw);
+    memory::format_tag nCsp8c = ndims == 3 ? memory::format_tag::nCw8c
+                                           : (ndims == 4 ? memory::format_tag::nChw8c : memory::format_tag::nCdhw8c);
+    memory::format_tag nCsp16c = ndims == 3 ? memory::format_tag::nCw16c
+                                            : (ndims == 4 ? memory::format_tag::nChw16c : memory::format_tag::nCdhw16c);
 
     if (canBeExecutedInInt8()) {
         DEBUG_LOG(getName(), "Creating I8 descriptor");
@@ -524,7 +544,7 @@ void Convolution::getSupportedDescriptors() {
 
         in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(0), inputDataType, nspc);
         out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(getOutputShapeAtPort(0), outputDataType, nspc);
-        createDescriptor({ in_candidate }, { out_candidate });
+        createDescriptor({in_candidate}, {out_candidate});
         return;
     }
 
@@ -549,7 +569,7 @@ void Convolution::getSupportedDescriptors() {
     eltwisePrecision = ov::element::f32;
     for (size_t i = 0; i < fusedWith.size(); i++) {
         if (fusedWith[i]->getAlgorithm() == Algorithm::EltwiseAdd) {
-            auto* eltwiseNode = dynamic_cast<Eltwise *>(fusedWith[i].get());
+            auto* eltwiseNode = dynamic_cast<Eltwise*>(fusedWith[i].get());
             if (eltwiseNode && eltwiseNode->isSpecialConvolutionAddFusing()) {
                 eltwisePrecision = fusedEltwisePrecision(fusedWith[i]);
                 // TODO(amalyshe): there might be situation when convolution can be executed in BF16,
@@ -581,42 +601,44 @@ void Convolution::getSupportedDescriptors() {
 
 #if defined(OPENVINO_ARCH_X86_64)
     // nspc shows better performance only with brgconv implementation
-    bool nspcFirst = isBrgConvAvailable() && one_of(inputDataType, memory::data_type::f16, memory::data_type::bf16, memory::data_type::f32);
+    bool nspcFirst = isBrgConvAvailable() &&
+                     one_of(inputDataType, memory::data_type::f16, memory::data_type::bf16, memory::data_type::f32);
     bool nspcAdded = false;
     if (nspcFirst) {
         in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(inputShape, inputDataType, nspc);
         out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, nspc);
-        createDescriptor({ in_candidate }, { out_candidate });
+        createDescriptor({in_candidate}, {out_candidate});
         nspcAdded = true;
     }
 
     if (IC == 1 && groupOC == 1) {
         in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(inputShape, inputDataType, ncsp);
         out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, ncsp);
-        createDescriptor({ in_candidate }, { out_candidate });
+        createDescriptor({in_candidate}, {out_candidate});
     } else if (IC < 4) {
         in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(inputShape, inputDataType, ncsp);
         out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, nCsp16c);
-        createDescriptor({ in_candidate }, { out_candidate });
+        createDescriptor({in_candidate}, {out_candidate});
         out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, nCsp8c);
-        createDescriptor({ in_candidate }, { out_candidate });
+        createDescriptor({in_candidate}, {out_candidate});
     } else {
         in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(inputShape, inputDataType, nCsp16c);
         out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, nCsp16c);
-        createDescriptor({ in_candidate }, { out_candidate });
+        createDescriptor({in_candidate}, {out_candidate});
         in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(inputShape, inputDataType, nCsp8c);
         out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, nCsp8c);
-        createDescriptor({ in_candidate }, { out_candidate });
+        createDescriptor({in_candidate}, {out_candidate});
     }
 
     in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(inputShape, inputDataType, ncsp);
     out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, ncsp);
-    createDescriptor({ in_candidate }, { out_candidate });
+    createDescriptor({in_candidate}, {out_candidate});
 
-    if (!nspcAdded && (inputDataType != memory::data_type::bf16 && inputDataType != memory::data_type::f16 && isNspcAvailable())) {
+    if (!nspcAdded &&
+        (inputDataType != memory::data_type::bf16 && inputDataType != memory::data_type::f16 && isNspcAvailable())) {
         in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(inputShape, inputDataType, nspc);
         out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, nspc);
-        createDescriptor({ in_candidate }, { out_candidate });
+        createDescriptor({in_candidate}, {out_candidate});
     }
 #else
     (void)ncsp;
@@ -625,7 +647,7 @@ void Convolution::getSupportedDescriptors() {
 
     in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(inputShape, inputDataType, nspc);
     out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, nspc);
-    createDescriptor({ in_candidate }, { out_candidate });
+    createDescriptor({in_candidate}, {out_candidate});
 #endif
 }
 
@@ -636,9 +658,11 @@ void Convolution::setPostOps(dnnl::primitive_attr& attr,
     dnnl::post_ops ops;
     auto& args = convPostOpsArgs[useLegacyPostOps];
     bool isINT8 = canBeExecutedInInt8();
-    // Weight dims in NON-Group CONV: [OC, IC, KH, KW], perchannel weight scale applied on OC DIM, weiScaleMaskPerChannel =  1 << 0
-    // Weight dims in Group CONV:[Group, OC, IC, KH, KW], perchannel weight scale applied on GROUP and OC DIM, weiScaleMaskPerChannel = ( 1 << 0 | 1<< 1) = 0x03
-    DnnlPostOpsComposerLegacy dnnlpoc(getEngine(), attr, ops, args, dims, 1, isINT8, isGrouped ? 3 : 1 << 0, getDQScales(), withBiases);
+    // Weight dims in NON-Group CONV: [OC, IC, KH, KW], perchannel weight scale applied on OC DIM,
+    // weiScaleMaskPerChannel =  1 << 0 Weight dims in Group CONV:[Group, OC, IC, KH, KW], perchannel weight scale
+    // applied on GROUP and OC DIM, weiScaleMaskPerChannel = ( 1 << 0 | 1<< 1) = 0x03
+    DnnlPostOpsComposerLegacy
+        dnnlpoc(getEngine(), attr, ops, args, dims, 1, isINT8, isGrouped ? 3 : 1 << 0, getDQScales(), withBiases);
 
     DEBUG_LOG(getName(), " useLegacyPostOps=", useLegacyPostOps, " initWeights=", initWeights);
 
@@ -681,14 +705,14 @@ void Convolution::setPostOps(dnnl::primitive_attr& attr,
                 bool hasSubsequentSum = false;
                 bool hasSubsequentFQ = false;
                 for (size_t j = i + 1; j < fusedWith.size(); j++) {
-                    auto &nextNode = fusedWith[j];
+                    auto& nextNode = fusedWith[j];
 
-                    auto *nextEltwiseNode = dynamic_cast<Eltwise *>(nextNode.get());
+                    auto* nextEltwiseNode = dynamic_cast<Eltwise*>(nextNode.get());
                     if (nextEltwiseNode && nextEltwiseNode->isSpecialConvolutionAddFusing()) {
                         hasSubsequentSum = true;
                     }
 
-                    auto *nextQuantizeNode = dynamic_cast<FakeQuantize *>(nextNode.get());
+                    auto* nextQuantizeNode = dynamic_cast<FakeQuantize*>(nextNode.get());
                     if (nextQuantizeNode) {
                         hasSubsequentFQ = true;
                     }
@@ -781,12 +805,16 @@ void Convolution::initSupportedPrimitiveDescriptors() {
             const std::vector<size_t> dwWeightsDims{dw_conv_oc, 1, 1, dw_conv_kernel[Y_AXIS], dw_conv_kernel[X_AXIS]};
             const std::vector<size_t> dwBiasesDims{dw_conv_oc};
 
-            const auto dwWeightsPrc = DnnlExtensionUtils::ElementTypeToDataType(dw_conv_in_dt == dnnl_u8 ? ov::element::i8 : ov::element::f32);
-            const auto dwWeightsDesc = std::make_shared<DnnlBlockedMemoryDesc>(Shape(dwWeightsDims), dwWeightsPrc, memory::format_tag::Goihw8g);
+            const auto dwWeightsPrc = DnnlExtensionUtils::ElementTypeToDataType(
+                dw_conv_in_dt == dnnl_u8 ? ov::element::i8 : ov::element::f32);
+            const auto dwWeightsDesc = std::make_shared<DnnlBlockedMemoryDesc>(Shape(dwWeightsDims),
+                                                                               dwWeightsPrc,
+                                                                               memory::format_tag::Goihw8g);
             inConfs.emplace_back(dwWeightsDesc);
 
             const auto dwBiasPrc = memory::data_type::f32;
-            const auto dwBiasDesc = std::make_shared<DnnlBlockedMemoryDesc>(Shape(dwBiasesDims), dwBiasPrc, memory::format_tag::x);
+            const auto dwBiasDesc =
+                std::make_shared<DnnlBlockedMemoryDesc>(Shape(dwBiasesDims), dwBiasPrc, memory::format_tag::x);
             inConfs.emplace_back(dwBiasDesc);
         }
 
@@ -809,15 +837,21 @@ void Convolution::initSupportedPrimitiveDescriptors() {
     };
 #ifdef CPU_DEBUG_CAPS
     {
-       if (!customImplPriorities.empty()) {
-            DEBUG_LOG("#", getName(), " customImplPriorities [", 0 , "/", customImplPriorities.size(),
-                        "]: ", impl_type_to_string(customImplPriorities[0]));
-       }
+        if (!customImplPriorities.empty()) {
+            DEBUG_LOG("#",
+                      getName(),
+                      " customImplPriorities [",
+                      0,
+                      "/",
+                      customImplPriorities.size(),
+                      "]: ",
+                      impl_type_to_string(customImplPriorities[0]));
+        }
     }
 #endif
     for (size_t dIdx = 0; dIdx < descs.size(); dIdx++) {
         auto& desc = descs[dIdx];
-        auto primitive_desc = desc.get(true); //true mean allow empty
+        auto primitive_desc = desc.get(true);  // true mean allow empty
         if (primitive_desc == nullptr) {
             continue;
         }
@@ -829,16 +863,25 @@ void Convolution::initSupportedPrimitiveDescriptors() {
         };
 
         const bool first_match = customImplPriorities.empty();
-        DEBUG_LOG("#", getName(), ",descIndex:", dIdx + 1, "/", descs.size(),
-                       ", itpd.impl_info_str(): ", desc.impl_info_str(),
-                    ", parsed imp_type: ", impl_type_to_string(parse_impl_name(desc.impl_info_str())),
-                    ", first_match: ", first_match ? "true" : "false");
-        DnnlExtensionUtils::for_each_implementation(desc,
-                                                    first_match,
-                                                    [&](impl_desc_type implType) {
-                                                        return contains(getImplPriority(), implType);
-                                                    },
-                                                    add_supported_desc);
+        DEBUG_LOG("#",
+                  getName(),
+                  ",descIndex:",
+                  dIdx + 1,
+                  "/",
+                  descs.size(),
+                  ", itpd.impl_info_str(): ",
+                  desc.impl_info_str(),
+                  ", parsed imp_type: ",
+                  impl_type_to_string(parse_impl_name(desc.impl_info_str())),
+                  ", first_match: ",
+                  first_match ? "true" : "false");
+        DnnlExtensionUtils::for_each_implementation(
+            desc,
+            first_match,
+            [&](impl_desc_type implType) {
+                return contains(getImplPriority(), implType);
+            },
+            add_supported_desc);
 
         // fallback. if none of the primitive types is present in the priority list just add first implementation
         // @todo this fallback is not necessary if primitive priority list is filled correctly
@@ -852,46 +895,48 @@ bool Convolution::created() const {
 }
 
 namespace {
-dnnl::convolution_forward::primitive_desc
-createDescriptorInternal(const dnnl::engine& engine,
-                         const dnnl::memory::desc& inputDesc,
-                         const dnnl::memory::desc& weightDesc,
-                         const dnnl::memory::desc& biasDesc,
-                         const dnnl::memory::desc& outputDesc,
-                         bool withBiases,
-                         const std::vector<size_t>& stride,
-                         const std::vector<ptrdiff_t>& dilation,
-                         const std::vector<ptrdiff_t>& paddingL,
-                         const std::vector<ptrdiff_t>& paddingR,
-                         dnnl::algorithm alg,
-                         const dnnl::primitive_attr& attr) {
+dnnl::convolution_forward::primitive_desc createDescriptorInternal(const dnnl::engine& engine,
+                                                                   const dnnl::memory::desc& inputDesc,
+                                                                   const dnnl::memory::desc& weightDesc,
+                                                                   const dnnl::memory::desc& biasDesc,
+                                                                   const dnnl::memory::desc& outputDesc,
+                                                                   bool withBiases,
+                                                                   const std::vector<size_t>& stride,
+                                                                   const std::vector<ptrdiff_t>& dilation,
+                                                                   const std::vector<ptrdiff_t>& paddingL,
+                                                                   const std::vector<ptrdiff_t>& paddingR,
+                                                                   dnnl::algorithm alg,
+                                                                   const dnnl::primitive_attr& attr) {
     if (withBiases) {
-        return dnnl::convolution_forward::primitive_desc(
-            engine,
-            prop_kind::forward_inference,
-            alg,
-            inputDesc, weightDesc, biasDesc, outputDesc,
-            dnnl::memory::dims(stride.begin(), stride.end()),
-            dnnl::memory::dims(dilation.begin(), dilation.end()),
-            dnnl::memory::dims(paddingL.begin(), paddingL.end()),
-            dnnl::memory::dims(paddingR.begin(), paddingR.end()),
-            attr,
-            true); // allow_empty
+        return dnnl::convolution_forward::primitive_desc(engine,
+                                                         prop_kind::forward_inference,
+                                                         alg,
+                                                         inputDesc,
+                                                         weightDesc,
+                                                         biasDesc,
+                                                         outputDesc,
+                                                         dnnl::memory::dims(stride.begin(), stride.end()),
+                                                         dnnl::memory::dims(dilation.begin(), dilation.end()),
+                                                         dnnl::memory::dims(paddingL.begin(), paddingL.end()),
+                                                         dnnl::memory::dims(paddingR.begin(), paddingR.end()),
+                                                         attr,
+                                                         true);  // allow_empty
     } else {
-        return dnnl::convolution_forward::primitive_desc(
-            engine,
-            prop_kind::forward_inference,
-            alg,
-            inputDesc, weightDesc, outputDesc,
-            dnnl::memory::dims(stride.begin(), stride.end()),
-            dnnl::memory::dims(dilation.begin(), dilation.end()),
-            dnnl::memory::dims(paddingL.begin(), paddingL.end()),
-            dnnl::memory::dims(paddingR.begin(), paddingR.end()),
-            attr,
-            true); // allow_empty
+        return dnnl::convolution_forward::primitive_desc(engine,
+                                                         prop_kind::forward_inference,
+                                                         alg,
+                                                         inputDesc,
+                                                         weightDesc,
+                                                         outputDesc,
+                                                         dnnl::memory::dims(stride.begin(), stride.end()),
+                                                         dnnl::memory::dims(dilation.begin(), dilation.end()),
+                                                         dnnl::memory::dims(paddingL.begin(), paddingL.end()),
+                                                         dnnl::memory::dims(paddingR.begin(), paddingR.end()),
+                                                         attr,
+                                                         true);  // allow_empty
     }
 }
-} // namespace
+}  // namespace
 
 static memory::data_type deriveWeightDataType(memory::data_type src_dt) {
     memory::data_type wdt = src_dt;
@@ -916,7 +961,7 @@ void Convolution::createDescriptor(const std::vector<MemoryDescPtr>& inputDesc,
     if (outputDesc[0]->isDefined()) {
         definedOutMemDesc = MemoryDescUtils::convertToDnnlMemoryDesc(outputDesc[0]);
     } else {
-        std::vector<Shape> shapes = { definedInpMemDesc->getShape(), Shape(weightDims) };
+        std::vector<Shape> shapes = {definedInpMemDesc->getShape(), Shape(weightDims)};
         auto outDims = shapeInferGeneric(shapes);
         definedOutMemDesc = MemoryDescUtils::convertToDnnlMemoryDesc(outputDesc[0]->cloneWithNewDims(outDims.front()));
     }
@@ -930,13 +975,14 @@ void Convolution::createDescriptor(const std::vector<MemoryDescPtr>& inputDesc,
     dnnl::memory::desc biasDnnlDesc;
 
     if (withBiases) {
-        //oneDNN ARM Convolution primitive supports only identical in/out data types
+        // oneDNN ARM Convolution primitive supports only identical in/out data types
 #if defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)
         memory::data_type bdt = outDnnlDesc.get_data_type();
 #else
         memory::data_type bdt = memory::data_type::f32;
 #endif
-        biasDnnlDesc = dnnl::memory::desc(DnnlExtensionUtils::convertToDnnlDims(expectedBiasDims), bdt, memory::format_tag::any);
+        biasDnnlDesc =
+            dnnl::memory::desc(DnnlExtensionUtils::convertToDnnlDims(expectedBiasDims), bdt, memory::format_tag::any);
     }
 
     std::vector<dnnl::algorithm> algorithms;
@@ -948,8 +994,17 @@ void Convolution::createDescriptor(const std::vector<MemoryDescPtr>& inputDesc,
     for (const auto alg : algorithms) {
         for (const auto& attr : attrs) {
             const auto desc = createDescriptorInternal(getEngine(),
-                                                       inDnnlDesc, weightDnnlDesc, biasDnnlDesc, outDnnlDesc, withBiases,
-                                                       stride, dilation, paddingL, paddingR, alg, attr);
+                                                       inDnnlDesc,
+                                                       weightDnnlDesc,
+                                                       biasDnnlDesc,
+                                                       outDnnlDesc,
+                                                       withBiases,
+                                                       stride,
+                                                       dilation,
+                                                       paddingL,
+                                                       paddingR,
+                                                       alg,
+                                                       attr);
             descs.emplace_back(desc);
         }
     }
@@ -983,7 +1038,8 @@ void Convolution::addLegacyZeroPoints(dnnl::primitive_attr& attr) {
 
         if (!legacyWeightsZeroPointsMemPtr) {
             DnnlBlockedMemoryDesc memoryDesc(ov::element::f32, {legacyWeightsZeroPoints.size()});
-            legacyWeightsZeroPointsMemPtr = std::make_shared<Memory>(getEngine(), memoryDesc, legacyWeightsZeroPoints.data());
+            legacyWeightsZeroPointsMemPtr =
+                std::make_shared<Memory>(getEngine(), memoryDesc, legacyWeightsZeroPoints.data());
         }
     }
 
@@ -993,7 +1049,8 @@ void Convolution::addLegacyZeroPoints(dnnl::primitive_attr& attr) {
 
         if (!legacyOutputCompensationMemPtr) {
             DnnlBlockedMemoryDesc memoryDesc(ov::element::i32, {legacyOutputCompensation.size()});
-            legacyOutputCompensationMemPtr = std::make_shared<Memory>(getEngine(), memoryDesc, legacyOutputCompensation.data());
+            legacyOutputCompensationMemPtr =
+                std::make_shared<Memory>(getEngine(), memoryDesc, legacyOutputCompensation.data());
         }
     }
 }
@@ -1004,7 +1061,7 @@ static bool attrContainsPostOp(const dnnl::primitive_attr& attr, const dnnl::imp
 }
 
 // See the src/plugins/intel_cpu/src/docs/convPostOps.md for details
-void Convolution::SetPostOpsAndZeroPoints(std::vector<dnnl::primitive_attr> &attrs) {
+void Convolution::SetPostOpsAndZeroPoints(std::vector<dnnl::primitive_attr>& attrs) {
     attrs.resize(1);
     auto outputShape = outputStaticShape();
     // attr[0] - Legacy post ops + Legacy zero points.
@@ -1012,14 +1069,13 @@ void Convolution::SetPostOpsAndZeroPoints(std::vector<dnnl::primitive_attr> &att
     setPostOps(attrs[0], outputShape, true);
     addLegacyZeroPoints(attrs[0]);
 
-    //dw-conv would be fused into conv only on AVX2 platform. no need attr[1]. Avoid extra useless attribute.
+    // dw-conv would be fused into conv only on AVX2 platform. no need attr[1]. Avoid extra useless attribute.
     if (attrContainsPostOp(attrs[0], dnnl::impl::primitive_kind::convolution)) {
         return;
     }
 
     // no matter if brgconv is available, 1 attribute is enough. Avoid duplicated attribute
-    if (inputZeroPointType == zpType::None &&
-        !attrContainsPostOp(attrs[0], dnnl::impl::primitive_kind::depthwise) &&
+    if (inputZeroPointType == zpType::None && !attrContainsPostOp(attrs[0], dnnl::impl::primitive_kind::depthwise) &&
         !attrContainsPostOp(attrs[0], dnnl::impl::primitive_kind::quantization)) {
         return;
     }
@@ -1034,10 +1090,11 @@ void Convolution::SetPostOpsAndZeroPoints(std::vector<dnnl::primitive_attr> &att
     }
     // Try 2 attributes.
     attrs.resize(2);
-    if (inputZeroPointType == zpType::PerTensor && dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_amx)) {
-        //WR to ONEDNN limitation. attr[1] - legacy post ops + stock zero point.
+    if (inputZeroPointType == zpType::PerTensor &&
+        dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_amx)) {
+        // WR to ONEDNN limitation. attr[1] - legacy post ops + stock zero point.
         //@todo:Unify to use binary postops+stock zero point when limitation is fixed.
-        //For now, have to adapt to JIT_AMX kernel for performance.
+        // For now, have to adapt to JIT_AMX kernel for performance.
         DEBUG_LOG(getName(), ": set post ops, attr 1, useLegacyPostOps=true");
         setPostOps(attrs[1], outputShape, true);
     } else {
@@ -1048,7 +1105,7 @@ void Convolution::SetPostOpsAndZeroPoints(std::vector<dnnl::primitive_attr> &att
 }
 
 void Convolution::initDescriptor(const NodeConfig& config) {
-    auto *selectedPD = getSelectedPrimitiveDescriptor();
+    auto* selectedPD = getSelectedPrimitiveDescriptor();
 
     if (!selectedPD) {
         return;
@@ -1057,24 +1114,29 @@ void Convolution::initDescriptor(const NodeConfig& config) {
     // attr[0] for legacy post ops;
     // attr[1] is mostly for binaryPostops except when having per-tensor zp on AMX.
     const int descId = descIdx[selectedPrimitiveDescriptorIndex];
-    int attrId = attrs.size() == 1 ? 0 :
-        descId % 2 == 0 ? 0 : 1;
+    int attrId = attrs.size() == 1 ? 0 : descId % 2 == 0 ? 0 : 1;
 
     preferLegacyPostOps = (attrId == 0 || (attrId == 1 && (inputZeroPointType == zpType::PerTensor) &&
-                                      dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_amx)));
-    //attr[0] for legacy zero point.
-    //attr[1] for stock per-tensor zero point.
+                                           dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_amx)));
+    // attr[0] for legacy zero point.
+    // attr[1] for stock per-tensor zero point.
     preferLegacyZeroPoint = (attrId == 0);
 
     DEBUG_LOG(getName(),
-              " selectedPrimitiveDescriptorIndex: ", selectedPrimitiveDescriptorIndex,
-              " DescIdx: ", descId,
-              " Selected impl type: ", selectedPD->getImplementationType(),
-              " Desc impl type: ", parse_impl_name(descs[descId].impl_info_str()),
-              " preferLegacyPostOps: ", preferLegacyPostOps,
-              " preferLegacyZeroPoint: ", preferLegacyZeroPoint);
-
-    auto updateNodeConfig = [&](const NodeConfig& cfg){
+              " selectedPrimitiveDescriptorIndex: ",
+              selectedPrimitiveDescriptorIndex,
+              " DescIdx: ",
+              descId,
+              " Selected impl type: ",
+              selectedPD->getImplementationType(),
+              " Desc impl type: ",
+              parse_impl_name(descs[descId].impl_info_str()),
+              " preferLegacyPostOps: ",
+              preferLegacyPostOps,
+              " preferLegacyZeroPoint: ",
+              preferLegacyZeroPoint);
+
+    auto updateNodeConfig = [&](const NodeConfig& cfg) {
         auto updatedConfig = cfg;
 
         for (size_t i = 0; i < descInputNumbers(); i++) {
@@ -1097,7 +1159,7 @@ void Convolution::initDescriptor(const NodeConfig& config) {
         return updatedConfig;
     };
 
-    if (!canBeExecutedInInt8()) { // strided blobs are suppoted only for FP32 convolutions
+    if (!canBeExecutedInInt8()) {  // strided blobs are suppoted only for FP32 convolutions
         descs.clear();
         createDescriptor({config.inConfs[0].getMemDesc()}, {config.outConfs[0].getMemDesc()});
 
@@ -1115,7 +1177,7 @@ void Convolution::initDescriptor(const NodeConfig& config) {
     selectedPD->setConfig(updatedConfig);
 }
 
-std::shared_ptr<MemoryDesc> Convolution::getSrcMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const {
+std::shared_ptr<MemoryDesc> Convolution::getSrcMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const {
     if (idx == 1) {
         // report original plain layout for weight since it needs to be reordered dynamically at runtime
         return std::make_shared<CpuBlockedMemoryDesc>(getOriginalInputPrecisionAtPort(idx),
@@ -1151,7 +1213,8 @@ ov::element::Type Convolution::getRuntimePrecision() const {
     for (size_t i = 0; i < std::min(getParentEdges().size(), inputsNumLimit); i++) {
         auto parentEdge = getParentEdgeAt(i);
         if (parentEdge && parentEdge->getStatus() == Edge::Status::Validated) {
-            inputPrecisions.emplace_back(DnnlExtensionUtils::DataTypeToElementType((parentEdge->getMemoryPtr()->getDataType())));
+            inputPrecisions.emplace_back(
+                DnnlExtensionUtils::DataTypeToElementType((parentEdge->getMemoryPtr()->getDataType())));
         }
     }
 
@@ -1183,8 +1246,9 @@ bool Convolution::isNspcAvailable() const {
             return false;
         }
     } else {
-        // it was empirically observed that the nspc convolutions perform much slower than the blocked ones if the channels number more than the specific value
-        size_t spatialRank = ndims - 2; //two means batch dim plus channels dim
+        // it was empirically observed that the nspc convolutions perform much slower than the blocked ones if the
+        // channels number more than the specific value
+        size_t spatialRank = ndims - 2;  // two means batch dim plus channels dim
 
         bool is1x1 = false;
 
@@ -1195,24 +1259,24 @@ bool Convolution::isNspcAvailable() const {
             auto paddingRreversItr = paddingR.crbegin();
 
             for (size_t i = 0; i < spatialRank; ++i) {
-                is1x1 = true
-                        && *(weightDimsReversItr++) == 1
-                        && *(strideReversItr++) == 1
-                        && *(paddingLreversItr++) == 0
-                        && *(paddingRreversItr++) == 0;
+                is1x1 = true && *(weightDimsReversItr++) == 1 && *(strideReversItr++) == 1 &&
+                        *(paddingLreversItr++) == 0 && *(paddingRreversItr++) == 0;
             }
         }
 
-        // if the activation field size is 1x1 the avx512 1x1 nspc convolution pollutes caches so that the layer after the convolution performs slow
+        // if the activation field size is 1x1 the avx512 1x1 nspc convolution pollutes caches so that the layer after
+        // the convolution performs slow
         if (mayiuse(impl::cpu::x64::avx512_core) && is1x1) {
             auto end = inpDims.rbegin();
             std::advance(end, spatialRank);
-            if (std::all_of(inpDims.rbegin(), end, [](size_t x) { return dimsEqualStrong(1, x); })) {
+            if (std::all_of(inpDims.rbegin(), end, [](size_t x) {
+                    return dimsEqualStrong(1, x);
+                })) {
                 return false;
             }
         }
 
-        unsigned thresholdNumChannels = 128u; // for avx and below
+        unsigned thresholdNumChannels = 128u;  // for avx and below
         if (is1x1) {
             thresholdNumChannels = 2048u;
         } else if (mayiuse(impl::cpu::x64::avx512_core)) {
@@ -1224,7 +1288,8 @@ bool Convolution::isNspcAvailable() const {
             return false;
         }
         if (!mayiuse(impl::cpu::x64::avx)) {
-            // SSE41 nspc convolutions do not support ic and oc tails yet and the blocked implementation will be much better than gemm
+            // SSE41 nspc convolutions do not support ic and oc tails yet and the blocked implementation will be much
+            // better than gemm
             if ((IC % 8) || (OC % 8)) {
                 return false;
             }
@@ -1251,7 +1316,7 @@ void Convolution::prepareParams() {
             OPENVINO_THROW("Input memory is undefined.");
     }
 
-    const NodeDesc *selected_pd = getSelectedPrimitiveDescriptor();
+    const NodeDesc* selected_pd = getSelectedPrimitiveDescriptor();
     if (selected_pd == nullptr)
         OPENVINO_THROW("Preferable primitive descriptor is not set for node ", getName(), ".");
 
@@ -1324,44 +1389,41 @@ void Convolution::prepareParams() {
                 dnnlBiasDesc = biasDescPtr->getDnnlDesc();
             }
 
-            return createDescriptorInternal(
-                engine,
-                srcDesc,
-                wghDesc,
-                dnnlBiasDesc,
-                dstDesc,
-                (biasDescPtr != nullptr),
-                stride,
-                dilation,
-                paddingL,
-                paddingR,
-                alg,
-                attr);
+            return createDescriptorInternal(engine,
+                                            srcDesc,
+                                            wghDesc,
+                                            dnnlBiasDesc,
+                                            dstDesc,
+                                            (biasDescPtr != nullptr),
+                                            stride,
+                                            dilation,
+                                            paddingL,
+                                            paddingR,
+                                            alg,
+                                            attr);
         };
 
-        dnnl::primitive_desc prim_desc = createDnnlConvDesc(
-            engine,
-            key.inp0->getDnnlDesc(),
-            wghDescAny,
-            key.out->getDnnlDesc(),
-            key.bias,
-            key.stride,
-            key.dilation,
-            key.paddingL,
-            key.paddingR,
-            convAlg,
-            key.attr);
+        dnnl::primitive_desc prim_desc = createDnnlConvDesc(engine,
+                                                            key.inp0->getDnnlDesc(),
+                                                            wghDescAny,
+                                                            key.out->getDnnlDesc(),
+                                                            key.bias,
+                                                            key.stride,
+                                                            key.dilation,
+                                                            key.paddingL,
+                                                            key.paddingR,
+                                                            convAlg,
+                                                            key.attr);
 
         const bool found = DnnlExtensionUtils::find_implementation(prim_desc, key.implType);
 
         if (found) {
-            return std::make_shared<ConvolutionExecutor>(
-                prim_desc,
-                key.inp0->getDnnlDesc(),
-                key.inp1->getDnnlDesc(),
-                key.out->getDnnlDesc(),
-                engine,
-                key.constWeight);
+            return std::make_shared<ConvolutionExecutor>(prim_desc,
+                                                         key.inp0->getDnnlDesc(),
+                                                         key.inp1->getDnnlDesc(),
+                                                         key.out->getDnnlDesc(),
+                                                         engine,
+                                                         key.constWeight);
         }
 
         // primitive desc with proper implementation type not found, use the first available
@@ -1372,40 +1434,37 @@ void Convolution::prepareParams() {
                                           key.out->getDataType(),
                                           memory::format_tag::any);
 
-        auto reorderConvDesc = createDnnlConvDesc(
-            engine,
-            inDesc,
-            wghDescAny,
-            outDesc,
-            key.bias,
-            key.stride,
-            key.dilation,
-            key.paddingL,
-            key.paddingR,
-            convAlg,
-            key.attr);
+        auto reorderConvDesc = createDnnlConvDesc(engine,
+                                                  inDesc,
+                                                  wghDescAny,
+                                                  outDesc,
+                                                  key.bias,
+                                                  key.stride,
+                                                  key.dilation,
+                                                  key.paddingL,
+                                                  key.paddingR,
+                                                  convAlg,
+                                                  key.attr);
 
         // unable to create a primitive desc
         if (!reorderConvDesc)
             return nullptr;
 
         if (key.attr.get()->post_ops_.count(dnnl::impl::primitive_kind::sum)) {
-            return std::make_shared<ConvolutionSumExecutor>(
-                reorderConvDesc,
-                key.inp0->getDnnlDesc(),
-                key.inp1->getDnnlDesc(),
-                key.out->getDnnlDesc(),
-                engine,
-                key.constWeight);
+            return std::make_shared<ConvolutionSumExecutor>(reorderConvDesc,
+                                                            key.inp0->getDnnlDesc(),
+                                                            key.inp1->getDnnlDesc(),
+                                                            key.out->getDnnlDesc(),
+                                                            engine,
+                                                            key.constWeight);
         }
 
-        return std::make_shared<ConvolutionExecutor>(
-            reorderConvDesc,
-            key.inp0->getDnnlDesc(),
-            key.inp1->getDnnlDesc(),
-            key.out->getDnnlDesc(),
-            engine,
-            key.constWeight);
+        return std::make_shared<ConvolutionExecutor>(reorderConvDesc,
+                                                     key.inp0->getDnnlDesc(),
+                                                     key.inp1->getDnnlDesc(),
+                                                     key.out->getDnnlDesc(),
+                                                     engine,
+                                                     key.constWeight);
     };
 
     auto prevExecPtr = execPtr;
@@ -1460,7 +1519,8 @@ Convolution::ConvolutionExecutor::ConvolutionExecutor(const dnnl::primitive_desc
                                                       const dnnl::memory::desc& weightMemDesc,
                                                       const dnnl::memory::desc& outMemDesc,
                                                       const dnnl::engine& engine,
-                                                      bool constWeight) : DnnlExecutor(pd) {
+                                                      bool constWeight)
+    : DnnlExecutor(pd) {
     if (inMemDesc != getDnnlSrcDesc()) {
         inputReorders.insert({DNNL_ARG_SRC, IntermReorder(inMemDesc, getDnnlSrcDesc(), engine)});
     }
@@ -1480,7 +1540,8 @@ Convolution::ConvolutionSumExecutor::ConvolutionSumExecutor(const dnnl::primitiv
                                                             const dnnl::memory::desc& weightMemDesc,
                                                             const dnnl::memory::desc& outMemDesc,
                                                             const dnnl::engine& engine,
-                                                            bool constWeight) : DnnlExecutor(pd) {
+                                                            bool constWeight)
+    : DnnlExecutor(pd) {
     if (inMemDesc != getDnnlSrcDesc()) {
         inputReorders.insert({DNNL_ARG_SRC, IntermReorder(inMemDesc, getDnnlSrcDesc(), engine)});
     }
@@ -1498,9 +1559,10 @@ Convolution::ConvolutionSumExecutor::ConvolutionSumExecutor(const dnnl::primitiv
     }
 }
 
-void Convolution::ConvolutionSumExecutor::reorder_exec(std::unordered_map<int, dnnl::memory> primArgs, dnnl::stream strm) {
+void Convolution::ConvolutionSumExecutor::reorder_exec(std::unordered_map<int, dnnl::memory> primArgs,
+                                                       dnnl::stream strm) {
     auto outputMem = primArgs.at(DNNL_ARG_DST);
-    for (auto &inReorder : inputReorders) {
+    for (auto& inReorder : inputReorders) {
         if (primArgs.count(inReorder.first)) {
             dnnl::memory memDst(inReorder.second.getDstDesc(), strm.get_engine());
             inReorder.second.exec(primArgs[inReorder.first], memDst, strm);
@@ -1549,14 +1611,14 @@ void Convolution::executeDynamicImpl(dnnl::stream strm) {
 }
 
 void Convolution::updatePadding() {
-    //update padding.
+    // update padding.
     if (isDynamicNode() && autoPadding) {
         paddingL = shapeInference->get_pads_begin();
         paddingR = shapeInference->get_pads_end();
     }
 }
 
-void Convolution::redefineOutputMemory(const std::vector<VectorDims> &newOutputShapes) {
+void Convolution::redefineOutputMemory(const std::vector<VectorDims>& newOutputShapes) {
     if (withSum) {
         const size_t sumPortNum = getParentEdges().size() - 1;
         const auto& sumInpMem = getParentEdgeAt(sumPortNum)->getMemory();
@@ -1570,7 +1632,8 @@ void Convolution::redefineOutputMemory(const std::vector<VectorDims> &newOutputS
 
             auto inp1 = subgraph->getInput(1);
             inp1->redefineOutputMemory({sumInpMem.getStaticDims()});
-            // here we postpone output memory reallocation due to the fact that it is the same memory with the sum second input
+            // here we postpone output memory reallocation due to the fact that it is the same memory with the sum
+            // second input
             return;
         } else {
             withSumBroadcast = false;
@@ -1579,12 +1642,10 @@ void Convolution::redefineOutputMemory(const std::vector<VectorDims> &newOutputS
     Node::redefineOutputMemory(newOutputShapes);
 }
 
-MemoryDescPtr Convolution::getSumMemDesc(const primitive_desc &primitive_desc_it) {
+MemoryDescPtr Convolution::getSumMemDesc(const primitive_desc& primitive_desc_it) {
     if (getOutputShapeAtPort(0).isDynamic()) {
-        // When we set input shape with ranged dims, sum node input shape maybe mismatch with output shape, we just change
-        // ranged min value to 1 to meet this case.
-        // For example:
-        // Output shape = {1, 160, {128, 256}, {128, 256}}
+        // When we set input shape with ranged dims, sum node input shape maybe mismatch with output shape, we just
+        // change ranged min value to 1 to meet this case. For example: Output shape = {1, 160, {128, 256}, {128, 256}}
         // Sum input shape = {1, 160, 1, 1}
         // Update sum shape to {1, 160, {1, 256}, {1, 256}}
         auto shape = getOutputShapeAtPort(0);
@@ -1622,7 +1683,7 @@ MemoryPtr Convolution::getOutputMemory() const {
     }
 }
 
-void Convolution::addFusedNode(const NodePtr &fusingNode) {
+void Convolution::addFusedNode(const NodePtr& fusingNode) {
     if (Type::Eltwise == fusingNode->getType()) {
         if (fusingNode->getAlgorithm() == Algorithm::EltwiseAdd) {
             auto eltwiseNode = std::dynamic_pointer_cast<Eltwise>(fusingNode);
@@ -1655,7 +1716,6 @@ void Convolution::appendLegacyZeroPointsArgs() {
     }
 }
 
-
 void Convolution::appendZeroPointsArgs() {
     if (stockInputZeroPointsMemPtr != nullptr) {
         primArgs[DNNL_ARG_ATTR_ZERO_POINTS | DNNL_ARG_SRC] = stockInputZeroPointsMemPtr->getPrimitive();
@@ -1673,10 +1733,9 @@ void Convolution::initializeInputZeroPoints(const uint8_t* inputZpData, const si
             inputZeroPointType = zpType::PerChannel;
     }
     // Only enable per-tensor zero point on avx512-amx and avx512-core-vnni, avx2_vnni_2.
-    // avx2_vnni is not enabled per-tensor z because of perf regression brgconv with per-tensor zpcompared with jit per-channel zp
-    // If zero point is pertensor, both legacy zp and stock zp
-    // would be passed into conv node. The conv node would determine how to create
-    // post-ops attribute and prioritize to choose final onednn kernel.
+    // avx2_vnni is not enabled per-tensor z because of perf regression brgconv with per-tensor zpcompared with jit
+    // per-channel zp If zero point is pertensor, both legacy zp and stock zp would be passed into conv node. The conv
+    // node would determine how to create post-ops attribute and prioritize to choose final onednn kernel.
     if (inputZeroPointType == zpType::PerTensor && (impl::cpu::x64::mayiuse(impl::cpu::x64::avx512_core_amx) ||
                                                     impl::cpu::x64::mayiuse(impl::cpu::x64::avx512_core_vnni) ||
                                                     impl::cpu::x64::mayiuse(impl::cpu::x64::avx2_vnni_2)))
@@ -1694,15 +1753,14 @@ VectorDims Convolution::makeInputDummyShape(const Shape& inpShape) const {
     const size_t filterStartIndx = weightDims.size() - spatialRank;
 
     VectorDims dummyInputShapeVals(inpShape.getRank(), dummyInputDim);
-    dummyInputShapeVals[1] = IC; //channels
+    dummyInputShapeVals[1] = IC;  // channels
 
     for (size_t i = 0; i < spatialRank; i++) {
         if (weightDims[filterStartIndx + i] > dummyInputShapeVals[2 + i]) {
             constexpr Dim dummyOutputDim = 16;
-            dummyInputShapeVals[2 + i] = (dummyOutputDim - 1) * stride[i] -
-                                (paddingL[i] + paddingR[i]) +
-                                weightDims[filterStartIndx + i] +
-                                (weightDims[filterStartIndx + i]- 1) * (dilation[i]);
+            dummyInputShapeVals[2 + i] = (dummyOutputDim - 1) * stride[i] - (paddingL[i] + paddingR[i]) +
+                                         weightDims[filterStartIndx + i] +
+                                         (weightDims[filterStartIndx + i] - 1) * (dilation[i]);
         }
     }
     return MemoryDescUtils::makeDummyShape(inpShape, dummyInputShapeVals).getStaticDims();
@@ -1712,12 +1770,12 @@ VectorDims Convolution::outputStaticShape() const {
     auto& outputShape = getOutputShapeAtPort(0);
     if (outputShape.isDynamic()) {
         auto inpDummyShape = makeInputDummyShape(getInputShapeAtPort(0));
-        auto outputDims = shapeInferGeneric({ Shape(inpDummyShape), Shape(weightDims) });
+        auto outputDims = shapeInferGeneric({Shape(inpDummyShape), Shape(weightDims)});
         return Shape(outputDims.front()).getStaticDims();
     }
     return outputShape.getStaticDims();
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/conv.h b/src/plugins/intel_cpu/src/nodes/conv.h
index a7cac9bced1241..8da3193e5760cf 100644
--- a/src/plugins/intel_cpu/src/nodes/conv.h
+++ b/src/plugins/intel_cpu/src/nodes/conv.h
@@ -29,7 +29,7 @@ class Convolution : public Node {
         return false;
     }
     ov::element::Type getRuntimePrecision() const override;
-    std::shared_ptr<MemoryDesc> getSrcMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const override;
+    std::shared_ptr<MemoryDesc> getSrcMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const override;
 
     dnnl::memory getWeights() const;
     dnnl::memory getBias() const;
@@ -39,23 +39,35 @@ class Convolution : public Node {
     }
 
     bool canBeExecutedInInt8() const override;
-    size_t getGroupNum() const { return groupNum; }
-    //OV Legacy input zero point mechanism can support per-channel zero point.
-    //Hold legacy input zero point.
+    size_t getGroupNum() const {
+        return groupNum;
+    }
+    // OV Legacy input zero point mechanism can support per-channel zero point.
+    // Hold legacy input zero point.
     std::vector<uint8_t> legacyInputZeroPoints;
-    //Hold legacy weight zero point.
+    // Hold legacy weight zero point.
     std::vector<float> legacyWeightsZeroPoints;
-    //Hold legacy pre-calculated output compensation
+    // Hold legacy pre-calculated output compensation
     std::vector<int32_t> legacyOutputCompensation;
-    //Hold stock per-tensor input zero point. Pass to onednn to calculate output compensation.
+    // Hold stock per-tensor input zero point. Pass to onednn to calculate output compensation.
     std::vector<int32_t> inputZeroPoints;
     void initializeInputZeroPoints(const uint8_t* inputZpData, const size_t inputZpSize);
 
-    const VectorDims &getWeightDims() { return weightDims; }
-    const std::vector<size_t> &getStride() { return stride; }
-    const std::vector<ptrdiff_t> &getDilation() { return dilation; }
-    const std::vector<ptrdiff_t> &getPaddingL() { return paddingL; }
-    const std::vector<ptrdiff_t> &getPaddingR() { return paddingR; }
+    const VectorDims& getWeightDims() {
+        return weightDims;
+    }
+    const std::vector<size_t>& getStride() {
+        return stride;
+    }
+    const std::vector<ptrdiff_t>& getDilation() {
+        return dilation;
+    }
+    const std::vector<ptrdiff_t>& getPaddingL() {
+        return paddingL;
+    }
+    const std::vector<ptrdiff_t>& getPaddingR() {
+        return paddingR;
+    }
 
     bool canFuse(const NodePtr& node) const override;
     bool isDepthWise() const {
@@ -64,16 +76,12 @@ class Convolution : public Node {
 
 protected:
     ov::element::Type fusedEltwisePrecision(const NodePtr& fusingNode) const;
-    void redefineOutputMemory(const std::vector<VectorDims> &newOutputShapes) override;
-    void addFusedNode(const NodePtr &fusingNode) override;
+    void redefineOutputMemory(const std::vector<VectorDims>& newOutputShapes) override;
+    void addFusedNode(const NodePtr& fusingNode) override;
     const std::vector<impl_desc_type>& getDefaultImplPriority() override;
 
 private:
-    enum class zpType {
-        None,
-        PerTensor,
-        PerChannel
-    };
+    enum class zpType { None, PerTensor, PerChannel };
 
     class FusedSubgraph;
     using FusedSubgraphPtr = std::shared_ptr<FusedSubgraph>;
@@ -81,26 +89,26 @@ class Convolution : public Node {
     executorPtr execPtr = nullptr;
 
     class ConvolutionExecutor : public DnnlExecutor {
-        public:
-            ConvolutionExecutor(const dnnl::primitive_desc& pd,
-                                const dnnl::memory::desc& inMemDesc,
-                                const dnnl::memory::desc& weightMemDesc,
-                                const dnnl::memory::desc& outMemDesc,
-                                const dnnl::engine& engine,
-                                bool constWeight);
+    public:
+        ConvolutionExecutor(const dnnl::primitive_desc& pd,
+                            const dnnl::memory::desc& inMemDesc,
+                            const dnnl::memory::desc& weightMemDesc,
+                            const dnnl::memory::desc& outMemDesc,
+                            const dnnl::engine& engine,
+                            bool constWeight);
     };
 
     class ConvolutionSumExecutor : public DnnlExecutor {
-        public:
-            ConvolutionSumExecutor(const dnnl::primitive_desc& pd,
-                    const dnnl::memory::desc& inMemDesc,
-                    const dnnl::memory::desc& weightMemDesc,
-                    const dnnl::memory::desc& outMemDesc,
-                    const dnnl::engine& engine,
-                    bool constWeight);
-
-        private:
-            void reorder_exec(std::unordered_map<int, dnnl::memory> primArgs, dnnl::stream strm) override;
+    public:
+        ConvolutionSumExecutor(const dnnl::primitive_desc& pd,
+                               const dnnl::memory::desc& inMemDesc,
+                               const dnnl::memory::desc& weightMemDesc,
+                               const dnnl::memory::desc& outMemDesc,
+                               const dnnl::engine& engine,
+                               bool constWeight);
+
+    private:
+        void reorder_exec(std::unordered_map<int, dnnl::memory> primArgs, dnnl::stream strm) override;
     };
 
     void prepareParams() override;
@@ -108,13 +116,16 @@ class Convolution : public Node {
     void executeDynamicImpl(dnnl::stream strm) override;
     void addLegacyZeroPoints(dnnl::primitive_attr& attr);
     void addZeroPoints(dnnl::primitive_attr& attr);
-    void setPostOps(dnnl::primitive_attr &attr, const VectorDims &dims, bool useLegacyPostOps, bool initWeights = false);
-    void SetPostOpsAndZeroPoints(std::vector<dnnl::primitive_attr> &attrs);
+    void setPostOps(dnnl::primitive_attr& attr,
+                    const VectorDims& dims,
+                    bool useLegacyPostOps,
+                    bool initWeights = false);
+    void SetPostOpsAndZeroPoints(std::vector<dnnl::primitive_attr>& attrs);
     void filterSupportedDescriptors();
     bool isNspcAvailable() const;
 
     void updatePadding();
-    MemoryDescPtr getSumMemDesc(const dnnl::primitive_desc &primitive_desc_it);
+    MemoryDescPtr getSumMemDesc(const dnnl::primitive_desc& primitive_desc_it);
     MemoryPtr getOutputMemory() const;
     VectorDims makeInputDummyShape(const Shape& inpShape) const;
     VectorDims outputStaticShape() const;
@@ -131,7 +142,7 @@ class Convolution : public Node {
     zpType inputZeroPointType = zpType::None;
     // maps each supportedPrimitiveDescriptor to corresponding desc from descs
     std::vector<size_t> descIdx;
-    VectorDims expectedBiasDims {};
+    VectorDims expectedBiasDims{};
 
     std::vector<size_t> stride;
     std::vector<ptrdiff_t> dilation;
@@ -179,6 +190,6 @@ class Convolution : public Node {
 #endif
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/convert.cpp b/src/plugins/intel_cpu/src/nodes/convert.cpp
index 1987c9cc83d5f2..d01a56aac1b86d 100644
--- a/src/plugins/intel_cpu/src/nodes/convert.cpp
+++ b/src/plugins/intel_cpu/src/nodes/convert.cpp
@@ -26,7 +26,8 @@ bool Convert::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, st
         auto srcPrc = op->get_input_element_type(0);
         auto dstPrc = op->get_output_element_type(0);
         if (!CommonConvertExecutor::isSupported(srcPrc, dstPrc)) {
-            errorMessage = "cpu_convert can't convert from: " + srcPrc.to_string() + " precision to: " + dstPrc.to_string();
+            errorMessage =
+                "cpu_convert can't convert from: " + srcPrc.to_string() + " precision to: " + dstPrc.to_string();
             return false;
         }
     } catch (...) {
@@ -36,7 +37,7 @@ bool Convert::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, st
 }
 
 Convert::Convert(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
-        : Node(op, context, PassThroughShapeInferFactory()) {
+    : Node(op, context, PassThroughShapeInferFactory()) {
     std::string errorMessage;
     if (isSupportedOperation(op, errorMessage)) {
         errorPrefix = "Convert node with name '" + getName() + "'";
@@ -48,8 +49,11 @@ Convert::Convert(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr c
     convertParams.origPrc = convert->get_destination_type();
 }
 
-Convert::Convert(const Shape &shape, const ov::element::Type &inPrc, const ov::element::Type &outPrc,
-                 const std::string &nodeName, const GraphContext::CPtr context)
+Convert::Convert(const Shape& shape,
+                 const ov::element::Type& inPrc,
+                 const ov::element::Type& outPrc,
+                 const std::string& nodeName,
+                 const GraphContext::CPtr context)
     : Node("Convert", {shape}, {shape}, {inPrc}, {outPrc}, nodeName, context) {
     convertParams.origPrc = outPrc;
 
@@ -74,7 +78,7 @@ void Convert::getSupportedDescriptors() {
         OPENVINO_THROW(errorPrefix, " has incorrect number of output edges");
 }
 
-bool Convert::isSupportedDesc(const MemoryDesc &desc) {
+bool Convert::isSupportedDesc(const MemoryDesc& desc) {
     bool isSupported = desc.getType() & MemoryDescType::Blocked;
     if (desc.getType() == MemoryDescType::DnnlBlocked)
         isSupported &= desc.as<const DnnlMemoryDesc>()->hasEmptyExtraData();
@@ -101,13 +105,16 @@ void Convert::initSupportedPrimitiveDescriptors() {
         MemoryDescPtr dstMemoryDesc = config.outConfs[0].getMemDesc();
         convertParams.srcPrc = srcMemoryDesc->getPrecision();
         convertParams.dstPrc = dstMemoryDesc->getPrecision();
-        auto factory = std::make_shared<ConvertExecutorFactory>(convertParams, srcMemoryDesc, dstMemoryDesc,
-                                                                std::make_shared<ExecutorContext>(context, getImplPriority()));
+        auto factory =
+            std::make_shared<ConvertExecutorFactory>(convertParams,
+                                                     srcMemoryDesc,
+                                                     dstMemoryDesc,
+                                                     std::make_shared<ExecutorContext>(context, getImplPriority()));
         supportedPrimitiveDescriptors.emplace_back(config, impl_desc_type::unknown, factory);
     };
 
-    // if input and output pointers are not null and not contain extra data, then the inp/output tensor descriptors were set using setDescs method, so
-    // they should be used as the actual descriptors.
+    // if input and output pointers are not null and not contain extra data, then the inp/output tensor descriptors were
+    // set using setDescs method, so they should be used as the actual descriptors.
     if (canInitExternalDesc) {
         dataIn.setMemDesc(input);
         config.inConfs.push_back(dataIn);
@@ -142,8 +149,10 @@ void Convert::initSupportedPrimitiveDescriptors() {
                          : BlockedDescCreator::makeFilteredRange(creators, insShape.getRank());
 
         for (auto itr = range.first; itr != range.second; ++itr) {
-            config.inConfs[0].setMemDesc(std::make_shared<CpuBlockedMemoryDesc>(itr->second->createDesc(insPrecision, insShape)));
-            config.outConfs[0].setMemDesc(std::make_shared<CpuBlockedMemoryDesc>(itr->second->createDesc(outPrecision, outputShape)));
+            config.inConfs[0].setMemDesc(
+                std::make_shared<CpuBlockedMemoryDesc>(itr->second->createDesc(insPrecision, insShape)));
+            config.outConfs[0].setMemDesc(
+                std::make_shared<CpuBlockedMemoryDesc>(itr->second->createDesc(outPrecision, outputShape)));
 
             supportedPrimitiveDescriptorsBuilder(config);
         }
@@ -159,10 +168,8 @@ void Convert::prepareParams() {
     auto selectedPD = getSelectedPrimitiveDescriptor();
     MemoryDescPtr srcDesc = getSrcMemoryAtPort(0)->getDescPtr();
     MemoryDescPtr dstDesc = getDstMemoryAtPort(0)->getDescPtr();
-    execPtr = selectedPD->getExecutorFactoryAs<ConvertExecutorFactory>()->makeExecutor(convertParams,
-                                                                                       srcDesc,
-                                                                                       dstDesc,
-                                                                                       {});
+    execPtr =
+        selectedPD->getExecutorFactoryAs<ConvertExecutorFactory>()->makeExecutor(convertParams, srcDesc, dstDesc, {});
     selectedPD->setImplementationType(execPtr->implType());
 }
 
@@ -189,6 +196,6 @@ bool Convert::created() const {
     return getType() == Type::Convert;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/convert.h b/src/plugins/intel_cpu/src/nodes/convert.h
index 2a257bd1d31cd8..3bc911d118fd7a 100644
--- a/src/plugins/intel_cpu/src/nodes/convert.h
+++ b/src/plugins/intel_cpu/src/nodes/convert.h
@@ -14,8 +14,11 @@ namespace node {
 class Convert : public Node {
 public:
     Convert(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
-    Convert(const Shape &shape, const ov::element::Type &inPrc, const ov::element::Type &outPrc,
-            const std::string &nodeName, const GraphContext::CPtr context);
+    Convert(const Shape& shape,
+            const ov::element::Type& inPrc,
+            const ov::element::Type& outPrc,
+            const std::string& nodeName,
+            const GraphContext::CPtr context);
 
     void getSupportedDescriptors() override;
     void initSupportedPrimitiveDescriptors() override;
@@ -28,22 +31,28 @@ class Convert : public Node {
     }
 
     // This is the interface extension designed to provide inp and output tensor descriptors without the CNNLayer.
-    // In that case the Convert node is instantiated with default CNNLayer and inp/out tensor descriptors are set via this method.
-    // This is useful if the Convert node is added to the graph as an auxiliary operation at the Graph
+    // In that case the Convert node is instantiated with default CNNLayer and inp/out tensor descriptors are set via
+    // this method. This is useful if the Convert node is added to the graph as an auxiliary operation at the Graph
     // initialization stage.
     void setDescs(const MemoryDesc& input, const MemoryDesc& output) {
         this->input = input.clone();
         this->output = output.clone();
     }
 
-    const MemoryDesc& getInput() const { return *input; }
-    const MemoryDesc& getOutput() const { return *output; }
+    const MemoryDesc& getInput() const {
+        return *input;
+    }
+    const MemoryDesc& getOutput() const {
+        return *output;
+    }
 
-    bool needPrepareParams() const override { return inputShapesModified(); }
+    bool needPrepareParams() const override {
+        return inputShapesModified();
+    }
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
-    static bool isSupportedDesc(const MemoryDesc &desc);
+    static bool isSupportedDesc(const MemoryDesc& desc);
 
 private:
     MemoryDescPtr input;
@@ -55,6 +64,6 @@ class Convert : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder.cpp b/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder.cpp
index 0b467fe452e061..2869d782cdb445 100644
--- a/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder.cpp
+++ b/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder.cpp
@@ -2,18 +2,20 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "openvino/op/ctc_greedy_decoder.hpp"
+
 #include <string>
 #include <vector>
 
-#include "openvino/op/ctc_greedy_decoder.hpp"
-#include "openvino/core/parallel.hpp"
 #include "ctc_greedy_decoder.h"
+#include "openvino/core/parallel.hpp"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-bool CTCGreedyDecoder::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool CTCGreedyDecoder::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                            std::string& errorMessage) noexcept {
     try {
         const auto greedyDecOp = ov::as_type_ptr<const ov::op::v0::CTCGreedyDecoder>(op);
         if (!greedyDecOp) {
@@ -61,8 +63,7 @@ void CTCGreedyDecoder::initSupportedPrimitiveDescriptors() {
     if (!one_of(seqLenPrecision, ov::element::f32, ov::element::bf16, ov::element::f16))
         OPENVINO_THROW(errorPrefix, "has unsupported 'sequence_length' input precision: ", seqLenPrecision);
 
-    addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32},
-                          {LayoutType::ncsp, ov::element::f32}},
+    addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32}, {LayoutType::ncsp, ov::element::f32}},
                          {{LayoutType::ncsp, ov::element::f32}},
                          impl_desc_type::ref_any);
 }
@@ -141,7 +142,7 @@ void CTCGreedyDecoder::execute(dnnl::stream strm) {
             }
             tStart = 0lu;
         }
-    }; // thread body
+    };  // thread body
 
     parallel_nt(0, threadBody);
 
@@ -151,8 +152,7 @@ void CTCGreedyDecoder::execute(dnnl::stream strm) {
         const size_t sequenceLength = sequenceLengths[b];
         float* shiftedOut = outputSequences + b * T;
         for (size_t t = 0; t < sequenceLength; ++t) {
-            if (*shiftedOut < blankIndex &&
-                !(mergeRepeated && *shiftedOut == prevClassIdx)) {
+            if (*shiftedOut < blankIndex && !(mergeRepeated && *shiftedOut == prevClassIdx)) {
                 outputSequences[outputIndex++] = *shiftedOut;
             }
             prevClassIdx = *shiftedOut;
@@ -174,6 +174,6 @@ bool CTCGreedyDecoder::needPrepareParams() const {
     return false;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder.h b/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder.h
index 1f3179edb904d2..a552ff7db3c566 100644
--- a/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder.h
+++ b/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder.h
@@ -14,7 +14,7 @@ class CTCGreedyDecoder : public Node {
 public:
     CTCGreedyDecoder(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -22,6 +22,7 @@ class CTCGreedyDecoder : public Node {
     bool needPrepareParams() const override;
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
+
 private:
     const size_t DATA_INDEX = 0lu;
     const size_t SEQUENCE_LENGTH_INDEX = 1lu;
@@ -30,6 +31,6 @@ class CTCGreedyDecoder : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder_seq_len.cpp b/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder_seq_len.cpp
index 63db3968094c3a..3eb02f2583e551 100644
--- a/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder_seq_len.cpp
+++ b/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder_seq_len.cpp
@@ -2,18 +2,20 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "ctc_greedy_decoder_seq_len.h"
+
+#include <openvino/op/ctc_greedy_decoder_seq_len.hpp>
 #include <string>
 #include <vector>
 
-#include <openvino/op/ctc_greedy_decoder_seq_len.hpp>
 #include "openvino/core/parallel.hpp"
-#include "ctc_greedy_decoder_seq_len.h"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-bool CTCGreedyDecoderSeqLen::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool CTCGreedyDecoderSeqLen::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                                  std::string& errorMessage) noexcept {
     try {
         const auto greedyDecOp = ov::as_type_ptr<const ov::op::v6::CTCGreedyDecoderSeqLen>(op);
         if (!greedyDecOp) {
@@ -67,33 +69,35 @@ void CTCGreedyDecoderSeqLen::initSupportedPrimitiveDescriptors() {
         inDataConf.emplace_back(LayoutType::ncsp, ov::element::i32);
 
     addSupportedPrimDesc(inDataConf,
-                         {{LayoutType::ncsp, ov::element::i32},
-                          {LayoutType::ncsp, ov::element::i32}},
+                         {{LayoutType::ncsp, ov::element::i32}, {LayoutType::ncsp, ov::element::i32}},
                          impl_desc_type::ref_any);
 }
 
 void CTCGreedyDecoderSeqLen::execute(dnnl::stream strm) {
     const float* probabilities = getSrcDataAtPortAs<const float>(DATA_INDEX);
     const int* sequenceLengths = getSrcDataAtPortAs<const int>(SEQUENCE_LENGTH_INDEX);
-    int* decodedClasses =  getDstDataAtPortAs<int>(DECODED_CLASSES_INDEX);
+    int* decodedClasses = getDstDataAtPortAs<int>(DECODED_CLASSES_INDEX);
     int* decodedClassesLength = getDstDataAtPortAs<int>(DECODED_CLASSES_LENGTH_INDEX);
 
-    const size_t B = getParentEdgeAt(DATA_INDEX)->getMemory().getStaticDims()[0];;
-    const size_t T = getParentEdgeAt(DATA_INDEX)->getMemory().getStaticDims()[1];;
-    const int C = getParentEdgeAt(DATA_INDEX)->getMemory().getStaticDims()[2];;
+    const size_t B = getParentEdgeAt(DATA_INDEX)->getMemory().getStaticDims()[0];
+    ;
+    const size_t T = getParentEdgeAt(DATA_INDEX)->getMemory().getStaticDims()[1];
+    ;
+    const int C = getParentEdgeAt(DATA_INDEX)->getMemory().getStaticDims()[2];
+    ;
     const size_t TC = T * C;
 
     int blankIndex = C - 1;
     if (inputShapes.size() > BLANK_INDEX)
-        blankIndex = (getSrcDataAtPortAs<const int >(BLANK_INDEX))[0];
+        blankIndex = (getSrcDataAtPortAs<const int>(BLANK_INDEX))[0];
 
     size_t workAmount = 0;
     for (size_t b = 0; b < B; b++) {
         if (sequenceLengths[b] > static_cast<int>(T)) {
-            std::string errorMsg = errorPrefix
-                                   + ". Sequence length " + std::to_string(sequenceLengths[b])
-                                   + " cannot be greater than according decoded classes dimension size "
-                                   + std::to_string(getChildEdgeAt(DECODED_CLASSES_INDEX)->getMemory().getStaticDims()[1]);
+            std::string errorMsg =
+                errorPrefix + ". Sequence length " + std::to_string(sequenceLengths[b]) +
+                " cannot be greater than according decoded classes dimension size " +
+                std::to_string(getChildEdgeAt(DECODED_CLASSES_INDEX)->getMemory().getStaticDims()[1]);
             OPENVINO_THROW(errorMsg);
         }
         workAmount += sequenceLengths[b];
@@ -142,7 +146,7 @@ void CTCGreedyDecoderSeqLen::execute(dnnl::stream strm) {
             }
             tStart = 0lu;
         }
-    }; // thread body
+    };  // thread body
 
     parallel_nt(0, threadBody);
 
@@ -153,8 +157,7 @@ void CTCGreedyDecoderSeqLen::execute(dnnl::stream strm) {
         int* shiftedOut = decodedClasses + b * T;
 
         for (size_t t = 0; t < actualSeqLen; ++t) {
-            if (*shiftedOut != blankIndex &&
-                !(mergeRepeated && *shiftedOut == prevClassIdx)) {
+            if (*shiftedOut != blankIndex && !(mergeRepeated && *shiftedOut == prevClassIdx)) {
                 decodedClasses[outputIndex++] = *shiftedOut;
             }
             prevClassIdx = *shiftedOut;
@@ -177,6 +180,6 @@ bool CTCGreedyDecoderSeqLen::needPrepareParams() const {
     return false;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder_seq_len.h b/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder_seq_len.h
index 4e7d14fd23556a..95ab8ef84b07eb 100644
--- a/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder_seq_len.h
+++ b/src/plugins/intel_cpu/src/nodes/ctc_greedy_decoder_seq_len.h
@@ -14,7 +14,7 @@ class CTCGreedyDecoderSeqLen : public Node {
 public:
     CTCGreedyDecoderSeqLen(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -34,6 +34,6 @@ class CTCGreedyDecoderSeqLen : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/ctc_loss.cpp b/src/plugins/intel_cpu/src/nodes/ctc_loss.cpp
index 6d09b0aea7e934..0ed3d95503eb62 100644
--- a/src/plugins/intel_cpu/src/nodes/ctc_loss.cpp
+++ b/src/plugins/intel_cpu/src/nodes/ctc_loss.cpp
@@ -2,11 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "openvino/op/ctc_loss.hpp"
+
 #include <cmath>
 
-#include "openvino/op/ctc_loss.hpp"
-#include "openvino/core/parallel.hpp"
 #include "ctc_loss.h"
+#include "openvino/core/parallel.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -53,9 +54,7 @@ void CTCLoss::initSupportedPrimitiveDescriptors() {
     for (size_t i = 1; i < inputShapes.size(); ++i)
         inDataConf.emplace_back(LayoutType::ncsp, ov::element::i32);
 
-    addSupportedPrimDesc(inDataConf,
-                         {{LayoutType::ncsp, ov::element::f32}},
-                         impl_desc_type::ref_any);
+    addSupportedPrimDesc(inDataConf, {{LayoutType::ncsp, ov::element::f32}}, impl_desc_type::ref_any);
 }
 
 void CTCLoss::executeDynamicImpl(dnnl::stream strm) {
@@ -71,7 +70,7 @@ void CTCLoss::execute(dnnl::stream strm) {
     const int* labelsLength = getSrcDataAtPortAs<const int>(3);
     float* dstData = getDstDataAtPortAs<float>(0);
 
-    const auto &inDims = getParentEdgeAt(0)->getMemory().getStaticDims();
+    const auto& inDims = getParentEdgeAt(0)->getMemory().getStaticDims();
     const size_t batchNum = inDims[0];
     const size_t maxTime = inDims[1];
     const size_t classesNum = inDims[2];
@@ -96,11 +95,11 @@ void CTCLoss::execute(dnnl::stream strm) {
         for (size_t b = start; b < end; b++) {
             if (logitsLength[b] < 0 || labelsLength[b] < 0 || logitsLength[b] > static_cast<int>(maxTime) ||
                 labelsLength[b] > logitsLength[b]) {
-                errorMsgB[ithr] = errorPrefix + ". Logit length cannot be greater than max sequence length. "
-                                  + "Label length cannot be greater than a logit length"
-                                  + " and both cannot be negative.\nMaxSeqLen: "
-                                  + std::to_string(maxTime) + "; Logit len: " + std::to_string(logitsLength[b])
-                                  + "; Label len: " + std::to_string(labelsLength[b]);
+                errorMsgB[ithr] = errorPrefix + ". Logit length cannot be greater than max sequence length. " +
+                                  "Label length cannot be greater than a logit length" +
+                                  " and both cannot be negative.\nMaxSeqLen: " + std::to_string(maxTime) +
+                                  "; Logit len: " + std::to_string(logitsLength[b]) +
+                                  "; Label len: " + std::to_string(labelsLength[b]);
                 returnCode = -1;
                 return;
             }
@@ -151,8 +150,8 @@ void CTCLoss::execute(dnnl::stream strm) {
             for (size_t ll = 0; ll < actualLogitLen; ll++) {
                 logProbabilities[ll].resize(decodedTargetLen);
             }
-        } // for batch
-    }; // threadBody_1
+        }  // for batch
+    };     // threadBody_1
 
     parallel_nt(threads_num, threadBody_1);
     if (returnCode != 0) {
@@ -211,7 +210,7 @@ void CTCLoss::execute(dnnl::stream strm) {
             }
             sT = 0lu;
         }  // for batch
-    }; // threadBody_2
+    };     // threadBody_2
 
     parallel_nt(0, threadBody_2);
 
@@ -236,8 +235,8 @@ void CTCLoss::execute(dnnl::stream strm) {
         if (start >= end)
             return;
 
-        // As per Connectionist Temporal Classification - Labeling Unsegmented Sequence Data with Recurrent Neural Networks:
-        // Graves et al., 2016, paragraph 4.1 (10)
+        // As per Connectionist Temporal Classification - Labeling Unsegmented Sequence Data with Recurrent Neural
+        // Networks: Graves et al., 2016, paragraph 4.1 (10)
         for (size_t b = start; b < end; b++) {
             auto& targetD = targetDB[b];
             auto& logProbabilities = logProbabilitiesB[b];
@@ -250,21 +249,19 @@ void CTCLoss::execute(dnnl::stream strm) {
             for (int t = actualLogitLen - 2; t >= 0; t--) {
                 const int t_1 = t + 1;
                 for (int s = std::max(0, decodedTargetLen - (2 * (actualLogitLen - t)));
-                     s < std::min(decodedTargetLen, 2 * (t_1)); s++) {
+                     s < std::min(decodedTargetLen, 2 * (t_1));
+                     s++) {
                     if (ctcMergeRepeated || targetD[s] == blankIndex) {
-                        logBwd[s][t] = sumLogs(logBwd[s][t],
-                                               logBwd[s][t_1] + logProbabilities[t_1][s]);
+                        logBwd[s][t] = sumLogs(logBwd[s][t], logBwd[s][t_1] + logProbabilities[t_1][s]);
                     }
 
                     if (s + 1 < decodedTargetLen) {
-                        logBwd[s][t] = sumLogs(logBwd[s][t],
-                                               logBwd[s + 1][t_1] + logProbabilities[t_1][s + 1]);
+                        logBwd[s][t] = sumLogs(logBwd[s][t], logBwd[s + 1][t_1] + logProbabilities[t_1][s + 1]);
                     }
 
                     if (s + 2 < decodedTargetLen) {
                         if (targetD[s] != blankIndex && (!ctcMergeRepeated || (targetD[s] != targetD[s + 2]))) {
-                            logBwd[s][t] = sumLogs(logBwd[s][t],
-                                                   logBwd[s + 2][t_1] + logProbabilities[t_1][s + 2]);
+                            logBwd[s][t] = sumLogs(logBwd[s][t], logBwd[s + 2][t_1] + logProbabilities[t_1][s + 2]);
                         }
                     }
                 }
@@ -274,8 +271,8 @@ void CTCLoss::execute(dnnl::stream strm) {
             logBwd[1][0] += logProbabilities[0][(decodedTargetLen > 1) ? 1 : 0];
 
             dstData[b] = -sumLogs(logBwd[0][0], logBwd[1][0]);
-        } // for batch
-    }; // threadBody_3
+        }  // for batch
+    };     // threadBody_3
 
     parallel_nt(0, threadBody_3);
 }
@@ -284,6 +281,6 @@ bool CTCLoss::created() const {
     return getType() == Type::CTCLoss;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/ctc_loss.h b/src/plugins/intel_cpu/src/nodes/ctc_loss.h
index a07d8f0fc59479..d1a66df3b92b89 100644
--- a/src/plugins/intel_cpu/src/nodes/ctc_loss.h
+++ b/src/plugins/intel_cpu/src/nodes/ctc_loss.h
@@ -14,7 +14,7 @@ class CTCLoss : public Node {
 public:
     CTCLoss(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -22,7 +22,9 @@ class CTCLoss : public Node {
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
     void executeDynamicImpl(dnnl::stream strm) override;
-    bool needPrepareParams() const override { return false; };
+    bool needPrepareParams() const override {
+        return false;
+    };
 
 private:
     bool ctcMergeRepeated;
@@ -32,6 +34,6 @@ class CTCLoss : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/cum_sum.cpp b/src/plugins/intel_cpu/src/nodes/cum_sum.cpp
index e411283e661585..43e69e29916430 100644
--- a/src/plugins/intel_cpu/src/nodes/cum_sum.cpp
+++ b/src/plugins/intel_cpu/src/nodes/cum_sum.cpp
@@ -3,15 +3,16 @@
 //
 
 #include "cum_sum.h"
+
+#include <string>
+#include <vector>
+
 #include "openvino/core/parallel.hpp"
 #include "openvino/core/type/float16.hpp"
 #include "openvino/opsets/opset1.hpp"
 #include "openvino/opsets/opset3.hpp"
 #include "utils/bfloat16.hpp"
 
-#include <string>
-#include <vector>
-
 namespace ov {
 namespace intel_cpu {
 namespace node {
@@ -38,10 +39,11 @@ CumSum::CumSum(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr con
 
     errorPrefix = "CumSum layer with name '" + op->get_friendly_name() + "' ";
 
-    if ((getOriginalInputsNumber() != numOfInputs && getOriginalInputsNumber() != (numOfInputs - 1)) || getOriginalOutputsNumber() != 1)
+    if ((getOriginalInputsNumber() != numOfInputs && getOriginalInputsNumber() != (numOfInputs - 1)) ||
+        getOriginalOutputsNumber() != 1)
         OPENVINO_THROW(errorPrefix, " has incorrect number of input/output edges!");
 
-    const auto &dataShape = getInputShapeAtPort(CUM_SUM_DATA);
+    const auto& dataShape = getInputShapeAtPort(CUM_SUM_DATA);
     numOfDims = dataShape.getRank();
     if (numOfDims < 1) {
         OPENVINO_THROW(errorPrefix, " doesn't support 'data' input tensor with rank: ", numOfDims);
@@ -70,13 +72,19 @@ void CumSum::initSupportedPrimitiveDescriptors() {
 
     dataPrecision = getOriginalInputPrecisionAtPort(CUM_SUM_DATA);
     if (!one_of(dataPrecision,
-                ov::element::i8, ov::element::u8,
-                ov::element::i16, ov::element::i32, ov::element::i64, ov::element::u64,
-                ov::element::bf16, ov::element::f16, ov::element::f32))
+                ov::element::i8,
+                ov::element::u8,
+                ov::element::i16,
+                ov::element::i32,
+                ov::element::i64,
+                ov::element::u64,
+                ov::element::bf16,
+                ov::element::f16,
+                ov::element::f32))
         OPENVINO_THROW(errorPrefix, " has unsupported 'data' input precision: ", dataPrecision.get_type_name());
 
     if (inputShapes.size() == numOfInputs) {
-        const auto &axisTensorPrec = getOriginalInputPrecisionAtPort(AXIS);
+        const auto& axisTensorPrec = getOriginalInputPrecisionAtPort(AXIS);
         if (axisTensorPrec != ov::element::i32 && axisTensorPrec != ov::element::i64)
             OPENVINO_THROW(errorPrefix, " has unsupported 'axis' input precision: ", axisTensorPrec.get_type_name());
     }
@@ -87,16 +95,17 @@ void CumSum::initSupportedPrimitiveDescriptors() {
     for (size_t i = 1; i < inputShapes.size(); ++i)
         inDataConf.emplace_back(LayoutType::ncsp, ov::element::i32);
 
-    addSupportedPrimDesc(inDataConf,
-                         {{LayoutType::ncsp, dataPrecision}},
-                         impl_desc_type::ref_any);
+    addSupportedPrimDesc(inDataConf, {{LayoutType::ncsp, dataPrecision}}, impl_desc_type::ref_any);
 }
 
 void CumSum::execute(dnnl::stream strm) {
     if (inputShapes.size() == numOfInputs)
         axis = getAxis(getParentEdgeAt(AXIS)->getMemory(), getParentEdgeAt(CUM_SUM_DATA)->getMemory());
 
-    OV_SWITCH(intel_cpu, CumSumExecute, this, dataPrecision,
+    OV_SWITCH(intel_cpu,
+              CumSumExecute,
+              this,
+              dataPrecision,
               OV_CASE(ov::element::i8, int8_t),
               OV_CASE(ov::element::u8, uint8_t),
               OV_CASE(ov::element::i16, int16_t),
@@ -110,9 +119,10 @@ void CumSum::execute(dnnl::stream strm) {
 
 template <typename dataType>
 void CumSum::exec() {
-    const auto *input = getSrcDataAtPortAs<const dataType>(CUM_SUM_DATA);
-    auto *output = getDstDataAtPortAs<dataType>(0);
-    const VectorDims strides = getParentEdgeAt(CUM_SUM_DATA)->getMemory().getDescWithType<BlockedMemoryDesc>()->getStrides();
+    const auto* input = getSrcDataAtPortAs<const dataType>(CUM_SUM_DATA);
+    auto* output = getDstDataAtPortAs<dataType>(0);
+    const VectorDims strides =
+        getParentEdgeAt(CUM_SUM_DATA)->getMemory().getDescWithType<BlockedMemoryDesc>()->getStrides();
 
     if (reverse) {
         if (exclusive) {
@@ -130,16 +140,17 @@ void CumSum::exec() {
 }
 
 template <bool reverse, bool exclusive, typename dataType>
-void CumSum::cumSum(const dataType *input, dataType *output, const VectorDims &strides) {
+void CumSum::cumSum(const dataType* input, dataType* output, const VectorDims& strides) {
     VectorDims iterationRange(numOfDims - 1);
     size_t j = 0;
-    const auto &shape = getParentEdgeAt(CUM_SUM_DATA)->getMemory().getStaticDims();
+    const auto& shape = getParentEdgeAt(CUM_SUM_DATA)->getMemory().getStaticDims();
     for (size_t i = 0; i < shape.size(); i++) {
         if (i == axis)
             continue;
         iterationRange[j++] = shape[i];
     }
-    size_t work_amount_dst = std::accumulate(iterationRange.begin(), iterationRange.end(), size_t(1), std::multiplies<size_t>());
+    size_t work_amount_dst =
+        std::accumulate(iterationRange.begin(), iterationRange.end(), size_t(1), std::multiplies<size_t>());
     parallel_nt(0, [&](const int ithr, const int nthr) {
         size_t start = 0, end = 0;
         VectorDims counters(numOfDims - 1, 0);
@@ -159,32 +170,32 @@ void CumSum::cumSum(const dataType *input, dataType *output, const VectorDims &s
 
             size_t startOffset = getStartOffset(forStartOffset, strides);
 
-            const dataType *inputStart = input + startOffset;
-            dataType *outputStart = output + startOffset;
+            const dataType* inputStart = input + startOffset;
+            dataType* outputStart = output + startOffset;
 
             size_t offset = strides[axis];
             if (reverse) {
                 if (exclusive) {
-                    outputStart[offset*(shape[axis] - 1)] = 0;
+                    outputStart[offset * (shape[axis] - 1)] = 0;
                     for (int64_t i = shape[axis] - 2; i >= 0; i--) {
-                        outputStart[i*offset] = inputStart[(i+1)*offset] + outputStart[(i+1)*offset];
+                        outputStart[i * offset] = inputStart[(i + 1) * offset] + outputStart[(i + 1) * offset];
                     }
                 } else {
-                    outputStart[offset*(shape[axis] - 1)] = inputStart[offset * (shape[axis] - 1)];
+                    outputStart[offset * (shape[axis] - 1)] = inputStart[offset * (shape[axis] - 1)];
                     for (int64_t i = shape[axis] - 2; i >= 0; i--) {
-                        outputStart[i*offset] = inputStart[i*offset] + outputStart[(i+1)*offset];
+                        outputStart[i * offset] = inputStart[i * offset] + outputStart[(i + 1) * offset];
                     }
                 }
             } else {
                 if (exclusive) {
                     outputStart[0] = 0;
                     for (size_t i = 1; i < shape[axis]; i++) {
-                        outputStart[i*offset] = inputStart[(i-1)*offset] + outputStart[(i-1)*offset];
+                        outputStart[i * offset] = inputStart[(i - 1) * offset] + outputStart[(i - 1) * offset];
                     }
                 } else {
                     outputStart[0] = inputStart[0];
                     for (size_t i = 1; i < shape[axis]; i++) {
-                        outputStart[i*offset] = inputStart[i*offset] + outputStart[(i-1)*offset];
+                        outputStart[i * offset] = inputStart[i * offset] + outputStart[(i - 1) * offset];
                     }
                 }
             }
@@ -219,7 +230,8 @@ inline void CumSum::parallelItStep(std::vector<size_t>& counters, const std::vec
     }
 }
 
-inline size_t CumSum::getStartOffset(const std::vector<size_t> &forStartOffset, const std::vector<size_t>& strides) const {
+inline size_t CumSum::getStartOffset(const std::vector<size_t>& forStartOffset,
+                                     const std::vector<size_t>& strides) const {
     size_t startOffset = 0;
     for (size_t idx = 0; idx < forStartOffset.size(); ++idx) {
         startOffset += forStartOffset[idx] * strides[idx];
@@ -232,19 +244,19 @@ size_t CumSum::getAxis(const IMemory& _axis, const IMemory& _data) const {
     const int64_t dataShapeSize = static_cast<int64_t>(_data.getShape().getRank());
     int64_t axisValueFromBlob = 0;
     switch (axisPrecision) {
-        case ov::element::i32 : {
-            const auto *axisPtr = _axis.getDataAs<const int32_t>();
-            axisValueFromBlob = static_cast<int64_t>(axisPtr[0]);
-            break;
-        }
-        case ov::element::i64 : {
-            const auto *axisPtr = _axis.getDataAs<const int64_t>();
-            axisValueFromBlob = axisPtr[0];
-            break;
-        }
-        default : {
-            OPENVINO_THROW(errorPrefix, "  doesn't support 'axis' input with precision: ", axisPrecision.get_type_name());
-        }
+    case ov::element::i32: {
+        const auto* axisPtr = _axis.getDataAs<const int32_t>();
+        axisValueFromBlob = static_cast<int64_t>(axisPtr[0]);
+        break;
+    }
+    case ov::element::i64: {
+        const auto* axisPtr = _axis.getDataAs<const int64_t>();
+        axisValueFromBlob = axisPtr[0];
+        break;
+    }
+    default: {
+        OPENVINO_THROW(errorPrefix, "  doesn't support 'axis' input with precision: ", axisPrecision.get_type_name());
+    }
     }
     if (axisValueFromBlob < -dataShapeSize || axisValueFromBlob > dataShapeSize - 1)
         OPENVINO_THROW(errorPrefix, "  has axis with a value out of range: ", axisValueFromBlob);
@@ -263,6 +275,6 @@ void CumSum::executeDynamicImpl(dnnl::stream strm) {
     execute(strm);
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/cum_sum.h b/src/plugins/intel_cpu/src/nodes/cum_sum.h
index b0aad351d55f93..139c7205e81fcc 100644
--- a/src/plugins/intel_cpu/src/nodes/cum_sum.h
+++ b/src/plugins/intel_cpu/src/nodes/cum_sum.h
@@ -14,7 +14,7 @@ class CumSum : public Node {
 public:
     CumSum(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -29,13 +29,13 @@ class CumSum : public Node {
     void exec();
 
     template <bool reverse, bool exclusive, typename dataType>
-    void cumSum(const dataType *input, dataType *output, const std::vector<size_t> &strides);
+    void cumSum(const dataType* input, dataType* output, const std::vector<size_t>& strides);
 
     void parallelItInit(size_t start, std::vector<size_t>& counters, const std::vector<size_t>& iterationRange);
 
     inline void parallelItStep(std::vector<size_t>& counters, const std::vector<size_t>& iterationRange);
 
-    inline size_t getStartOffset(const std::vector<size_t> &forStartOffset, const std::vector<size_t>& strides) const;
+    inline size_t getStartOffset(const std::vector<size_t>& forStartOffset, const std::vector<size_t>& strides) const;
 
     size_t getAxis(const IMemory& _axis, const IMemory& _data) const;
 
@@ -48,7 +48,7 @@ class CumSum : public Node {
     ov::element::Type dataPrecision;
     std::string errorPrefix;
 
-    template<typename T>
+    template <typename T>
     struct CumSumExecute {
         void operator()(CumSum* node) {
             node->exec<T>();
@@ -56,6 +56,6 @@ class CumSum : public Node {
     };
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/deconv.cpp b/src/plugins/intel_cpu/src/nodes/deconv.cpp
index 537f9111b0ceec..f30e3481afbb3d 100644
--- a/src/plugins/intel_cpu/src/nodes/deconv.cpp
+++ b/src/plugins/intel_cpu/src/nodes/deconv.cpp
@@ -4,16 +4,15 @@
 
 #include "deconv.h"
 
-#include "dnnl_extension_utils.h"
 #include <memory_desc/cpu_memory_desc_utils.h>
 #include <nodes/common/cpu_memcpy.h>
 
-#include "common/primitive_hashing_utils.hpp"
 #include <common/primitive_desc.hpp>
 #include <common/primitive_desc_iface.hpp>
-#include "cpu/x64/cpu_isa_traits.hpp"
-#include "shape_inference/shape_inference.hpp"
 
+#include "common/primitive_hashing_utils.hpp"
+#include "cpu/x64/cpu_isa_traits.hpp"
+#include "dnnl_extension_utils.h"
 #include "eltwise.h"
 #include "fake_quantize.h"
 #include "input.h"
@@ -21,16 +20,16 @@
 #include "openvino/core/parallel.hpp"
 #include "openvino/opsets/opset1.hpp"
 #include "openvino/runtime/make_tensor.hpp"
-#include "utils/general_utils.h"
+#include "shape_inference/shape_inference.hpp"
 #include "utils/cpu_utils.hpp"
+#include "utils/general_utils.h"
 
 #if defined(OV_CPU_WITH_ACL)
-#include "executors/acl/acl_utils.hpp"
-#include "utils/debug_capabilities.h"
+#    include "executors/acl/acl_utils.hpp"
+#    include "utils/debug_capabilities.h"
 #endif
 
 #include <oneapi/dnnl/dnnl.hpp>
-
 #include <string>
 #include <vector>
 
@@ -40,8 +39,8 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 
-using DefaultDeconvDescs = std::pair<dnnl::convolution_backward_data::primitive_desc,
-                                     dnnl::convolution_forward::primitive_desc>;
+using DefaultDeconvDescs =
+    std::pair<dnnl::convolution_backward_data::primitive_desc, dnnl::convolution_forward::primitive_desc>;
 using Int8DeconvDesc = dnnl::deconvolution_forward::primitive_desc;
 
 namespace {
@@ -92,7 +91,7 @@ size_t DeconvKey::hash() const {
     return seed;
 }
 
-bool DeconvKey::operator==(const DeconvKey &rhs) const {
+bool DeconvKey::operator==(const DeconvKey& rhs) const {
     bool retVal = true;
     if (inp0 != rhs.inp0) {
         retVal = retVal && inp0 && rhs.inp0 && inp0->getDnnlDesc() == rhs.inp0->getDnnlDesc();
@@ -122,8 +121,8 @@ bool DeconvKey::operator==(const DeconvKey &rhs) const {
 }
 
 /**
- * Deconvolution shape inference factory. It defines the input mask depending on the existence of the `output_shape` input.
- * Since in case it exists, plugin should pass the input data to the shape inference function.
+ * Deconvolution shape inference factory. It defines the input mask depending on the existence of the `output_shape`
+ * input. Since in case it exists, plugin should pass the input data to the shape inference function.
  *
  */
 class DeconfolutionShapeInferFactory : public ShapeInferFactory {
@@ -134,16 +133,19 @@ class DeconfolutionShapeInferFactory : public ShapeInferFactory {
         const auto port_mask = (m_op->get_input_size() > 2) ? PortMask(2) : EMPTY_PORT_MASK;
         return make_shape_inference(m_op, port_mask);
     }
+
 private:
     std::shared_ptr<ov::Node> m_op;
 };
-} // namespace
+}  // namespace
 
-bool Deconvolution::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool Deconvolution::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                         std::string& errorMessage) noexcept {
     try {
         if (std::dynamic_pointer_cast<const ov::op::v1::ConvolutionBackpropData>(op) == nullptr &&
-                std::dynamic_pointer_cast<const ov::op::v1::GroupConvolutionBackpropData>(op) == nullptr) {
-            errorMessage = "Only opset1 ConvolutionBackpropData and GroupConvolutionBackpropData operations are supported";
+            std::dynamic_pointer_cast<const ov::op::v1::GroupConvolutionBackpropData>(op) == nullptr) {
+            errorMessage =
+                "Only opset1 ConvolutionBackpropData and GroupConvolutionBackpropData operations are supported";
             return false;
         }
         size_t ndims = op->get_input_partial_shape(0).rank().get_length();
@@ -151,7 +153,8 @@ bool Deconvolution::isSupportedOperation(const std::shared_ptr<const ov::Node>&
             errorMessage = "Only 3D, 4D and 5D blobs are supported as input";
             return false;
         }
-        if (op->get_input_partial_shape(1).is_dynamic() || (op->get_input_size() > 2 && op->get_input_partial_shape(2).is_dynamic())) {
+        if (op->get_input_partial_shape(1).is_dynamic() ||
+            (op->get_input_size() > 2 && op->get_input_partial_shape(2).is_dynamic())) {
             errorMessage = "Doesn't support dynamic shapes for 'weights' and 'output_shape' inputs";
             return false;
         }
@@ -161,8 +164,8 @@ bool Deconvolution::isSupportedOperation(const std::shared_ptr<const ov::Node>&
     return true;
 }
 
-Deconvolution::Deconvolution(const std::shared_ptr<ov::Node>& op,
-                             const GraphContext::CPtr context) : Node(op, context, DeconfolutionShapeInferFactory(op)) {
+Deconvolution::Deconvolution(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, DeconfolutionShapeInferFactory(op)) {
     std::string errorMessage;
     errorPrefix = "Deconvolution node with name '" + getName() + "' ";
     if (!isSupportedOperation(op, errorMessage))
@@ -175,7 +178,7 @@ Deconvolution::Deconvolution(const std::shared_ptr<ov::Node>& op,
 
         IC = weightDims[0];
         OC = weightDims[1];
-        expectedBiasDims  = {OC};
+        expectedBiasDims = {OC};
 
         groupNum = 1;
         withGroups = false;
@@ -198,7 +201,7 @@ Deconvolution::Deconvolution(const std::shared_ptr<ov::Node>& op,
         groupNum = weightDims[0];
         IC = groupNum * weightDims[1];
         OC = groupNum * weightDims[2];
-        expectedBiasDims  = {OC};
+        expectedBiasDims = {OC};
         withGroups = groupNum > 1;
         isDW = withGroups && groupNum == OC && groupNum == IC;
 
@@ -228,8 +231,11 @@ Deconvolution::Deconvolution(const std::shared_ptr<ov::Node>& op,
         lastOutputSpatialDims = ov::as_type<ov::op::v0::Constant>(op->get_input_node_ptr(2))->cast_vector<int32_t>();
     if (externOutShape && isDynamicNode()) {
         const auto spDimsNum = getInputShapeAtPort(0).getRank() - 2;
-        if (getInputShapeAtPort(2).getStaticDims()[0] != spDimsNum || (isConstOutShape && lastOutputSpatialDims.size() != spDimsNum)) {
-            OPENVINO_THROW(errorPrefix, "'output_shape' input has incorrect number of elements. Expected = ", spDimsNum);
+        if (getInputShapeAtPort(2).getStaticDims()[0] != spDimsNum ||
+            (isConstOutShape && lastOutputSpatialDims.size() != spDimsNum)) {
+            OPENVINO_THROW(errorPrefix,
+                           "'output_shape' input has incorrect number of elements. Expected = ",
+                           spDimsNum);
         }
     }
 
@@ -239,8 +245,10 @@ Deconvolution::Deconvolution(const std::shared_ptr<ov::Node>& op,
     for (size_t i = 0; i < spatialRank; ++i)
         is1x1 = is1x1 && *(weightDimsReversItr++) == 1;
     // 1x1 deconv has some test case failed. The cause is upstream ONEDNN unsupported brgemm implementation cases are
-    // enabled in forked ONEDNNN https://github.com/openvinotoolkit/oneDNN/blob/117e287000b48a34a7218fcaa274a91571141728/src/common/convolution.cpp#L138.
-    // Some test cases on 1x1 kernel failed on accuracy check, current WA is disabling brgemm deconv implementation for such cases.
+    // enabled in forked ONEDNNN
+    // https://github.com/openvinotoolkit/oneDNN/blob/117e287000b48a34a7218fcaa274a91571141728/src/common/convolution.cpp#L138.
+    // Some test cases on 1x1 kernel failed on accuracy check, current WA is disabling brgemm deconv implementation for
+    // such cases.
     if (is1x1 && deconvAttrs.paddingL != deconvAttrs.paddingR) {
         // case1: Specify asymmetric padding explicitly
         asymmetricPaddingAnd1x1 = true;
@@ -289,7 +297,9 @@ bool Deconvolution::canBeExecutedInInt8() const {
         return false;
     if (!impl::cpu::x64::mayiuse(impl::cpu::x64::avx512_core)) {
         const auto& inMaxDims = getOutputShapeAtPort(0).getMaxDims();
-        if (std::any_of(inMaxDims.begin(), inMaxDims.end(), [](Dim dim) { return dim == Shape::UNDEFINED_DIM; })) {
+        if (std::any_of(inMaxDims.begin(), inMaxDims.end(), [](Dim dim) {
+                return dim == Shape::UNDEFINED_DIM;
+            })) {
             return false;
         }
         // heuristicConst = 2^26
@@ -309,7 +319,8 @@ bool Deconvolution::canBeExecutedInInt8() const {
 
     // not supported in oneDNN
     int channelBlock = impl::cpu::x64::mayiuse(impl::cpu::x64::avx512_core) ? 16
-            : impl::cpu::x64::mayiuse(impl::cpu::x64::avx2) ? 8 : 4;
+                       : impl::cpu::x64::mayiuse(impl::cpu::x64::avx2)      ? 8
+                                                                            : 4;
     if (withGroups && !isDW && (IC % channelBlock != 0 || OC % channelBlock != 0))
         return false;
     if (!impl::cpu::x64::mayiuse(impl::cpu::x64::avx512_core) && deconvAttrs.stride.back() > 3)
@@ -330,16 +341,18 @@ bool Deconvolution::canBeExecutedInInt8() const {
 bool Deconvolution::canFuse(const NodePtr& node) const {
     if (canBeExecutedInInt8())
         return canFuseSimpleOperation(node);
-    // Upstream ONEDNN conv_backward_data primitive can't support any post-ops, fork onednn added depthwise support in conv_backward_data JIT implementation.
-    // ONEDNN deconv primitive can support most of post-ops, but the post-ops implementation details are different.
-    // So current deconv implementation list in onednn has 2 kinds of implements:
+    // Upstream ONEDNN conv_backward_data primitive can't support any post-ops, fork onednn added depthwise support in
+    // conv_backward_data JIT implementation. ONEDNN deconv primitive can support most of post-ops, but the post-ops
+    // implementation details are different. So current deconv implementation list in onednn has 2 kinds of implements:
     //    1. deconv implementation with JIT post-ops supported in the kernel (such as brgdeconv)
-    //    2. forked conv_data_backwards implementation with JIT depthwise post-ops + reference implementation for other post ops.
-    // Considering that some deconv fallback on the JIT implementation, we limit the post ops fusing to avoid regressions.
-    // Regression with stylegan2 int8 model pattern:
-    // none-quantzied deconv(with none-const weight) + FQ pattern fall back on JIT because of onednn limitation. (fall back ticket MFDNN-11577).
-    // If FQ is fused, it runs with the ref post-ops implementation.
-    // @todo: if onednn can ensure all the deconv run with the brgemm implementation, we can unify the fuse criteria between int8 and fp32 use cases.
+    //    2. forked conv_data_backwards implementation with JIT depthwise post-ops + reference implementation for other
+    //    post ops.
+    // Considering that some deconv fallback on the JIT implementation, we limit the post ops fusing to avoid
+    // regressions. Regression with stylegan2 int8 model pattern: none-quantzied deconv(with none-const weight) + FQ
+    // pattern fall back on JIT because of onednn limitation. (fall back ticket MFDNN-11577). If FQ is fused, it runs
+    // with the ref post-ops implementation.
+    // @todo: if onednn can ensure all the deconv run with the brgemm implementation, we can unify the fuse criteria
+    // between int8 and fp32 use cases.
     return (fusedWith.empty() && node->canBePerformedAsScaleShift(this));
 }
 
@@ -360,8 +373,10 @@ std::pair<VectorDims, VectorDims> Deconvolution::makeDummyInOutShape() {
                 const auto& maxDims = shape.getMaxDims();
                 const auto& dims = shape.getDims();
                 for (size_t i = 0; i < dims.size() - 2; ++i) {
-                    lastOutputSpatialDims[i] = dims[i + 2] == Shape::UNDEFINED_DIM ? std::min(maxDims[i + 2],
-                                                                                              std::max(minDims[i + 2], static_cast<Dim>(64))) : dims[i + 2];
+                    lastOutputSpatialDims[i] =
+                        dims[i + 2] == Shape::UNDEFINED_DIM
+                            ? std::min(maxDims[i + 2], std::max(minDims[i + 2], static_cast<Dim>(64)))
+                            : dims[i + 2];
                 }
             }
 
@@ -380,14 +395,18 @@ std::pair<VectorDims, VectorDims> Deconvolution::makeDummyInOutShape() {
                 for (size_t i = 0; i < origInDims.size() - 2; i++) {
                     if (origInDims[i + 2] == Shape::UNDEFINED_DIM &&
                         (origInMinDims[i + 2] != 0 || origInMaxDims[i + 2] != Shape::UNDEFINED_DIM)) {
-                        // if input shape is dynamic and bounded, paddings should be computed basing on the following limitations:
+                        // if input shape is dynamic and bounded, paddings should be computed basing on the following
+                        // limitations:
                         // 1. paddings must not be negative
-                        // 2. the result padding must have such a value to keep the dummy dimensions inside the predefined interval
-                        auto c1 = lastOutputSpatialDims[i] - deconvAttrs.outputPadding[i] - 1 -
-                                    (deconvAttrs.dilation[i] + 1) * static_cast<int32_t>(weightDims[wghOffset + 2 + i] - 1);
+                        // 2. the result padding must have such a value to keep the dummy dimensions inside the
+                        // predefined interval
+                        auto c1 =
+                            lastOutputSpatialDims[i] - deconvAttrs.outputPadding[i] - 1 -
+                            (deconvAttrs.dilation[i] + 1) * static_cast<int32_t>(weightDims[wghOffset + 2 + i] - 1);
 
                         if (origInMaxDims[i + 2] != Shape::UNDEFINED_DIM) {
-                            auto upper_bound = deconvAttrs.stride[i] * static_cast<int32_t>(origInMaxDims[i + 2] - 1) - c1;
+                            auto upper_bound =
+                                deconvAttrs.stride[i] * static_cast<int32_t>(origInMaxDims[i + 2] - 1) - c1;
                             if (upper_bound < 0) {
                                 OPENVINO_THROW(errorPrefix, ": paddings for dummy shapes can't be computed");
                             }
@@ -403,9 +422,11 @@ std::pair<VectorDims, VectorDims> Deconvolution::makeDummyInOutShape() {
 
             for (size_t i = 0; i < inputDims.size() - 2; i++) {
                 if (origInDims[2 + i] == Shape::UNDEFINED_DIM) {
-                    inputDims[2 + i] = (lastOutputSpatialDims[i] - (deconvAttrs.dilation[i] + 1) *
-                                        (weightDims[wghOffset + 2 + i] - 1) - 1 + paddings[i] - deconvAttrs.outputPadding[i]) /
-                                        deconvAttrs.stride[i] + 1;
+                    inputDims[2 + i] = (lastOutputSpatialDims[i] -
+                                        (deconvAttrs.dilation[i] + 1) * (weightDims[wghOffset + 2 + i] - 1) - 1 +
+                                        paddings[i] - deconvAttrs.outputPadding[i]) /
+                                           deconvAttrs.stride[i] +
+                                       1;
                 }
             }
         }
@@ -456,12 +477,14 @@ void Deconvolution::getSupportedDescriptors() {
     if (!descs.empty())
         return;
     isInt8 = canBeExecutedInInt8();
-    deconvAttrs.withBiasesParam = withBiases = externOutShape ? getOriginalInputsNumber() == 4 : getOriginalInputsNumber() == 3;
+    deconvAttrs.withBiasesParam = withBiases =
+        externOutShape ? getOriginalInputsNumber() == 4 : getOriginalInputsNumber() == 3;
 
     ov::element::Type inPrecision = getOriginalInputPrecisionAtPort(0);
     ov::element::Type outPrecision = getOriginalOutputPrecisionAtPort(0);
     if (isInt8) {
-        // TODO: We have to extend jit_avx512_core_x8s8s32x_deconv_fwd_kernel from oneDNN to support BF16 output data type
+        // TODO: We have to extend jit_avx512_core_x8s8s32x_deconv_fwd_kernel from oneDNN to support BF16 output data
+        // type
         if (ov::element::bf16 == inPrecision)
             inPrecision = ov::element::f32;
         if (ov::element::bf16 == outPrecision)
@@ -475,11 +498,12 @@ void Deconvolution::getSupportedDescriptors() {
     auto inputDataType = DnnlExtensionUtils::ElementTypeToDataType(inPrecision);
     outputDataType = DnnlExtensionUtils::ElementTypeToDataType(outPrecision);
     if (inputDataType == memory::data_type::bf16 || outputDataType == memory::data_type::bf16)
-       inputDataType = outputDataType = memory::data_type::bf16;
+        inputDataType = outputDataType = memory::data_type::bf16;
     if (inputDataType == memory::data_type::f16 || outputDataType == memory::data_type::f16)
-       inputDataType = outputDataType = memory::data_type::f16;
+        inputDataType = outputDataType = memory::data_type::f16;
     if (!fusedWith.empty()) {
-        outputDataType = DnnlExtensionUtils::ElementTypeToDataType(fusedWith[fusedWith.size() - 1]->getOriginalOutputPrecisionAtPort(0));
+        outputDataType = DnnlExtensionUtils::ElementTypeToDataType(
+            fusedWith[fusedWith.size() - 1]->getOriginalOutputPrecisionAtPort(0));
     }
     if (getParentEdges().size() != (withBiases ? (biasPort + 1) : biasPort)) {
         OPENVINO_THROW(errorPrefix, " has incorrect number of input edges");
@@ -489,7 +513,7 @@ void Deconvolution::getSupportedDescriptors() {
     }
     VectorDims inDims, outDims;
     std::tie(inDims, outDims) = makeDummyInOutShape();
-    inShape  = Shape(inDims);
+    inShape = Shape(inDims);
     outShape = Shape(outDims);
     initPaddingR(inShape, outShape);
 
@@ -505,17 +529,18 @@ void Deconvolution::getSupportedDescriptors() {
         config.outConfs.resize(getOriginalOutputsNumber());
         // ACL use same precision for all inputs
         config.inConfs[0].setMemDesc(
-                creatorsMap.at(format)->createSharedDesc(getOriginalInputPrecisionAtPort(0), getInputShapeAtPort(0)));
+            creatorsMap.at(format)->createSharedDesc(getOriginalInputPrecisionAtPort(0), getInputShapeAtPort(0)));
         config.inConfs[1].setMemDesc(
-                creatorsMap.at(weights_format)->createSharedDesc(getOriginalInputPrecisionAtPort(0), getInputShapeAtPort(1)));
+            creatorsMap.at(weights_format)
+                ->createSharedDesc(getOriginalInputPrecisionAtPort(0), getInputShapeAtPort(1)));
         for (size_t i = 2; i < getParentEdges().size(); ++i) {
             config.inConfs[i].setMemDesc(
-                    creatorsMap.at(format)->createSharedDesc(getOriginalInputPrecisionAtPort(0), getInputShapeAtPort(i)));
+                creatorsMap.at(format)->createSharedDesc(getOriginalInputPrecisionAtPort(0), getInputShapeAtPort(i)));
         }
 
         for (size_t i = 0; i < config.outConfs.size(); ++i) {
             config.outConfs[i].setMemDesc(
-                    creatorsMap.at(format)->createSharedDesc(getOriginalOutputPrecisionAtPort(0), getOutputShapeAtPort(i)));
+                creatorsMap.at(format)->createSharedDesc(getOriginalOutputPrecisionAtPort(0), getOutputShapeAtPort(i)));
         }
 
         std::vector<MemoryDescPtr> srcMemoryDescs;
@@ -532,7 +557,8 @@ void Deconvolution::getSupportedDescriptors() {
         return AclDeconvExecutorBuilder::customIsSupported(deconvAttrs, srcMemoryDescs, dstMemoryDescs);
     };
     useACL = checkDesc(LayoutType::nspc) || checkDesc(LayoutType::ncsp);
-    if (useACL) return;
+    if (useACL)
+        return;
 #endif
     dnnlCompatibleWeiDims = getWeightDims();
     // Construct the ONEDNN deconv OP weight shape.
@@ -547,26 +573,30 @@ void Deconvolution::getSupportedDescriptors() {
         auto format = rank == 5   ? dnnl::memory::format_tag::ndhwc
                       : rank == 4 ? dnnl::memory::format_tag::nhwc
                                   : dnnl::memory::format_tag::nwc;
-        MemoryDescPtr in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(0), inputDataType, format);
-        MemoryDescPtr out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(getOutputShapeAtPort(0), outputDataType, format);
+        MemoryDescPtr in_candidate =
+            std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(0), inputDataType, format);
+        MemoryDescPtr out_candidate =
+            std::make_shared<DnnlBlockedMemoryDesc>(getOutputShapeAtPort(0), outputDataType, format);
         createDescriptor({in_candidate}, {out_candidate});
     } else {
         for (auto format : getAvailableFormatsForDims(getInputShapeAtPort(0))) {
-            MemoryDescPtr in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(0), inputDataType, format);
-            MemoryDescPtr out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(getOutputShapeAtPort(0), outputDataType, format);
+            MemoryDescPtr in_candidate =
+                std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(0), inputDataType, format);
+            MemoryDescPtr out_candidate =
+                std::make_shared<DnnlBlockedMemoryDesc>(getOutputShapeAtPort(0), outputDataType, format);
             createDescriptor({in_candidate}, {out_candidate});
         }
     }
 }
 
-void Deconvolution::initPaddingR(const Shape &inShape, const Shape &outShape) {
+void Deconvolution::initPaddingR(const Shape& inShape, const Shape& outShape) {
     for (size_t i = 0; i < deconvAttrs.paddingR.size(); i++) {
         int with_group = getAlgorithm() == Algorithm::DeconvolutionGrouped ? 1 : 0;
         const auto& weightDims = getWeightDims();
         int krn = weightDims[with_group + 2 + i];
         int src = outShape.getStaticDims()[2 + i];
         int dst = inShape.getStaticDims()[2 + i];
-        krn = (krn - 1)*(deconvAttrs.dilation[i] + 1) + 1;
+        krn = (krn - 1) * (deconvAttrs.dilation[i] + 1) + 1;
         deconvAttrs.paddingR[i] = (dst - 1) * deconvAttrs.stride[i] - (src - krn + deconvAttrs.paddingL[i]);
     }
 }
@@ -584,11 +614,22 @@ void Deconvolution::setPostOps(dnnl::primitive_attr& attr, const VectorDims& dim
     // For deconv OP,  Deconv_OC = IC, Deconv_IC = OC.
     // Openvino per-channel weight scales are applied on IC/Deconv_OC dimension.
     // So for deconvolution,
-    // Weight dims in NON-Group deconv: [Deconv_OC, Deconv_IC, KH, KW], perchannel weight scale is applied on Deconv_OC DIM
+    // Weight dims in NON-Group deconv: [Deconv_OC, Deconv_IC, KH, KW], perchannel weight scale is applied on Deconv_OC
+    // DIM
     //                                  weiScaleMaskPerChannel =  1 << 0
-    // Weight dims in Group deconv:     [Group, Deconv_OC, Deconv_IC, KH, KW], perchannel weight scale is applied on GROUP and Deconv_OC,
+    // Weight dims in Group deconv:     [Group, Deconv_OC, Deconv_IC, KH, KW], perchannel weight scale is applied on
+    // GROUP and Deconv_OC,
     //                                   weiScaleMaskPerChannel = ( 1 << 0 | 1 << 1) = 0x03
-    DnnlPostOpsComposerLegacy dnnlpoc(getEngine(), attr, ops, postOpsArgs, dims, 1, isInt8, withGroups ? 3 : 1 << 0,  getDQScales(), withBiases);
+    DnnlPostOpsComposerLegacy dnnlpoc(getEngine(),
+                                      attr,
+                                      ops,
+                                      postOpsArgs,
+                                      dims,
+                                      1,
+                                      isInt8,
+                                      withGroups ? 3 : 1 << 0,
+                                      getDQScales(),
+                                      withBiases);
 
     for (size_t i = 0; i < fusedWith.size(); ++i) {
         auto& node = fusedWith[i];
@@ -633,7 +674,7 @@ bool Deconvolution::needShapeInfer() const {
     return false;
 }
 
-VectorDims Deconvolution::shapeInferInternal(const VectorDims &inDims, std::vector<int32_t> outSpDims) const {
+VectorDims Deconvolution::shapeInferInternal(const VectorDims& inDims, std::vector<int32_t> outSpDims) const {
     std::vector<std::reference_wrapper<const VectorDims>> inputShapesRefs{std::ref(inDims), std::ref(getWeightDims())};
     std::unordered_map<size_t, MemoryPtr> inputValues;
     VectorDims outSpDimsVecShape;
@@ -678,7 +719,7 @@ void Deconvolution::execute(dnnl::stream strm) {
         for (size_t i = 0; i < getOriginalOutputsNumber(); i++) {
             dstMemory.push_back(getDstMemoryAtPort(i));
         }
-        //TODO: need to pass post ops data
+        // TODO: need to pass post ops data
         execPtrDeconvACL->exec(srcMemory, dstMemory, nullptr);
         return;
     }
@@ -696,43 +737,50 @@ void Deconvolution::execute(dnnl::stream strm) {
 
 namespace {
 dnnl::primitive_desc createDescriptorInternal(const dnnl::memory::desc& in_candidate,
-                                                  const dnnl::memory::desc& wgh_candidate,
-                                                  const dnnl::memory::desc& bias_candidate,
-                                                  const dnnl::memory::desc& out_candidate,
-                                                  const bool with_bias,
-                                                  const std::vector<ptrdiff_t>& stride,
-                                                  const std::vector<ptrdiff_t>& dilation,
-                                                  const ov::CoordinateDiff& paddingL,
-                                                  const ov::CoordinateDiff& paddingR,
-                                                  const dnnl::primitive_attr& attr,
-                                                  const dnnl::engine& engine) {
-    auto convertDims = [] (const std::vector<ptrdiff_t>& orig_dims) {
+                                              const dnnl::memory::desc& wgh_candidate,
+                                              const dnnl::memory::desc& bias_candidate,
+                                              const dnnl::memory::desc& out_candidate,
+                                              const bool with_bias,
+                                              const std::vector<ptrdiff_t>& stride,
+                                              const std::vector<ptrdiff_t>& dilation,
+                                              const ov::CoordinateDiff& paddingL,
+                                              const ov::CoordinateDiff& paddingR,
+                                              const dnnl::primitive_attr& attr,
+                                              const dnnl::engine& engine) {
+    auto convertDims = [](const std::vector<ptrdiff_t>& orig_dims) {
         return memory::dims(orig_dims.begin(), orig_dims.end());
     };
 
     if (with_bias) {
-        return dnnl::deconvolution_forward::primitive_desc(
-            engine,
-            prop_kind::forward_inference,
-            dnnl::algorithm::deconvolution_direct,
-            in_candidate, wgh_candidate, bias_candidate, out_candidate,
-            convertDims(stride), convertDims(dilation),
-            convertDims(paddingL), convertDims(paddingR),
-            attr);
+        return dnnl::deconvolution_forward::primitive_desc(engine,
+                                                           prop_kind::forward_inference,
+                                                           dnnl::algorithm::deconvolution_direct,
+                                                           in_candidate,
+                                                           wgh_candidate,
+                                                           bias_candidate,
+                                                           out_candidate,
+                                                           convertDims(stride),
+                                                           convertDims(dilation),
+                                                           convertDims(paddingL),
+                                                           convertDims(paddingR),
+                                                           attr);
     } else {
-        return dnnl::deconvolution_forward::primitive_desc(
-            engine,
-            prop_kind::forward_inference,
-            dnnl::algorithm::deconvolution_direct,
-            in_candidate, wgh_candidate, out_candidate,
-            convertDims(stride), convertDims(dilation),
-            convertDims(paddingL), convertDims(paddingR),
-            attr);
+        return dnnl::deconvolution_forward::primitive_desc(engine,
+                                                           prop_kind::forward_inference,
+                                                           dnnl::algorithm::deconvolution_direct,
+                                                           in_candidate,
+                                                           wgh_candidate,
+                                                           out_candidate,
+                                                           convertDims(stride),
+                                                           convertDims(dilation),
+                                                           convertDims(paddingL),
+                                                           convertDims(paddingR),
+                                                           attr);
     }
 }
-} // namespace
+}  // namespace
 
-Node::AttrPtr Deconvolution::makePrimitiveAttr(const VectorDims &dims) {
+Node::AttrPtr Deconvolution::makePrimitiveAttr(const VectorDims& dims) {
     auto attr = std::make_shared<dnnl::primitive_attr>(dnnl::primitive_attr());
 
     setPostOps(*attr, dims);
@@ -747,81 +795,61 @@ Node::AttrPtr Deconvolution::initPrimitiveAttr() {
 const std::vector<impl_desc_type>& Deconvolution::getDefaultImplPriority() {
     static const std::vector<impl_desc_type> priorities {
         impl_desc_type::unknown,
-        // Undef impl type is used to express use-cases there real type is unkown during compilation
-        // Undef has higher priority than defined types in order to force primitive selection logic to make decision based on other properties
-        impl_desc_type::undef,
-        impl_desc_type::brgconv_avx512_amx_1x1,
-        impl_desc_type::brgconv_avx512_amx,
-        impl_desc_type::jit_avx512_amx_dw,
-        impl_desc_type::jit_avx512_amx_1x1,
-        impl_desc_type::jit_avx512_amx,
-        impl_desc_type::brgconv_avx512_1x1,
-        impl_desc_type::brgconv_avx512,
-        impl_desc_type::jit_avx512_dw,
-        impl_desc_type::jit_avx512_1x1,
-        impl_desc_type::jit_avx512,
-        impl_desc_type::brgconv_avx2_1x1,
-        impl_desc_type::brgconv_avx2,
-        impl_desc_type::jit_uni_dw,
-        impl_desc_type::jit_uni_1x1,
-        impl_desc_type::jit_uni,
-        impl_desc_type::jit_avx2_dw,
-        impl_desc_type::jit_avx2_1x1,
-        impl_desc_type::jit_avx2,
-        impl_desc_type::jit_avx_dw,
-        impl_desc_type::jit_avx_1x1,
-        impl_desc_type::jit_avx,
-        impl_desc_type::jit_sse42_dw,
-        impl_desc_type::jit_sse42_1x1,
-        impl_desc_type::jit_sse42,
+            // Undef impl type is used to express use-cases there real type is unkown during compilation
+            // Undef has higher priority than defined types in order to force primitive selection logic to make decision
+            // based on other properties
+            impl_desc_type::undef, impl_desc_type::brgconv_avx512_amx_1x1, impl_desc_type::brgconv_avx512_amx,
+            impl_desc_type::jit_avx512_amx_dw, impl_desc_type::jit_avx512_amx_1x1, impl_desc_type::jit_avx512_amx,
+            impl_desc_type::brgconv_avx512_1x1, impl_desc_type::brgconv_avx512, impl_desc_type::jit_avx512_dw,
+            impl_desc_type::jit_avx512_1x1, impl_desc_type::jit_avx512, impl_desc_type::brgconv_avx2_1x1,
+            impl_desc_type::brgconv_avx2, impl_desc_type::jit_uni_dw, impl_desc_type::jit_uni_1x1,
+            impl_desc_type::jit_uni, impl_desc_type::jit_avx2_dw, impl_desc_type::jit_avx2_1x1,
+            impl_desc_type::jit_avx2, impl_desc_type::jit_avx_dw, impl_desc_type::jit_avx_1x1, impl_desc_type::jit_avx,
+            impl_desc_type::jit_sse42_dw, impl_desc_type::jit_sse42_1x1, impl_desc_type::jit_sse42,
 #if defined(OPENVINO_ARCH_ARM64)
-        impl_desc_type::jit_asimd,
+            impl_desc_type::jit_asimd,
 #endif
-        impl_desc_type::gemm_any,
-        impl_desc_type::gemm_blas,
-        impl_desc_type::gemm_avx512,
-        impl_desc_type::gemm_avx2,
-        impl_desc_type::gemm_avx,
-        impl_desc_type::gemm_sse42,
-        impl_desc_type::gemm_acl,
-        impl_desc_type::acl,
-        impl_desc_type::jit_gemm,
-        impl_desc_type::ref_any,
-        impl_desc_type::ref,
+            impl_desc_type::gemm_any, impl_desc_type::gemm_blas, impl_desc_type::gemm_avx512, impl_desc_type::gemm_avx2,
+            impl_desc_type::gemm_avx, impl_desc_type::gemm_sse42, impl_desc_type::gemm_acl, impl_desc_type::acl,
+            impl_desc_type::jit_gemm, impl_desc_type::ref_any, impl_desc_type::ref,
     };
 
     if (!asymmetricPaddingAnd1x1)
         return priorities;
 
     static const std::vector<impl_desc_type> priorities_wo_brgemm = [&] {
-        std::vector<impl_desc_type>result;
-        std::copy_if(priorities.begin(), priorities.end(), std::back_inserter(result),
-            [](impl_desc_type type) { return !(type & impl_desc_type::brgconv); });
-        return result;}();
+        std::vector<impl_desc_type> result;
+        std::copy_if(priorities.begin(), priorities.end(), std::back_inserter(result), [](impl_desc_type type) {
+            return !(type & impl_desc_type::brgconv);
+        });
+        return result;
+    }();
     return priorities_wo_brgemm;
 }
 
 bool Deconvolution::isImplicit1x1PaddingAsymmetric(const VectorDims& inputDims) {
-    auto isZero = [](std::ptrdiff_t i) { return i == 0; };
+    auto isZero = [](std::ptrdiff_t i) {
+        return i == 0;
+    };
     size_t spatialRank = getInputShapeAtPort(0).getRank() - 2;
-    if (is1x1 && std::all_of(deconvAttrs.paddingR.begin(), deconvAttrs.paddingR.end(), isZero)
-                        && std::all_of(deconvAttrs.paddingL.begin(), deconvAttrs.paddingL.end(), isZero)
-                        && std::all_of(deconvAttrs.outputPadding.begin(), deconvAttrs.outputPadding.end(), isZero)
-                       ) {
-            auto calPaddingEnd =  [](int64_t i, int64_t o,  int64_t s) -> int64_t {
-                // Accoriding to https://pytorch.org/docs/stable/generated/torch.nn.ConvTranspose2d.html,
-                // output[i] = (input[i] -1) * stride[i] - 2 x padding[i] + dilation[i] x (kernel_size[i] - 1) + output_padding[i] + 1.
-                // When kernel_size[i] = 1, output_padding = 0, output[i] = (input[i] -1) * stride[i]  - 2 x padding[i] + 1.
-                // implicit padding end =  2 x padding[i]  = (input[i] -1) * stride[i] + 1 - output[i]
-                return (i - 1) * s + 1 - o;};
-            for (size_t i = 0; i < spatialRank; i++) {
-                int64_t inputDim = static_cast<int64_t>(inputDims[i + 2]);
-                int64_t outputDim = static_cast<int64_t>(lastOutputSpatialDims[i]);
-                int64_t stride = static_cast<int64_t>(deconvAttrs.stride[i]);
-                if (calPaddingEnd(inputDim, outputDim, stride) > 0) {
-                    return true;
-                }
+    if (is1x1 && std::all_of(deconvAttrs.paddingR.begin(), deconvAttrs.paddingR.end(), isZero) &&
+        std::all_of(deconvAttrs.paddingL.begin(), deconvAttrs.paddingL.end(), isZero) &&
+        std::all_of(deconvAttrs.outputPadding.begin(), deconvAttrs.outputPadding.end(), isZero)) {
+        auto calPaddingEnd = [](int64_t i, int64_t o, int64_t s) -> int64_t {
+            // Accoriding to https://pytorch.org/docs/stable/generated/torch.nn.ConvTranspose2d.html,
+            // output[i] = (input[i] -1) * stride[i] - 2 x padding[i] + dilation[i] x (kernel_size[i] - 1) +
+            // output_padding[i] + 1. When kernel_size[i] = 1, output_padding = 0, output[i] = (input[i] -1) * stride[i]
+            // - 2 x padding[i] + 1. implicit padding end =  2 x padding[i]  = (input[i] -1) * stride[i] + 1 - output[i]
+            return (i - 1) * s + 1 - o;
+        };
+        for (size_t i = 0; i < spatialRank; i++) {
+            int64_t inputDim = static_cast<int64_t>(inputDims[i + 2]);
+            int64_t outputDim = static_cast<int64_t>(lastOutputSpatialDims[i]);
+            int64_t stride = static_cast<int64_t>(deconvAttrs.stride[i]);
+            if (calPaddingEnd(inputDim, outputDim, stride) > 0) {
+                return true;
             }
+        }
     }
     return false;
 }
@@ -854,8 +882,10 @@ void Deconvolution::prepareParams() {
             dstMemoryDescs.push_back(getChildEdgeAt(i)->getMemory().getDescWithType<DnnlMemoryDesc>());
         }
 
-        execPtrDeconvACL = selected_pd->getExecutorFactoryAs<DeconvExecutorFactory>()->makeExecutor(deconvAttrs, srcMemoryDescs,
-                                                                                                 dstMemoryDescs, *attr);
+        execPtrDeconvACL = selected_pd->getExecutorFactoryAs<DeconvExecutorFactory>()->makeExecutor(deconvAttrs,
+                                                                                                    srcMemoryDescs,
+                                                                                                    dstMemoryDescs,
+                                                                                                    *attr);
         selected_pd->setImplementationType(execPtrDeconvACL->getImplType());
         return;
     }
@@ -891,7 +921,7 @@ void Deconvolution::prepareParams() {
             OPENVINO_THROW("Bias memory  memory is undefined.");
         biasDesc = biasMemPtr->getDescWithType<DnnlMemoryDesc>();
     }
-    bool is1x1PaddingAsymmetric  = false;
+    bool is1x1PaddingAsymmetric = false;
     if (externOutShape && (!isConstOutShape || isDynamicNode())) {
         // Check implicit asymmetric padding case for dynamic case and runtime output shape.
         is1x1PaddingAsymmetric = isImplicit1x1PaddingAsymmetric(getSrcMemoryAtPort(0)->getShape().getStaticDims());
@@ -917,34 +947,41 @@ void Deconvolution::prepareParams() {
         dnnl::memory::desc dnnlBiasDesc;
         const auto& weiDims = key.inp1->getShape().getStaticDims();
         const auto srcDataType = key.inp0->getDataType();
-        const auto weiDataType = (one_of(srcDataType, memory::data_type::s8, memory::data_type::u8)) ?
-                                    memory::data_type::s8 : srcDataType;
+        const auto weiDataType =
+            (one_of(srcDataType, memory::data_type::s8, memory::data_type::u8)) ? memory::data_type::s8 : srcDataType;
         auto wghDescAny =
-            dnnl::memory::desc(DnnlExtensionUtils::convertToDnnlDims(weiDims),
-                               weiDataType,
-                               memory::format_tag::any);
+            dnnl::memory::desc(DnnlExtensionUtils::convertToDnnlDims(weiDims), weiDataType, memory::format_tag::any);
         if (key.bias)
             dnnlBiasDesc = key.bias->getDnnlDesc();
 
-        desc = createDescriptorInternal(key.inp0->getDnnlDesc(), wghDescAny, dnnlBiasDesc, key.out->getDnnlDesc(),
-                                            key.bias != nullptr, key.stride, key.dilation, key.paddingL, key.paddingR, key.attr, engine);
+        desc = createDescriptorInternal(key.inp0->getDnnlDesc(),
+                                        wghDescAny,
+                                        dnnlBiasDesc,
+                                        key.out->getDnnlDesc(),
+                                        key.bias != nullptr,
+                                        key.stride,
+                                        key.dilation,
+                                        key.paddingL,
+                                        key.paddingR,
+                                        key.attr,
+                                        engine);
 
         primitive_desc_iterator itpd = desc;
         executorPtr execPtr = nullptr;
 
         while (static_cast<bool>(itpd)) {
             impl_desc_type impl_type = parse_impl_name(itpd.impl_info_str());
-            //Skip the brgemm implemenation for asymmetric padding case because of the accuracy issue.
+            // Skip the brgemm implemenation for asymmetric padding case because of the accuracy issue.
             if (key.isImplicit1x1PaddingAsymmetric && (impl_type & impl_desc_type::brgconv))
                 continue;
             if (impl_type == key.implType) {
                 auto prim_desc = deconvolution_forward::primitive_desc(itpd.get());
                 execPtr = std::make_shared<DeconvDNNLExecutor>(prim_desc,
-                                                            key.inp0->getDnnlDesc(),
-                                                            key.inp1->getDnnlDesc(),
-                                                            key.out->getDnnlDesc(),
-                                                            engine,
-                                                            key.constWeight);
+                                                               key.inp0->getDnnlDesc(),
+                                                               key.inp1->getDnnlDesc(),
+                                                               key.out->getDnnlDesc(),
+                                                               engine,
+                                                               key.constWeight);
                 break;
             }
 
@@ -954,16 +991,27 @@ void Deconvolution::prepareParams() {
         }
 
         if (!execPtr) {
-            auto inDesc = dnnl::memory::desc(DnnlExtensionUtils::convertToDnnlDims(key.inp0->getShape().getStaticDims()),
-                                                                                       key.inp0->getDataType(),
-                                                                                       memory::format_tag::any);
-            auto outDesc = dnnl::memory::desc(DnnlExtensionUtils::convertToDnnlDims(key.out->getShape().getStaticDims()),
-                                                                                        key.out->getDataType(),
-                                                                                        memory::format_tag::any);
+            auto inDesc =
+                dnnl::memory::desc(DnnlExtensionUtils::convertToDnnlDims(key.inp0->getShape().getStaticDims()),
+                                   key.inp0->getDataType(),
+                                   memory::format_tag::any);
+            auto outDesc =
+                dnnl::memory::desc(DnnlExtensionUtils::convertToDnnlDims(key.out->getShape().getStaticDims()),
+                                   key.out->getDataType(),
+                                   memory::format_tag::any);
 
             dnnl::primitive_desc anyDeconvDesc;
-            anyDeconvDesc = createDescriptorInternal(inDesc, wghDescAny, dnnlBiasDesc, outDesc, key.bias != nullptr,
-                                                        key.stride, key.dilation, key.paddingL, key.paddingR, key.attr, engine);
+            anyDeconvDesc = createDescriptorInternal(inDesc,
+                                                     wghDescAny,
+                                                     dnnlBiasDesc,
+                                                     outDesc,
+                                                     key.bias != nullptr,
+                                                     key.stride,
+                                                     key.dilation,
+                                                     key.paddingL,
+                                                     key.paddingR,
+                                                     key.attr,
+                                                     engine);
             if (anyDeconvDesc) {
                 auto prim_desc = deconvolution_forward::primitive_desc(anyDeconvDesc.get());
                 execPtr = std::make_shared<DeconvDNNLExecutor>(prim_desc,
@@ -983,13 +1031,12 @@ void Deconvolution::prepareParams() {
     auto cache = context->getParamsCache();
     auto result = cache->getOrCreate(key, builder);
 
-
     execPtr = result.first;
     if (!execPtr)
         OPENVINO_THROW("Primitive descriptor was not found for node ", getName(), ".");
 
     primArgs[DNNL_ARG_SRC] = srcMemPtr->getPrimitive();
-    primArgs[DNNL_ARG_DST]=  dstMemPtr->getPrimitive();
+    primArgs[DNNL_ARG_DST] = dstMemPtr->getPrimitive();
     if (weightIsConst) {
         // const weight preparation/reordering needs to be done once at next execution
         // when the input weight data is guaranteed to be ready (considering possible const-folding
@@ -1017,8 +1064,8 @@ void Deconvolution::prepareParams() {
 #endif
 }
 
-void Deconvolution::createDescriptor(const std::vector<MemoryDescPtr> &inputDesc,
-                                     const std::vector<MemoryDescPtr> &outputDesc) {
+void Deconvolution::createDescriptor(const std::vector<MemoryDescPtr>& inputDesc,
+                                     const std::vector<MemoryDescPtr>& outputDesc) {
     auto inDesc = inputDesc[0]->isDefined() ? inputDesc[0] : inputDesc[0]->cloneWithNewDims(inShape.getStaticDims());
     auto dnnlInDesc = MemoryDescUtils::convertToDnnlBlockedMemoryDesc(*inDesc);
     const auto& in_candidate = dnnlInDesc.getDnnlDesc();
@@ -1039,26 +1086,38 @@ void Deconvolution::createDescriptor(const std::vector<MemoryDescPtr> &inputDesc
     AttrPtr attr = initPrimitiveAttr();
     if (withBiases) {
         memory::data_type bdt = memory::data_type::f32;
-        bias_candidate = dnnl::memory::desc(DnnlExtensionUtils::convertToDnnlDims(expectedBiasDims), bdt, memory::format_tag::any);
+        bias_candidate =
+            dnnl::memory::desc(DnnlExtensionUtils::convertToDnnlDims(expectedBiasDims), bdt, memory::format_tag::any);
     }
-    dnnl::memory::desc wgh_candidate(DnnlExtensionUtils::convertToDnnlDims(dnnlCompatibleWeiDims), isInt8 ? memory::data_type::s8 : dnnlInDesc.getDataType(),
-                                    memory::format_tag::any);
-    descs.emplace_back(createDescriptorInternal(in_candidate, wgh_candidate, bias_candidate,
-                                                    out_candidate, withBiases, deconvAttrs.stride, deconvAttrs.dilation,
-                                                    deconvAttrs.paddingL, deconvAttrs.paddingR, *attr, getEngine()));
+    dnnl::memory::desc wgh_candidate(DnnlExtensionUtils::convertToDnnlDims(dnnlCompatibleWeiDims),
+                                     isInt8 ? memory::data_type::s8 : dnnlInDesc.getDataType(),
+                                     memory::format_tag::any);
+    descs.emplace_back(createDescriptorInternal(in_candidate,
+                                                wgh_candidate,
+                                                bias_candidate,
+                                                out_candidate,
+                                                withBiases,
+                                                deconvAttrs.stride,
+                                                deconvAttrs.dilation,
+                                                deconvAttrs.paddingL,
+                                                deconvAttrs.paddingR,
+                                                *attr,
+                                                getEngine()));
 }
 
-std::shared_ptr<MemoryDesc> Deconvolution::getSrcMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const {
+std::shared_ptr<MemoryDesc> Deconvolution::getSrcMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const {
     if (idx == 2 && !withBiases) {
-        //Expected dest shape;
+        // Expected dest shape;
         return std::make_shared<CpuBlockedMemoryDesc>(ov::element::i32, Shape(getInputShapeAtPort(2).getStaticDims()));
     } else if (idx > 0) {
         // weight and bias are exposed with the planar layout.
         // we need to store 'weight' input as edge,
-        // because at this moment we can't simple replace internal blob with input, since we need to save weight data as is, but with different order
-        return std::make_shared<CpuBlockedMemoryDesc>(getOriginalInputPrecisionAtPort(idx), Shape(getInputShapeAtPort(idx).getStaticDims()));
+        // because at this moment we can't simple replace internal blob with input, since we need to save weight data as
+        // is, but with different order
+        return std::make_shared<CpuBlockedMemoryDesc>(getOriginalInputPrecisionAtPort(idx),
+                                                      Shape(getInputShapeAtPort(idx).getStaticDims()));
     }
-    //idx =0 case
+    // idx =0 case
     auto desc = prim_desc.src_desc(idx);
     if (getInputShapeAtPort(idx).isDynamic()) {
         return DnnlExtensionUtils::makeUndefinedDesc(desc, getInputShapeAtPort(idx));
@@ -1066,8 +1125,8 @@ std::shared_ptr<MemoryDesc> Deconvolution::getSrcMemDesc(const dnnl::primitive_d
     return DnnlExtensionUtils::makeDescriptor(desc);
 }
 
-std::shared_ptr<MemoryDesc> Deconvolution::getDstMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const {
-    auto desc =  prim_desc.dst_desc(idx);
+std::shared_ptr<MemoryDesc> Deconvolution::getDstMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const {
+    auto desc = prim_desc.dst_desc(idx);
     if (getOutputShapeAtPort(idx).isDynamic()) {
         return DnnlExtensionUtils::makeUndefinedDesc(desc, getOutputShapeAtPort(idx));
     }
@@ -1081,7 +1140,8 @@ ov::element::Type Deconvolution::getRuntimePrecision() const {
     for (size_t i = 0; i < std::min(getParentEdges().size(), inputsNumLimit); i++) {
         auto parentEdge = getParentEdgeAt(i);
         if (parentEdge && parentEdge->getStatus() == Edge::Status::Validated) {
-            inputPrecisions.emplace_back(DnnlExtensionUtils::DataTypeToElementType((parentEdge->getMemoryPtr()->getDataType())));
+            inputPrecisions.emplace_back(
+                DnnlExtensionUtils::DataTypeToElementType((parentEdge->getMemoryPtr()->getDataType())));
         }
     }
 
@@ -1089,11 +1149,12 @@ ov::element::Type Deconvolution::getRuntimePrecision() const {
 }
 
 Deconvolution::DeconvDNNLExecutor::DeconvDNNLExecutor(const dnnl::deconvolution_forward::primitive_desc& pd,
-                                                                const dnnl::memory::desc& inMemDesc,
-                                                                const dnnl::memory::desc& weightMemDesc,
-                                                                const dnnl::memory::desc& outMemDesc,
-                                                                const dnnl::engine& engine,
-                                                                bool constWeight) : DnnlExecutor(pd) {
+                                                      const dnnl::memory::desc& inMemDesc,
+                                                      const dnnl::memory::desc& weightMemDesc,
+                                                      const dnnl::memory::desc& outMemDesc,
+                                                      const dnnl::engine& engine,
+                                                      bool constWeight)
+    : DnnlExecutor(pd) {
     if (inMemDesc != getDnnlSrcDesc()) {
         inputReorders.insert({DNNL_ARG_SRC, IntermReorder(inMemDesc, getDnnlSrcDesc(), engine)});
     }
@@ -1111,7 +1172,7 @@ std::vector<int32_t> Deconvolution::readOutputSpatialDims() const {
     if (getParentEdges().size() < 3) {
         OPENVINO_THROW("Can't get output spatial dims. Inputs number = ", getParentEdges().size());
     }
-    const auto &shapeMemPtr = getSrcMemoryAtPort(2);
+    const auto& shapeMemPtr = getSrcMemoryAtPort(2);
     if (!shapeMemPtr || !shapeMemPtr->isDefined()) {
         OPENVINO_THROW("'output_shape' input memory is undefined.");
     }
@@ -1119,20 +1180,20 @@ std::vector<int32_t> Deconvolution::readOutputSpatialDims() const {
     if (shapeMemPtr->getStaticDims()[0] != spDimsNum) {
         OPENVINO_THROW("Can't read output spatial dims, beause 'output_shape' input has incorrect number of elements");
     }
-    const int32_t *outShapePtr = shapeMemPtr->getDataAs<const int32_t>();
+    const int32_t* outShapePtr = shapeMemPtr->getDataAs<const int32_t>();
     std::vector<int32_t> outSpDims(outShapePtr, outShapePtr + shapeMemPtr->getStaticDims()[0]);
     return outSpDims;
 }
 
 bool Deconvolution::canFuseBias() const {
-    //ONEDNN deconvolution_fwd_t primitive can support bias fusing. but has different implementations.
-    //For the brgdeconv implementation in the deconv list, bias is implemented via JIT kernel.
-    //For the fall back ref implementation entry(previous conv_backward_data), bias is implemented via reference post-ops.
-    //It is difficult to recognize  whether the deconv will run with brg or fall back to backwards data implementation on the fusing
-    //transformation stage. In the end, all the deconv should run with brg implement.
-    //And in model zoo only limited deconv has bias or other post-ops in IR.
-    //Based on above, enable the bias fusing for all deconv implementations.
-    return  (externOutShape ? getParentEdges().size() == 3 : getParentEdges().size() == 2);
+    // ONEDNN deconvolution_fwd_t primitive can support bias fusing. but has different implementations.
+    // For the brgdeconv implementation in the deconv list, bias is implemented via JIT kernel.
+    // For the fall back ref implementation entry(previous conv_backward_data), bias is implemented via reference
+    // post-ops. It is difficult to recognize  whether the deconv will run with brg or fall back to backwards data
+    // implementation on the fusing transformation stage. In the end, all the deconv should run with brg implement. And
+    // in model zoo only limited deconv has bias or other post-ops in IR. Based on above, enable the bias fusing for all
+    // deconv implementations.
+    return (externOutShape ? getParentEdges().size() == 3 : getParentEdges().size() == 2);
 }
 
 void Deconvolution::initSupportedPrimitiveDescriptors() {
@@ -1143,7 +1204,7 @@ void Deconvolution::initSupportedPrimitiveDescriptors() {
 
     VectorDims inDims, outDims;
     std::tie(inDims, outDims) = makeDummyInOutShape();
-    auto tmpInShape  = Shape(inDims);
+    auto tmpInShape = Shape(inDims);
     auto tmpOutShape = Shape(outDims);
     initPaddingR(tmpInShape, tmpOutShape);
 
@@ -1154,18 +1215,19 @@ void Deconvolution::initSupportedPrimitiveDescriptors() {
         config.outConfs.resize(getOriginalOutputsNumber());
 
         config.inConfs[0].setMemDesc(
-                creatorsMap.at(format)->createSharedDesc(getOriginalInputPrecisionAtPort(0), getInputShapeAtPort(0)));
+            creatorsMap.at(format)->createSharedDesc(getOriginalInputPrecisionAtPort(0), getInputShapeAtPort(0)));
         config.inConfs[1].setMemDesc(
-                creatorsMap.at(weights_format)->createSharedDesc(getOriginalInputPrecisionAtPort(0), getInputShapeAtPort(1)));
+            creatorsMap.at(weights_format)
+                ->createSharedDesc(getOriginalInputPrecisionAtPort(0), getInputShapeAtPort(1)));
 
         for (size_t i = 2; i < getParentEdges().size(); ++i) {
             config.inConfs[i].setMemDesc(
-                    creatorsMap.at(format)->createSharedDesc(getOriginalInputPrecisionAtPort(0), getInputShapeAtPort(i)));
+                creatorsMap.at(format)->createSharedDesc(getOriginalInputPrecisionAtPort(0), getInputShapeAtPort(i)));
         }
 
         for (size_t i = 0; i < config.outConfs.size(); ++i) {
             config.outConfs[i].setMemDesc(
-                    creatorsMap.at(format)->createSharedDesc(getOriginalOutputPrecisionAtPort(0), getOutputShapeAtPort(i)));
+                creatorsMap.at(format)->createSharedDesc(getOriginalOutputPrecisionAtPort(0), getOutputShapeAtPort(i)));
         }
 
         std::vector<MemoryDescPtr> srcMemoryDescs;
@@ -1179,8 +1241,11 @@ void Deconvolution::initSupportedPrimitiveDescriptors() {
             dstMemoryDescs.push_back(config.outConfs[i].getMemDesc()->clone());
         }
 
-        auto factory = std::make_shared<DeconvExecutorFactory>(deconvAttrs, srcMemoryDescs, dstMemoryDescs,
-                                                               std::make_shared<ExecutorContext>(context, getImplPriority()));
+        auto factory =
+            std::make_shared<DeconvExecutorFactory>(deconvAttrs,
+                                                    srcMemoryDescs,
+                                                    dstMemoryDescs,
+                                                    std::make_shared<ExecutorContext>(context, getImplPriority()));
 
         supportedPrimitiveDescriptors.emplace_back(config, impl_desc_type::gemm_acl, factory);
     };
@@ -1188,7 +1253,6 @@ void Deconvolution::initSupportedPrimitiveDescriptors() {
     pushDesc(LayoutType::ncsp);
 }
 
-
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/deconv.h b/src/plugins/intel_cpu/src/nodes/deconv.h
index d94bcd8bcaca13..1c3e1fe8978918 100644
--- a/src/plugins/intel_cpu/src/nodes/deconv.h
+++ b/src/plugins/intel_cpu/src/nodes/deconv.h
@@ -29,27 +29,32 @@ class Deconvolution : public Node {
         return static_cast<size_t>(getParentEdges().size());
     }
 
-    std::shared_ptr<MemoryDesc> getSrcMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const override;
-    std::shared_ptr<MemoryDesc> getDstMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const override;
+    std::shared_ptr<MemoryDesc> getSrcMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const override;
+    std::shared_ptr<MemoryDesc> getDstMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const override;
 
     ov::element::Type getRuntimePrecision() const override;
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
     bool canFuse(const NodePtr& node) const override;
 
-    const VectorDims& getWeightDims() const { return getInputShapeAtPort(1).getStaticDims(); }
-    const std::vector<ptrdiff_t>& getStride() const { return deconvAttrs.stride; }
+    const VectorDims& getWeightDims() const {
+        return getInputShapeAtPort(1).getStaticDims();
+    }
+    const std::vector<ptrdiff_t>& getStride() const {
+        return deconvAttrs.stride;
+    }
 
     void prepareParams() override;
     void execute(dnnl::stream strm) override;
-    void executeDynamicImpl(dnnl::stream strm) override { execute(strm); }
+    void executeDynamicImpl(dnnl::stream strm) override {
+        execute(strm);
+    }
     bool needShapeInfer() const override;
 
     bool canFuseBias() const;
     bool canBeExecutedInInt8() const override;
     const std::vector<impl_desc_type>& getDefaultImplPriority() override;
 
-
 protected:
     AttrPtr initPrimitiveAttr() override;
     AttrPtr makePrimitiveAttr(const VectorDims& dims);
@@ -60,13 +65,13 @@ class Deconvolution : public Node {
     using executorPtr = std::shared_ptr<DnnlExecutor>;
     executorPtr execPtr = nullptr;
     class DeconvDNNLExecutor : public DnnlExecutor {
-        public:
-            DeconvDNNLExecutor(const dnnl::deconvolution_forward::primitive_desc& pd,
-                               const dnnl::memory::desc& inMemDesc,
-                               const dnnl::memory::desc& weightMemDesc,
-                               const dnnl::memory::desc& outMemDesc,
-                               const dnnl::engine& engine,
-                               bool constWeight);
+    public:
+        DeconvDNNLExecutor(const dnnl::deconvolution_forward::primitive_desc& pd,
+                           const dnnl::memory::desc& inMemDesc,
+                           const dnnl::memory::desc& weightMemDesc,
+                           const dnnl::memory::desc& outMemDesc,
+                           const dnnl::engine& engine,
+                           bool constWeight);
     };
 
     bool isImplicit1x1PaddingAsymmetric(const VectorDims& inputDims);
@@ -79,8 +84,8 @@ class Deconvolution : public Node {
     size_t IC = 0;
     size_t OC = 0;
     std::vector<int32_t> lastOutputSpatialDims;
-    VectorDims dnnlCompatibleWeiDims {};
-    VectorDims expectedBiasDims {};
+    VectorDims dnnlCompatibleWeiDims{};
+    VectorDims expectedBiasDims{};
 
     bool useACL = false;
     DeconvAttrs deconvAttrs;
@@ -93,9 +98,9 @@ class Deconvolution : public Node {
     MemoryPtr dnnlCompatibleWeights = nullptr;
 
     std::shared_ptr<dnnl::primitive_attr> attr;
-    void setPostOps(dnnl::primitive_attr &attr, const VectorDims &dims);
-    VectorDims shapeInferInternal(const VectorDims &inDims, std::vector<int32_t> outSpDims) const;
-    void initPaddingR(const Shape &inShape, const Shape &outShape);
+    void setPostOps(dnnl::primitive_attr& attr, const VectorDims& dims);
+    VectorDims shapeInferInternal(const VectorDims& inDims, std::vector<int32_t> outSpDims) const;
+    void initPaddingR(const Shape& inShape, const Shape& outShape);
     std::vector<int32_t> readOutputSpatialDims() const;
     std::pair<VectorDims, VectorDims> makeDummyInOutShape();
     bool withBiases = false;
@@ -110,6 +115,6 @@ class Deconvolution : public Node {
     bool isConstOutShape = false;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/def_conv.cpp b/src/plugins/intel_cpu/src/nodes/def_conv.cpp
index 0167a18673c444..7c5427d0def045 100644
--- a/src/plugins/intel_cpu/src/nodes/def_conv.cpp
+++ b/src/plugins/intel_cpu/src/nodes/def_conv.cpp
@@ -4,21 +4,20 @@
 
 #include "def_conv.h"
 
-#include <openvino/op/deformable_convolution.hpp>
+#include <math.h>
 
+#include <common/dnnl_thread.hpp>
+#include <openvino/op/deformable_convolution.hpp>
 #include <string>
 #include <vector>
-#include <math.h>
 
-#include "openvino/core/parallel.hpp"
-#include "memory_desc/dnnl_blocked_memory_desc.h"
 #include "common/primitive_hashing_utils.hpp"
-#include "openvino/util/pp.hpp"
-
-#include "dnnl_types.h"
-#include "dnnl_extension_utils.h"
 #include "cpu/x64/jit_generator.hpp"
-#include <common/dnnl_thread.hpp>
+#include "dnnl_extension_utils.h"
+#include "dnnl_types.h"
+#include "memory_desc/dnnl_blocked_memory_desc.h"
+#include "openvino/core/parallel.hpp"
+#include "openvino/util/pp.hpp"
 
 using namespace dnnl;
 using namespace dnnl::impl;
@@ -30,7 +29,7 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 #if defined(OPENVINO_ARCH_X86_64)
-#define GET_OFF(field) offsetof(jit_def_conv_call_args, field)
+#    define GET_OFF(field) offsetof(jit_def_conv_call_args, field)
 
 template <cpu_isa_t isa>
 struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_generator {
@@ -38,7 +37,9 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
 
     constexpr static int sampledPointsPerPixel = DeformableConvolution::sampledPointsPerPixel;
 
-    explicit jit_uni_def_conv_kernel_f32(const jit_def_conv_params& jcp) : jit_uni_def_conv_kernel(jcp), jit_generator(jit_name()) {}
+    explicit jit_uni_def_conv_kernel_f32(const jit_def_conv_params& jcp)
+        : jit_uni_def_conv_kernel(jcp),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -72,8 +73,8 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
 
     const int vlen = cpu_isa_traits<isa>::vlen;
     using Ymm = const Xbyak::Ymm;
@@ -113,18 +114,29 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
 
     Xbyak::Opmask ktail_mask = Xbyak::Opmask(2);
 
-    inline Xbyak::Address table_val(int index)
-    { return ptr[reg_table + index * vlen]; }
+    inline Xbyak::Address table_val(int index) {
+        return ptr[reg_table + index * vlen];
+    }
 
-    inline Vmm get_vmm_ker(int idx) { return Vmm(idx + 0); }
-    inline Vmm get_vmm_src(int idx) { return Vmm(idx + 1); }
-    inline Vmm get_vmm_acc(int idx) { return Vmm(idx + jcp_.ur_w + 1); }
-    inline Ymm get_ymm_acc(int idx) { return Ymm(idx + jcp_.ur_w + 1); }
-    inline Xmm get_xmm_acc(int idx) { return Xmm(idx + jcp_.ur_w + 1); }
+    inline Vmm get_vmm_ker(int idx) {
+        return Vmm(idx + 0);
+    }
+    inline Vmm get_vmm_src(int idx) {
+        return Vmm(idx + 1);
+    }
+    inline Vmm get_vmm_acc(int idx) {
+        return Vmm(idx + jcp_.ur_w + 1);
+    }
+    inline Ymm get_ymm_acc(int idx) {
+        return Ymm(idx + jcp_.ur_w + 1);
+    }
+    inline Xmm get_xmm_acc(int idx) {
+        return Xmm(idx + jcp_.ur_w + 1);
+    }
 
     Xbyak::Label l_table;
 
-    inline void checkZeroWei(const Xbyak::Xmm &x1, Label &nullifyLabel) {
+    inline void checkZeroWei(const Xbyak::Xmm& x1, Label& nullifyLabel) {
         ptest(x1, x1);
         jz(nullifyLabel);
     }
@@ -135,13 +147,16 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
 
         mov(reg_ow_pos, 0);
 
-        L(ow_loop_main); {
+        L(ow_loop_main);
+        {
             cmp(reg_ow_pos, jcp_.ow - jcp_.ur_w);
             jg(ow_tail, T_NEAR);
 
             oc_loop(jcp_.ur_w);
-            add(reg_sampled_wei, jcp_.ur_w * jcp_.kh * jcp_.kw * sampledPointsPerPixel * jcp_.typesize_sampled_wei);  // type = float
-            add(reg_sampled_offs, jcp_.ur_w * jcp_.kh * jcp_.kw * sampledPointsPerPixel * jcp_.typesize_sampled_offsets);  // type = int
+            add(reg_sampled_wei,
+                jcp_.ur_w * jcp_.kh * jcp_.kw * sampledPointsPerPixel * jcp_.typesize_sampled_wei);  // type = float
+            add(reg_sampled_offs,
+                jcp_.ur_w * jcp_.kh * jcp_.kw * sampledPointsPerPixel * jcp_.typesize_sampled_offsets);  // type = int
 
             add(reg_output, jcp_.ur_w * jcp_.oc * jcp_.typesize_out);
 
@@ -149,7 +164,8 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
             jmp(ow_loop_main, T_NEAR);
         }
 
-        L(ow_tail); {
+        L(ow_tail);
+        {
             if (jcp_.ow % jcp_.ur_w != 0)
                 oc_loop(jcp_.ow % jcp_.ur_w);
         }
@@ -191,7 +207,8 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                 for (int ic = 0; ic < ic_step; ic++) {
                     for (int ow = 0; ow < ow_step; ow++) {
                         Vmm vmm_src = get_vmm_src(ow);
-                        size_t inp_off = (size_t) ow * jcp_.kh * jcp_.kw * jcp_.ic + kh * jcp_.kw * jcp_.ic + kw * jcp_.ic + ic;
+                        size_t inp_off =
+                            (size_t)ow * jcp_.kh * jcp_.kw * jcp_.ic + kh * jcp_.kw * jcp_.ic + kw * jcp_.ic + ic;
 
                         uni_vbroadcastss(vmm_src, ptr[aux2_reg_input_buffer + inp_off * jcp_.typesize_in]);
                     }
@@ -199,10 +216,10 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                     for (int r = 0; r < repeats; r++) {
                         for (int ocb = 0; ocb < oc_blocks_step; ocb++) {
                             Vmm vmm_ker = get_vmm_ker(0);
-                            size_t ker_off = (size_t) ocb * jcp_.nb_ic * jcp_.kh * jcp_.kw * jcp_.ic_block * jcp_.oc_block +
-                                             kh * jcp_.kw * jcp_.ic_block * jcp_.oc_block +
-                                             kw * jcp_.ic_block * jcp_.oc_block +
-                                             ic * jcp_.oc_block + r * jcp_.oc_block / 2;
+                            size_t ker_off =
+                                (size_t)ocb * jcp_.nb_ic * jcp_.kh * jcp_.kw * jcp_.ic_block * jcp_.oc_block +
+                                kh * jcp_.kw * jcp_.ic_block * jcp_.oc_block + kw * jcp_.ic_block * jcp_.oc_block +
+                                ic * jcp_.oc_block + r * jcp_.oc_block / 2;
 
                             uni_vmovups(vmm_ker, ptr[aux2_reg_kernel + ker_off * jcp_.typesize_in]);
                             for (int ow = 0; ow < ow_step; ow++) {
@@ -248,7 +265,8 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
 
         init_accums(ow_step, oc_blocks_step, oc_step);
 
-        L(ic_main_loop); {
+        L(ic_main_loop);
+        {
             cmp(reg_ic_iter, jcp_.ic_block);
             jl(ic_tail, T_NEAR);
 
@@ -259,7 +277,8 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
             jmp(ic_main_loop, T_NEAR);
         }
 
-        L(ic_tail); {
+        L(ic_tail);
+        {
             if (jcp_.ic % jcp_.ic_block != 0) {
                 apply_filter(ow_step, oc_blocks_step, oc_step, jcp_.ic % jcp_.ic_block);
             }
@@ -283,7 +302,8 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
         xor_(reg_dg_iter, reg_dg_iter);
 
         const int ic_per_def_group = jcp_.ic / jcp_.dg;
-        L(dg_loop); {
+        L(dg_loop);
+        {
             cmp(reg_dg_iter, jcp_.dg);
             jge(dg_loop_end, T_NEAR);
 
@@ -326,7 +346,8 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                         Xmm xmm_w4 = Xmm(5);
 
                         Xmm xmm_v1 = Xmm(2);
-                        Xmm xmm_v2 = Xmm(3);;
+                        Xmm xmm_v2 = Xmm(3);
+                        ;
                         Xmm xmm_v3 = Xmm(6);
                         Xmm xmm_v4 = Xmm(7);
 
@@ -341,7 +362,8 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                         Vmm vmm_v4 = Vmm(xmm_v4.getIdx());
 
                         // offsets computation
-                        size_t ind_off_hh = sampledPointsPerPixel * (((size_t) kh * jcp_.kw + kw) + ow * (jcp_.kh * jcp_.kw));
+                        size_t ind_off_hh =
+                            sampledPointsPerPixel * (((size_t)kh * jcp_.kw + kw) + ow * (jcp_.kh * jcp_.kw));
                         size_t ind_off_hl = ind_off_hh + 1;
                         size_t ind_off_lh = ind_off_hl + 1;
                         size_t ind_off_ll = ind_off_lh + 1;
@@ -366,12 +388,16 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                             jl(ic_loop_tail, T_NEAR);
 
                             // check zero markers
-                            uni_vbroadcastss(xmm_v1, dword[aux_reg_sampled_wei + ind_off_ll * jcp_.typesize_sampled_wei]);
-                            uni_vbroadcastss(xmm_v2, dword[aux_reg_sampled_wei + ind_off_hl * jcp_.typesize_sampled_wei]);
-                            uni_vbroadcastss(xmm_v3, dword[aux_reg_sampled_wei + ind_off_lh * jcp_.typesize_sampled_wei]);
-                            uni_vbroadcastss(xmm_v4, dword[aux_reg_sampled_wei + ind_off_hh * jcp_.typesize_sampled_wei]);
+                            uni_vbroadcastss(xmm_v1,
+                                             dword[aux_reg_sampled_wei + ind_off_ll * jcp_.typesize_sampled_wei]);
+                            uni_vbroadcastss(xmm_v2,
+                                             dword[aux_reg_sampled_wei + ind_off_hl * jcp_.typesize_sampled_wei]);
+                            uni_vbroadcastss(xmm_v3,
+                                             dword[aux_reg_sampled_wei + ind_off_lh * jcp_.typesize_sampled_wei]);
+                            uni_vbroadcastss(xmm_v4,
+                                             dword[aux_reg_sampled_wei + ind_off_hh * jcp_.typesize_sampled_wei]);
 
-                            size_t input_buffer_off = (size_t) kh * jcp_.kw * jcp_.ic + kw * jcp_.ic;
+                            size_t input_buffer_off = (size_t)kh * jcp_.kw * jcp_.ic + kw * jcp_.ic;
 
                             uni_vpmovsxdq(xmm_v1_off, xmm_v1_off);
                             uni_vmovq(reg_tmp_64, xmm_v1_off);
@@ -382,9 +408,7 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                             uni_vmulps(vmm_v1, vmm_v1, vmm_w1);
                             jmp(nullify_v1_end, T_NEAR);
                             L(nullify_v1);
-                            {
-                                uni_vpxor(vmm_v1, vmm_v1, vmm_v1);
-                            }
+                            { uni_vpxor(vmm_v1, vmm_v1, vmm_v1); }
                             L(nullify_v1_end);
 
                             uni_vpmovsxdq(xmm_v2_off, xmm_v2_off);
@@ -396,9 +420,7 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                             uni_vmulps(vmm_v2, vmm_v2, vmm_w2);
                             jmp(nullify_v2_end, T_NEAR);
                             L(nullify_v2);
-                            {
-                                uni_vpxor(vmm_v2, vmm_v2, vmm_v2);
-                            }
+                            { uni_vpxor(vmm_v2, vmm_v2, vmm_v2); }
                             L(nullify_v2_end);
 
                             uni_vpmovsxdq(xmm_v3_off, xmm_v3_off);
@@ -410,9 +432,7 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                             uni_vmulps(vmm_v3, vmm_v3, vmm_w3);
                             jmp(nullify_v3_end, T_NEAR);
                             L(nullify_v3);
-                            {
-                                uni_vpxor(vmm_v3, vmm_v3, vmm_v3);
-                            }
+                            { uni_vpxor(vmm_v3, vmm_v3, vmm_v3); }
                             L(nullify_v3_end);
 
                             uni_vpmovsxdq(xmm_v4_off, xmm_v4_off);
@@ -424,9 +444,7 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                             uni_vmulps(vmm_v4, vmm_v4, vmm_w4);
                             jmp(nullify_v4_end, T_NEAR);
                             L(nullify_v4);
-                            {
-                                uni_vpxor(vmm_v4, vmm_v4, vmm_v4);
-                            }
+                            { uni_vpxor(vmm_v4, vmm_v4, vmm_v4); }
                             L(nullify_v4_end);
 
                             uni_vaddps(vmm_v1, vmm_v1, vmm_v2);
@@ -446,12 +464,16 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                             jl(loop_end, T_NEAR);
 
                             // check zero markers
-                            uni_vbroadcastss(xmm_v1, dword[aux_reg_sampled_wei + ind_off_ll * jcp_.typesize_sampled_wei]);
-                            uni_vbroadcastss(xmm_v2, dword[aux_reg_sampled_wei + ind_off_hl * jcp_.typesize_sampled_wei]);
-                            uni_vbroadcastss(xmm_v3, dword[aux_reg_sampled_wei + ind_off_lh * jcp_.typesize_sampled_wei]);
-                            uni_vbroadcastss(xmm_v4, dword[aux_reg_sampled_wei + ind_off_hh * jcp_.typesize_sampled_wei]);
-
-                            size_t input_buffer_off = (size_t) kh * jcp_.kw * jcp_.ic + kw * jcp_.ic;
+                            uni_vbroadcastss(xmm_v1,
+                                             dword[aux_reg_sampled_wei + ind_off_ll * jcp_.typesize_sampled_wei]);
+                            uni_vbroadcastss(xmm_v2,
+                                             dword[aux_reg_sampled_wei + ind_off_hl * jcp_.typesize_sampled_wei]);
+                            uni_vbroadcastss(xmm_v3,
+                                             dword[aux_reg_sampled_wei + ind_off_lh * jcp_.typesize_sampled_wei]);
+                            uni_vbroadcastss(xmm_v4,
+                                             dword[aux_reg_sampled_wei + ind_off_hh * jcp_.typesize_sampled_wei]);
+
+                            size_t input_buffer_off = (size_t)kh * jcp_.kw * jcp_.ic + kw * jcp_.ic;
                             uni_vpmovsxdq(xmm_v1_off, xmm_v1_off);
                             uni_vmovq(reg_tmp_64, xmm_v1_off);
                             imul(reg_tmp_64, reg_tmp_64, jcp_.ic * jcp_.typesize_in);
@@ -461,9 +483,7 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                             uni_vmulss(xmm_v1, xmm_v1, xmm_w1);
                             jmp(nullify_v1_end_tail, T_NEAR);
                             L(nullify_v1_tail);
-                            {
-                                uni_vpxor(xmm_v1, xmm_v1, xmm_v1);
-                            }
+                            { uni_vpxor(xmm_v1, xmm_v1, xmm_v1); }
                             L(nullify_v1_end_tail);
 
                             uni_vpmovsxdq(xmm_v2_off, xmm_v2_off);
@@ -475,9 +495,7 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                             uni_vmulss(xmm_v2, xmm_v2, xmm_w2);
                             jmp(nullify_v2_end_tail, T_NEAR);
                             L(nullify_v2_tail);
-                            {
-                                uni_vpxor(xmm_v2, xmm_v2, xmm_v2);
-                            }
+                            { uni_vpxor(xmm_v2, xmm_v2, xmm_v2); }
                             L(nullify_v2_end_tail);
 
                             uni_vpmovsxdq(xmm_v3_off, xmm_v3_off);
@@ -489,9 +507,7 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                             uni_vmulss(xmm_v3, xmm_v3, xmm_w3);
                             jmp(nullify_v3_end_tail, T_NEAR);
                             L(nullify_v3_tail);
-                            {
-                                uni_vpxor(xmm_v3, xmm_v3, xmm_v3);
-                            }
+                            { uni_vpxor(xmm_v3, xmm_v3, xmm_v3); }
                             L(nullify_v3_end_tail);
 
                             uni_vpmovsxdq(xmm_v4_off, xmm_v4_off);
@@ -503,9 +519,7 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                             uni_vmulss(xmm_v4, xmm_v4, xmm_w4);
                             jmp(nullify_v4_end_tail, T_NEAR);
                             L(nullify_v4_tail);
-                            {
-                                uni_vpxor(xmm_v4, xmm_v4, xmm_v4);
-                            }
+                            { uni_vpxor(xmm_v4, xmm_v4, xmm_v4); }
                             L(nullify_v4_end_tail);
 
                             uni_vaddss(xmm_v1, xmm_v1, xmm_v2);
@@ -524,8 +538,10 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                 }
             }
 
-            add(aux_reg_sampled_wei, sampledPointsPerPixel * jcp_.kh * jcp_.kw * jcp_.oh * jcp_.ow * jcp_.typesize_sampled_wei);
-            add(aux_reg_sampled_offs, sampledPointsPerPixel * jcp_.kh * jcp_.kw * jcp_.oh * jcp_.ow * jcp_.typesize_sampled_offsets);
+            add(aux_reg_sampled_wei,
+                sampledPointsPerPixel * jcp_.kh * jcp_.kw * jcp_.oh * jcp_.ow * jcp_.typesize_sampled_wei);
+            add(aux_reg_sampled_offs,
+                sampledPointsPerPixel * jcp_.kh * jcp_.kw * jcp_.oh * jcp_.ow * jcp_.typesize_sampled_offsets);
             add(aux_reg_input, ic_per_def_group * jcp_.typesize_in);
             add(aux2_reg_input_buffer, ic_per_def_group * jcp_.typesize_in);
             inc(reg_dg_iter);
@@ -542,7 +558,7 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
         if (jcp_.with_bias) {
             for (int r = 0; r < repeats; r++) {
                 for (int ocb = 0; ocb < oc_blocks_step; ocb++) {
-                    size_t bias_off = (size_t) ocb * jcp_.oc_block + r * jcp_.oc_block / 2;
+                    size_t bias_off = (size_t)ocb * jcp_.oc_block + r * jcp_.oc_block / 2;
                     uni_vmovups(Vmm(0), ptr[aux_reg_bias + bias_off * jcp_.typesize_bia]);
 
                     for (int ow = 0; ow < ow_step; ow++) {
@@ -560,7 +576,8 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
         }
 
         for (int r = 0; r < repeats; r++) {
-            int tail_size = isa == cpu::x64::sse41 ? std::min(jcp_.oc_block / 2, oc_step - r * jcp_.oc_block / 2) : oc_step;
+            int tail_size =
+                isa == cpu::x64::sse41 ? std::min(jcp_.oc_block / 2, oc_step - r * jcp_.oc_block / 2) : oc_step;
             bool is_scalar_store = isa == cpu::x64::sse41 ? tail_size < jcp_.oc_block / 2 : tail_size < jcp_.oc_block;
             if (is_scalar_store) {
                 for (int ow = 0; ow < ow_step; ow++) {
@@ -568,11 +585,11 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                     Xmm xmm_dst = get_xmm_acc(r * jcp_.ur_w * jcp_.nb_oc_blocking + ow);
 
                     if (isa == avx512_core) {
-                        size_t out_off = (size_t) ow * jcp_.oc;
+                        size_t out_off = (size_t)ow * jcp_.oc;
                         uni_vmovups(ptr[aux_reg_output + out_off * jcp_.typesize_out], vmm_dst | ktail_mask);
                     } else {
                         for (int oc = 0; oc < tail_size; oc++) {
-                            size_t out_off = (size_t) ow * jcp_.oc + oc + r * (jcp_.oc_block / 2);
+                            size_t out_off = (size_t)ow * jcp_.oc + oc + r * (jcp_.oc_block / 2);
                             uni_vmovq(reg_tmp_64, xmm_dst);
                             mov(ptr[aux_reg_output + out_off * jcp_.typesize_out], reg_tmp_32);
 
@@ -593,7 +610,8 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
                 for (int ocb = 0; ocb < oc_blocks_step; ocb++) {
                     for (int ow = 0; ow < ow_step; ow++) {
                         Vmm vmm_acc = get_vmm_acc(r * jcp_.ur_w * jcp_.nb_oc_blocking + ocb * ow_step + ow);
-                        size_t out_off = (size_t) ow * jcp_.oc * jcp_.ngroups + ocb * jcp_.oc_block + r * (jcp_.oc_block / 2);
+                        size_t out_off =
+                            (size_t)ow * jcp_.oc * jcp_.ngroups + ocb * jcp_.oc_block + r * (jcp_.oc_block / 2);
                         uni_vmovups(ptr[aux_reg_output + out_off * jcp_.typesize_out], vmm_acc);
                     }
                 }
@@ -629,14 +647,17 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
         mov(aux_reg_bias, reg_bias);
         mov(reg_oc_work, jcp_.oc);
 
-        L(oc_unrolled_loop); {
+        L(oc_unrolled_loop);
+        {
             cmp(reg_oc_work, jcp_.nb_oc_blocking * jcp_.oc_block);
             jl(oc_main_loop, T_NEAR);
 
             ic_loop(ow_step, jcp_.nb_oc_blocking, jcp_.oc_block);
             store_output(ow_step, jcp_.nb_oc_blocking, jcp_.oc_block);
 
-            add(aux_reg_kernel, jcp_.nb_oc_blocking * jcp_.nb_ic * jcp_.kh * jcp_.kw * jcp_.ic_block * jcp_.oc_block * jcp_.typesize_in);
+            add(aux_reg_kernel,
+                jcp_.nb_oc_blocking * jcp_.nb_ic * jcp_.kh * jcp_.kw * jcp_.ic_block * jcp_.oc_block *
+                    jcp_.typesize_in);
             add(aux_reg_output, jcp_.nb_oc_blocking * jcp_.oc_block * jcp_.typesize_out);
             add(aux_reg_bias, jcp_.nb_oc_blocking * jcp_.oc_block * jcp_.typesize_bia);
             sub(reg_oc_work, jcp_.nb_oc_blocking * jcp_.oc_block);
@@ -644,7 +665,8 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
             jmp(oc_unrolled_loop, T_NEAR);
         }
 
-        L(oc_main_loop); {
+        L(oc_main_loop);
+        {
             cmp(reg_oc_work, jcp_.oc_block);
             jl(oc_tail, T_NEAR);
 
@@ -659,7 +681,8 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
             jmp(oc_main_loop, T_NEAR);
         }
 
-        L(oc_tail); {
+        L(oc_tail);
+        {
             if (jcp_.oc % jcp_.oc_block != 0) {
                 ic_loop(ow_step, 1, jcp_.oc % jcp_.oc_block);
                 store_output(ow_step, 1, jcp_.oc % jcp_.oc_block);
@@ -672,11 +695,12 @@ struct jit_uni_def_conv_kernel_f32 : public jit_uni_def_conv_kernel, public jit_
     }
 };
 #endif
-bool DeformableConvolution::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool DeformableConvolution::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                                 std::string& errorMessage) noexcept {
     try {
         if (!one_of(op->get_type_info(),
-                ov::op::v1::DeformableConvolution::get_type_info_static(),
-                ov::op::v8::DeformableConvolution::get_type_info_static())) {
+                    ov::op::v1::DeformableConvolution::get_type_info_static(),
+                    ov::op::v8::DeformableConvolution::get_type_info_static())) {
             errorMessage = "Node is not an instance of DeformableConvolution form the operation set v1 or v8.";
             return false;
         }
@@ -721,16 +745,16 @@ size_t DefConvKey::hash() const {
     return seed;
 }
 
-bool DefConvKey::operator==(const DefConvKey &rhs) const {
+bool DefConvKey::operator==(const DefConvKey& rhs) const {
     bool retVal = true;
     for (size_t i = 0; i < descVector.size(); i++) {
         if (descVector[i] != rhs.descVector[i]) {
             retVal = retVal && descVector[i] && rhs.descVector[i] &&
-            descVector[i]->getBlockDims() == rhs.descVector[i]->getBlockDims() &&
-            descVector[i]->getStrides() == rhs.descVector[i]->getStrides() &&
-            descVector[i]->getOrder() == rhs.descVector[i]->getOrder() &&
-            descVector[i]->getOffsetPaddingToData() == rhs.descVector[i]->getOffsetPaddingToData() &&
-            descVector[i]->getOffsetPadding() == rhs.descVector[i]->getOffsetPadding();
+                     descVector[i]->getBlockDims() == rhs.descVector[i]->getBlockDims() &&
+                     descVector[i]->getStrides() == rhs.descVector[i]->getStrides() &&
+                     descVector[i]->getOrder() == rhs.descVector[i]->getOrder() &&
+                     descVector[i]->getOffsetPaddingToData() == rhs.descVector[i]->getOffsetPaddingToData() &&
+                     descVector[i]->getOffsetPadding() == rhs.descVector[i]->getOffsetPadding();
         }
     }
 
@@ -742,7 +766,7 @@ bool DefConvKey::operator==(const DefConvKey &rhs) const {
     return retVal;
 }
 
-} // namespace
+}  // namespace
 
 DeformableConvolution::DeformableConvolution(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
     : Node(op, context, NgraphShapeInferFactory(op)) {
@@ -825,13 +849,14 @@ void DeformableConvolution::initSupportedPrimitiveDescriptors() {
     impl_desc_type impl_type;
     const int simd_w = mayiuse(cpu::x64::avx512_core) ? 16 : 8;
 
-    auto &weiDims = getInputShapeAtPort(WEI_ID).getDims();
+    auto& weiDims = getInputShapeAtPort(WEI_ID).getDims();
     if (weiDims[1] == Shape::UNDEFINED_DIM || weiDims[0] == Shape::UNDEFINED_DIM ||
         // 1. strict fallback, until devising of multigroup handling in common case
         defConvAttr.group != 1 ||
         // 2. common fallback, except specific n_group / n_channel combinations
-        (defConvAttr.group != 1 && ((weiDims[1] % simd_w != 0)  // in_channels_per_gr !% simd_w
-        || ((weiDims[0] / defConvAttr.group) % simd_w != 0)))) {  // out_channels_per_gr !% simd_w
+        (defConvAttr.group != 1 &&
+         ((weiDims[1] % simd_w != 0)                                // in_channels_per_gr !% simd_w
+          || ((weiDims[0] / defConvAttr.group) % simd_w != 0)))) {  // out_channels_per_gr !% simd_w
         enforceRef = true;
     } else {
         enforceRef = false;
@@ -854,41 +879,48 @@ void DeformableConvolution::initSupportedPrimitiveDescriptors() {
         auto dataFormat = memory::format_tag::nhwc;
         auto offFormat = memory::format_tag::nchw;
         auto weiFormat = mayiuse(avx512_core) ? memory::format_tag::OIhw16i16o : memory::format_tag::OIhw8i8o;
-        config.inConfs[DATA_ID].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(DATA_ID),
-                                                                                   memory::data_type::f32, dataFormat));
-        config.inConfs[OFF_ID].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(OFF_ID),
-                                                                                  memory::data_type::f32, offFormat));
+        config.inConfs[DATA_ID].setMemDesc(
+            std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(DATA_ID), memory::data_type::f32, dataFormat));
+        config.inConfs[OFF_ID].setMemDesc(
+            std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(OFF_ID), memory::data_type::f32, offFormat));
 
-        config.inConfs[WEI_ID].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(WEI_ID),
-                                                                                  memory::data_type::f32, weiFormat));
+        config.inConfs[WEI_ID].setMemDesc(
+            std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(WEI_ID), memory::data_type::f32, weiFormat));
 
         if (inputsNumber > 3) {
             config.inConfs[MOD_ID].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(MOD_ID),
-                                                                                      memory::data_type::f32, memory::format_tag::nchw));
+                                                                                      memory::data_type::f32,
+                                                                                      memory::format_tag::nchw));
         }
-        config.outConfs[0].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getOutputShapeAtPort(DATA_ID),
-                                                                              memory::data_type::f32, dataFormat));
+        config.outConfs[0].setMemDesc(
+            std::make_shared<DnnlBlockedMemoryDesc>(getOutputShapeAtPort(DATA_ID), memory::data_type::f32, dataFormat));
         supportedPrimitiveDescriptors.push_back({config, impl_type});
     } else {
         // reference implementation
-        config.inConfs[DATA_ID].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(DATA_ID), memory::data_type::f32,
+        config.inConfs[DATA_ID].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(DATA_ID),
+                                                                                   memory::data_type::f32,
                                                                                    memory::format_tag::nchw));
-        config.inConfs[OFF_ID].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(OFF_ID), memory::data_type::f32,
+        config.inConfs[OFF_ID].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(OFF_ID),
+                                                                                  memory::data_type::f32,
                                                                                   memory::format_tag::nchw));
-        config.inConfs[WEI_ID].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(WEI_ID), memory::data_type::f32,
+        config.inConfs[WEI_ID].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(WEI_ID),
+                                                                                  memory::data_type::f32,
                                                                                   memory::format_tag::oihw));
         if (inputsNumber > 3) {
-            config.inConfs[MOD_ID].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(MOD_ID), memory::data_type::f32,
+            config.inConfs[MOD_ID].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getInputShapeAtPort(MOD_ID),
+                                                                                      memory::data_type::f32,
                                                                                       memory::format_tag::nchw));
         }
-        config.outConfs[0].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getOutputShapeAtPort(DATA_ID), memory::data_type::f32,
+        config.outConfs[0].setMemDesc(std::make_shared<DnnlBlockedMemoryDesc>(getOutputShapeAtPort(DATA_ID),
+                                                                              memory::data_type::f32,
                                                                               memory::format_tag::nchw));
         supportedPrimitiveDescriptors.push_back({config, impl_type});
     }
 }
 
-void DeformableConvolution::DefConvExecutor::prepareSamplingWeights(
-        const float* offsets, const float* modulation, bool enforceRef) {
+void DeformableConvolution::DefConvExecutor::prepareSamplingWeights(const float* offsets,
+                                                                    const float* modulation,
+                                                                    bool enforceRef) {
     const int MB = jcp.mb;
     const int OH = jcp.oh;
     const int OW = jcp.ow;
@@ -918,45 +950,45 @@ void DeformableConvolution::DefConvExecutor::prepareSamplingWeights(
         const int h_in = oh * KSH - padT;
         const int w_in = ow * KSW - padL;
 
-        const float *data_offset_ptr = offsets + mb * offStrides[0] + (dg * 2 * KH * KW) * offStrides[1];
-        const float *modulation_offset_ptr = nullptr;
+        const float* data_offset_ptr = offsets + mb * offStrides[0] + (dg * 2 * KH * KW) * offStrides[1];
+        const float* modulation_offset_ptr = nullptr;
         if (modulation != nullptr) {
             modulation_offset_ptr = modulation + mb * modStrides[0] + (dg * ker_size) * modStrides[1];
         }
 
         for (int kh = 0; kh < KH; kh++) {
             for (int kw = 0; kw < KW; kw++) {
-                const size_t data_offset_h_index = 2 * ((size_t) kh * KW + kw) * offStrides[1] + oh * offStrides[2] + ow * offStrides[3];
-                const size_t data_offset_w_index = (2 * ((size_t) kh * KW + kw) + 1) * offStrides[1] + oh * offStrides[2] + ow * offStrides[3];
+                const size_t data_offset_h_index =
+                    2 * ((size_t)kh * KW + kw) * offStrides[1] + oh * offStrides[2] + ow * offStrides[3];
+                const size_t data_offset_w_index =
+                    (2 * ((size_t)kh * KW + kw) + 1) * offStrides[1] + oh * offStrides[2] + ow * offStrides[3];
                 const float offset_h = data_offset_ptr[data_offset_h_index];
                 const float offset_w = data_offset_ptr[data_offset_w_index];
                 float map_h = h_in + kh * (KDH + 1) + offset_h;
                 float map_w = w_in + kw * (KDW + 1) + offset_w;
                 bool skip_compute;
                 if (with_bi_pad) {
-                    skip_compute = !(static_cast<int>(map_w) > -1 &&
-                                     static_cast<int>(map_w) < IW &&
-                                     static_cast<int>(map_h) > -1 &&
-                                     static_cast<int>(map_h) < IH);
+                    skip_compute = !(static_cast<int>(map_w) > -1 && static_cast<int>(map_w) < IW &&
+                                     static_cast<int>(map_h) > -1 && static_cast<int>(map_h) < IH);
                 } else {
-                    skip_compute = !(map_w >= 0 && map_w < IW &&
-                                     map_h >= 0 && map_h < IH);
+                    skip_compute = !(map_w >= 0 && map_w < IW && map_h >= 0 && map_h < IH);
                 }
                 if (!skip_compute) {
                     // modulations precomp.
                     float modulation_scalar = 1.0f;
 
                     if (modulation_offset_ptr != nullptr) {
-                        size_t modulation_index = (kh * KW + kw) * modStrides[1] + oh * modStrides[2] + ow * modStrides[3];
+                        size_t modulation_index =
+                            (kh * KW + kw) * modStrides[1] + oh * modStrides[2] + ow * modStrides[3];
                         modulation_scalar = modulation_offset_ptr[modulation_index];
                     }
                     // interpolation precomp.
                     const int cur_h_end = IH;
                     const int cur_w_end = IW;
-                    int h_low = with_bi_pad ? static_cast<int>(floorf(map_h)) :
-                                std::max(static_cast<int>(floorf(map_h)), 0);
-                    int w_low = with_bi_pad ? static_cast<int>(floorf(map_w)) :
-                                std::max(static_cast<int>(floorf(map_w)), 0);
+                    int h_low =
+                        with_bi_pad ? static_cast<int>(floorf(map_h)) : std::max(static_cast<int>(floorf(map_h)), 0);
+                    int w_low =
+                        with_bi_pad ? static_cast<int>(floorf(map_w)) : std::max(static_cast<int>(floorf(map_w)), 0);
                     int h_high = with_bi_pad ? h_low + 1 : std::min(static_cast<int>(ceilf(map_h)), cur_h_end - 1);
                     int w_high = with_bi_pad ? w_low + 1 : std::min(static_cast<int>(ceilf(map_w)), cur_w_end - 1);
 
@@ -976,7 +1008,7 @@ void DeformableConvolution::DefConvExecutor::prepareSamplingWeights(
 
                     const int h_off_low = h_ind_low * (srcStrides[2] / srcStrides[3]);
                     const int h_off_high = h_ind_high * (srcStrides[2] / srcStrides[3]);
-                    const int w_off_low  = w_ind_low;
+                    const int w_off_low = w_ind_low;
                     const int w_off_high = w_ind_high;
                     pSampledCoordsVector[sampledCoordIndex] = h_off_high + w_off_high;
                     pSampledCoordsVector[sampledCoordIndex + 1] = h_off_high + w_off_low;
@@ -984,7 +1016,7 @@ void DeformableConvolution::DefConvExecutor::prepareSamplingWeights(
                     pSampledCoordsVector[sampledCoordIndex + 3] = h_off_low + w_off_low;
 
                     float w22 = hh * hw * modulation_scalar, w21 = hh * lw * modulation_scalar,
-                            w12 = lh * hw * modulation_scalar, w11 = lh * lw * modulation_scalar;
+                          w12 = lh * hw * modulation_scalar, w11 = lh * lw * modulation_scalar;
 
                     pInterpWeightsVector[sampledCoordIndex] = w11;
                     pInterpWeightsVector[sampledCoordIndex + 1] = w12;
@@ -1007,15 +1039,16 @@ void DeformableConvolution::DefConvExecutor::prepareSamplingWeights(
     });
 }
 
-DeformableConvolution::DefConvExecutor::DefConvExecutor(const DefConvAttr &defConvAttr,
-                                const std::vector<std::shared_ptr<BlockedMemoryDesc>> &descVector) {
+DeformableConvolution::DefConvExecutor::DefConvExecutor(
+    const DefConvAttr& defConvAttr,
+    const std::vector<std::shared_ptr<BlockedMemoryDesc>>& descVector) {
     if (descVector.size() != 4 && descVector.size() != 5) {
         OPENVINO_THROW("Deformable Convolution executor got incorrect desc's count (", descVector.size(), ")");
     }
     bool withModulation = descVector.size() == 5;
 
-    auto &srcDesc = descVector[DATA_ID];
-    auto &dstDesc = descVector[descVector.size() - 1];
+    auto& srcDesc = descVector[DATA_ID];
+    auto& dstDesc = descVector[descVector.size() - 1];
     srcStrides = std::vector<size_t>(srcDesc->getStrides().size());
     offStrides = descVector[OFF_ID]->getStrides();
     weiStrides = descVector[WEI_ID]->getStrides();
@@ -1085,9 +1118,10 @@ DeformableConvolution::DefConvExecutor::DefConvExecutor(const DefConvAttr &defCo
     jcp.nthr = dnnl_get_max_threads();
 }
 
-DeformableConvolution::DefConvJitExecutor::DefConvJitExecutor(const DefConvAttr &defConvAttr,
-                            const std::vector<std::shared_ptr<BlockedMemoryDesc>> &descVector) :
-                DefConvExecutor(defConvAttr, descVector) {
+DeformableConvolution::DefConvJitExecutor::DefConvJitExecutor(
+    const DefConvAttr& defConvAttr,
+    const std::vector<std::shared_ptr<BlockedMemoryDesc>>& descVector)
+    : DefConvExecutor(defConvAttr, descVector) {
 #if defined(OPENVINO_ARCH_X86_64)
     if (mayiuse(cpu::x64::avx512_core)) {
         def_conv_kernel.reset(new jit_uni_def_conv_kernel_f32<cpu::x64::avx512_core>(jcp));
@@ -1106,9 +1140,13 @@ DeformableConvolution::DefConvJitExecutor::DefConvJitExecutor(const DefConvAttr
 #endif
 }
 
-void DeformableConvolution::DefConvRefExecutor::exec(const float* src, const float* offsets,
-        const float* weights, const float* modulation, float* dst,
-        int *pSampledCoordsVector, float *pInterpWeightsVector) {
+void DeformableConvolution::DefConvRefExecutor::exec(const float* src,
+                                                     const float* offsets,
+                                                     const float* weights,
+                                                     const float* modulation,
+                                                     float* dst,
+                                                     int* pSampledCoordsVector,
+                                                     float* pInterpWeightsVector) {
     this->pSampledCoordsVector = pSampledCoordsVector;
     this->pInterpWeightsVector = pInterpWeightsVector;
     prepareSamplingWeights(offsets, modulation, true);
@@ -1133,17 +1171,18 @@ void DeformableConvolution::DefConvRefExecutor::exec(const float* src, const flo
     auto compKer = [OV_CAPTURE_CPY_AND_THIS](int g, int mb, int oc, int oh, int ow) {
         float d = 0;
         for (int ic = 0; ic < IC; ic++) {
-            const float *data_im_ptr = src + mb * srcStrides[0] + (g * IC + ic) * srcStrides[1];
+            const float* data_im_ptr = src + mb * srcStrides[0] + (g * IC + ic) * srcStrides[1];
             const int deformable_group_index = (IC * g + ic) / channel_per_deformable_group;
-            int sampledCoordIndex = (mb * DGHW + deformable_group_index * HW + oh * OW + ow) * ker_size * sampledPointsPerPixel;
-            size_t weiIndex = (size_t) g * group_wei_stride + oc * weiStrides[0] + ic * weiStrides[1];
+            int sampledCoordIndex =
+                (mb * DGHW + deformable_group_index * HW + oh * OW + ow) * ker_size * sampledPointsPerPixel;
+            size_t weiIndex = (size_t)g * group_wei_stride + oc * weiStrides[0] + ic * weiStrides[1];
             for (size_t kh_off = 0; kh_off < KH * weiStrides[2]; kh_off += weiStrides[2]) {
                 for (size_t kw_off = 0; kw_off < KW * weiStrides[3]; kw_off += weiStrides[3]) {
                     // check if current addendum marked as equal zero
                     if (pSampledCoordsVector[sampledCoordIndex] != -1) {
                         const int v11 = pSampledCoordsVector[sampledCoordIndex];
                         const int v12 = pSampledCoordsVector[sampledCoordIndex + 1];
-                        const int v21  = pSampledCoordsVector[sampledCoordIndex + 2];
+                        const int v21 = pSampledCoordsVector[sampledCoordIndex + 2];
                         const int v22 = pSampledCoordsVector[sampledCoordIndex + 3];
 
                         float val = 0;
@@ -1174,8 +1213,9 @@ void DeformableConvolution::DefConvRefExecutor::exec(const float* src, const flo
     };
 
     parallel_nd(G, MB, OC, OH, OW, [&](dnnl_dim_t g, dnnl_dim_t mb, dnnl_dim_t oc, dnnl_dim_t oh, dnnl_dim_t ow) {
-                    dst[mb * dstStrides[0] + (g * OC + oc) * dstStrides[1] + oh * dstStrides[2] + ow * dstStrides[3]] = compKer(g, mb, oc, oh, ow);
-                });
+        dst[mb * dstStrides[0] + (g * OC + oc) * dstStrides[1] + oh * dstStrides[2] + ow * dstStrides[3]] =
+            compKer(g, mb, oc, oh, ow);
+    });
 }
 
 void DeformableConvolution::prepareParams() {
@@ -1208,22 +1248,17 @@ void DeformableConvolution::prepareParams() {
 
     updatePadding();
 
-    std::vector<std::shared_ptr<BlockedMemoryDesc>> descVector {
+    std::vector<std::shared_ptr<BlockedMemoryDesc>> descVector{
         getParentEdgeAt(DATA_ID)->getMemory().getDescWithType<BlockedMemoryDesc>(),
         getParentEdgeAt(OFF_ID)->getMemory().getDescWithType<BlockedMemoryDesc>(),
-        getParentEdgeAt(WEI_ID)->getMemory().getDescWithType<BlockedMemoryDesc>()
-    };
+        getParentEdgeAt(WEI_ID)->getMemory().getDescWithType<BlockedMemoryDesc>()};
 
     if (withModulation) {
         descVector.push_back(getParentEdgeAt(MOD_ID)->getMemory().getDescWithType<BlockedMemoryDesc>());
     }
     descVector.push_back(getChildEdgeAt(0)->getMemory().getDescWithType<BlockedMemoryDesc>());
 
-    DefConvKey key = {
-        descVector,
-        defConvAttr,
-        getSelectedPrimitiveDescriptor()->getImplementationType()
-    };
+    DefConvKey key = {descVector, defConvAttr, getSelectedPrimitiveDescriptor()->getImplementationType()};
 
     const int MB = getParentEdgeAt(DATA_ID)->getMemory().getStaticDims()[0];
     const int OH = getChildEdgeAt(0)->getMemory().getStaticDims()[2];
@@ -1241,7 +1276,7 @@ void DeformableConvolution::prepareParams() {
     execPtr = nullptr;
 
     auto cache = context->getParamsCache();
-    auto result = cache->getOrCreate(key, [] (const DefConvKey& key) -> std::shared_ptr<DefConvExecutor> {
+    auto result = cache->getOrCreate(key, [](const DefConvKey& key) -> std::shared_ptr<DefConvExecutor> {
         if (key.implType == impl_desc_type::ref) {
             return std::make_shared<DefConvRefExecutor>(key.defConvAttr, key.descVector);
         }
@@ -1258,9 +1293,13 @@ void DeformableConvolution::executeDynamicImpl(dnnl::stream strm) {
     execute(strm);
 }
 
-void DeformableConvolution::DefConvJitExecutor::exec(const float* src, const float* offsets,
-        const float* weights, const float* modulation, float* dst,
-        int *pSampledCoordsVector, float *pInterpWeightsVector) {
+void DeformableConvolution::DefConvJitExecutor::exec(const float* src,
+                                                     const float* offsets,
+                                                     const float* weights,
+                                                     const float* modulation,
+                                                     float* dst,
+                                                     int* pSampledCoordsVector,
+                                                     float* pInterpWeightsVector) {
     this->pSampledCoordsVector = pSampledCoordsVector;
     this->pInterpWeightsVector = pInterpWeightsVector;
     prepareSamplingWeights(offsets, modulation, false);
@@ -1276,9 +1315,11 @@ void DeformableConvolution::DefConvJitExecutor::exec(const float* src, const flo
         const size_t _oc = g * jcp.nb_oc;
         const size_t _ic = g * jcp.nb_ic;
 
-        par_conv.src = &src[n * srcStrides[0] + _ic*jcp.ic_block * srcStrides[1]];
-        par_conv.sampledWei = &(pInterpWeightsVector[(n * jcp.dg * jcp.oh + oh) * jcp.kh * jcp.kw * jcp.ow * sampledPointsPerPixel]);
-        par_conv.sampledCoords = &(pSampledCoordsVector[(n * jcp.dg * jcp.oh + oh) * jcp.kh * jcp.kw * jcp.ow * sampledPointsPerPixel]);
+        par_conv.src = &src[n * srcStrides[0] + _ic * jcp.ic_block * srcStrides[1]];
+        par_conv.sampledWei =
+            &(pInterpWeightsVector[(n * jcp.dg * jcp.oh + oh) * jcp.kh * jcp.kw * jcp.ow * sampledPointsPerPixel]);
+        par_conv.sampledCoords =
+            &(pSampledCoordsVector[(n * jcp.dg * jcp.oh + oh) * jcp.kh * jcp.kw * jcp.ow * sampledPointsPerPixel]);
         par_conv.filt = &weights[g * jcp.nb_oc * jcp.nb_ic * jcp.kh * jcp.kw * jcp.ic_block * jcp.oc_block];
         par_conv.dst = &dst[n * dstStrides[0] + _oc * jcp.oc_block * dstStrides[1] + oh * dstStrides[2]];
         par_conv.buf = input_buffer_ptr + ithr * jcp.ur_w * jcp.kh * jcp.kw * jcp.ic;
@@ -1292,20 +1333,20 @@ void DeformableConvolution::DefConvJitExecutor::exec(const float* src, const flo
 void DeformableConvolution::execute(dnnl::stream strm) {
     const size_t inputsNumber = getOriginalInputsNumber();
 
-    auto &srcMemory0 = getParentEdgeAt(0)->getMemory();
-    auto &srcMemory1 = getParentEdgeAt(1)->getMemory();
-    auto &srcMemory2 = getParentEdgeAt(2)->getMemory();
-    auto &dstMemory = getChildEdgeAt(0)->getMemory();
+    auto& srcMemory0 = getParentEdgeAt(0)->getMemory();
+    auto& srcMemory1 = getParentEdgeAt(1)->getMemory();
+    auto& srcMemory2 = getParentEdgeAt(2)->getMemory();
+    auto& dstMemory = getChildEdgeAt(0)->getMemory();
 
-    const auto *src = srcMemory0.getDataAs<const float>();
-    const auto *offsets = srcMemory1.getDataAs<const float>();
-    const auto *weights = srcMemory2.getDataAs<const float>();
+    const auto* src = srcMemory0.getDataAs<const float>();
+    const auto* offsets = srcMemory1.getDataAs<const float>();
+    const auto* weights = srcMemory2.getDataAs<const float>();
     float* modulation = nullptr;
     if (inputsNumber > 3) {
         modulation = getSrcDataAtPortAs<float>(3);
     }
 
-    float *dst = dstMemory.getDataAs<float>();
+    float* dst = dstMemory.getDataAs<float>();
 
     auto selectedPrimitiveDescriptor = getSelectedPrimitiveDescriptor();
     if (!selectedPrimitiveDescriptor)
@@ -1333,6 +1374,6 @@ ov::element::Type DeformableConvolution::getRuntimePrecision() const {
     return getMaxPrecision(getInputPrecisions());
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/def_conv.h b/src/plugins/intel_cpu/src/nodes/def_conv.h
index 127fd00eb2bf00..ed5800a19a0e84 100644
--- a/src/plugins/intel_cpu/src/nodes/def_conv.h
+++ b/src/plugins/intel_cpu/src/nodes/def_conv.h
@@ -5,6 +5,7 @@
 #pragma once
 
 #include <node.h>
+
 #include <memory>
 #include <string>
 #include <vector>
@@ -43,20 +44,20 @@ struct jit_def_conv_params {
 };
 
 struct jit_def_conv_call_args {
-    const void *src;
-    const void *sampledWei;
-    const void *sampledCoords;
-    const void *filt;
-    const void *bias;
-    const void *dst;
-    const void *buf;
+    const void* src;
+    const void* sampledWei;
+    const void* sampledCoords;
+    const void* filt;
+    const void* bias;
+    const void* dst;
+    const void* buf;
     size_t oh_pos;
 };
 
 struct jit_uni_def_conv_kernel {
-    void (*ker_)(const jit_def_conv_call_args *);
+    void (*ker_)(const jit_def_conv_call_args*);
 
-    void operator()(const jit_def_conv_call_args *args) {
+    void operator()(const jit_def_conv_call_args* args) {
         assert(ker_);
         ker_(args);
     }
@@ -109,53 +110,66 @@ class DeformableConvolution : public Node {
     static constexpr size_t MOD_ID = 3;
     std::string errorPrefix;
     class DefConvExecutor {
-        public:
-            DefConvExecutor(const DefConvAttr &defConvAttr,
-                                const std::vector<std::shared_ptr<BlockedMemoryDesc>> &descVector);
-
-            virtual void exec(const float* src, const float* offsets,
-                const float* weights, const float* modulation, float* dst,
-                int *pSampledCoordsVector, float *pInterpWeightsVector) = 0;
-            virtual ~DefConvExecutor() = default;
-
-        protected:
-            void prepareSamplingWeights(const float* offsets, const float* modulation = nullptr, bool enforceRef = false);
-            jit_def_conv_params jcp = {};
-            VectorDims srcStrides;
-            VectorDims offStrides;
-            VectorDims weiStrides;
-            VectorDims modStrides;
-            VectorDims dstStrides;
-            int *pSampledCoordsVector;
-            float *pInterpWeightsVector;
+    public:
+        DefConvExecutor(const DefConvAttr& defConvAttr,
+                        const std::vector<std::shared_ptr<BlockedMemoryDesc>>& descVector);
+
+        virtual void exec(const float* src,
+                          const float* offsets,
+                          const float* weights,
+                          const float* modulation,
+                          float* dst,
+                          int* pSampledCoordsVector,
+                          float* pInterpWeightsVector) = 0;
+        virtual ~DefConvExecutor() = default;
+
+    protected:
+        void prepareSamplingWeights(const float* offsets, const float* modulation = nullptr, bool enforceRef = false);
+        jit_def_conv_params jcp = {};
+        VectorDims srcStrides;
+        VectorDims offStrides;
+        VectorDims weiStrides;
+        VectorDims modStrides;
+        VectorDims dstStrides;
+        int* pSampledCoordsVector;
+        float* pInterpWeightsVector;
     };
 
     class DefConvRefExecutor : public DefConvExecutor {
-        public:
-            DefConvRefExecutor(const DefConvAttr &defConvAttr,
-                            const std::vector<std::shared_ptr<BlockedMemoryDesc>> &descVector) :
-                DefConvExecutor(defConvAttr, descVector) {}
-
-            void exec(const float* src, const float* offsets,
-                const float* weights, const float* modulation, float* dst,
-                int *pSampledCoordsVector, float *pInterpWeightsVector) override;
+    public:
+        DefConvRefExecutor(const DefConvAttr& defConvAttr,
+                           const std::vector<std::shared_ptr<BlockedMemoryDesc>>& descVector)
+            : DefConvExecutor(defConvAttr, descVector) {}
+
+        void exec(const float* src,
+                  const float* offsets,
+                  const float* weights,
+                  const float* modulation,
+                  float* dst,
+                  int* pSampledCoordsVector,
+                  float* pInterpWeightsVector) override;
     };
 
     class DefConvJitExecutor : public DefConvExecutor {
-            std::shared_ptr<jit_uni_def_conv_kernel> def_conv_kernel = nullptr;
-        public:
-            DefConvJitExecutor(const DefConvAttr &defConvAttr,
-                            const std::vector<std::shared_ptr<BlockedMemoryDesc>> &descVector);
-
-            void exec(const float* src, const float* offsets,
-                const float* weights, const float* modulation, float* dst,
-                int *pSampledCoordsVector, float *pInterpWeightsVector) override;
+        std::shared_ptr<jit_uni_def_conv_kernel> def_conv_kernel = nullptr;
+
+    public:
+        DefConvJitExecutor(const DefConvAttr& defConvAttr,
+                           const std::vector<std::shared_ptr<BlockedMemoryDesc>>& descVector);
+
+        void exec(const float* src,
+                  const float* offsets,
+                  const float* weights,
+                  const float* modulation,
+                  float* dst,
+                  int* pSampledCoordsVector,
+                  float* pInterpWeightsVector) override;
     };
 
     std::shared_ptr<DefConvExecutor> execPtr = nullptr;
     bool autoPadding = false;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/depth_to_space.cpp b/src/plugins/intel_cpu/src/nodes/depth_to_space.cpp
index eb3789068adca1..a8629ce2592d76 100644
--- a/src/plugins/intel_cpu/src/nodes/depth_to_space.cpp
+++ b/src/plugins/intel_cpu/src/nodes/depth_to_space.cpp
@@ -4,16 +4,15 @@
 
 #include "depth_to_space.h"
 
-#include "dnnl_extension_utils.h"
-#include "utils/general_utils.h"
-
 #include <cmath>
-#include "common/primitive_hashing_utils.hpp"
-#include "cpu/x64/jit_generator.hpp"
-#include "openvino/opsets/opset1.hpp"
 #include <string>
 
 #include "common/blocked_desc_creator.h"
+#include "common/primitive_hashing_utils.hpp"
+#include "cpu/x64/jit_generator.hpp"
+#include "dnnl_extension_utils.h"
+#include "openvino/opsets/opset1.hpp"
+#include "utils/general_utils.h"
 
 #define THROW_ERROR(...) OPENVINO_THROW("DepthToSpace layer with name '", getName(), "' ", __VA_ARGS__)
 
@@ -40,9 +39,8 @@ size_t DepthToSpace::DepthToSpaceAttrs::hash() const {
 }
 
 bool DepthToSpace::DepthToSpaceAttrs::operator==(const DepthToSpaceAttrs& rhs) const {
-    bool result = layoutType == rhs.layoutType && mode == rhs.mode &&
-                  blockSize == rhs.blockSize && blockStep == rhs.blockStep &&
-                  dataSize == rhs.dataSize && nSpatialDims == rhs.nSpatialDims &&
+    bool result = layoutType == rhs.layoutType && mode == rhs.mode && blockSize == rhs.blockSize &&
+                  blockStep == rhs.blockStep && dataSize == rhs.dataSize && nSpatialDims == rhs.nSpatialDims &&
                   srcBlockedDims == rhs.srcBlockedDims;
 
     return result;
@@ -56,7 +54,9 @@ bool DepthToSpace::isSupportedOperation(const std::shared_ptr<const ov::Node>& o
             return false;
         }
         const auto mode = depthToSpace->get_mode();
-        if (!one_of(mode, ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST, ov::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST)) {
+        if (!one_of(mode,
+                    ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST,
+                    ov::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST)) {
             errorMessage = "Does not support mode: " + ov::as_string(mode);
             return false;
         }
@@ -138,7 +138,8 @@ void DepthToSpace::initSupportedPrimitiveDescriptors() {
     if (inputDataShape.getRank() > 2) {
         const auto& srcDims = inputDataShape.getDims();
         auto canUseBlocked = [OV_CAPTURE_CPY_AND_THIS](const size_t block) {
-            return srcDims[1] != Shape::UNDEFINED_DIM && srcDims[1] % block == 0 && (srcDims[1] / block) % attrs.blockStep == 0 &&
+            return srcDims[1] != Shape::UNDEFINED_DIM && srcDims[1] % block == 0 &&
+                   (srcDims[1] / block) % attrs.blockStep == 0 &&
                    (attrs.mode == Mode::DEPTH_FIRST ? block % attrs.blockStep == 0 : true);
         };
 
@@ -172,9 +173,10 @@ void DepthToSpace::createPrimitive() {
     const auto& memoryDesc = srcMemPtr->getDesc();
     attrs.dataSize = memoryDesc.getPrecision().size();
     attrs.nSpatialDims = memoryDesc.getShape().getRank() - 2;
-    attrs.layoutType = memoryDesc.hasLayoutType(LayoutType::nCsp16c) ? LayoutType::nCsp16c :
-                       memoryDesc.hasLayoutType(LayoutType::nCsp8c) ? LayoutType::nCsp8c :
-                       memoryDesc.hasLayoutType(LayoutType::nspc) ? LayoutType::nspc : LayoutType::ncsp;
+    attrs.layoutType = memoryDesc.hasLayoutType(LayoutType::nCsp16c)  ? LayoutType::nCsp16c
+                       : memoryDesc.hasLayoutType(LayoutType::nCsp8c) ? LayoutType::nCsp8c
+                       : memoryDesc.hasLayoutType(LayoutType::nspc)   ? LayoutType::nspc
+                                                                      : LayoutType::ncsp;
 
     if (inputShapesDefined()) {
         if (needPrepareParams())
@@ -205,7 +207,8 @@ DepthToSpace::DepthToSpaceExecutor::DepthToSpaceExecutor(const DepthToSpaceAttrs
     const bool isBlocked = one_of(attrs.layoutType, LayoutType::nCsp16c, LayoutType::nCsp8c);
     const bool isChannelsFirst = attrs.layoutType == LayoutType::nspc;
     const size_t nDims = attrs.srcBlockedDims.size();
-    const size_t reshapedRank = nDims + attrs.nSpatialDims + static_cast<int>(isBlocked && attrs.mode == Mode::DEPTH_FIRST);
+    const size_t reshapedRank =
+        nDims + attrs.nSpatialDims + static_cast<int>(isBlocked && attrs.mode == Mode::DEPTH_FIRST);
     const size_t lastIdx = reshapedRank - 1;
     size_t firstSpatialOrder = 2;
 
@@ -219,21 +222,24 @@ DepthToSpace::DepthToSpaceExecutor::DepthToSpaceExecutor(const DepthToSpaceAttrs
     params.src_block_dims[0] = attrs.srcBlockedDims[0];
 
     // reshaping of src dimensions and creating the permutation order for each layout:
-    // new shape: mode = blocks_first [N, block_size, block_size, ..., block_size, C / (block_size ^ K), D1, D2, ..., DK]
-    //            mode = depth_first  [N, C / (block_size ^ K), block_size, block_size, ..., block_size, D1, D2, ..., DK]
+    // new shape: mode = blocks_first [N, block_size, block_size, ..., block_size, C / (block_size ^ K), D1, D2, ...,
+    // DK]
+    //            mode = depth_first  [N, C / (block_size ^ K), block_size, block_size, ..., block_size, D1, D2, ...,
+    //            DK]
     // order    : mode = blocks_first : [0,  K + 1,  K + 2, 1, K + 3, 2, K + 4, 3, ..., K + (K + 1), K]
     //            mode = depth_first  : [0,  1,  K + 2, 2, K + 3, 3, K + 4, 4, ..., K + (K + 1), K + 1]
     // where `k` is number of spatial dimensions
 
-    auto reshapeAndSetPermOrder = [&](const size_t idx1, const size_t idx2, const size_t shift, const VectorDims& dims) {
-        for (size_t i = 0; i < attrs.nSpatialDims; i++) {
-            params.order[i * 2 + shift] = i + idx1;
-            params.order[i * 2 + shift + 1] = i + idx2;
+    auto reshapeAndSetPermOrder =
+        [&](const size_t idx1, const size_t idx2, const size_t shift, const VectorDims& dims) {
+            for (size_t i = 0; i < attrs.nSpatialDims; i++) {
+                params.order[i * 2 + shift] = i + idx1;
+                params.order[i * 2 + shift + 1] = i + idx2;
 
-            params.src_block_dims[params.order[i * 2 + shift]] = dims[i + shift];
-            params.src_block_dims[params.order[i * 2 + shift + 1]] = attrs.blockSize;
-        }
-    };
+                params.src_block_dims[params.order[i * 2 + shift]] = dims[i + shift];
+                params.src_block_dims[params.order[i * 2 + shift + 1]] = attrs.blockSize;
+            }
+        };
 
     if (isBlocked) {
         size_t orderShiftForBlocks, orderShiftForDims;
@@ -314,6 +320,6 @@ bool DepthToSpace::created() const {
     return getType() == Type::DepthToSpace;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/depth_to_space.h b/src/plugins/intel_cpu/src/nodes/depth_to_space.h
index 2eda39f60394af..21eca73f97318c 100644
--- a/src/plugins/intel_cpu/src/nodes/depth_to_space.h
+++ b/src/plugins/intel_cpu/src/nodes/depth_to_space.h
@@ -54,6 +54,6 @@ class DepthToSpace : public Node {
     executorPtr execPtr = nullptr;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/detection_output.cpp b/src/plugins/intel_cpu/src/nodes/detection_output.cpp
index 99702780b83034..9cf52e7042c6ba 100644
--- a/src/plugins/intel_cpu/src/nodes/detection_output.cpp
+++ b/src/plugins/intel_cpu/src/nodes/detection_output.cpp
@@ -16,8 +16,7 @@ namespace node {
 namespace {
 
 template <typename T>
-bool SortScorePairDescend(const std::pair<float, T>& pair1,
-                          const std::pair<float, T>& pair2) {
+bool SortScorePairDescend(const std::pair<float, T>& pair1, const std::pair<float, T>& pair2) {
     return (pair1.first > pair2.first) || (pair1.first == pair2.first && pair1.second < pair2.second);
 }
 
@@ -27,9 +26,10 @@ bool SortScorePairDescend<std::pair<int, int>>(const std::pair<float, std::pair<
     return (pair1.first > pair2.first) || (pair1.first == pair2.first && pair1.second.second < pair2.second.second);
 }
 
-} // namespace
+}  // namespace
 
-bool DetectionOutput::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool DetectionOutput::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                           std::string& errorMessage) noexcept {
     try {
         const auto doOp = ov::as_type_ptr<const ov::op::v8::DetectionOutput>(op);
         if (!doOp) {
@@ -58,7 +58,7 @@ DetectionOutput::DetectionOutput(const std::shared_ptr<ov::Node>& op, const Grap
     errorPrefix = "DetectionOutput node with name '" + getName() + "' ";
 
     if (getOriginalInputsNumber() != 3 && getOriginalInputsNumber() != 5)
-        OPENVINO_THROW(errorPrefix,  "has incorrect number of input edges.");
+        OPENVINO_THROW(errorPrefix, "has incorrect number of input edges.");
 
     if (getOriginalOutputsNumber() != 1)
         OPENVINO_THROW(errorPrefix, "has incorrect number of output edges.");
@@ -93,7 +93,7 @@ DetectionOutput::DetectionOutput(const std::shared_ptr<ov::Node>& op, const Grap
 
 void DetectionOutput::prepareParams() {
     const auto& idPriorDims = getParentEdgeAt(ID_PRIOR)->getMemory().getShape().getStaticDims();
-    const auto &idConfDims = getParentEdgeAt(ID_CONF)->getMemory().getShape().getStaticDims();
+    const auto& idConfDims = getParentEdgeAt(ID_CONF)->getMemory().getShape().getStaticDims();
     priorsNum = static_cast<int>(idPriorDims.back() / priorSize);
     isPriorsPerImg = idPriorDims.front() != 1;
     classesNum = static_cast<int>(idConfDims.back() / priorsNum);
@@ -130,9 +130,8 @@ void DetectionOutput::prepareParams() {
     //        --> g_topk(vector<>(all detections) --> indices per class))
     // MXNet: max conf for prior within img, filter(indices) --> topk_img(buffer) --> nms_cls(indices)
     //        --> g_topk(vector<>(all detections) --> indices per class))
-    isSparsityWorthwhile =
-        (confidenceThreshold > sparsityThreshold) &&
-        ((classesNum * priorsNum * sizeof(float) * 2) > static_cast<size_t>(cacheSizeL3));
+    isSparsityWorthwhile = (confidenceThreshold > sparsityThreshold) &&
+                           ((classesNum * priorsNum * sizeof(float) * 2) > static_cast<size_t>(cacheSizeL3));
     confInfoLen = (!decreaseClassId && isSparsityWorthwhile) ? (2 * priorsNum + 1) : priorsNum;
     reorderedConf.resize(imgNum * classesNum * confInfoLen);
 
@@ -149,17 +148,17 @@ void DetectionOutput::initSupportedPrimitiveDescriptors() {
     for (size_t i = 0; i < inputShapes.size(); ++i)
         inDataConf.emplace_back(LayoutType::ncsp, ov::element::f32);
 
-    addSupportedPrimDesc(inDataConf,
-                         {{LayoutType::ncsp, ov::element::f32}},
-                         impl_desc_type::ref_any);
+    addSupportedPrimDesc(inDataConf, {{LayoutType::ncsp, ov::element::f32}}, impl_desc_type::ref_any);
 }
 
 struct ConfidenceComparatorDO {
     explicit ConfidenceComparatorDO(const float* confDataIn) : confData(confDataIn) {}
 
     bool operator()(int idx1, int idx2) {
-        if (confData[idx1] > confData[idx2]) return true;
-        if (confData[idx1] < confData[idx2]) return false;
+        if (confData[idx1] > confData[idx2])
+            return true;
+        if (confData[idx1] < confData[idx2])
+            return false;
         return idx1 < idx2;
     }
 
@@ -171,31 +170,29 @@ void DetectionOutput::executeDynamicImpl(dnnl::stream strm) {
 }
 
 void DetectionOutput::execute(dnnl::stream strm) {
-    float *dstData = getDstDataAtPortAs<float>(0);
+    float* dstData = getDstDataAtPortAs<float>(0);
 
-    const float *locData     = getSrcDataAtPortAs<const float>(ID_LOC);
-    const float *confData    = getSrcDataAtPortAs<const float>(ID_CONF);
-    const float *priorData   = getSrcDataAtPortAs<const float>(ID_PRIOR);
-    const float *ARMConfData = inputShapes.size() > 3 ?
-            getSrcDataAtPortAs<const float>(ID_ARM_CONF) : nullptr;
-    const float *ARMLocData = inputShapes.size() > 4 ?
-            getSrcDataAtPortAs<const float>(ID_ARM_LOC) : nullptr;
+    const float* locData = getSrcDataAtPortAs<const float>(ID_LOC);
+    const float* confData = getSrcDataAtPortAs<const float>(ID_CONF);
+    const float* priorData = getSrcDataAtPortAs<const float>(ID_PRIOR);
+    const float* ARMConfData = inputShapes.size() > 3 ? getSrcDataAtPortAs<const float>(ID_ARM_CONF) : nullptr;
+    const float* ARMLocData = inputShapes.size() > 4 ? getSrcDataAtPortAs<const float>(ID_ARM_LOC) : nullptr;
 
-    float *reorderedConfData = reorderedConf.data();
-    int *reorderedConfDataIndices = reinterpret_cast<int*>(reorderedConf.data());
+    float* reorderedConfData = reorderedConf.data();
+    int* reorderedConfDataIndices = reinterpret_cast<int*>(reorderedConf.data());
 
-    float *decodedBboxesData = decodedBboxes.data();
-    float *bboxSizesData     = bboxSizes.data();
-    int *indicesData         = indices.data();
-    int *indicesBufData      = indicesBuffer.data();
-    int *detectionsData      = detectionsCount.data();
+    float* decodedBboxesData = decodedBboxes.data();
+    float* bboxSizesData = bboxSizes.data();
+    int* indicesData = indices.data();
+    int* indicesBufData = indicesBuffer.data();
+    int* detectionsData = detectionsCount.data();
 
     memset(detectionsData, 0, imgNum * classesNum * sizeof(int));
 
     int priorsBatch = isPriorsPerImg ? imgNum : 1;
-    int *numPriorsActualdata = numPriorsActual.data();
+    int* numPriorsActualdata = numPriorsActual.data();
     for (int n = 0; n < priorsBatch; ++n) {
-        const float *ppriors = priorData;
+        const float* ppriors = priorData;
         ppriors += varianceEncodedInTarget ? (n * priorsNum * priorSize) : (2 * n * priorsNum * priorSize);
         getActualPriorNum(ppriors, numPriorsActualdata, n);
     }
@@ -204,21 +201,32 @@ void DetectionOutput::execute(dnnl::stream strm) {
 
     if (!isSparsityWorthwhile) {
         confReorderDense(confData, ARMConfData, reorderedConfData);
-    } else { // sparsity
+    } else {  // sparsity
         if (!decreaseClassId) {
-            confReorderAndFilterSparsityCF(confData, ARMConfData, reorderedConfData, indicesData, indicesBufData, detectionsData);
+            confReorderAndFilterSparsityCF(confData,
+                                           ARMConfData,
+                                           reorderedConfData,
+                                           indicesData,
+                                           indicesBufData,
+                                           detectionsData);
         } else {
-            confReorderAndFilterSparsityMX(confData, ARMConfData, reorderedConfData, indicesData, indicesBufData, detectionsData);
+            confReorderAndFilterSparsityMX(confData,
+                                           ARMConfData,
+                                           reorderedConfData,
+                                           indicesData,
+                                           indicesBufData,
+                                           detectionsData);
         }
     }
 
-    int *confInfoV = confInfoForPrior.data();
+    int* confInfoV = confInfoForPrior.data();
 
     for (int n = 0; n < imgNum; ++n) {
-        const float *ppriors = priorData;
-        const float *priorVariances = priorData + priorsNum * priorSize;
+        const float* ppriors = priorData;
+        const float* priorVariances = priorData + priorsNum * priorSize;
         if (isPriorsPerImg) {
-            int priorSizePerImg = varianceEncodedInTarget ? (n * priorsNum * priorSize) : (2 * n * priorsNum * priorSize);
+            int priorSizePerImg =
+                varianceEncodedInTarget ? (n * priorsNum * priorSize) : (2 * n * priorsNum * priorSize);
             ppriors += priorSizePerImg;
             priorVariances += varianceEncodedInTarget ? 0 : priorSizePerImg;
         }
@@ -226,17 +234,50 @@ void DetectionOutput::execute(dnnl::stream strm) {
         if (isShareLoc) {
             int locShift = n * priorsNum;
             int coordShift = locShift * 4;
-            const float *ploc = locData + coordShift;
-            float *pboxes = decodedBboxesData + coordShift;
-            float *psizes = bboxSizesData + locShift;
-            int *confInfoVB = confInfoV + locShift;
+            const float* ploc = locData + coordShift;
+            float* pboxes = decodedBboxesData + coordShift;
+            float* psizes = bboxSizesData + locShift;
+            int* confInfoVB = confInfoV + locShift;
 
             if (withAddBoxPred) {
-                const float *pARMLoc = ARMLocData + coordShift;
-                decodeBBoxes(ppriors, pARMLoc, priorVariances, pboxes, psizes, numPriorsActualdata, n, coordOffset, priorSize, true, nullptr, confInfoVB);
-                decodeBBoxes(pboxes, ploc, priorVariances, pboxes, psizes, numPriorsActualdata, n, 0, 4, false, nullptr, confInfoVB);
+                const float* pARMLoc = ARMLocData + coordShift;
+                decodeBBoxes(ppriors,
+                             pARMLoc,
+                             priorVariances,
+                             pboxes,
+                             psizes,
+                             numPriorsActualdata,
+                             n,
+                             coordOffset,
+                             priorSize,
+                             true,
+                             nullptr,
+                             confInfoVB);
+                decodeBBoxes(pboxes,
+                             ploc,
+                             priorVariances,
+                             pboxes,
+                             psizes,
+                             numPriorsActualdata,
+                             n,
+                             0,
+                             4,
+                             false,
+                             nullptr,
+                             confInfoVB);
             } else {
-                decodeBBoxes(ppriors, ploc, priorVariances, pboxes, psizes, numPriorsActualdata, n, coordOffset, priorSize, true, nullptr, confInfoVB);
+                decodeBBoxes(ppriors,
+                             ploc,
+                             priorVariances,
+                             pboxes,
+                             psizes,
+                             numPriorsActualdata,
+                             n,
+                             coordOffset,
+                             priorSize,
+                             true,
+                             nullptr,
+                             confInfoVB);
             }
         } else {
             for (int c = 0; c < locNumForClasses; ++c) {
@@ -245,16 +286,46 @@ void DetectionOutput::execute(dnnl::stream strm) {
                 }
                 int locShift = n * priorsNum * locNumForClasses;
                 int coordShift = locShift * 4;
-                const float *ploc = locData + coordShift + c * 4;
-                float *pboxes = decodedBboxesData + coordShift + c * 4 * priorsNum;
-                float *psizes = bboxSizesData + locShift + c * priorsNum;
-                int *confInfoHBC = reorderedConfDataIndices + n * confInfoLen * classesNum + c*confInfoLen;
+                const float* ploc = locData + coordShift + c * 4;
+                float* pboxes = decodedBboxesData + coordShift + c * 4 * priorsNum;
+                float* psizes = bboxSizesData + locShift + c * priorsNum;
+                int* confInfoHBC = reorderedConfDataIndices + n * confInfoLen * classesNum + c * confInfoLen;
                 if (withAddBoxPred) {
-                    const float *pARMLoc = ARMLocData + n * 4 * locNumForClasses * priorsNum + c * 4;
-                    decodeBBoxes(ppriors, pARMLoc, priorVariances, pboxes, psizes, numPriorsActualdata, n, coordOffset, priorSize, true, confInfoHBC);
-                    decodeBBoxes(pboxes, ploc, priorVariances, pboxes, psizes, numPriorsActualdata, n, 0, 4, false, confInfoHBC);
+                    const float* pARMLoc = ARMLocData + n * 4 * locNumForClasses * priorsNum + c * 4;
+                    decodeBBoxes(ppriors,
+                                 pARMLoc,
+                                 priorVariances,
+                                 pboxes,
+                                 psizes,
+                                 numPriorsActualdata,
+                                 n,
+                                 coordOffset,
+                                 priorSize,
+                                 true,
+                                 confInfoHBC);
+                    decodeBBoxes(pboxes,
+                                 ploc,
+                                 priorVariances,
+                                 pboxes,
+                                 psizes,
+                                 numPriorsActualdata,
+                                 n,
+                                 0,
+                                 4,
+                                 false,
+                                 confInfoHBC);
                 } else {
-                    decodeBBoxes(ppriors, ploc, priorVariances, pboxes, psizes, numPriorsActualdata, n, coordOffset, priorSize, true, confInfoHBC);
+                    decodeBBoxes(ppriors,
+                                 ploc,
+                                 priorVariances,
+                                 pboxes,
+                                 psizes,
+                                 numPriorsActualdata,
+                                 n,
+                                 coordOffset,
+                                 priorSize,
+                                 true,
+                                 confInfoHBC);
                 }
             }
         }
@@ -267,16 +338,16 @@ void DetectionOutput::execute(dnnl::stream strm) {
             parallel_for(classesNum, [&](int c) {
                 if (c != backgroundClassId) {  // Ignore background class
                     const int off = n * priorsNum * classesNum + c * priorsNum;
-                    const float *pconfReorder = reorderedConfData + off;
-                    int *pindices = indicesData + off;
-                    int *pbuffer = indicesBufData + off;
-                    int *pdetections = detectionsData + n * classesNum + c;
+                    const float* pconfReorder = reorderedConfData + off;
+                    int* pindices = indicesData + off;
+                    int* pbuffer = indicesBufData + off;
+                    int* pdetections = detectionsData + n * classesNum + c;
 
                     if (!isSparsityWorthwhile)
                         confFilterCF(pconfReorder, pindices, pbuffer, pdetections, n);
 
-                    const float *pboxes;
-                    const float *psizes;
+                    const float* pboxes;
+                    const float* psizes;
                     if (isShareLoc) {
                         pboxes = decodedBboxesData + n * 4 * priorsNum;
                         psizes = bboxSizesData + n * priorsNum;
@@ -291,23 +362,23 @@ void DetectionOutput::execute(dnnl::stream strm) {
         } else {
             // MXNet style
             const int offImg = n * priorsNum * classesNum;
-            const float *pconf = confData + offImg;
-            float *pconfReorder = reorderedConfData + offImg;
-            int *pbuffer = indicesBufData + offImg;
-            int *pindices = indicesData + offImg;
-            int *pdetections = detectionsData + n * classesNum;
+            const float* pconf = confData + offImg;
+            float* pconfReorder = reorderedConfData + offImg;
+            int* pbuffer = indicesBufData + offImg;
+            int* pindices = indicesData + offImg;
+            int* pdetections = detectionsData + n * classesNum;
 
             if (!isSparsityWorthwhile)
                 confFilterMX(pconf, ARMConfData, pconfReorder, pindices, pbuffer, pdetections, n);
 
-            const float *pboxes = decodedBboxesData + n * 4 * locNumForClasses * priorsNum;
-            const float *psizes = bboxSizesData + n * locNumForClasses * priorsNum;
+            const float* pboxes = decodedBboxesData + n * 4 * locNumForClasses * priorsNum;
+            const float* psizes = bboxSizesData + n * locNumForClasses * priorsNum;
 
             NMSMX(pbuffer, pdetections, pindices, pboxes, psizes);
         }
 
         int detectionsTotal = 0;
-        detectionsTotal = parallel_sum(classesNum, detectionsTotal, [&](size_t c)->int {
+        detectionsTotal = parallel_sum(classesNum, detectionsTotal, [&](size_t c) -> int {
             return detectionsData[n * classesNum + c];
         });
 
@@ -318,9 +389,9 @@ void DetectionOutput::execute(dnnl::stream strm) {
             std::mutex mtx;
             parallel_for(classesNum, [&](int c) {
                 const int detections = detectionsData[n * classesNum + c];
-                int *pindices = indicesData + n * classesNum * priorsNum + c * priorsNum;
+                int* pindices = indicesData + n * classesNum * priorsNum + c * priorsNum;
 
-                float *pconf  = reorderedConfData + n * classesNum * confInfoLen + c * confInfoLen;
+                float* pconf = reorderedConfData + n * classesNum * confInfoLen + c * confInfoLen;
 
                 for (int i = 0; i < detections; ++i) {
                     int pr = pindices[i];
@@ -330,7 +401,8 @@ void DetectionOutput::execute(dnnl::stream strm) {
                 }
             });
 
-            std::sort(confIndicesClassMap.begin(), confIndicesClassMap.end(),
+            std::sort(confIndicesClassMap.begin(),
+                      confIndicesClassMap.end(),
                       SortScorePairDescend<std::pair<int, int>>);
             confIndicesClassMap.resize(keepTopK);
 
@@ -340,7 +412,7 @@ void DetectionOutput::execute(dnnl::stream strm) {
             for (size_t j = 0; j < confIndicesClassMap.size(); ++j) {
                 const int cls = confIndicesClassMap[j].second.first;
                 const int pr = confIndicesClassMap[j].second.second;
-                int *pindices = indicesData + n * classesNum * priorsNum + cls * priorsNum;
+                int* pindices = indicesData + n * classesNum * priorsNum + cls * priorsNum;
                 pindices[detectionsData[n * classesNum + cls]] = pr;
                 detectionsData[n * classesNum + cls]++;
             }
@@ -351,7 +423,11 @@ void DetectionOutput::execute(dnnl::stream strm) {
     generateOutput(reorderedConfData, indicesData, detectionsData, decodedBboxesData, dstData);
 }
 
-inline void DetectionOutput::confFilterCF(const float* pconf, int* pindices, int* pbuffer, int* detectionsData, const int& n) {
+inline void DetectionOutput::confFilterCF(const float* pconf,
+                                          int* pindices,
+                                          int* pbuffer,
+                                          int* detectionsData,
+                                          const int& n) {
     // in:  reorderedConf
     // out: pindices count
     int count = 0;
@@ -371,21 +447,27 @@ inline void DetectionOutput::confFilterCF(const float* pconf, int* pindices, int
 
 // MX filter is per image filter, max output is prior num(select max for all class within this prior)
 // NMS is per class, keep topk is per image, final output is per class
-inline void DetectionOutput::confFilterMX(const float* confData, const float* ARMConfData, float* reorderedConfData,
-    int* indicesData, int* indicesBufData, int* detectionsData, const int& n) {
+inline void DetectionOutput::confFilterMX(const float* confData,
+                                          const float* ARMConfData,
+                                          float* reorderedConfData,
+                                          int* indicesData,
+                                          int* indicesBufData,
+                                          int* detectionsData,
+                                          const int& n) {
     std::mutex mtx;
     parallel_for(numPriorsActual[n], [&](size_t p) {
         // in:  origin conf
         // out: pindices, detectionCount
         // intentionally code branch from higher level
         if (withAddBoxPred) {
-            const bool isARMPrior = ARMConfData[n*priorsNum*2 + p * 2 + 1] < objScore;
+            const bool isARMPrior = ARMConfData[n * priorsNum * 2 + p * 2 + 1] < objScore;
             float maxConf = -1;
             int maxCIdx = 0;
             for (int c = 1; c < classesNum; ++c) {
                 float conf = confData[p * classesNum + c];
                 if (isARMPrior)
-                    conf = (c == backgroundClassId) ? 1.0f : 0.0f;  // still need refresh conf due to read from origin conf
+                    conf =
+                        (c == backgroundClassId) ? 1.0f : 0.0f;  // still need refresh conf due to read from origin conf
                 if (conf >= confidenceThreshold && conf > maxConf) {
                     maxConf = conf;
                     maxCIdx = c;
@@ -394,7 +476,7 @@ inline void DetectionOutput::confFilterMX(const float* confData, const float* AR
             if (maxCIdx > 0) {
                 // include this prior
                 mtx.lock();
-                indicesData[detectionsData[0]] = maxCIdx*priorsNum + p;  // de-refer to get prior and class id.
+                indicesData[detectionsData[0]] = maxCIdx * priorsNum + p;  // de-refer to get prior and class id.
                 detectionsData[0]++;
                 mtx.unlock();
             }
@@ -411,7 +493,7 @@ inline void DetectionOutput::confFilterMX(const float* confData, const float* AR
             if (maxCIdx > 0) {
                 // include this prior and class with max conf
                 mtx.lock();
-                indicesData[detectionsData[0]] = maxCIdx*priorsNum + p;  // de-refer to get prior and class id.
+                indicesData[detectionsData[0]] = maxCIdx * priorsNum + p;  // de-refer to get prior and class id.
                 detectionsData[0]++;
                 mtx.unlock();
             }
@@ -423,14 +505,14 @@ inline void DetectionOutput::confFilterMX(const float* confData, const float* AR
     int count = detectionsData[0];
     int k = (topK == -1 ? count : (std::min)(topK, count));
 
-    const float *pconf = reorderedConfData;
+    const float* pconf = reorderedConfData;
     // int *indices = indicesData;
     // int *pbuffer = indicesBufData;
     topk(indicesData, indicesBufData, pconf, count, k);
     detectionsData[0] = k;
 }
 
-inline void DetectionOutput::getActualPriorNum(const float *priorData, int* numPriorsActual, int n) {
+inline void DetectionOutput::getActualPriorNum(const float* priorData, int* numPriorsActual, int n) {
     numPriorsActual[n] = priorsNum;
     if (!normalized) {
         int num = 0;
@@ -444,16 +526,20 @@ inline void DetectionOutput::getActualPriorNum(const float *priorData, int* numP
     }
 }
 
-inline void DetectionOutput::confReorderDense(const float *confData, const float *ARMConfData, float *reorderedConfData) {
+inline void DetectionOutput::confReorderDense(const float* confData,
+                                              const float* ARMConfData,
+                                              float* reorderedConfData) {
     if (withAddBoxPred) {
         parallel_for2d(imgNum, priorsNum, [&](size_t n, size_t p) {
             if (ARMConfData[n * priorsNum * 2 + p * 2 + 1] < objScore) {
                 for (int c = 0; c < classesNum; ++c) {
-                    reorderedConfData[n * priorsNum * classesNum + c * priorsNum + p] = c == backgroundClassId ? 1.0f : 0.0f;
+                    reorderedConfData[n * priorsNum * classesNum + c * priorsNum + p] =
+                        c == backgroundClassId ? 1.0f : 0.0f;
                 }
             } else {
                 for (int c = 0; c < classesNum; ++c) {
-                    reorderedConfData[n * priorsNum * classesNum + c * priorsNum + p] = confData[n * priorsNum * classesNum + p * classesNum + c];
+                    reorderedConfData[n * priorsNum * classesNum + c * priorsNum + p] =
+                        confData[n * priorsNum * classesNum + p * classesNum + c];
                 }
             }
         });
@@ -463,20 +549,23 @@ inline void DetectionOutput::confReorderDense(const float *confData, const float
     parallel_for2d(imgNum, classesNum, [&](size_t n, size_t c) {
         const int offset = n * priorsNum * classesNum;
         for (int p = 0; p < priorsNum; ++p) {
-            reorderedConfData[offset + c * priorsNum + p] =
-            confData[offset + p * classesNum + c];
+            reorderedConfData[offset + c * priorsNum + p] = confData[offset + p * classesNum + c];
         }
     });
 }
 
-inline void DetectionOutput::confReorderAndFilterSparsityCF(const float* confData, const float* ARMConfData, float* reorderedConfData,
-    int* indicesData, int* indicesBufData, int* detectionsData) {
+inline void DetectionOutput::confReorderAndFilterSparsityCF(const float* confData,
+                                                            const float* ARMConfData,
+                                                            float* reorderedConfData,
+                                                            int* indicesData,
+                                                            int* indicesBufData,
+                                                            int* detectionsData) {
     int* reorderedConfDataIndices = reinterpret_cast<int*>(reorderedConfData);
     for (int n = 0; n < imgNum; ++n) {
         const int off = n * priorsNum * classesNum;
         const int offV = n * priorsNum;  // vertical info
 
-        const int offH = n * confInfoLen * classesNum; // horizontal info
+        const int offH = n * confInfoLen * classesNum;  // horizontal info
         // reset count
         parallel_for(classesNum, [&](size_t c) {
             const int countIdx = offH + c * confInfoLen + priorsNum;
@@ -506,7 +595,7 @@ inline void DetectionOutput::confReorderAndFilterSparsityCF(const float* confDat
 
                         // vertical info for isShareLoc(flag to decode for each prior)
                         if (!priorStatusSet && isShareLoc) {
-                            confInfoForPrior[offV + p] = 1; // 1 for decode
+                            confInfoForPrior[offV + p] = 1;  // 1 for decode
                         }
                     }
                 }
@@ -542,9 +631,9 @@ inline void DetectionOutput::confReorderAndFilterSparsityCF(const float* confDat
             const int count = reorderedConfDataIndices[countIdx];
             const int k = (topK == -1 ? count : (std::min)(topK, count));
 
-            int *reorderedConfIndices = reorderedConfDataIndices + countIdx + 1;
-            int *pbuffer = indicesBufData + off + c * priorsNum;
-            const float *pconf = reorderedConfData + offH + c * confInfoLen;
+            int* reorderedConfIndices = reorderedConfDataIndices + countIdx + 1;
+            int* pbuffer = indicesBufData + off + c * priorsNum;
+            const float* pconf = reorderedConfData + offH + c * confInfoLen;
 
             topk(reorderedConfIndices, pbuffer, pconf, count, k);
             detectionsData[n * classesNum + c] = k;
@@ -552,8 +641,12 @@ inline void DetectionOutput::confReorderAndFilterSparsityCF(const float* confDat
     }
 }
 
-inline void DetectionOutput::confReorderAndFilterSparsityMX(const float* confData, const float* ARMConfData, float* reorderedConfData,
-    int* indicesData, int* indicesBufData, int* detectionsData) {
+inline void DetectionOutput::confReorderAndFilterSparsityMX(const float* confData,
+                                                            const float* ARMConfData,
+                                                            float* reorderedConfData,
+                                                            int* indicesData,
+                                                            int* indicesBufData,
+                                                            int* detectionsData) {
     for (int n = 0; n < imgNum; ++n) {
         const int off = n * priorsNum * classesNum;
         const int offV = n * priorsNum;  // vertical info
@@ -579,7 +672,7 @@ inline void DetectionOutput::confReorderAndFilterSparsityMX(const float* confDat
 
                     // vertical info for isShareLoc(flag to decode for each prior)
                     if (!priorStatusSet && isShareLoc) {
-                        confInfoForPrior[offV + p] = 1; // 1 for decode
+                        confInfoForPrior[offV + p] = 1;  // 1 for decode
                     }
                     // vertical info for MXNet style(max conf for each prior)
                     if (c != 0) {
@@ -593,7 +686,8 @@ inline void DetectionOutput::confReorderAndFilterSparsityMX(const float* confDat
             // MXNet statistic, indices and detectionCount is for each image
             if (maxCIdx > 0) {
                 mtx.lock();
-                indicesData[off + detectionsData[n * classesNum]] = maxCIdx * priorsNum + p;  // de-refer to get prior and class id.
+                indicesData[off + detectionsData[n * classesNum]] =
+                    maxCIdx * priorsNum + p;  // de-refer to get prior and class id.
                 detectionsData[n * classesNum]++;
                 mtx.unlock();
             }
@@ -604,27 +698,27 @@ inline void DetectionOutput::confReorderAndFilterSparsityMX(const float* confDat
         const int count = detectionsData[n * classesNum];
         const int k = (topK == -1 ? count : (std::min)(topK, count));
 
-        const float *pconf = reorderedConfData + off;
-        int *indices = indicesData + off;
-        int *pbuffer = indicesBufData + off;
+        const float* pconf = reorderedConfData + off;
+        int* indices = indicesData + off;
+        int* pbuffer = indicesBufData + off;
         topk(indices, pbuffer, pconf, count, k);
         detectionsData[n * classesNum] = k;
     }
 }
 
 // apply locData(offset) to priordata, generate decodedBox
-inline void DetectionOutput::decodeBBoxes(const float *priorData,
-                                       const float *locData,
-                                       const float *varianceData,
-                                       float *decodedBboxes,
-                                       float *decodedBboxSizes,
-                                       int* numPriorsActual,
-                                       int n,
-                                       const int& offs,
-                                       const int& priorSize,
-                                       bool decodeType,
-                                       const int *confInfoH,
-                                       const int *confInfoV) {
+inline void DetectionOutput::decodeBBoxes(const float* priorData,
+                                          const float* locData,
+                                          const float* varianceData,
+                                          float* decodedBboxes,
+                                          float* decodedBboxSizes,
+                                          int* numPriorsActual,
+                                          int n,
+                                          const int& offs,
+                                          const int& priorSize,
+                                          bool decodeType,
+                                          const int* confInfoH,
+                                          const int* confInfoV) {
     int prNum = numPriorsActual[n];
     if (!decodeType) {
         prNum = priorsNum;
@@ -672,8 +766,8 @@ inline void DetectionOutput::decodeBBoxes(const float *priorData,
                 newYMax = priorYMax + varianceData[p * 4 + 3] * locYMax;
             }
         } else if (codeType == CodeType::CENTER_SIZE) {
-            float priorWidth    =  priorXMax - priorXMin;
-            float priorHeight   =  priorYMax - priorYMin;
+            float priorWidth = priorXMax - priorXMin;
+            float priorHeight = priorYMax - priorYMin;
             float priorCenterX = (priorXMin + priorXMax) / 2.0f;
             float priorCenterY = (priorYMin + priorYMax) / 2.0f;
 
@@ -682,21 +776,21 @@ inline void DetectionOutput::decodeBBoxes(const float *priorData,
 
             if (varianceEncodedInTarget) {
                 // variance is encoded in target, we simply need to restore the offset predictions.
-                decodeBboxCenterX = locXMin * priorWidth  + priorCenterX;
+                decodeBboxCenterX = locXMin * priorWidth + priorCenterX;
                 decodeBboxCenterY = locYMin * priorHeight + priorCenterY;
-                decodeBboxWidth  = std::exp(locXMax) * priorWidth;
+                decodeBboxWidth = std::exp(locXMax) * priorWidth;
                 decodeBboxHeight = std::exp(locYMax) * priorHeight;
             } else {
                 // variance is encoded in bbox, we need to scale the offset accordingly.
-                decodeBboxCenterX = varianceData[p*4 + 0] * locXMin * priorWidth + priorCenterX;
-                decodeBboxCenterY = varianceData[p*4 + 1] * locYMin * priorHeight + priorCenterY;
-                decodeBboxWidth    = std::exp(varianceData[p*4 + 2] * locXMax) * priorWidth;
-                decodeBboxHeight   = std::exp(varianceData[p*4 + 3] * locYMax) * priorHeight;
+                decodeBboxCenterX = varianceData[p * 4 + 0] * locXMin * priorWidth + priorCenterX;
+                decodeBboxCenterY = varianceData[p * 4 + 1] * locYMin * priorHeight + priorCenterY;
+                decodeBboxWidth = std::exp(varianceData[p * 4 + 2] * locXMax) * priorWidth;
+                decodeBboxHeight = std::exp(varianceData[p * 4 + 3] * locYMax) * priorHeight;
             }
 
-            newXMin = decodeBboxCenterX - decodeBboxWidth  / 2.0f;
+            newXMin = decodeBboxCenterX - decodeBboxWidth / 2.0f;
             newYMin = decodeBboxCenterY - decodeBboxHeight / 2.0f;
-            newXMax = decodeBboxCenterX + decodeBboxWidth  / 2.0f;
+            newXMax = decodeBboxCenterX + decodeBboxWidth / 2.0f;
             newYMax = decodeBboxCenterY + decodeBboxHeight / 2.0f;
         }
 
@@ -707,25 +801,20 @@ inline void DetectionOutput::decodeBBoxes(const float *priorData,
             newYMax = (std::max)(0.0f, (std::min)(1.0f, newYMax));
         }
 
-        decodedBboxes[p*4 + 0] = newXMin;
-        decodedBboxes[p*4 + 1] = newYMin;
-        decodedBboxes[p*4 + 2] = newXMax;
-        decodedBboxes[p*4 + 3] = newYMax;
+        decodedBboxes[p * 4 + 0] = newXMin;
+        decodedBboxes[p * 4 + 1] = newYMin;
+        decodedBboxes[p * 4 + 2] = newXMax;
+        decodedBboxes[p * 4 + 3] = newYMax;
 
         decodedBboxSizes[p] = (newXMax - newXMin) * (newYMax - newYMin);
     });
 }
 
-inline void DetectionOutput::topk(const int *indicesIn, int *indicesOut, const float *conf, int n, int k) {
-    std::partial_sort_copy(indicesIn, indicesIn + n,
-                           indicesOut, indicesOut + k,
-                           ConfidenceComparatorDO(conf));
+inline void DetectionOutput::topk(const int* indicesIn, int* indicesOut, const float* conf, int n, int k) {
+    std::partial_sort_copy(indicesIn, indicesIn + n, indicesOut, indicesOut + k, ConfidenceComparatorDO(conf));
 }
 
-static inline float JaccardOverlap(const float *decodedBbox,
-                                   const float *bboxSizes,
-                                   const int idx1,
-                                   const int idx2) {
+static inline float JaccardOverlap(const float* decodedBbox, const float* bboxSizes, const int idx1, const int idx2) {
     const float xmin1 = decodedBbox[idx1 * 4 + 0];
     const float ymin1 = decodedBbox[idx1 * 4 + 1];
     const float xmax1 = decodedBbox[idx1 * 4 + 2];
@@ -745,7 +834,7 @@ static inline float JaccardOverlap(const float *decodedBbox,
     float intersectXMax = (std::min)(xmax1, xmax2);
     float intersectYMax = (std::min)(ymax1, ymax2);
 
-    float intersectWidth  = intersectXMax - intersectXMin;
+    float intersectWidth = intersectXMax - intersectXMin;
     float intersectHeight = intersectYMax - intersectYMin;
 
     if (intersectWidth <= 0 || intersectHeight <= 0) {
@@ -760,10 +849,10 @@ static inline float JaccardOverlap(const float *decodedBbox,
 }
 
 inline void DetectionOutput::NMSCF(int* indicesIn,
-                                        int& detections,
-                                        int* indicesOut,
-                                        const float* bboxes,
-                                        const float* boxSizes) {
+                                   int& detections,
+                                   int* indicesOut,
+                                   const float* bboxes,
+                                   const float* boxSizes) {
     // nms for this class
     int countIn = detections;
     detections = 0;
@@ -787,10 +876,10 @@ inline void DetectionOutput::NMSCF(int* indicesIn,
 }
 
 inline void DetectionOutput::NMSMX(int* indicesIn,
-                                    int* detections,
-                                    int* indicesOut,
-                                    const float* bboxes,
-                                    const float* sizes) {
+                                   int* detections,
+                                   int* indicesOut,
+                                   const float* bboxes,
+                                   const float* sizes) {
     // Input is candidate for image, output is candidate for each class within image
     int countIn = detections[0];
     detections[0] = 0;
@@ -801,8 +890,8 @@ inline void DetectionOutput::NMSMX(int* indicesIn,
         const int prior = idx % priorsNum;
 
         // nms within this class
-        int &ndetection = detections[cls];
-        int *pindices = indicesOut + cls * priorsNum;
+        int& ndetection = detections[cls];
+        int* pindices = indicesOut + cls * priorsNum;
 
         bool keep = true;
         for (int k = 0; k < ndetection; ++k) {
@@ -825,8 +914,11 @@ inline void DetectionOutput::NMSMX(int* indicesIn,
     }
 }
 
-inline void DetectionOutput::generateOutput(float* reorderedConfData, int* indicesData, int* detectionsData, float* decodedBboxesData,
-    float* dstData) {
+inline void DetectionOutput::generateOutput(float* reorderedConfData,
+                                            int* indicesData,
+                                            int* detectionsData,
+                                            float* decodedBboxesData,
+                                            float* dstData) {
     const auto& outDims = getChildEdgeAt(0)->getMemory().getStaticDims();
     const int numResults = outDims[2];
     const int DETECTION_SIZE = outDims[3];
@@ -850,26 +942,22 @@ inline void DetectionOutput::generateOutput(float* reorderedConfData, int* indic
     // set final detection result to output blob
     int count = 0;
     for (int n = 0; n < imgNum; ++n) {
-        const float *pconf   = reorderedConfData + n * confInfoLen * classesNum;
-        const float *pboxes  = decodedBboxesData + n * priorsNum * 4 * locNumForClasses;
-        const int *pindices  = indicesData + n * classesNum * priorsNum;
+        const float* pconf = reorderedConfData + n * confInfoLen * classesNum;
+        const float* pboxes = decodedBboxesData + n * priorsNum * 4 * locNumForClasses;
+        const int* pindices = indicesData + n * classesNum * priorsNum;
 
         for (int c = 0; c < classesNum; ++c) {
             for (int i = 0; i < detectionsData[n * classesNum + c]; ++i) {
                 int prIdx = pindices[c * priorsNum + i];
 
                 dstData[count * DETECTION_SIZE + 0] = static_cast<float>(n);
-                dstData[count * DETECTION_SIZE + 1] = static_cast<float>(decreaseClassId ? c-1 : c);
+                dstData[count * DETECTION_SIZE + 1] = static_cast<float>(decreaseClassId ? c - 1 : c);
                 dstData[count * DETECTION_SIZE + 2] = pconf[c * confInfoLen + prIdx];
 
-                float xmin = isShareLoc ? pboxes[prIdx * 4 + 0] :
-                             pboxes[c * 4 * priorsNum + prIdx * 4 + 0];
-                float ymin = isShareLoc ? pboxes[prIdx * 4 + 1] :
-                             pboxes[c * 4 * priorsNum + prIdx * 4 + 1];
-                float xmax = isShareLoc ? pboxes[prIdx * 4 + 2] :
-                             pboxes[c * 4 * priorsNum + prIdx * 4 + 2];
-                float ymax = isShareLoc ? pboxes[prIdx * 4 + 3] :
-                             pboxes[c * 4 * priorsNum + prIdx * 4 + 3];
+                float xmin = isShareLoc ? pboxes[prIdx * 4 + 0] : pboxes[c * 4 * priorsNum + prIdx * 4 + 0];
+                float ymin = isShareLoc ? pboxes[prIdx * 4 + 1] : pboxes[c * 4 * priorsNum + prIdx * 4 + 1];
+                float xmax = isShareLoc ? pboxes[prIdx * 4 + 2] : pboxes[c * 4 * priorsNum + prIdx * 4 + 2];
+                float ymax = isShareLoc ? pboxes[prIdx * 4 + 3] : pboxes[c * 4 * priorsNum + prIdx * 4 + 3];
 
                 if (clipAfterNMS) {
                     xmin = (std::max)(0.0f, (std::min)(1.0f, xmin));
@@ -898,6 +986,6 @@ bool DetectionOutput::created() const {
     return getType() == Type::DetectionOutput;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/detection_output.h b/src/plugins/intel_cpu/src/nodes/detection_output.h
index 418898f011f313..1a42bfa9b2980a 100644
--- a/src/plugins/intel_cpu/src/nodes/detection_output.h
+++ b/src/plugins/intel_cpu/src/nodes/detection_output.h
@@ -15,7 +15,7 @@ class DetectionOutput : public Node {
 public:
     DetectionOutput(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -47,8 +47,8 @@ class DetectionOutput : public Node {
     float sparsityThreshold = 0.03f;
     int topK = 0;
     float NMSThreshold = 0.0f;
-    bool clipBeforeNMS   = false;
-    bool clipAfterNMS    = false;
+    bool clipBeforeNMS = false;
+    bool clipAfterNMS = false;
     int backgroundClassId = 0;
     bool decreaseClassId = false;
     int keepTopK = 0;
@@ -75,28 +75,52 @@ class DetectionOutput : public Node {
 
     inline void confFilterCF(const float* pConf, int* pindices, int* pbuffer, int* detectionsData, const int& n);
 
-    inline void confFilterMX(const float* confData, const float* ARMConfData, float* reorderedConfData,
-        int* indicesData, int* indicesBufData, int* detectionsData, const int& n);
-
-    inline void confReorderAndFilterSparsityCF(const float* confData, const float* ARMConfData, float* reorderedConfData,
-        int* indicesData, int* indicesBufData, int* detectionsData);
-
-    inline void confReorderAndFilterSparsityMX(const float* confData, const float* ARMConfData, float* reorderedConfData,
-        int* indicesData, int* indicesBufData, int* detectionsData);
-
-    inline void decodeBBoxes(const float* prior_data, const float* loc_data, const float* variance_data,
-                      float* decoded_bboxes, float* decoded_bbox_sizes, int* num_priors_actual, int n, const int& offs, const int& pr_size,
-                      bool decodeType = true, const int* conf_info_h = nullptr, const int* conf_info_v = nullptr); // decodeType is false after ARM
-
-    inline void NMSCF(int* indicesIn, int& detections, int* indicesOut,
-        const float* bboxes, const float* boxSizes);
-
-    inline void NMSMX(int* indicesIn, int* detections, int* indicesOut,
-        const float* bboxes, const float* sizes);
+    inline void confFilterMX(const float* confData,
+                             const float* ARMConfData,
+                             float* reorderedConfData,
+                             int* indicesData,
+                             int* indicesBufData,
+                             int* detectionsData,
+                             const int& n);
+
+    inline void confReorderAndFilterSparsityCF(const float* confData,
+                                               const float* ARMConfData,
+                                               float* reorderedConfData,
+                                               int* indicesData,
+                                               int* indicesBufData,
+                                               int* detectionsData);
+
+    inline void confReorderAndFilterSparsityMX(const float* confData,
+                                               const float* ARMConfData,
+                                               float* reorderedConfData,
+                                               int* indicesData,
+                                               int* indicesBufData,
+                                               int* detectionsData);
+
+    inline void decodeBBoxes(const float* prior_data,
+                             const float* loc_data,
+                             const float* variance_data,
+                             float* decoded_bboxes,
+                             float* decoded_bbox_sizes,
+                             int* num_priors_actual,
+                             int n,
+                             const int& offs,
+                             const int& pr_size,
+                             bool decodeType = true,
+                             const int* conf_info_h = nullptr,
+                             const int* conf_info_v = nullptr);  // decodeType is false after ARM
+
+    inline void NMSCF(int* indicesIn, int& detections, int* indicesOut, const float* bboxes, const float* boxSizes);
+
+    inline void NMSMX(int* indicesIn, int* detections, int* indicesOut, const float* bboxes, const float* sizes);
 
     inline void topk(const int* indicesIn, int* indicesOut, const float* conf, int n, int k);
 
-    inline void generateOutput(float* reorderedConfData, int* indicesData, int* detectionsData, float* decodedBboxesData, float* dstData);
+    inline void generateOutput(float* reorderedConfData,
+                               int* indicesData,
+                               int* detectionsData,
+                               float* decodedBboxesData,
+                               float* dstData);
 
     std::vector<float> decodedBboxes;
     std::vector<int> indicesBuffer;
@@ -110,6 +134,6 @@ class DetectionOutput : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/dft.cpp b/src/plugins/intel_cpu/src/nodes/dft.cpp
index 76ecbbb36617f5..5fa8053d7024d7 100644
--- a/src/plugins/intel_cpu/src/nodes/dft.cpp
+++ b/src/plugins/intel_cpu/src/nodes/dft.cpp
@@ -4,17 +4,17 @@
 
 #include "dft.h"
 
+#include <cmath>
+#include <openvino/opsets/opset7.hpp>
 #include <string>
 #include <vector>
-#include <cmath>
-#include "dnnl_extension_utils.h"
 
-#include "openvino/core/parallel.hpp"
+#include "common/cpu_memcpy.h"
+#include "dnnl_extension_utils.h"
 #include "onednn/dnnl.h"
+#include "openvino/core/parallel.hpp"
 #include "utils/general_utils.h"
-#include "common/cpu_memcpy.h"
 #include "utils/ngraph_utils.hpp"
-#include <openvino/opsets/opset7.hpp>
 
 using namespace dnnl::impl;
 using namespace dnnl::impl::cpu::x64;
@@ -104,10 +104,10 @@ void DFT::initSupportedPrimitiveDescriptors() {
         }
     }
 
-    std::vector<PortConfigurator> inDataConfigurators({{LayoutType::ncsp, ov::element::f32},
-                                                       {LayoutType::ncsp, ov::element::i32}});
+    std::vector<PortConfigurator> inDataConfigurators(
+        {{LayoutType::ncsp, ov::element::f32}, {LayoutType::ncsp, ov::element::i32}});
     if (inputShapes.size() > SIGNAL_SIZE_INDEX)
-        inDataConfigurators.push_back({LayoutType::ncsp,  ov::element::i32});
+        inDataConfigurators.push_back({LayoutType::ncsp, ov::element::i32});
 
     addSupportedPrimDesc(inDataConfigurators, {{LayoutType::ncsp, ov::element::f32}}, impl_desc_type::ref_any);
 }
@@ -172,8 +172,12 @@ size_t calculateOffsetFromStrides(const std::vector<size_t>& coords, const std::
     return offset;
 }
 
-void gatherToBufferND(float* buffer, const float* data, size_t axis, const std::vector<size_t>& dimIndexes,
-                                     const std::vector<size_t>& shape, const std::vector<size_t>& strides) {
+void gatherToBufferND(float* buffer,
+                      const float* data,
+                      size_t axis,
+                      const std::vector<size_t>& dimIndexes,
+                      const std::vector<size_t>& shape,
+                      const std::vector<size_t>& strides) {
     size_t numberOfComplex = shape[axis];
     size_t offset = calculateOffsetFromStrides(dimIndexes, strides);
 
@@ -184,8 +188,12 @@ void gatherToBufferND(float* buffer, const float* data, size_t axis, const std::
     }
 }
 
-void applyBufferND(const float* buffer, float* output, size_t axis, const std::vector<size_t>& dimIndexes,
-                                  const std::vector<size_t>& shape, const std::vector<size_t>& strides) {
+void applyBufferND(const float* buffer,
+                   float* output,
+                   size_t axis,
+                   const std::vector<size_t>& dimIndexes,
+                   const std::vector<size_t>& shape,
+                   const std::vector<size_t>& strides) {
     size_t numberOfComplex = shape[axis];
     size_t offset = calculateOffsetFromStrides(dimIndexes, strides);
 
@@ -196,8 +204,12 @@ void applyBufferND(const float* buffer, float* output, size_t axis, const std::v
     }
 }
 
-void copyDataToOutputWithSignalSize(const float* input, const std::vector<size_t>& inputShape, const std::vector<size_t>& inputStrides,
-                                    float* output, const std::vector<size_t>& outputShape, const std::vector<size_t>& outputStrides) {
+void copyDataToOutputWithSignalSize(const float* input,
+                                    const std::vector<size_t>& inputShape,
+                                    const std::vector<size_t>& inputStrides,
+                                    float* output,
+                                    const std::vector<size_t>& outputShape,
+                                    const std::vector<size_t>& outputStrides) {
     auto totalInput = std::accumulate(inputShape.begin(), inputShape.end(), size_t(1), std::multiplies<size_t>());
     auto totalOutput = std::accumulate(outputShape.begin(), outputShape.end(), size_t(1), std::multiplies<size_t>());
     std::fill_n(output, totalOutput, 0.f);
@@ -221,7 +233,10 @@ void copyDataToOutputWithSignalSize(const float* input, const std::vector<size_t
 
     const std::vector<size_t> inputStridesRange(inputStrides.begin(), inputStrides.begin() + iterationRange.size());
     const std::vector<size_t> outputStridesRange(outputStrides.begin(), outputStrides.begin() + iterationRange.size());
-    const size_t blockSize = std::accumulate(inputShape.begin() + lastChangedDim + 1, inputShape.end(), size_t(1), std::multiplies<size_t>());
+    const size_t blockSize = std::accumulate(inputShape.begin() + lastChangedDim + 1,
+                                             inputShape.end(),
+                                             size_t(1),
+                                             std::multiplies<size_t>());
     const size_t blockSizeBytes = blockSize * sizeof(float);
     std::vector<size_t> iterationCounter(iterationRange.size(), 0);
     do {
@@ -231,7 +246,7 @@ void copyDataToOutputWithSignalSize(const float* input, const std::vector<size_t
     } while (copyStep(iterationCounter, iterationRange));
 }
 
-} // namespace
+}  // namespace
 
 void DFT::execute(dnnl::stream strm) {
     const auto& outputShape = getChildEdgeAt(0)->getMemory().getStaticDims();
@@ -269,7 +284,8 @@ void DFT::execute(dnnl::stream strm) {
     if (inputShape != outputShape) {
         copyDataToOutputWithSignalSize(src, inputShape, inputStrides, dst, outputShape, outputStrides);
     } else {
-        auto totalElements = std::accumulate(inputShape.begin(), inputShape.end(), size_t(1), std::multiplies<size_t>());
+        auto totalElements =
+            std::accumulate(inputShape.begin(), inputShape.end(), size_t(1), std::multiplies<size_t>());
         cpu_memcpy(dst, src, totalElements * sizeof(float));
     }
 
@@ -315,17 +331,32 @@ void DFT::dftNd(float* output,
                     std::vector<float> gatheredData(outputLen * 2);
                     auto parallelIterationCounter = iterationCounter;
                     parallelIterationCounter[parallelDimIndex] = dim;
-                    gatherToBufferND(gatheredData.data(), output, currentAxis, parallelIterationCounter, outputShape, outputStrides);
+                    gatherToBufferND(gatheredData.data(),
+                                     output,
+                                     currentAxis,
+                                     parallelIterationCounter,
+                                     outputShape,
+                                     outputStrides);
                     const float* resultBufPtr;
                     fft(gatheredData.data(), gatheredData.data() + outputLen, outputLen, inverse, false, &resultBufPtr);
-                    applyBufferND(resultBufPtr, output, currentAxis, parallelIterationCounter, outputShape, outputStrides);
+                    applyBufferND(resultBufPtr,
+                                  output,
+                                  currentAxis,
+                                  parallelIterationCounter,
+                                  outputShape,
+                                  outputStrides);
                 });
                 iterationCounter[parallelDimIndex] = iterationRange[parallelDimIndex] - 1;
             } while (nextIterationStep(iterationCounter, iterationRange, currentAxis));
         } else {
             std::vector<float> gatheredData(outputLen);
             do {
-                gatherToBufferND(gatheredData.data(), output, currentAxis, iterationCounter, outputShape, outputStrides);
+                gatherToBufferND(gatheredData.data(),
+                                 output,
+                                 currentAxis,
+                                 iterationCounter,
+                                 outputShape,
+                                 outputStrides);
                 naiveDFT(gatheredData.data(), outputLen, inverse);
                 applyBufferND(gatheredData.data(), output, currentAxis, iterationCounter, outputShape, outputStrides);
             } while (nextIterationStep(iterationCounter, iterationRange, currentAxis));
@@ -585,6 +616,6 @@ void DFT::createJITKernels(bool hasDFT, bool hasFFT) {
     }
 #endif
 }
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/dft.h b/src/plugins/intel_cpu/src/nodes/dft.h
index 82b6ea3b33a618..eef5e2ea529066 100644
--- a/src/plugins/intel_cpu/src/nodes/dft.h
+++ b/src/plugins/intel_cpu/src/nodes/dft.h
@@ -63,6 +63,6 @@ class DFT : public Node {
     bool lastInverse;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/eltwise.cpp b/src/plugins/intel_cpu/src/nodes/eltwise.cpp
index 54cf435009059d..5daefa01eddfab 100644
--- a/src/plugins/intel_cpu/src/nodes/eltwise.cpp
+++ b/src/plugins/intel_cpu/src/nodes/eltwise.cpp
@@ -3,6 +3,18 @@
 //
 
 #include "eltwise.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cpu/x64/cpu_isa_traits.hpp>
+#include <cpu/x64/injectors/jit_uni_quantization_injector.hpp>
+#include <functional>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
 #include "common/cpu_convert.h"
 #include "common/float16.hpp"
 #include "common/primitive_hashing_utils.hpp"
@@ -10,6 +22,10 @@
 #include "cpu/ref_eltwise.hpp"
 #include "cpu_types.h"
 #include "dnnl_extension_utils.h"
+#include "emitters/plugin/x64/jit_bf16_emitters.hpp"
+#include "emitters/plugin/x64/jit_dnnl_emitters.hpp"
+#include "emitters/plugin/x64/jit_eltwise_emitters.hpp"
+#include "emitters/plugin/x64/jit_emitter.hpp"
 #include "fake_quantize.h"
 #include "input.h"
 #include "memory_desc/dnnl_blocked_memory_desc.h"
@@ -17,13 +33,13 @@
 #include "onednn/dnnl.h"
 #include "openvino/core/except.hpp"
 #include "openvino/core/parallel.hpp"
-#include "openvino/opsets/opset1.hpp"
 #include "openvino/op/bitwise_and.hpp"
 #include "openvino/op/bitwise_left_shift.hpp"
 #include "openvino/op/bitwise_not.hpp"
 #include "openvino/op/bitwise_or.hpp"
 #include "openvino/op/bitwise_right_shift.hpp"
 #include "openvino/op/bitwise_xor.hpp"
+#include "openvino/opsets/opset1.hpp"
 #include "pooling.h"
 #include "selective_build.h"
 #include "shape_inference/custom/eltwise.hpp"
@@ -35,27 +51,10 @@
 #include "utils/general_utils.h"
 #include "utils/ngraph_utils.hpp"
 
-#include <algorithm>
-#include <cmath>
-#include <functional>
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <vector>
-
-#include <cpu/x64/cpu_isa_traits.hpp>
-#include <cpu/x64/injectors/jit_uni_quantization_injector.hpp>
-
-#include "emitters/plugin/x64/jit_emitter.hpp"
-#include "emitters/plugin/x64/jit_eltwise_emitters.hpp"
-#include "emitters/plugin/x64/jit_dnnl_emitters.hpp"
-#include "emitters/plugin/x64/jit_bf16_emitters.hpp"
-
 #if defined(OPENVINO_ARCH_ARM64)
-#include "cpu/aarch64/cpu_isa_traits.hpp"
-#include "kernels/aarch64/jit_uni_eltwise_generic.hpp"
-#include "executors/aarch64/jit_eltwise.hpp"
+#    include "cpu/aarch64/cpu_isa_traits.hpp"
+#    include "executors/aarch64/jit_eltwise.hpp"
+#    include "kernels/aarch64/jit_uni_eltwise_generic.hpp"
 #endif
 
 using namespace dnnl::impl::utils;
@@ -92,60 +91,72 @@ bool jitIsSupported(const Node* node,
         beta,
         gamma);
 }
-} // namespace
+}  // namespace
 #endif
 
 #if defined(OPENVINO_ARCH_X86_64)
 
-template<typename T>
+template <typename T>
 struct SupportedPrecisions {
-    void operator()(std::set<std::vector<element::Type>> &precisions) {
+    void operator()(std::set<std::vector<element::Type>>& precisions) {
         precisions = T::get_supported_precisions();
     }
 };
 
 struct EltwiseEmitterContext {
     std::shared_ptr<jit_emitter> emitter;
-    jit_generator *host;
+    jit_generator* host;
     cpu_isa_t host_isa;
     const EltwiseData& opData;
     ov::element::Type exec_prc;
 };
 
-template<typename T>
+template <typename T>
 struct EltwiseEmitter {
-    void operator()(EltwiseEmitterContext & ctx) {
+    void operator()(EltwiseEmitterContext& ctx) {
         ctx.emitter = std::make_shared<T>(ctx.host, ctx.host_isa, ctx.exec_prc);
     }
 };
 
-template<>
+template <>
 struct EltwiseEmitter<jit_dnnl_aux_emitter> {
-    void operator()(EltwiseEmitterContext & ctx) {
+    void operator()(EltwiseEmitterContext& ctx) {
         auto algKind = static_cast<dnnl_alg_kind_t>(ctx.opData.onednnAlgorithm);
-        ctx.emitter = std::make_shared<jit_dnnl_aux_emitter>(ctx.host, ctx.host_isa, algKind,
-                                                               ctx.opData.alpha, ctx.opData.beta, ctx.exec_prc);
+        ctx.emitter = std::make_shared<jit_dnnl_aux_emitter>(ctx.host,
+                                                             ctx.host_isa,
+                                                             algKind,
+                                                             ctx.opData.alpha,
+                                                             ctx.opData.beta,
+                                                             ctx.exec_prc);
     }
 };
 
-template<>
+template <>
 struct EltwiseEmitter<jit_power_static_emitter> {
-    void operator()(EltwiseEmitterContext & ctx) {
-        ctx.emitter = std::make_shared<jit_power_static_emitter>(ctx.host, ctx.host_isa, ctx.opData.alpha,
-                                                                 ctx.opData.beta, ctx.opData.gamma, ctx.exec_prc);
+    void operator()(EltwiseEmitterContext& ctx) {
+        ctx.emitter = std::make_shared<jit_power_static_emitter>(ctx.host,
+                                                                 ctx.host_isa,
+                                                                 ctx.opData.alpha,
+                                                                 ctx.opData.beta,
+                                                                 ctx.opData.gamma,
+                                                                 ctx.exec_prc);
     }
 };
 
-template<>
+template <>
 struct EltwiseEmitter<jit_is_inf_emitter> {
-    void operator()(EltwiseEmitterContext & ctx) {
-        ctx.emitter = std::make_shared<jit_is_inf_emitter>(ctx.host, ctx.host_isa, ctx.exec_prc, ctx.opData.alpha, ctx.opData.beta);
+    void operator()(EltwiseEmitterContext& ctx) {
+        ctx.emitter = std::make_shared<jit_is_inf_emitter>(ctx.host,
+                                                           ctx.host_isa,
+                                                           ctx.exec_prc,
+                                                           ctx.opData.alpha,
+                                                           ctx.opData.beta);
     }
 };
 
 static void set_intersection(const std::set<std::vector<element::Type>>& precisions1,
-                      const std::set<std::vector<element::Type>>& precisions2,
-                      std::set<std::vector<element::Type>>& intersection) {
+                             const std::set<std::vector<element::Type>>& precisions2,
+                             std::set<std::vector<element::Type>>& intersection) {
     std::map<element::Type, size_t> intersection_types;
 
     for (auto it1 = precisions1.begin(); it1 != precisions1.end(); ++it1) {
@@ -195,15 +206,8 @@ ov::element::Type eltwise_precision_helper::get_precision(const size_t inputs_nu
         supported_precision_intersection = prcs_intersect;
     }
 
-    static const element::Type exec_precisions_priority[] = {
-            element::u8,
-            element::i8,
-            element::u16,
-            element::i16,
-            element::bf16,
-            element::i32,
-            element::f32
-    };
+    static const element::Type exec_precisions_priority[] =
+        {element::u8, element::i8, element::u16, element::i16, element::bf16, element::i32, element::f32};
 
     for (const auto prc : exec_precisions_priority) {
         if (std::any_of(supported_precision_intersection.begin(),
@@ -234,59 +238,62 @@ ov::element::Type eltwise_precision_helper::get_precision(const size_t inputs_nu
 std::set<std::vector<element::Type>> eltwise_precision_helper::get_supported_precisions(const Algorithm& algo) {
     std::set<std::vector<element::Type>> precisions;
 
-    OV_SWITCH(intel_cpu, SupportedPrecisions, precisions, algo,
-        OV_CASE(Algorithm::EltwiseRelu, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseGeluErf, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseGeluTanh, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseElu, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseTanh, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseSigmoid, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseAbs, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseSqrt, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseSoftRelu, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseClamp, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseSwish, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseHswish, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseMish, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseHsigmoid, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseRoundHalfToEven, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseRoundHalfAwayFromZero, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseAdd, jit_add_emitter),
-        OV_CASE(Algorithm::EltwiseMulAdd, jit_mul_add_emitter),
-        OV_CASE(Algorithm::EltwiseSubtract, jit_subtract_emitter),
-        OV_CASE(Algorithm::EltwiseMultiply, jit_multiply_emitter),
-        OV_CASE(Algorithm::EltwiseDivide, jit_divide_emitter),
-        OV_CASE(Algorithm::EltwiseFloor, jit_floor_emitter),
-        OV_CASE(Algorithm::EltwiseCeiling, jit_ceiling_emitter),
-        OV_CASE(Algorithm::EltwiseFloorMod, jit_floor_mod_emitter),
-        OV_CASE(Algorithm::EltwiseMod, jit_mod_emitter),
-        OV_CASE(Algorithm::EltwiseMaximum, jit_maximum_emitter),
-        OV_CASE(Algorithm::EltwiseMinimum, jit_minimum_emitter),
-        OV_CASE(Algorithm::EltwiseExp, jit_exp_emitter),
-        OV_CASE(Algorithm::EltwiseSquaredDifference, jit_squared_difference_emitter),
-        OV_CASE(Algorithm::EltwisePowerDynamic, jit_power_dynamic_emitter),
-        OV_CASE(Algorithm::EltwiseEqual, jit_equal_emitter),
-        OV_CASE(Algorithm::EltwiseNotEqual, jit_not_equal_emitter),
-        OV_CASE(Algorithm::EltwiseGreater, jit_greater_emitter),
-        OV_CASE(Algorithm::EltwiseGreaterEqual, jit_greater_equal_emitter),
-        OV_CASE(Algorithm::EltwiseLess, jit_less_emitter),
-        OV_CASE(Algorithm::EltwiseLessEqual, jit_less_equal_emitter),
-        OV_CASE(Algorithm::EltwiseLogicalAnd, jit_logical_and_emitter),
-        OV_CASE(Algorithm::EltwiseLogicalOr, jit_logical_or_emitter),
-        OV_CASE(Algorithm::EltwiseLogicalXor, jit_logical_xor_emitter),
-        OV_CASE(Algorithm::EltwiseLogicalNot, jit_logical_not_emitter),
-        OV_CASE(Algorithm::EltwisePowerStatic, jit_power_static_emitter),
-        OV_CASE(Algorithm::EltwisePrelu, jit_prelu_emitter),
-        OV_CASE(Algorithm::EltwiseErf, jit_erf_emitter),
-        OV_CASE(Algorithm::EltwiseSoftSign, jit_soft_sign_emitter),
-        OV_CASE(Algorithm::EltwiseIsFinite, jit_is_finite_emitter),
-        OV_CASE(Algorithm::EltwiseIsInf, jit_is_inf_emitter),
-        OV_CASE(Algorithm::EltwiseIsNaN, jit_is_nan_emitter),
-        OV_CASE(Algorithm::EltwiseSelect, jit_select_emitter),
-        OV_CASE(Algorithm::EltwiseBitwiseAnd, jit_bitwise_and_emitter),
-        OV_CASE(Algorithm::EltwiseBitwiseNot, jit_bitwise_not_emitter),
-        OV_CASE(Algorithm::EltwiseBitwiseOr, jit_bitwise_or_emitter),
-        OV_CASE(Algorithm::EltwiseBitwiseXor, jit_bitwise_xor_emitter));
+    OV_SWITCH(intel_cpu,
+              SupportedPrecisions,
+              precisions,
+              algo,
+              OV_CASE(Algorithm::EltwiseRelu, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseGeluErf, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseGeluTanh, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseElu, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseTanh, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseSigmoid, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseAbs, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseSqrt, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseSoftRelu, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseClamp, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseSwish, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseHswish, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseMish, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseHsigmoid, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseRoundHalfToEven, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseRoundHalfAwayFromZero, jit_dnnl_aux_emitter),
+              OV_CASE(Algorithm::EltwiseAdd, jit_add_emitter),
+              OV_CASE(Algorithm::EltwiseMulAdd, jit_mul_add_emitter),
+              OV_CASE(Algorithm::EltwiseSubtract, jit_subtract_emitter),
+              OV_CASE(Algorithm::EltwiseMultiply, jit_multiply_emitter),
+              OV_CASE(Algorithm::EltwiseDivide, jit_divide_emitter),
+              OV_CASE(Algorithm::EltwiseFloor, jit_floor_emitter),
+              OV_CASE(Algorithm::EltwiseCeiling, jit_ceiling_emitter),
+              OV_CASE(Algorithm::EltwiseFloorMod, jit_floor_mod_emitter),
+              OV_CASE(Algorithm::EltwiseMod, jit_mod_emitter),
+              OV_CASE(Algorithm::EltwiseMaximum, jit_maximum_emitter),
+              OV_CASE(Algorithm::EltwiseMinimum, jit_minimum_emitter),
+              OV_CASE(Algorithm::EltwiseExp, jit_exp_emitter),
+              OV_CASE(Algorithm::EltwiseSquaredDifference, jit_squared_difference_emitter),
+              OV_CASE(Algorithm::EltwisePowerDynamic, jit_power_dynamic_emitter),
+              OV_CASE(Algorithm::EltwiseEqual, jit_equal_emitter),
+              OV_CASE(Algorithm::EltwiseNotEqual, jit_not_equal_emitter),
+              OV_CASE(Algorithm::EltwiseGreater, jit_greater_emitter),
+              OV_CASE(Algorithm::EltwiseGreaterEqual, jit_greater_equal_emitter),
+              OV_CASE(Algorithm::EltwiseLess, jit_less_emitter),
+              OV_CASE(Algorithm::EltwiseLessEqual, jit_less_equal_emitter),
+              OV_CASE(Algorithm::EltwiseLogicalAnd, jit_logical_and_emitter),
+              OV_CASE(Algorithm::EltwiseLogicalOr, jit_logical_or_emitter),
+              OV_CASE(Algorithm::EltwiseLogicalXor, jit_logical_xor_emitter),
+              OV_CASE(Algorithm::EltwiseLogicalNot, jit_logical_not_emitter),
+              OV_CASE(Algorithm::EltwisePowerStatic, jit_power_static_emitter),
+              OV_CASE(Algorithm::EltwisePrelu, jit_prelu_emitter),
+              OV_CASE(Algorithm::EltwiseErf, jit_erf_emitter),
+              OV_CASE(Algorithm::EltwiseSoftSign, jit_soft_sign_emitter),
+              OV_CASE(Algorithm::EltwiseIsFinite, jit_is_finite_emitter),
+              OV_CASE(Algorithm::EltwiseIsInf, jit_is_inf_emitter),
+              OV_CASE(Algorithm::EltwiseIsNaN, jit_is_nan_emitter),
+              OV_CASE(Algorithm::EltwiseSelect, jit_select_emitter),
+              OV_CASE(Algorithm::EltwiseBitwiseAnd, jit_bitwise_and_emitter),
+              OV_CASE(Algorithm::EltwiseBitwiseNot, jit_bitwise_not_emitter),
+              OV_CASE(Algorithm::EltwiseBitwiseOr, jit_bitwise_or_emitter),
+              OV_CASE(Algorithm::EltwiseBitwiseXor, jit_bitwise_xor_emitter));
 
     if (precisions.empty())
         OPENVINO_THROW("Unsupported operation type for Eltwise emitter");
@@ -302,7 +309,11 @@ struct jit_uni_eltwise_generic : public jit_uni_eltwise_kernel, public jit_gener
                                      const std::vector<EltwiseData>& eltwise_data,
                                      const std::vector<ov::intel_cpu::Type>& ops_list,
                                      const dnnl::post_ops& post_ops)
-    : jit_uni_eltwise_kernel(jep), jit_generator(jit_name()), eltwise_data_(eltwise_data), ops_list_(ops_list), post_ops_(post_ops) {}
+        : jit_uni_eltwise_kernel(jep),
+          jit_generator(jit_name()),
+          eltwise_data_(eltwise_data),
+          ops_list_(ops_list),
+          post_ops_(post_ops) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -322,14 +333,18 @@ struct jit_uni_eltwise_generic : public jit_uni_eltwise_kernel, public jit_gener
             if (!p->entry_[i].is_quantization()) {
                 OPENVINO_THROW("Eltwise jitter error. Unsupported post op detected");
             }
-            quantization_injectors.push_back(std::make_shared<jit_uni_quantization_injector_f32<isa>>(
-                    this, p->entry_[i], vmm_d_weights, vmm_d_bias, reg_d_weights, reg_d_bias));
+            quantization_injectors.push_back(std::make_shared<jit_uni_quantization_injector_f32<isa>>(this,
+                                                                                                      p->entry_[i],
+                                                                                                      vmm_d_weights,
+                                                                                                      vmm_d_bias,
+                                                                                                      reg_d_weights,
+                                                                                                      reg_d_bias));
         }
 
         if (mayiuse(avx512_core) || mayiuse(avx2_vnni_2))
             uni_vcvtneps2bf16.reset(new jit_uni_vcvtneps2bf16(this, isa));
 
-        const auto &jep = jep_;
+        const auto& jep = jep_;
 
         this->preamble();
 
@@ -435,7 +450,11 @@ struct jit_uni_eltwise_generic : public jit_uni_eltwise_kernel, public jit_gener
                 for (size_t j = 0; j < min_src_size / vec_step; j++) {
                     for (size_t i = 0; i < jep.inputs_number; i++) {
                         if (jep.src_size[i] != 1)
-                            load_vector(get_vmm_reg(i), ptr[get_src_reg(i) + j * vec_step * jep.src_prc[i].size()], jep.src_prc[i], exec_prc, false);
+                            load_vector(get_vmm_reg(i),
+                                        ptr[get_src_reg(i) + j * vec_step * jep.src_prc[i].size()],
+                                        jep.src_prc[i],
+                                        exec_prc,
+                                        false);
                     }
 
                     compute_eltwise_op();
@@ -449,7 +468,10 @@ struct jit_uni_eltwise_generic : public jit_uni_eltwise_kernel, public jit_gener
                 for (size_t j = tail_start; j < min_src_size; j++) {
                     for (size_t i = 0; i < jep.inputs_number; i++) {
                         if (jep.src_size[i] != 1)
-                            load_scalar(get_xmm_reg(i), ptr[get_src_reg(i) + j * jep.src_prc[i].size()], jep.src_prc[i], exec_prc);
+                            load_scalar(get_xmm_reg(i),
+                                        ptr[get_src_reg(i) + j * jep.src_prc[i].size()],
+                                        jep.src_prc[i],
+                                        exec_prc);
                     }
 
                     compute_eltwise_op();
@@ -571,7 +593,7 @@ struct jit_uni_eltwise_generic : public jit_uni_eltwise_kernel, public jit_gener
     }
 
     Reg64 reg_post_op_ptrs = rax;
-    Reg64 start_to_offsets = reg_post_op_ptrs; // rax
+    Reg64 start_to_offsets = reg_post_op_ptrs;  // rax
     Reg64 reg_dst = rbx;
     Reg64 reg_work_amount = rdx;
 
@@ -606,67 +628,64 @@ struct jit_uni_eltwise_generic : public jit_uni_eltwise_kernel, public jit_gener
     const dnnl::post_ops& post_ops_;
 
     std::shared_ptr<jit_emitter> create_eltwise_emitter(const EltwiseData& data, ov::element::Type exec_prec) {
-        EltwiseEmitterContext ctx = {
-            nullptr,
-            this,
-            isa,
-            data,
-            exec_prec
-        };
-
-        OV_SWITCH(intel_cpu, EltwiseEmitter, ctx, data.algo,
-        OV_CASE(Algorithm::EltwiseRelu, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseGeluErf, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseGeluTanh, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseElu, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseTanh, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseSigmoid, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseAbs, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseSqrt, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseSoftRelu, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseClamp, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseSwish, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseHswish, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseMish, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseHsigmoid, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseRoundHalfToEven, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseRoundHalfAwayFromZero, jit_dnnl_aux_emitter),
-        OV_CASE(Algorithm::EltwiseAdd, jit_add_emitter),
-        OV_CASE(Algorithm::EltwiseMulAdd, jit_mul_add_emitter),
-        OV_CASE(Algorithm::EltwiseSubtract, jit_subtract_emitter),
-        OV_CASE(Algorithm::EltwiseMultiply, jit_multiply_emitter),
-        OV_CASE(Algorithm::EltwiseDivide, jit_divide_emitter),
-        OV_CASE(Algorithm::EltwiseFloor, jit_floor_emitter),
-        OV_CASE(Algorithm::EltwiseCeiling, jit_ceiling_emitter),
-        OV_CASE(Algorithm::EltwiseFloorMod, jit_floor_mod_emitter),
-        OV_CASE(Algorithm::EltwiseMod, jit_mod_emitter),
-        OV_CASE(Algorithm::EltwiseMaximum, jit_maximum_emitter),
-        OV_CASE(Algorithm::EltwiseMinimum, jit_minimum_emitter),
-        OV_CASE(Algorithm::EltwiseExp, jit_exp_emitter),
-        OV_CASE(Algorithm::EltwiseSquaredDifference, jit_squared_difference_emitter),
-        OV_CASE(Algorithm::EltwisePowerDynamic, jit_power_dynamic_emitter),
-        OV_CASE(Algorithm::EltwiseEqual, jit_equal_emitter),
-        OV_CASE(Algorithm::EltwiseNotEqual, jit_not_equal_emitter),
-        OV_CASE(Algorithm::EltwiseGreater, jit_greater_emitter),
-        OV_CASE(Algorithm::EltwiseGreaterEqual, jit_greater_equal_emitter),
-        OV_CASE(Algorithm::EltwiseLess, jit_less_emitter),
-        OV_CASE(Algorithm::EltwiseLessEqual, jit_less_equal_emitter),
-        OV_CASE(Algorithm::EltwiseLogicalAnd, jit_logical_and_emitter),
-        OV_CASE(Algorithm::EltwiseLogicalOr, jit_logical_or_emitter),
-        OV_CASE(Algorithm::EltwiseLogicalXor, jit_logical_xor_emitter),
-        OV_CASE(Algorithm::EltwiseLogicalNot, jit_logical_not_emitter),
-        OV_CASE(Algorithm::EltwisePowerStatic, jit_power_static_emitter),
-        OV_CASE(Algorithm::EltwisePrelu, jit_prelu_emitter),
-        OV_CASE(Algorithm::EltwiseErf, jit_erf_emitter),
-        OV_CASE(Algorithm::EltwiseSoftSign, jit_soft_sign_emitter),
-        OV_CASE(Algorithm::EltwiseIsFinite, jit_is_finite_emitter),
-        OV_CASE(Algorithm::EltwiseIsInf, jit_is_inf_emitter),
-        OV_CASE(Algorithm::EltwiseIsNaN, jit_is_nan_emitter),
-        OV_CASE(Algorithm::EltwiseSelect, jit_select_emitter),
-        OV_CASE(Algorithm::EltwiseBitwiseAnd, jit_bitwise_and_emitter),
-        OV_CASE(Algorithm::EltwiseBitwiseNot, jit_bitwise_not_emitter),
-        OV_CASE(Algorithm::EltwiseBitwiseOr, jit_bitwise_or_emitter),
-        OV_CASE(Algorithm::EltwiseBitwiseXor, jit_bitwise_xor_emitter));
+        EltwiseEmitterContext ctx = {nullptr, this, isa, data, exec_prec};
+
+        OV_SWITCH(intel_cpu,
+                  EltwiseEmitter,
+                  ctx,
+                  data.algo,
+                  OV_CASE(Algorithm::EltwiseRelu, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseGeluErf, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseGeluTanh, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseElu, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseTanh, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseSigmoid, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseAbs, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseSqrt, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseSoftRelu, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseClamp, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseSwish, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseHswish, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseMish, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseHsigmoid, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseRoundHalfToEven, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseRoundHalfAwayFromZero, jit_dnnl_aux_emitter),
+                  OV_CASE(Algorithm::EltwiseAdd, jit_add_emitter),
+                  OV_CASE(Algorithm::EltwiseMulAdd, jit_mul_add_emitter),
+                  OV_CASE(Algorithm::EltwiseSubtract, jit_subtract_emitter),
+                  OV_CASE(Algorithm::EltwiseMultiply, jit_multiply_emitter),
+                  OV_CASE(Algorithm::EltwiseDivide, jit_divide_emitter),
+                  OV_CASE(Algorithm::EltwiseFloor, jit_floor_emitter),
+                  OV_CASE(Algorithm::EltwiseCeiling, jit_ceiling_emitter),
+                  OV_CASE(Algorithm::EltwiseFloorMod, jit_floor_mod_emitter),
+                  OV_CASE(Algorithm::EltwiseMod, jit_mod_emitter),
+                  OV_CASE(Algorithm::EltwiseMaximum, jit_maximum_emitter),
+                  OV_CASE(Algorithm::EltwiseMinimum, jit_minimum_emitter),
+                  OV_CASE(Algorithm::EltwiseExp, jit_exp_emitter),
+                  OV_CASE(Algorithm::EltwiseSquaredDifference, jit_squared_difference_emitter),
+                  OV_CASE(Algorithm::EltwisePowerDynamic, jit_power_dynamic_emitter),
+                  OV_CASE(Algorithm::EltwiseEqual, jit_equal_emitter),
+                  OV_CASE(Algorithm::EltwiseNotEqual, jit_not_equal_emitter),
+                  OV_CASE(Algorithm::EltwiseGreater, jit_greater_emitter),
+                  OV_CASE(Algorithm::EltwiseGreaterEqual, jit_greater_equal_emitter),
+                  OV_CASE(Algorithm::EltwiseLess, jit_less_emitter),
+                  OV_CASE(Algorithm::EltwiseLessEqual, jit_less_equal_emitter),
+                  OV_CASE(Algorithm::EltwiseLogicalAnd, jit_logical_and_emitter),
+                  OV_CASE(Algorithm::EltwiseLogicalOr, jit_logical_or_emitter),
+                  OV_CASE(Algorithm::EltwiseLogicalXor, jit_logical_xor_emitter),
+                  OV_CASE(Algorithm::EltwiseLogicalNot, jit_logical_not_emitter),
+                  OV_CASE(Algorithm::EltwisePowerStatic, jit_power_static_emitter),
+                  OV_CASE(Algorithm::EltwisePrelu, jit_prelu_emitter),
+                  OV_CASE(Algorithm::EltwiseErf, jit_erf_emitter),
+                  OV_CASE(Algorithm::EltwiseSoftSign, jit_soft_sign_emitter),
+                  OV_CASE(Algorithm::EltwiseIsFinite, jit_is_finite_emitter),
+                  OV_CASE(Algorithm::EltwiseIsInf, jit_is_inf_emitter),
+                  OV_CASE(Algorithm::EltwiseIsNaN, jit_is_nan_emitter),
+                  OV_CASE(Algorithm::EltwiseSelect, jit_select_emitter),
+                  OV_CASE(Algorithm::EltwiseBitwiseAnd, jit_bitwise_and_emitter),
+                  OV_CASE(Algorithm::EltwiseBitwiseNot, jit_bitwise_not_emitter),
+                  OV_CASE(Algorithm::EltwiseBitwiseOr, jit_bitwise_or_emitter),
+                  OV_CASE(Algorithm::EltwiseBitwiseXor, jit_bitwise_xor_emitter));
 
         if (!ctx.emitter)
             OPENVINO_THROW("Unsupported operation type for Eltwise emitter");
@@ -714,17 +733,31 @@ struct jit_uni_eltwise_generic : public jit_uni_eltwise_kernel, public jit_gener
                 bool do_rounding = do_dequantization || jep_.dst_prc == ov::element::f32 || i != ops_list_.size() - 1;
                 int s_idx = vmm_dst.getIdx();
 
-                size_t ptrs_table_off = quantization_post_op_idx * quantization_injectors[quantization_post_op_idx]->memoryStep();
-
-                quantization_injectors[quantization_post_op_idx]->init_crop_ptrs(reg_post_op_ptrs + ptrs_table_off, reg_oc_off);
-                quantization_injectors[quantization_post_op_idx]->compute_crop(s_idx, s_idx + 1, offset, is_scalar, jep_.oc_size == 1);
-
-                quantization_injectors[quantization_post_op_idx]->init_input_scale_shift_ptrs(reg_post_op_ptrs + ptrs_table_off, reg_oc_off);
-                quantization_injectors[quantization_post_op_idx]->compute_input_scale_shift(s_idx, s_idx + 1, offset, do_rounding,
-                                                                                            is_scalar, jep_.oc_size == 1);
-
-                quantization_injectors[quantization_post_op_idx]->init_output_scale_shift_ptrs(reg_post_op_ptrs + ptrs_table_off, reg_oc_off);
-                quantization_injectors[quantization_post_op_idx]->compute_output_scale_shift(s_idx, s_idx + 1, offset, is_scalar, jep_.oc_size == 1);
+                size_t ptrs_table_off =
+                    quantization_post_op_idx * quantization_injectors[quantization_post_op_idx]->memoryStep();
+
+                quantization_injectors[quantization_post_op_idx]->init_crop_ptrs(reg_post_op_ptrs + ptrs_table_off,
+                                                                                 reg_oc_off);
+                quantization_injectors[quantization_post_op_idx]->compute_crop(s_idx,
+                                                                               s_idx + 1,
+                                                                               offset,
+                                                                               is_scalar,
+                                                                               jep_.oc_size == 1);
+
+                quantization_injectors[quantization_post_op_idx]->init_input_scale_shift_ptrs(
+                    reg_post_op_ptrs + ptrs_table_off,
+                    reg_oc_off);
+                quantization_injectors[quantization_post_op_idx]
+                    ->compute_input_scale_shift(s_idx, s_idx + 1, offset, do_rounding, is_scalar, jep_.oc_size == 1);
+
+                quantization_injectors[quantization_post_op_idx]->init_output_scale_shift_ptrs(
+                    reg_post_op_ptrs + ptrs_table_off,
+                    reg_oc_off);
+                quantization_injectors[quantization_post_op_idx]->compute_output_scale_shift(s_idx,
+                                                                                             s_idx + 1,
+                                                                                             offset,
+                                                                                             is_scalar,
+                                                                                             jep_.oc_size == 1);
 
                 quantization_post_op_idx++;
             } else {
@@ -733,7 +766,11 @@ struct jit_uni_eltwise_generic : public jit_uni_eltwise_kernel, public jit_gener
         }
     }
 
-    inline void load_vector(Vmm vmm_src, const Xbyak::Address &op, ov::element::Type src_prc, ov::element::Type dst_prc, bool broadcast) {
+    inline void load_vector(Vmm vmm_src,
+                            const Xbyak::Address& op,
+                            ov::element::Type src_prc,
+                            ov::element::Type dst_prc,
+                            bool broadcast) {
         Xmm xmm_src = Xmm(vmm_src.getIdx());
 
         if (src_prc == dst_prc) {
@@ -751,120 +788,126 @@ struct jit_uni_eltwise_generic : public jit_uni_eltwise_kernel, public jit_gener
             uni_vbroadcastss(vmm_src, xmm_src);
         } else {
             switch (src_prc) {
-                case ov::element::f32:
-                case ov::element::i32:
-                    uni_vmovups(vmm_src, op);
-                    break;
-                case ov::element::bf16:
-                    vpmovzxwd(vmm_src, op);
-                    uni_vpslld(vmm_src, vmm_src, 16);
-                    break;
-                case ov::element::f16:
-                    vcvtph2ps(vmm_src, op);
-                    break;
-                case ov::element::u16:
-                    uni_vpmovzxwd(vmm_src, op);
-                    break;
-                case ov::element::i16:
-                    uni_vpmovsxwd(vmm_src, op);
-                    break;
-                case ov::element::i8:
-                    uni_vpmovsxbd(vmm_src, op);
-                    break;
-                case ov::element::u8:
-                    uni_vpmovzxbd(vmm_src, op);
-                    break;
-                default:
-                    OPENVINO_THROW("unknown src_prc");
-            }
-
-            switch (dst_prc) {
-                case ov::element::f32:
-                    if (!src_prc.is_real())
-                        uni_vcvtdq2ps(vmm_src, vmm_src);
-                    break;
-                case ov::element::i32:
-                    if (src_prc.is_real())
-                        uni_vcvtps2dq(vmm_src, vmm_src);
-                    break;
-                default:
-                    OPENVINO_THROW("unknown dst_prc");
-            }
-        }
-    }
-
-    inline void load_scalar(Xmm xmm_src, const Xbyak::Address &op, ov::element::Type src_prc, ov::element::Type dst_prc) {
-        if (src_prc == dst_prc) {
-            switch (src_prc.size()) {
-                case 4:
-                    uni_vmovss(xmm_src, op);
-                    break;
-                case 1:
-                    mov(reg_tmp_8, op);
-                    movzx(reg_tmp_32, reg_tmp_8);
-                    uni_vmovd(xmm_src, reg_tmp_32);
-                    break;
-                default:
-                    OPENVINO_THROW("unknown prc");
-            }
-            return;
-        }
-
-        switch (src_prc) {
             case ov::element::f32:
             case ov::element::i32:
-                uni_vmovss(xmm_src, op);
+                uni_vmovups(vmm_src, op);
                 break;
             case ov::element::bf16:
-                if (isa == x64::avx2_vnni_2) {
-                    vbcstnebf162ps(xmm_src, op);
-                } else {
-                    uni_vpinsrw(xmm_src, xmm_src, op, 0);
-                    uni_vpslld(xmm_src, xmm_src, 16);
-                }
+                vpmovzxwd(vmm_src, op);
+                uni_vpslld(vmm_src, vmm_src, 16);
                 break;
             case ov::element::f16:
-                if (isa == x64::avx2_vnni_2) {
-                    vbcstnesh2ps(xmm_src, op);
-                } else {
-                    vcvtph2ps(xmm_src, op);
-                }
-                break;
-            case ov::element::i16:
-                uni_vpinsrw(xmm_src, xmm_src, op, 0);
-                uni_vpmovsxwd(xmm_src, op);
+                vcvtph2ps(vmm_src, op);
                 break;
             case ov::element::u16:
-                uni_vpinsrw(xmm_src, xmm_src, op, 0);
-                uni_vpmovzxwd(xmm_src, op);
+                uni_vpmovzxwd(vmm_src, op);
+                break;
+            case ov::element::i16:
+                uni_vpmovsxwd(vmm_src, op);
                 break;
             case ov::element::i8:
-                movsx(reg_tmp_32, op);
-                uni_vmovq(xmm_src, reg_tmp_64);
+                uni_vpmovsxbd(vmm_src, op);
                 break;
             case ov::element::u8:
-                movzx(reg_tmp_32, op);
-                uni_vmovq(xmm_src, reg_tmp_64);
+                uni_vpmovzxbd(vmm_src, op);
                 break;
             default:
                 OPENVINO_THROW("unknown src_prc");
-        }
+            }
 
-        switch (dst_prc) {
+            switch (dst_prc) {
             case ov::element::f32:
                 if (!src_prc.is_real())
-                    uni_vcvtdq2ps(xmm_src, xmm_src);
+                    uni_vcvtdq2ps(vmm_src, vmm_src);
                 break;
             case ov::element::i32:
                 if (src_prc.is_real())
-                    uni_vcvtps2dq(xmm_src, xmm_src);
+                    uni_vcvtps2dq(vmm_src, vmm_src);
                 break;
             default:
                 OPENVINO_THROW("unknown dst_prc");
+            }
+        }
+    }
+
+    inline void load_scalar(Xmm xmm_src,
+                            const Xbyak::Address& op,
+                            ov::element::Type src_prc,
+                            ov::element::Type dst_prc) {
+        if (src_prc == dst_prc) {
+            switch (src_prc.size()) {
+            case 4:
+                uni_vmovss(xmm_src, op);
+                break;
+            case 1:
+                mov(reg_tmp_8, op);
+                movzx(reg_tmp_32, reg_tmp_8);
+                uni_vmovd(xmm_src, reg_tmp_32);
+                break;
+            default:
+                OPENVINO_THROW("unknown prc");
+            }
+            return;
+        }
+
+        switch (src_prc) {
+        case ov::element::f32:
+        case ov::element::i32:
+            uni_vmovss(xmm_src, op);
+            break;
+        case ov::element::bf16:
+            if (isa == x64::avx2_vnni_2) {
+                vbcstnebf162ps(xmm_src, op);
+            } else {
+                uni_vpinsrw(xmm_src, xmm_src, op, 0);
+                uni_vpslld(xmm_src, xmm_src, 16);
+            }
+            break;
+        case ov::element::f16:
+            if (isa == x64::avx2_vnni_2) {
+                vbcstnesh2ps(xmm_src, op);
+            } else {
+                vcvtph2ps(xmm_src, op);
+            }
+            break;
+        case ov::element::i16:
+            uni_vpinsrw(xmm_src, xmm_src, op, 0);
+            uni_vpmovsxwd(xmm_src, op);
+            break;
+        case ov::element::u16:
+            uni_vpinsrw(xmm_src, xmm_src, op, 0);
+            uni_vpmovzxwd(xmm_src, op);
+            break;
+        case ov::element::i8:
+            movsx(reg_tmp_32, op);
+            uni_vmovq(xmm_src, reg_tmp_64);
+            break;
+        case ov::element::u8:
+            movzx(reg_tmp_32, op);
+            uni_vmovq(xmm_src, reg_tmp_64);
+            break;
+        default:
+            OPENVINO_THROW("unknown src_prc");
+        }
+
+        switch (dst_prc) {
+        case ov::element::f32:
+            if (!src_prc.is_real())
+                uni_vcvtdq2ps(xmm_src, xmm_src);
+            break;
+        case ov::element::i32:
+            if (src_prc.is_real())
+                uni_vcvtps2dq(xmm_src, xmm_src);
+            break;
+        default:
+            OPENVINO_THROW("unknown dst_prc");
         }
     }
 
-    inline void store_vector(const Xbyak::Address &op, Vmm vmm_dst, ov::element::Type src_prc, ov::element::Type dst_prc) {
+    inline void store_vector(const Xbyak::Address& op,
+                             Vmm vmm_dst,
+                             ov::element::Type src_prc,
+                             ov::element::Type dst_prc) {
         Xmm xmm_dst = Xmm(vmm_dst.getIdx());
         Ymm ymm_dst = Ymm(vmm_dst.getIdx());
 
@@ -874,170 +917,173 @@ struct jit_uni_eltwise_generic : public jit_uni_eltwise_kernel, public jit_gener
         }
 
         switch (src_prc) {
-            case ov::element::f32:
-                if (!dst_prc.is_real())
-                    uni_vcvtps2dq(vmm_dst, vmm_dst);
-                break;
-            case ov::element::i32:
-                if (dst_prc.is_real())
-                    uni_vcvtdq2ps(vmm_dst, vmm_dst);
-                break;
-            default:
-                OPENVINO_THROW("unknown src_prc");
+        case ov::element::f32:
+            if (!dst_prc.is_real())
+                uni_vcvtps2dq(vmm_dst, vmm_dst);
+            break;
+        case ov::element::i32:
+            if (dst_prc.is_real())
+                uni_vcvtdq2ps(vmm_dst, vmm_dst);
+            break;
+        default:
+            OPENVINO_THROW("unknown src_prc");
         }
 
         switch (dst_prc) {
-            case ov::element::f32:
-            case ov::element::i32:
-                uni_vmovups(op, vmm_dst);
-                break;
-            case ov::element::bf16:
-                if (isa == x64::avx512_core) {
-                    uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
-                                                 {static_cast<size_t>(ymm_dst.getIdx())});
-                    vmovdqu16(op, ymm_dst);
-                } else {
-                    uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
-                                                 {static_cast<size_t>(xmm_dst.getIdx())});
+        case ov::element::f32:
+        case ov::element::i32:
+            uni_vmovups(op, vmm_dst);
+            break;
+        case ov::element::bf16:
+            if (isa == x64::avx512_core) {
+                uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
+                                             {static_cast<size_t>(ymm_dst.getIdx())});
+                vmovdqu16(op, ymm_dst);
+            } else {
+                uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
+                                             {static_cast<size_t>(xmm_dst.getIdx())});
+                uni_vmovdqu(op, xmm_dst);
+            }
+            break;
+        case ov::element::f16:
+            vcvtps2ph(op, vmm_dst, 0x4);
+            break;
+        case ov::element::i16:
+            if (isa == x64::avx512_core) {
+                vpmovsdw(op, vmm_dst);
+            } else {
+                uni_vpackssdw(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != x64::sse41) {
+                    vpermq(ymm_dst, ymm_dst, 0x08);
                     uni_vmovdqu(op, xmm_dst);
-                }
-                break;
-            case ov::element::f16:
-                vcvtps2ph(op, vmm_dst, 0x4);
-                break;
-            case ov::element::i16:
-                if (isa == x64::avx512_core) {
-                    vpmovsdw(op, vmm_dst);
                 } else {
-                    uni_vpackssdw(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != x64::sse41) {
-                        vpermq(ymm_dst, ymm_dst, 0x08);
-                        uni_vmovdqu(op, xmm_dst);
-                    } else {
-                        movq(op, xmm_dst);
-                    }
+                    movq(op, xmm_dst);
                 }
-                break;
-            case ov::element::u16:
-                if (isa == x64::avx512_core) {
-                    vpmaxsd(vmm_dst, vmm_zero, vmm_dst);
-                    vpmovusdw(op, vmm_dst);
-                } else {
-                    uni_vpackusdw(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != x64::sse41) {
-                        vpermq(ymm_dst, ymm_dst, 0x08);
-                        uni_vmovdqu(op, xmm_dst);
-                    } else {
-                        movq(op, xmm_dst);
-                    }
-                }
-                break;
-            case ov::element::i8:
-                if (isa == x64::avx512_core) {
-                    vpmovsdb(op, vmm_dst);
-                } else {
-                    uni_vpackssdw(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != x64::sse41)
-                        vpermq(ymm_dst, ymm_dst, 0x08);
-                    uni_vpacksswb(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != x64::sse41)
-                        vmovq(op, xmm_dst);
-                    else
-                        movd(op, xmm_dst);
-                }
-                break;
-            case ov::element::u8:
-                if (isa == x64::avx512_core) {
-                    vpmaxsd(vmm_dst, vmm_zero, vmm_dst);
-                    vpmovusdb(op, vmm_dst);
+            }
+            break;
+        case ov::element::u16:
+            if (isa == x64::avx512_core) {
+                vpmaxsd(vmm_dst, vmm_zero, vmm_dst);
+                vpmovusdw(op, vmm_dst);
+            } else {
+                uni_vpackusdw(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != x64::sse41) {
+                    vpermq(ymm_dst, ymm_dst, 0x08);
+                    uni_vmovdqu(op, xmm_dst);
                 } else {
-                    uni_vpackusdw(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != x64::sse41)
-                        vpermq(ymm_dst, ymm_dst, 0x08);
-                    uni_vpackuswb(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != x64::sse41)
-                        vmovq(op, xmm_dst);
-                    else
-                        movd(op, xmm_dst);
+                    movq(op, xmm_dst);
                 }
-                break;
-            default:
-                OPENVINO_THROW("unknown dst_prc");
+            }
+            break;
+        case ov::element::i8:
+            if (isa == x64::avx512_core) {
+                vpmovsdb(op, vmm_dst);
+            } else {
+                uni_vpackssdw(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != x64::sse41)
+                    vpermq(ymm_dst, ymm_dst, 0x08);
+                uni_vpacksswb(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != x64::sse41)
+                    vmovq(op, xmm_dst);
+                else
+                    movd(op, xmm_dst);
+            }
+            break;
+        case ov::element::u8:
+            if (isa == x64::avx512_core) {
+                vpmaxsd(vmm_dst, vmm_zero, vmm_dst);
+                vpmovusdb(op, vmm_dst);
+            } else {
+                uni_vpackusdw(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != x64::sse41)
+                    vpermq(ymm_dst, ymm_dst, 0x08);
+                uni_vpackuswb(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != x64::sse41)
+                    vmovq(op, xmm_dst);
+                else
+                    movd(op, xmm_dst);
+            }
+            break;
+        default:
+            OPENVINO_THROW("unknown dst_prc");
         }
     }
 
-    inline void store_scalar(const Xbyak::Address &op, Xmm xmm_dst, ov::element::Type src_prc, ov::element::Type dst_prc) {
+    inline void store_scalar(const Xbyak::Address& op,
+                             Xmm xmm_dst,
+                             ov::element::Type src_prc,
+                             ov::element::Type dst_prc) {
         if (src_prc == dst_prc) {
             switch (src_prc.size()) {
-                case 4:
-                    uni_vmovss(op, xmm_dst);
-                    break;
-                case 1:
-                    movq(reg_tmp_64, xmm_dst);
-                    mov(op, reg_tmp_8);
-                    break;
-                default:
-                    OPENVINO_THROW("unknown prc");
+            case 4:
+                uni_vmovss(op, xmm_dst);
+                break;
+            case 1:
+                movq(reg_tmp_64, xmm_dst);
+                mov(op, reg_tmp_8);
+                break;
+            default:
+                OPENVINO_THROW("unknown prc");
             }
             return;
         }
 
         switch (src_prc) {
-            case ov::element::f32:
-                if (!dst_prc.is_real())
-                    uni_vcvtps2dq(xmm_dst, xmm_dst);
-                break;
-            case ov::element::i32:
-                if (dst_prc.is_real())
-                    uni_vcvtdq2ps(xmm_dst, xmm_dst);
-                break;
-            default:
-                OPENVINO_THROW("unknown src_prc");
+        case ov::element::f32:
+            if (!dst_prc.is_real())
+                uni_vcvtps2dq(xmm_dst, xmm_dst);
+            break;
+        case ov::element::i32:
+            if (dst_prc.is_real())
+                uni_vcvtdq2ps(xmm_dst, xmm_dst);
+            break;
+        default:
+            OPENVINO_THROW("unknown src_prc");
         }
 
         switch (dst_prc) {
-            case ov::element::f32:
-            case ov::element::i32:
-                uni_vmovss(op, xmm_dst);
-                break;
-            case ov::element::bf16:
-                uni_vpsrld(xmm_dst, xmm_dst, 16);
-                uni_vpextrw(op, xmm_dst, 0x0);
-                break;
-            case ov::element::f16:
-                vcvtps2ph(xmm_dst, xmm_dst, 0x4);
-                movq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_16);
-                break;
-            case ov::element::i16:
-                uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
-                movq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_16);
-                break;
-            case ov::element::u16:
-                uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
-                movq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_16);
-                break;
-            case ov::element::i8:
-                uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
-                movq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_8);
-                break;
-            case ov::element::u8:
-                uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
-                movq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_8);
-                break;
-            default:
-                OPENVINO_THROW("unknown dst_prc");
+        case ov::element::f32:
+        case ov::element::i32:
+            uni_vmovss(op, xmm_dst);
+            break;
+        case ov::element::bf16:
+            uni_vpsrld(xmm_dst, xmm_dst, 16);
+            uni_vpextrw(op, xmm_dst, 0x0);
+            break;
+        case ov::element::f16:
+            vcvtps2ph(xmm_dst, xmm_dst, 0x4);
+            movq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_16);
+            break;
+        case ov::element::i16:
+            uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
+            movq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_16);
+            break;
+        case ov::element::u16:
+            uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
+            movq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_16);
+            break;
+        case ov::element::i8:
+            uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
+            movq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_8);
+            break;
+        case ov::element::u8:
+            uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
+            movq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_8);
+            break;
+        default:
+            OPENVINO_THROW("unknown dst_prc");
         }
     }
 };
 
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
 Eltwise::BroadcastingPolicy Eltwise::determineBroadcastingPolicy(const std::shared_ptr<ov::Node>& op) {
     const auto const1 = ov::as_type_ptr<ov::opset1::Constant>(op->get_input_node_shared_ptr(0));
@@ -1297,7 +1343,6 @@ const std::map<const ov::DiscreteTypeInfo, Eltwise::Initializer>& Eltwise::getIn
     return initializers;
 }
 
-
 namespace {
 
 struct EltwiseKey {
@@ -1353,12 +1398,8 @@ struct EltwiseKey {
             return false;
         }
 
-        bool result = eltwise_data == rhs.eltwise_data &&
-                      ops_list == rhs.ops_list &&
-                      inpPrc == rhs.inpPrc &&
-                      outPrc == rhs.outPrc &&
-                      *postOps.get() == *rhs.postOps.get() &&
-                      implType == rhs.implType;
+        bool result = eltwise_data == rhs.eltwise_data && ops_list == rhs.ops_list && inpPrc == rhs.inpPrc &&
+                      outPrc == rhs.outPrc && *postOps.get() == *rhs.postOps.get() && implType == rhs.implType;
 
         if (result) {
             if (implType == EltwiseImplType::optimizedShapeAgnostic) {
@@ -1370,8 +1411,7 @@ struct EltwiseKey {
                         return false;
                 }
             } else {
-                result = result && outOrder == rhs.outOrder &&
-                         outBlkDims == rhs.outBlkDims;
+                result = result && outOrder == rhs.outOrder && outBlkDims == rhs.outBlkDims;
                 for (size_t i = 0; i < inpDims.size() && result; ++i) {
                     result = result && (inpDims[i] == rhs.inpDims[i]);
                 }
@@ -1426,7 +1466,8 @@ class EltwiseJitExecutor : public Eltwise::IEltwiseExecutor {
         auto collapseLastOffsets = [](std::vector<size_t>& dims, int dimsToCollapse) {
             for (size_t i = dims.size() - 2; i > dims.size() - dimsToCollapse - 2; i--) {
                 if (dims[dims.size() - 1] > 0 || dims[i] > 0)
-                    dims[dims.size() - 1] = std::max(dims[dims.size() - 1], static_cast<size_t>(1)) * std::max(dims[i], static_cast<size_t>(1));
+                    dims[dims.size() - 1] = std::max(dims[dims.size() - 1], static_cast<size_t>(1)) *
+                                            std::max(dims[i], static_cast<size_t>(1));
                 else
                     dims[dims.size() - 1] *= dims[i];
             }
@@ -1442,8 +1483,10 @@ class EltwiseJitExecutor : public Eltwise::IEltwiseExecutor {
 
         auto isFusedWith = [&](Type type_) {
             auto start_itr = ops_list.begin();
-            std::advance(start_itr, 1); // apply offset since the first op in the list is the op itself
-            return any_of(start_itr, ops_list.end(), [=](Type type) { return type == type_; });
+            std::advance(start_itr, 1);  // apply offset since the first op in the list is the op itself
+            return any_of(start_itr, ops_list.end(), [=](Type type) {
+                return type == type_;
+            });
         };
 
         if (inpDims.empty()) {
@@ -1493,7 +1536,8 @@ class EltwiseJitExecutor : public Eltwise::IEltwiseExecutor {
                     int oc_dim_idx = i + (jep.input_size - outOrder.size());
                     jep.oc_offsets[oc_dim_idx] = offset_oc;
                     offset_oc *= jep.dims[oc_dim_idx];
-                    if (oc_dim_idx + 1 != static_cast<int>(jep.input_size)) { // since in nspc case we can safely collapse the last axis
+                    if (oc_dim_idx + 1 !=
+                        static_cast<int>(jep.input_size)) {  // since in nspc case we can safely collapse the last axis
                         lastUnchangedAxis = oc_dim_idx;
                     }
                 }
@@ -1514,7 +1558,8 @@ class EltwiseJitExecutor : public Eltwise::IEltwiseExecutor {
         int collapsedDims = 0;
 
         bool hasDifferentDims = false;
-        while (!useRuntimePtrs && currentJitWorkAmount < minimalJitWorkAmount && currentJitWorkAmount < fullWorkAmount) {
+        while (!useRuntimePtrs && currentJitWorkAmount < minimalJitWorkAmount &&
+               currentJitWorkAmount < fullWorkAmount) {
             if (collapsedDims >= maxCollapsedDims)
                 break;
 
@@ -1595,8 +1640,9 @@ class EltwiseJitExecutor : public Eltwise::IEltwiseExecutor {
         jep.work_amount = jep.dst_size = jep.dims.back();
         jep.oc_size = oc_size;
 
-        std::transform(jep.oc_offsets.begin(), jep.oc_offsets.end(), jep.oc_offsets.begin(),
-                       [](size_t& offset) { return offset * sizeof(float);});
+        std::transform(jep.oc_offsets.begin(), jep.oc_offsets.end(), jep.oc_offsets.begin(), [](size_t& offset) {
+            return offset * sizeof(float);
+        });
 
 #if defined(OPENVINO_ARCH_X86_64)
         if (mayiuse(x64::avx512_core)) {
@@ -1608,7 +1654,7 @@ class EltwiseJitExecutor : public Eltwise::IEltwiseExecutor {
         } else {
             OPENVINO_THROW("Can't create jit eltwise kernel");
         }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
 #if defined(OPENVINO_ARCH_ARM64)
         if (mayiuse(aarch64::asimd)) {
@@ -1616,28 +1662,28 @@ class EltwiseJitExecutor : public Eltwise::IEltwiseExecutor {
         } else {
             OPENVINO_THROW("Can't create jit eltwise kernel");
         }
-#endif // OPENVINO_ARCH_ARM64
+#endif  // OPENVINO_ARCH_ARM64
 
         if (_pKernel)
             _pKernel->create_ker();
     }
 
-    void exec(const jit_eltwise_call_args_ptrs &args_ptrs, const VectorDims &dims_out) override {
+    void exec(const jit_eltwise_call_args_ptrs& args_ptrs, const VectorDims& dims_out) override {
         if (!_pKernel)
             OPENVINO_THROW("Can't execute, kernel for eltwise node is not compiled");
 
         if (_pKernel->jep_.input_size == optimalTensorRank) {
             // execute Optimized 6D
             auto d6_loop = [&](size_t i0, size_t i1, size_t i2, size_t i3, size_t i4) {
-                               auto args = jit_eltwise_call_args_indexes();
-                               args.indexes[0] = i0;
-                               args.indexes[1] = i1;
-                               args.indexes[2] = i2;
-                               args.indexes[3] = i3;
-                               args.indexes[4] = i4;
+                auto args = jit_eltwise_call_args_indexes();
+                args.indexes[0] = i0;
+                args.indexes[1] = i1;
+                args.indexes[2] = i2;
+                args.indexes[3] = i3;
+                args.indexes[4] = i4;
 
-                               (*_pKernel)(&args_ptrs, &args);
-                           };
+                (*_pKernel)(&args_ptrs, &args);
+            };
 
             parallel_nt_static(m_threads_num, [&](const int ithr, const int nthr) {
                 for_5d(ithr, nthr, dims_out[0], dims_out[1], dims_out[2], dims_out[3], dims_out[4], d6_loop);
@@ -1693,13 +1739,14 @@ class EltwiseJitExecutor : public Eltwise::IEltwiseExecutor {
 
 /* enabled only for float at float16_t at the moment
  * can be extended in the future */
-template<typename T>
+template <typename T>
 class EltwiseRefBaseExecutor : public Eltwise::IEltwiseExecutor {
 public:
     EltwiseRefBaseExecutor(const EltwiseData& opData,
                            const VectorDims& outBlkDims,
                            const std::vector<VectorDims>& inpDims)
-    : _opData(std::move(opData)), _inpDims(inpDims) {
+        : _opData(std::move(opData)),
+          _inpDims(inpDims) {
         if (inpDims.empty()) {
             OPENVINO_THROW("Can not make Eltwise executor from empty input dims array");
         } else if (inpDims.front().empty()) {
@@ -1750,18 +1797,18 @@ class EltwiseRefBaseExecutor : public Eltwise::IEltwiseExecutor {
 
 protected:
     void init_ptr(const jit_eltwise_call_args_ptrs& args_ptrs,
-        const VectorDims& dims_out,
-        std::vector<size_t>& counters,
-        const size_t iwork,
-        std::vector<T>& src_f,
-        T*& dst_ptr_f) {
+                  const VectorDims& dims_out,
+                  std::vector<size_t>& counters,
+                  const size_t iwork,
+                  std::vector<T>& src_f,
+                  T*& dst_ptr_f) {
         size_t tmp = iwork;
         for (ptrdiff_t j = dims_out.size() - 1; j >= 0; j--) {
             counters[j] = tmp % dims_out[j];
             tmp /= dims_out[j];
         }
 
-        size_t index_in[MAX_ELTWISE_INPUTS] = { 0 };
+        size_t index_in[MAX_ELTWISE_INPUTS] = {0};
         for (size_t i = 0; i < _inputNum; i++) {
             index_in[i] = 0;
             for (size_t j = 0; j < counters.size(); j++) {
@@ -1776,7 +1823,7 @@ class EltwiseRefBaseExecutor : public Eltwise::IEltwiseExecutor {
         }
         index_out /= sizeof(T);
 
-        //std::vector<T> src_f(_inputNum);
+        // std::vector<T> src_f(_inputNum);
         for (size_t i = 0; i < _inputNum; i++) {
             src_f[i] = (reinterpret_cast<const T*>(args_ptrs.src_ptr[i]) + index_in[i])[0];
         }
@@ -1795,19 +1842,15 @@ class EltwiseRefBaseExecutor : public Eltwise::IEltwiseExecutor {
 
 /* enabled only for float at float16_t at the moment
  * can be extended in the future */
-template<typename T,
-    typename std::enable_if<
-    std::is_same<T, float>::value ||
-    std::is_same<T, dnnl::impl::float16_t>::value>
-    ::type * = nullptr>
+template <typename T,
+          typename std::enable_if<std::is_same<T, float>::value ||
+                                  std::is_same<T, dnnl::impl::float16_t>::value>::type* = nullptr>
 class EltwiseRefExecutor : public EltwiseRefBaseExecutor<T> {
 public:
-    EltwiseRefExecutor(const EltwiseData& opData,
-                       const VectorDims& outBlkDims,
-                       std::vector<VectorDims> inpDims) : EltwiseRefBaseExecutor<T>(opData, outBlkDims, inpDims) {
-    }
+    EltwiseRefExecutor(const EltwiseData& opData, const VectorDims& outBlkDims, std::vector<VectorDims> inpDims)
+        : EltwiseRefBaseExecutor<T>(opData, outBlkDims, inpDims) {}
 
-    void exec(const jit_eltwise_call_args_ptrs &args_ptrs, const VectorDims &dims_out) override {
+    void exec(const jit_eltwise_call_args_ptrs& args_ptrs, const VectorDims& dims_out) override {
         if (this->_opData.algo == Algorithm::EltwiseLog) {
             const T* src_ptr_f = reinterpret_cast<const T*>(args_ptrs.src_ptr[0]);
             T* dst_ptr_f = reinterpret_cast<T*>(args_ptrs.dst_ptr);
@@ -1857,8 +1900,11 @@ class EltwiseRefExecutor : public EltwiseRefBaseExecutor<T> {
 
         std::shared_ptr<ref_eltwise_scalar_fwd_t> ref_eltwise_injector = nullptr;
         if (this->_opData.onednnAlgorithm != dnnl::algorithm::undef) {
-            ref_eltwise_injector = std::make_shared<ref_eltwise_scalar_fwd_t>(
-                    static_cast<dnnl_alg_kind_t>(this->_opData.onednnAlgorithm), this->_opData.alpha, this->_opData.beta, 1.f);
+            ref_eltwise_injector =
+                std::make_shared<ref_eltwise_scalar_fwd_t>(static_cast<dnnl_alg_kind_t>(this->_opData.onednnAlgorithm),
+                                                           this->_opData.alpha,
+                                                           this->_opData.beta,
+                                                           1.f);
         }
 
         parallel_nt(0, [&](const int ithr, const int nthr) {
@@ -1873,86 +1919,144 @@ class EltwiseRefExecutor : public EltwiseRefBaseExecutor<T> {
                 this->init_ptr(args_ptrs, dims_out, counters, iwork, src_f, dst_ptr_f);
 
                 switch (this->_opData.algo) {
-                    case Algorithm::EltwiseRelu:
-                    case Algorithm::EltwiseGeluErf:
-                    case Algorithm::EltwiseGeluTanh:
-                    case Algorithm::EltwiseElu:
-                    case Algorithm::EltwiseTanh:
-                    case Algorithm::EltwiseSigmoid:
-                    case Algorithm::EltwiseAbs:
-                    case Algorithm::EltwiseSqrt:
-                    case Algorithm::EltwiseSoftRelu:
-                    case Algorithm::EltwiseClamp:
-                    case Algorithm::EltwiseSwish:
-                    case Algorithm::EltwiseHswish:
-                    case Algorithm::EltwiseMish:
-                    case Algorithm::EltwiseHsigmoid:
-                    case Algorithm::EltwiseRoundHalfToEven:
-                    case Algorithm::EltwiseRoundHalfAwayFromZero:
-                        *dst_ptr_f = ref_eltwise_injector->compute_scalar(src_f[0]);
-                        break;
-                    case Algorithm::EltwiseAdd:               *dst_ptr_f = src_f[0] + src_f[1]; break;
-                    case Algorithm::EltwiseMulAdd:            *dst_ptr_f = src_f[0] * src_f[1] + src_f[2]; break;
-                    case Algorithm::EltwiseSubtract:          *dst_ptr_f = src_f[0] - src_f[1]; break;
-                    case Algorithm::EltwiseMultiply:          *dst_ptr_f = src_f[0] * src_f[1]; break;
-                    case Algorithm::EltwiseDivide:            *dst_ptr_f = src_f[0] / src_f[1]; break;
-                    case Algorithm::EltwiseCeiling:           *dst_ptr_f = ceilf(src_f[0]); break;
-                    case Algorithm::EltwiseFloor:             *dst_ptr_f = floorf(src_f[0]); break;
-                    case Algorithm::EltwiseFloorMod:          *dst_ptr_f = src_f[0] - floorf(src_f[0] / src_f[1]) * src_f[1]; break;
-                    case Algorithm::EltwiseMod:               *dst_ptr_f = src_f[0] - truncf(src_f[0] / src_f[1]) * src_f[1]; break;
-                    case Algorithm::EltwiseMaximum:           *dst_ptr_f = std::max(src_f[0], src_f[1]); break;
-                    case Algorithm::EltwiseMinimum:           *dst_ptr_f = std::min(src_f[0], src_f[1]); break;
-                    case Algorithm::EltwiseExp:               *dst_ptr_f = expf(src_f[0]); break;
-                    case Algorithm::EltwiseSquaredDifference: *dst_ptr_f = powf((src_f[0] - src_f[1]), 2.f); break;
-                    case Algorithm::EltwisePowerDynamic:      *dst_ptr_f = powf(src_f[0], src_f[1]); break;
-                    case Algorithm::EltwiseEqual:             *dst_ptr_f = src_f[0] == src_f[1]; break;
-                    case Algorithm::EltwiseNotEqual:          *dst_ptr_f = src_f[0] != src_f[1]; break;
-                    case Algorithm::EltwiseGreater:           *dst_ptr_f = src_f[0] > src_f[1]; break;
-                    case Algorithm::EltwiseGreaterEqual:      *dst_ptr_f = src_f[0] >= src_f[1]; break;
-                    case Algorithm::EltwiseLess:              *dst_ptr_f = src_f[0] < src_f[1]; break;
-                    case Algorithm::EltwiseLessEqual:         *dst_ptr_f = src_f[0] <= src_f[1]; break;
-                    case Algorithm::EltwiseLogicalAnd:        *dst_ptr_f = src_f[0] && src_f[1]; break;
-                    case Algorithm::EltwiseLogicalOr:         *dst_ptr_f = src_f[0] || src_f[1]; break;
-                    case Algorithm::EltwiseLogicalXor:        *dst_ptr_f = (src_f[0] || src_f[1]) - (src_f[0] && src_f[1]); break;
-                    case Algorithm::EltwiseLogicalNot:        *dst_ptr_f = !src_f[0]; break;
-                    case Algorithm::EltwisePrelu:             *dst_ptr_f = src_f[0] > 0 ? src_f[0] : static_cast<T>(src_f[0] * src_f[1]); break;
-                    case Algorithm::EltwiseErf:               *dst_ptr_f = std::erf(src_f[0]); break;
-                    case Algorithm::EltwiseSoftSign:          *dst_ptr_f = src_f[0] / (1 + std::fabs(src_f[0])); break;
-                    // @todo implement proper isinfinite for non-float precisions
-                    case Algorithm::EltwiseIsFinite:          *dst_ptr_f = std::isfinite(static_cast<float>(src_f[0])); break;
-                    case Algorithm::EltwiseIsInf:
-                        *dst_ptr_f = (this->_opData.alpha && (src_f[0] == -std::numeric_limits<T>::infinity())) ||
-                                     (this->_opData.beta  && (src_f[0] == std::numeric_limits<T>::infinity()));
-                        break;
-                    case Algorithm::EltwiseIsNaN:             *dst_ptr_f = std::isnan(src_f[0]); break;
-                    case Algorithm::EltwiseSelect:            *dst_ptr_f = src_f[0] ? src_f[1] : src_f[2]; break;
-                    default: OPENVINO_THROW("Unsupported operation type for Eltwise executor");
+                case Algorithm::EltwiseRelu:
+                case Algorithm::EltwiseGeluErf:
+                case Algorithm::EltwiseGeluTanh:
+                case Algorithm::EltwiseElu:
+                case Algorithm::EltwiseTanh:
+                case Algorithm::EltwiseSigmoid:
+                case Algorithm::EltwiseAbs:
+                case Algorithm::EltwiseSqrt:
+                case Algorithm::EltwiseSoftRelu:
+                case Algorithm::EltwiseClamp:
+                case Algorithm::EltwiseSwish:
+                case Algorithm::EltwiseHswish:
+                case Algorithm::EltwiseMish:
+                case Algorithm::EltwiseHsigmoid:
+                case Algorithm::EltwiseRoundHalfToEven:
+                case Algorithm::EltwiseRoundHalfAwayFromZero:
+                    *dst_ptr_f = ref_eltwise_injector->compute_scalar(src_f[0]);
+                    break;
+                case Algorithm::EltwiseAdd:
+                    *dst_ptr_f = src_f[0] + src_f[1];
+                    break;
+                case Algorithm::EltwiseMulAdd:
+                    *dst_ptr_f = src_f[0] * src_f[1] + src_f[2];
+                    break;
+                case Algorithm::EltwiseSubtract:
+                    *dst_ptr_f = src_f[0] - src_f[1];
+                    break;
+                case Algorithm::EltwiseMultiply:
+                    *dst_ptr_f = src_f[0] * src_f[1];
+                    break;
+                case Algorithm::EltwiseDivide:
+                    *dst_ptr_f = src_f[0] / src_f[1];
+                    break;
+                case Algorithm::EltwiseCeiling:
+                    *dst_ptr_f = ceilf(src_f[0]);
+                    break;
+                case Algorithm::EltwiseFloor:
+                    *dst_ptr_f = floorf(src_f[0]);
+                    break;
+                case Algorithm::EltwiseFloorMod:
+                    *dst_ptr_f = src_f[0] - floorf(src_f[0] / src_f[1]) * src_f[1];
+                    break;
+                case Algorithm::EltwiseMod:
+                    *dst_ptr_f = src_f[0] - truncf(src_f[0] / src_f[1]) * src_f[1];
+                    break;
+                case Algorithm::EltwiseMaximum:
+                    *dst_ptr_f = std::max(src_f[0], src_f[1]);
+                    break;
+                case Algorithm::EltwiseMinimum:
+                    *dst_ptr_f = std::min(src_f[0], src_f[1]);
+                    break;
+                case Algorithm::EltwiseExp:
+                    *dst_ptr_f = expf(src_f[0]);
+                    break;
+                case Algorithm::EltwiseSquaredDifference:
+                    *dst_ptr_f = powf((src_f[0] - src_f[1]), 2.f);
+                    break;
+                case Algorithm::EltwisePowerDynamic:
+                    *dst_ptr_f = powf(src_f[0], src_f[1]);
+                    break;
+                case Algorithm::EltwiseEqual:
+                    *dst_ptr_f = src_f[0] == src_f[1];
+                    break;
+                case Algorithm::EltwiseNotEqual:
+                    *dst_ptr_f = src_f[0] != src_f[1];
+                    break;
+                case Algorithm::EltwiseGreater:
+                    *dst_ptr_f = src_f[0] > src_f[1];
+                    break;
+                case Algorithm::EltwiseGreaterEqual:
+                    *dst_ptr_f = src_f[0] >= src_f[1];
+                    break;
+                case Algorithm::EltwiseLess:
+                    *dst_ptr_f = src_f[0] < src_f[1];
+                    break;
+                case Algorithm::EltwiseLessEqual:
+                    *dst_ptr_f = src_f[0] <= src_f[1];
+                    break;
+                case Algorithm::EltwiseLogicalAnd:
+                    *dst_ptr_f = src_f[0] && src_f[1];
+                    break;
+                case Algorithm::EltwiseLogicalOr:
+                    *dst_ptr_f = src_f[0] || src_f[1];
+                    break;
+                case Algorithm::EltwiseLogicalXor:
+                    *dst_ptr_f = (src_f[0] || src_f[1]) - (src_f[0] && src_f[1]);
+                    break;
+                case Algorithm::EltwiseLogicalNot:
+                    *dst_ptr_f = !src_f[0];
+                    break;
+                case Algorithm::EltwisePrelu:
+                    *dst_ptr_f = src_f[0] > 0 ? src_f[0] : static_cast<T>(src_f[0] * src_f[1]);
+                    break;
+                case Algorithm::EltwiseErf:
+                    *dst_ptr_f = std::erf(src_f[0]);
+                    break;
+                case Algorithm::EltwiseSoftSign:
+                    *dst_ptr_f = src_f[0] / (1 + std::fabs(src_f[0]));
+                    break;
+                // @todo implement proper isinfinite for non-float precisions
+                case Algorithm::EltwiseIsFinite:
+                    *dst_ptr_f = std::isfinite(static_cast<float>(src_f[0]));
+                    break;
+                case Algorithm::EltwiseIsInf:
+                    *dst_ptr_f = (this->_opData.alpha && (src_f[0] == -std::numeric_limits<T>::infinity())) ||
+                                 (this->_opData.beta && (src_f[0] == std::numeric_limits<T>::infinity()));
+                    break;
+                case Algorithm::EltwiseIsNaN:
+                    *dst_ptr_f = std::isnan(src_f[0]);
+                    break;
+                case Algorithm::EltwiseSelect:
+                    *dst_ptr_f = src_f[0] ? src_f[1] : src_f[2];
+                    break;
+                default:
+                    OPENVINO_THROW("Unsupported operation type for Eltwise executor");
                 }
             }
         });
     }
 };
 
-template<typename T,
-    typename std::enable_if<
-    std::is_same<T, int8_t>::value ||
-    std::is_same<T, uint8_t>::value ||
-    std::is_same<T, int16_t>::value ||
-    std::is_same<T, uint16_t>::value ||
-    std::is_same<T, int32_t>::value>
-    ::type * = nullptr>
+template <typename T,
+          typename std::enable_if<std::is_same<T, int8_t>::value || std::is_same<T, uint8_t>::value ||
+                                  std::is_same<T, int16_t>::value || std::is_same<T, uint16_t>::value ||
+                                  std::is_same<T, int32_t>::value>::type* = nullptr>
 class BitwiseRefExecutor : public EltwiseRefBaseExecutor<T> {
 public:
-    BitwiseRefExecutor(const EltwiseData& opData,
-                       const VectorDims& outBlkDims,
-                       const std::vector<VectorDims>& inpDims) : EltwiseRefBaseExecutor<T>(opData, outBlkDims, inpDims) {
-    }
+    BitwiseRefExecutor(const EltwiseData& opData, const VectorDims& outBlkDims, const std::vector<VectorDims>& inpDims)
+        : EltwiseRefBaseExecutor<T>(opData, outBlkDims, inpDims) {}
 
-    void exec(const jit_eltwise_call_args_ptrs &args_ptrs, const VectorDims &dims_out) override {
+    void exec(const jit_eltwise_call_args_ptrs& args_ptrs, const VectorDims& dims_out) override {
         std::shared_ptr<ref_eltwise_scalar_fwd_t> ref_eltwise_injector = nullptr;
         if (this->_opData.onednnAlgorithm != dnnl::algorithm::undef) {
-            ref_eltwise_injector = std::make_shared<ref_eltwise_scalar_fwd_t>(
-                    static_cast<dnnl_alg_kind_t>(this->_opData.onednnAlgorithm), this->_opData.alpha, this->_opData.beta, 1.f);
+            ref_eltwise_injector =
+                std::make_shared<ref_eltwise_scalar_fwd_t>(static_cast<dnnl_alg_kind_t>(this->_opData.onednnAlgorithm),
+                                                           this->_opData.alpha,
+                                                           this->_opData.beta,
+                                                           1.f);
         }
 
         parallel_nt(0, [&](const int ithr, const int nthr) {
@@ -1967,81 +2071,79 @@ class BitwiseRefExecutor : public EltwiseRefBaseExecutor<T> {
                 this->init_ptr(args_ptrs, dims_out, counters, iwork, src_f, dst_ptr_f);
 
                 switch (this->_opData.algo) {
-                    case Algorithm::EltwiseBitwiseAnd: {
-                        *dst_ptr_f = src_f[0] & src_f[1];
-                        break;
-                    }
-                    case Algorithm::EltwiseBitwiseNot: {
-                        *dst_ptr_f = ~src_f[0];
-                        break;
-                    }
-                    case Algorithm::EltwiseBitwiseOr: {
-                        *dst_ptr_f = src_f[0] | src_f[1];
-                        break;
-                    }
-                    case Algorithm::EltwiseBitwiseXor: {
-                        *dst_ptr_f = src_f[0] ^ src_f[1];
-                        break;
-                    }
-                    case Algorithm::EltwiseBitwiseLeftShift: {
-                        *dst_ptr_f = src_f[0] << src_f[1];
-                        break;
-                    }
-                    case Algorithm::EltwiseBitwiseRightShift: {
-                        *dst_ptr_f = src_f[0] >> src_f[1];
-                        break;
-                    }
-                    default:
-                        OPENVINO_THROW("Unsupported operation type for Eltwise executor");
+                case Algorithm::EltwiseBitwiseAnd: {
+                    *dst_ptr_f = src_f[0] & src_f[1];
+                    break;
+                }
+                case Algorithm::EltwiseBitwiseNot: {
+                    *dst_ptr_f = ~src_f[0];
+                    break;
+                }
+                case Algorithm::EltwiseBitwiseOr: {
+                    *dst_ptr_f = src_f[0] | src_f[1];
+                    break;
+                }
+                case Algorithm::EltwiseBitwiseXor: {
+                    *dst_ptr_f = src_f[0] ^ src_f[1];
+                    break;
+                }
+                case Algorithm::EltwiseBitwiseLeftShift: {
+                    *dst_ptr_f = src_f[0] << src_f[1];
+                    break;
+                }
+                case Algorithm::EltwiseBitwiseRightShift: {
+                    *dst_ptr_f = src_f[0] >> src_f[1];
+                    break;
+                }
+                default:
+                    OPENVINO_THROW("Unsupported operation type for Eltwise executor");
                 }
             }
         });
     }
 };
 
-} // namespace
+}  // namespace
 
 static Eltwise::executorPtr buildRefExecutor(const EltwiseKey& key) {
     switch (key.outPrc) {
-        case ov::element::f16:
-            return std::make_shared<EltwiseRefExecutor<dnnl::impl::float16_t>>(key.eltwise_data.front(),
-                                                                               key.outBlkDims,
-                                                                               key.inpDims);
-        case ov::element::i8:
-            return std::make_shared<BitwiseRefExecutor<element_type_traits<ov::element::i8>::value_type>>(
-                key.eltwise_data.front(),
-                key.outBlkDims,
-                key.inpDims);
-
-        case ov::element::u8:
-            return std::make_shared<BitwiseRefExecutor<element_type_traits<ov::element::u8>::value_type>>(
-                key.eltwise_data.front(),
-                key.outBlkDims,
-                key.inpDims);
-
-        case ov::element::i16:
-            return std::make_shared<BitwiseRefExecutor<element_type_traits<ov::element::i16>::value_type>>(
-                key.eltwise_data.front(),
-                key.outBlkDims,
-                key.inpDims);
-
-        case ov::element::u16:
-            return std::make_shared<BitwiseRefExecutor<element_type_traits<ov::element::u16>::value_type>>(
-                key.eltwise_data.front(),
-                key.outBlkDims,
-                key.inpDims);
+    case ov::element::f16:
+        return std::make_shared<EltwiseRefExecutor<dnnl::impl::float16_t>>(key.eltwise_data.front(),
+                                                                           key.outBlkDims,
+                                                                           key.inpDims);
+    case ov::element::i8:
+        return std::make_shared<BitwiseRefExecutor<element_type_traits<ov::element::i8>::value_type>>(
+            key.eltwise_data.front(),
+            key.outBlkDims,
+            key.inpDims);
+
+    case ov::element::u8:
+        return std::make_shared<BitwiseRefExecutor<element_type_traits<ov::element::u8>::value_type>>(
+            key.eltwise_data.front(),
+            key.outBlkDims,
+            key.inpDims);
+
+    case ov::element::i16:
+        return std::make_shared<BitwiseRefExecutor<element_type_traits<ov::element::i16>::value_type>>(
+            key.eltwise_data.front(),
+            key.outBlkDims,
+            key.inpDims);
+
+    case ov::element::u16:
+        return std::make_shared<BitwiseRefExecutor<element_type_traits<ov::element::u16>::value_type>>(
+            key.eltwise_data.front(),
+            key.outBlkDims,
+            key.inpDims);
 #
-        case ov::element::i32:
-            return std::make_shared<BitwiseRefExecutor<element_type_traits<ov::element::i32>::value_type>>(
-                key.eltwise_data.front(),
-                key.outBlkDims,
-                key.inpDims);
+    case ov::element::i32:
+        return std::make_shared<BitwiseRefExecutor<element_type_traits<ov::element::i32>::value_type>>(
+            key.eltwise_data.front(),
+            key.outBlkDims,
+            key.inpDims);
 
-        default:
-            // use float reference executor for any other precision for now
-            return std::make_shared<EltwiseRefExecutor<float>>(key.eltwise_data.front(),
-                                                               key.outBlkDims,
-                                                               key.inpDims);
+    default:
+        // use float reference executor for any other precision for now
+        return std::make_shared<EltwiseRefExecutor<float>>(key.eltwise_data.front(), key.outBlkDims, key.inpDims);
     }
 }
 
@@ -2064,7 +2166,7 @@ static Eltwise::executorPtr buildExecutor(const EltwiseKey& key) {
 bool Eltwise::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
         if (getInitializers().find(op->get_type_info()) == getInitializers().end()) {
-            errorMessage = "Doesn't support Eltwise algorithm: " +  std::string(op->get_type_name());
+            errorMessage = "Doesn't support Eltwise algorithm: " + std::string(op->get_type_name());
             return false;
         }
         if (const auto binOp = ov::as_type_ptr<const ov::op::util::BinaryElementwiseArithmetic>(op)) {
@@ -2087,8 +2189,9 @@ bool Eltwise::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, st
     return true;
 }
 
-Eltwise::Eltwise(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) :
-    Node(op, context, EltwiseShapeInferFactory()), broadcastingPolicy(Undefined) {
+Eltwise::Eltwise(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, EltwiseShapeInferFactory()),
+      broadcastingPolicy(Undefined) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
@@ -2098,67 +2201,68 @@ Eltwise::Eltwise(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr c
 
 size_t Eltwise::getOpInputsNum() const {
     switch (getAlgorithm()) {
-        case Algorithm::EltwiseIsFinite:
-        case Algorithm::EltwiseIsInf:
-        case Algorithm::EltwiseIsNaN:
-        case Algorithm::EltwiseRelu:
-        case Algorithm::EltwiseGeluErf:
-        case Algorithm::EltwiseGeluTanh:
-        case Algorithm::EltwiseCeiling:
-        case Algorithm::EltwiseFloor:
-        case Algorithm::EltwiseElu:
-        case Algorithm::EltwiseTanh:
-        case Algorithm::EltwiseSigmoid:
-        case Algorithm::EltwiseAbs:
-        case Algorithm::EltwiseSqrt:
-        case Algorithm::EltwiseSoftRelu:
-        case Algorithm::EltwiseExp:
-        case Algorithm::EltwiseClamp:
-        case Algorithm::EltwiseErf:
-        case Algorithm::EltwiseLogicalNot:
-        case Algorithm::EltwisePowerStatic:
-        case Algorithm::EltwiseSwish:
-        case Algorithm::EltwiseHswish:
-        case Algorithm::EltwiseMish:
-        case Algorithm::EltwiseHsigmoid:
-        case Algorithm::EltwiseRoundHalfToEven:
-        case Algorithm::EltwiseRoundHalfAwayFromZero:
-        case Algorithm::EltwiseSoftSign:
-        case Algorithm::EltwiseLog:
-            return 1;
-        case Algorithm::EltwiseAdd:
-        case Algorithm::EltwiseSubtract:
-        case Algorithm::EltwiseMultiply:
-        case Algorithm::EltwiseDivide:
-        case Algorithm::EltwiseFloorMod:
-        case Algorithm::EltwiseMod:
-        case Algorithm::EltwiseMaximum:
-        case Algorithm::EltwiseMinimum:
-        case Algorithm::EltwiseSquaredDifference:
-        case Algorithm::EltwisePowerDynamic:
-        case Algorithm::EltwiseEqual:
-        case Algorithm::EltwiseNotEqual:
-        case Algorithm::EltwiseGreater:
-        case Algorithm::EltwiseGreaterEqual:
-        case Algorithm::EltwiseLess:
-        case Algorithm::EltwiseLessEqual:
-        case Algorithm::EltwiseLogicalAnd:
-        case Algorithm::EltwiseLogicalOr:
-        case Algorithm::EltwiseLogicalXor:
-        case Algorithm::EltwiseBitwiseAnd:
-        case Algorithm::EltwiseBitwiseOr:
-        case Algorithm::EltwiseBitwiseXor:
-        case Algorithm::EltwiseBitwiseLeftShift:
-        case Algorithm::EltwiseBitwiseRightShift:
-            return 2;
-        case Algorithm::EltwiseBitwiseNot:
-            return 1;
-        case Algorithm::EltwisePrelu:
-            return 2;
-        case Algorithm::EltwiseMulAdd:
-        case Algorithm::EltwiseSelect:
-            return 3;
-        default: OPENVINO_THROW("Unsupported operation for Eltwise node with name `", getName(), "`.");
+    case Algorithm::EltwiseIsFinite:
+    case Algorithm::EltwiseIsInf:
+    case Algorithm::EltwiseIsNaN:
+    case Algorithm::EltwiseRelu:
+    case Algorithm::EltwiseGeluErf:
+    case Algorithm::EltwiseGeluTanh:
+    case Algorithm::EltwiseCeiling:
+    case Algorithm::EltwiseFloor:
+    case Algorithm::EltwiseElu:
+    case Algorithm::EltwiseTanh:
+    case Algorithm::EltwiseSigmoid:
+    case Algorithm::EltwiseAbs:
+    case Algorithm::EltwiseSqrt:
+    case Algorithm::EltwiseSoftRelu:
+    case Algorithm::EltwiseExp:
+    case Algorithm::EltwiseClamp:
+    case Algorithm::EltwiseErf:
+    case Algorithm::EltwiseLogicalNot:
+    case Algorithm::EltwisePowerStatic:
+    case Algorithm::EltwiseSwish:
+    case Algorithm::EltwiseHswish:
+    case Algorithm::EltwiseMish:
+    case Algorithm::EltwiseHsigmoid:
+    case Algorithm::EltwiseRoundHalfToEven:
+    case Algorithm::EltwiseRoundHalfAwayFromZero:
+    case Algorithm::EltwiseSoftSign:
+    case Algorithm::EltwiseLog:
+        return 1;
+    case Algorithm::EltwiseAdd:
+    case Algorithm::EltwiseSubtract:
+    case Algorithm::EltwiseMultiply:
+    case Algorithm::EltwiseDivide:
+    case Algorithm::EltwiseFloorMod:
+    case Algorithm::EltwiseMod:
+    case Algorithm::EltwiseMaximum:
+    case Algorithm::EltwiseMinimum:
+    case Algorithm::EltwiseSquaredDifference:
+    case Algorithm::EltwisePowerDynamic:
+    case Algorithm::EltwiseEqual:
+    case Algorithm::EltwiseNotEqual:
+    case Algorithm::EltwiseGreater:
+    case Algorithm::EltwiseGreaterEqual:
+    case Algorithm::EltwiseLess:
+    case Algorithm::EltwiseLessEqual:
+    case Algorithm::EltwiseLogicalAnd:
+    case Algorithm::EltwiseLogicalOr:
+    case Algorithm::EltwiseLogicalXor:
+    case Algorithm::EltwiseBitwiseAnd:
+    case Algorithm::EltwiseBitwiseOr:
+    case Algorithm::EltwiseBitwiseXor:
+    case Algorithm::EltwiseBitwiseLeftShift:
+    case Algorithm::EltwiseBitwiseRightShift:
+        return 2;
+    case Algorithm::EltwiseBitwiseNot:
+        return 1;
+    case Algorithm::EltwisePrelu:
+        return 2;
+    case Algorithm::EltwiseMulAdd:
+    case Algorithm::EltwiseSelect:
+        return 3;
+    default:
+        OPENVINO_THROW("Unsupported operation for Eltwise node with name `", getName(), "`.");
     }
 }
 
@@ -2183,40 +2287,37 @@ void Eltwise::getSupportedDescriptors() {
 
 void Eltwise::initSupportedPrimitiveDescriptors() {
     const auto isBitwise = [](const Algorithm& algorithm) {
-        return one_of(
-            algorithm,
-            Algorithm::EltwiseBitwiseAnd,
-            Algorithm::EltwiseBitwiseNot,
-            Algorithm::EltwiseBitwiseOr,
-            Algorithm::EltwiseBitwiseXor,
-            Algorithm::EltwiseBitwiseLeftShift,
-            Algorithm::EltwiseBitwiseRightShift);
+        return one_of(algorithm,
+                      Algorithm::EltwiseBitwiseAnd,
+                      Algorithm::EltwiseBitwiseNot,
+                      Algorithm::EltwiseBitwiseOr,
+                      Algorithm::EltwiseBitwiseXor,
+                      Algorithm::EltwiseBitwiseLeftShift,
+                      Algorithm::EltwiseBitwiseRightShift);
     };
 
-    std::vector<ov::element::Type> supportedPrecisions = isBitwise(algorithm) ?
-        std::vector<ov::element::Type> {
-            ov::element::u8,
-            ov::element::i8,
-            ov::element::u16,
-            ov::element::i16,
-            ov::element::i32
-        } : std::vector<ov::element::Type> {
-            ov::element::f32,
-            ov::element::u8,
-            ov::element::i8,
-            ov::element::u16,
-            ov::element::i16,
-            ov::element::bf16,
-            ov::element::f16,
-            ov::element::i32
-        };
+    std::vector<ov::element::Type> supportedPrecisions = isBitwise(algorithm)
+                                                             ? std::vector<ov::element::Type>{ov::element::u8,
+                                                                                              ov::element::i8,
+                                                                                              ov::element::u16,
+                                                                                              ov::element::i16,
+                                                                                              ov::element::i32}
+                                                             : std::vector<ov::element::Type>{ov::element::f32,
+                                                                                              ov::element::u8,
+                                                                                              ov::element::i8,
+                                                                                              ov::element::u16,
+                                                                                              ov::element::i16,
+                                                                                              ov::element::bf16,
+                                                                                              ov::element::f16,
+                                                                                              ov::element::i32};
 
     if (!supportedPrimitiveDescriptors.empty())
         return;
 
-    // if dim rank is greater than the maximum possible, we should use the reference execution
-#if defined (OPENVINO_ARCH_ARM64)
-    bool canUseOptimizedImpl = mayiuse(dnnl::impl::cpu::aarch64::asimd) && (getInputShapeAtPort(0).getRank() <= MAX_ELTWISE_DIM_RANK);
+        // if dim rank is greater than the maximum possible, we should use the reference execution
+#if defined(OPENVINO_ARCH_ARM64)
+    bool canUseOptimizedImpl =
+        mayiuse(dnnl::impl::cpu::aarch64::asimd) && (getInputShapeAtPort(0).getRank() <= MAX_ELTWISE_DIM_RANK);
     bool canUseOptimizedShapeAgnosticImpl = isDynamicNode() && canUseOptimizedImpl;
 #else
     bool canUseOptimizedImpl = mayiuse(x64::sse41) && getInputShapeAtPort(0).getRank() <= MAX_ELTWISE_DIM_RANK;
@@ -2261,7 +2362,7 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
                        ")");
 
     std::vector<ov::element::Type> inputPrecisions;
-    for (const auto &prec : getOriginalInputPrecisions()) {
+    for (const auto& prec : getOriginalInputPrecisions()) {
         inputPrecisions.push_back(prec);
     }
 
@@ -2288,31 +2389,32 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
     }
 
 #ifndef OPENVINO_ARCH_ARM64
-    implType = canUseOptimizedShapeAgnosticImpl ? EltwiseImplType::optimizedShapeAgnostic :
-            canUseOptimizedImpl ? EltwiseImplType::optimized : EltwiseImplType::reference;
+    implType = canUseOptimizedShapeAgnosticImpl ? EltwiseImplType::optimizedShapeAgnostic
+               : canUseOptimizedImpl            ? EltwiseImplType::optimized
+                                                : EltwiseImplType::reference;
 
     if (!hasHardwareSupport(ov::element::bf16)) {
         bool hasBF16 = false;
-        for (auto &inPrc : inputPrecisions)
+        for (auto& inPrc : inputPrecisions)
             if (inPrc == ov::element::bf16)
                 hasBF16 = true;
 
         if (outputPrecision == ov::element::bf16 || hasBF16)
             OPENVINO_THROW("Eltwise node with name `", getName(), "` doesn't support BF16 precision on this target.");
     }
-#if defined(OV_CPU_WITH_ACL)
+#    if defined(OV_CPU_WITH_ACL)
     const bool useJit = false;
-#endif
+#    endif
 #elif defined(OPENVINO_ARCH_ARM64)
-    const bool useJit = canUseOptimizedImpl &&
-                        jitIsSupported(this, getAlpha(), getBeta(), getGamma());
+    const bool useJit = canUseOptimizedImpl && jitIsSupported(this, getAlpha(), getBeta(), getGamma());
     if (!useJit) {
         canUseOptimizedImpl = false;
     }
 
-    implType = (useJit && canUseOptimizedImpl) ?
-                    (canUseOptimizedShapeAgnosticImpl ? EltwiseImplType::optimizedShapeAgnostic : EltwiseImplType::optimized) :
-                    EltwiseImplType::reference;
+    implType =
+        (useJit && canUseOptimizedImpl)
+            ? (canUseOptimizedShapeAgnosticImpl ? EltwiseImplType::optimizedShapeAgnostic : EltwiseImplType::optimized)
+            : EltwiseImplType::reference;
 #else
     OPENVINO_THROW("Unknow CPU architecture");
 #endif
@@ -2330,66 +2432,74 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
 
     const bool useAcl = !useJit;
     if (useAcl) {
-    // Use original output precision as a reference point since some eltwise algorithms have non-float inputs (i.e. EltwiseSelect)
-    ov::element::Type forcedPrec = getOriginalOutputPrecisionAtPort(0) == ov::element::f16 ? ov::element::f16 : ov::element::f32;
-    // ACL implementation supports only identical precisions on inputs/outputs so they are aligned it to highest one
-    if (AclEltwiseExecutor::isEltwiseAlgorithmSupported(getAlgorithm())) {
-        for (size_t i = 0; i < getParentEdges().size(); i++) {
-            if (!getParentEdgeAt(i)->getParent()->isConstant()) {
-                if (getOriginalInputPrecisionAtPort(i).size() > forcedPrec.size()) {
-                    forcedPrec = getOriginalInputPrecisionAtPort(i);
+        // Use original output precision as a reference point since some eltwise algorithms have non-float inputs (i.e.
+        // EltwiseSelect)
+        ov::element::Type forcedPrec =
+            getOriginalOutputPrecisionAtPort(0) == ov::element::f16 ? ov::element::f16 : ov::element::f32;
+        // ACL implementation supports only identical precisions on inputs/outputs so they are aligned it to highest one
+        if (AclEltwiseExecutor::isEltwiseAlgorithmSupported(getAlgorithm())) {
+            for (size_t i = 0; i < getParentEdges().size(); i++) {
+                if (!getParentEdgeAt(i)->getParent()->isConstant()) {
+                    if (getOriginalInputPrecisionAtPort(i).size() > forcedPrec.size()) {
+                        forcedPrec = getOriginalInputPrecisionAtPort(i);
+                    }
                 }
             }
+            if (!forcedPrec.is_real()) {
+                forcedPrec = ov::element::f32;
+            }
         }
-        if (!forcedPrec.is_real()) {
-            forcedPrec = ov::element::f32;
-        }
-    }
 
-    for (size_t i = 0; i < inputPrecisions.size(); i++) {
-        inputPrecisions[i] = filterPrecision(inputPrecisions[i], forcedPrec);
-    }
-    outputPrecision = filterPrecision(outputPrecision, forcedPrec);
-    } else {
-#endif
-#if defined(OV_CPU_WITH_SHL)
-    if (ShlEltwiseExecutor::isEltwiseAlgorithmSupported(getAlgorithm())) {
-        // SHL implementation supports only identical precisions on inputs/outputs and only FP32 for now
-        const ov::element::Type forcedPrec = ov::element::f32;
         for (size_t i = 0; i < inputPrecisions.size(); i++) {
-            inputPrecisions[i] = forcedPrec;
+            inputPrecisions[i] = filterPrecision(inputPrecisions[i], forcedPrec);
         }
-        outputPrecision = forcedPrec;
+        outputPrecision = filterPrecision(outputPrecision, forcedPrec);
     } else {
 #endif
-    auto filterPrecision = [&](const ov::element::Type& prc) {
-        if (implType == EltwiseImplType::reference) {
-            if (isBitwise(algorithm)) {
-                if (std::find(supportedPrecisions.begin(), supportedPrecisions.end(), prc) == supportedPrecisions.end()) {
-                    OPENVINO_THROW("Eltwise node with name `", getName(), "` doesn't support ", prc, " precision.");
-                }
-                return prc;
-            }
-            return ov::element::f32;
-        } else if (std::find(supportedPrecisions.begin(), supportedPrecisions.end(), prc) == supportedPrecisions.end()) {
-            if (prc == ov::element::u32 || prc == ov::element::i64 || prc == ov::element::u64) {
-                return ov::element::i32;
-            } else if (prc == ov::element::f64) {
-                return ov::element::f32;
-            } else {
-                OPENVINO_THROW("Eltwise node with name `", getName(), "` doesn't support ", prc, " precision.");
+#if defined(OV_CPU_WITH_SHL)
+        if (ShlEltwiseExecutor::isEltwiseAlgorithmSupported(getAlgorithm())) {
+            // SHL implementation supports only identical precisions on inputs/outputs and only FP32 for now
+            const ov::element::Type forcedPrec = ov::element::f32;
+            for (size_t i = 0; i < inputPrecisions.size(); i++) {
+                inputPrecisions[i] = forcedPrec;
             }
+            outputPrecision = forcedPrec;
         } else {
-            return prc;
-        }
-    };
+#endif
+            auto filterPrecision = [&](const ov::element::Type& prc) {
+                if (implType == EltwiseImplType::reference) {
+                    if (isBitwise(algorithm)) {
+                        if (std::find(supportedPrecisions.begin(), supportedPrecisions.end(), prc) ==
+                            supportedPrecisions.end()) {
+                            OPENVINO_THROW("Eltwise node with name `",
+                                           getName(),
+                                           "` doesn't support ",
+                                           prc,
+                                           " precision.");
+                        }
+                        return prc;
+                    }
+                    return ov::element::f32;
+                } else if (std::find(supportedPrecisions.begin(), supportedPrecisions.end(), prc) ==
+                           supportedPrecisions.end()) {
+                    if (prc == ov::element::u32 || prc == ov::element::i64 || prc == ov::element::u64) {
+                        return ov::element::i32;
+                    } else if (prc == ov::element::f64) {
+                        return ov::element::f32;
+                    } else {
+                        OPENVINO_THROW("Eltwise node with name `", getName(), "` doesn't support ", prc, " precision.");
+                    }
+                } else {
+                    return prc;
+                }
+            };
 
-    for (size_t i = 0; i < inputPrecisions.size(); i++) {
-        inputPrecisions[i] = filterPrecision(inputPrecisions[i]);
-    }
-    outputPrecision = filterPrecision(outputPrecision);
+            for (size_t i = 0; i < inputPrecisions.size(); i++) {
+                inputPrecisions[i] = filterPrecision(inputPrecisions[i]);
+            }
+            outputPrecision = filterPrecision(outputPrecision);
 #if defined(OV_CPU_WITH_SHL)
-    }
+        }
 #endif
 #if defined(OV_CPU_WITH_ACL)
     }
@@ -2398,22 +2508,19 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
     // TODO: delete after new LPT (ngraph based) is merged
     // WA is needed to handle bug in LPT that produces wrong precision after average pooling (I8/U8 instead of FP32)
     if ((getAlgorithm() == Algorithm::EltwiseMulAdd || getAlgorithm() == Algorithm::EltwisePowerStatic) &&
-            (inputPrecisions[0] == ov::element::u8 || inputPrecisions[0] == ov::element::i8)) {
+        (inputPrecisions[0] == ov::element::u8 || inputPrecisions[0] == ov::element::i8)) {
         auto parentNode = getParentEdgeAt(0)->getParent();
         if (getParentEdgeAt(0)->getParent()->getAlgorithm() == Algorithm::PoolingAvg) {
             inputPrecisions[0] = ov::element::f32;
         }
     }
 
-    enum LayoutType {
-        Planar,
-        ChannelsFirst,
-        Blocked
-    };
+    enum LayoutType { Planar, ChannelsFirst, Blocked };
 
-    auto initDesc = [&] (LayoutType lt, const bool useEltwiseExecutor = false, const bool useJit = false) -> NodeDesc {
-        auto createMemoryDesc = [lt](const Shape &shape, ov::element::Type prc, size_t offset) -> std::shared_ptr<CpuBlockedMemoryDesc> {
-            const auto &dims = shape.getDims();
+    auto initDesc = [&](LayoutType lt, const bool useEltwiseExecutor = false, const bool useJit = false) -> NodeDesc {
+        auto createMemoryDesc =
+            [lt](const Shape& shape, ov::element::Type prc, size_t offset) -> std::shared_ptr<CpuBlockedMemoryDesc> {
+            const auto& dims = shape.getDims();
             if (lt == ChannelsFirst && shape.getRank() != 1) {
                 auto ndims = shape.getRank();
                 VectorDims order(ndims);
@@ -2429,10 +2536,11 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
                 }
 
                 return std::make_shared<CpuBlockedMemoryDesc>(prc, shape, blocks, order, offset);
-            // TODO: need investigate
-            // bad accuracy for shape {1, 1, 4, 11}, {2, 5, 1, 1}
-            // same for disabled collapse dims
-            } else if (lt == Blocked && shape.getRank() != 1 && (shape.getMinDims()[1] != Shape::UNDEFINED_DIM && shape.getMinDims()[1] > 1)) {
+                // TODO: need investigate
+                // bad accuracy for shape {1, 1, 4, 11}, {2, 5, 1, 1}
+                // same for disabled collapse dims
+            } else if (lt == Blocked && shape.getRank() != 1 &&
+                       (shape.getMinDims()[1] != Shape::UNDEFINED_DIM && shape.getMinDims()[1] > 1)) {
                 size_t blockSize = dnnl::impl::cpu::x64::mayiuse(x64::avx512_core) ? 16 : 8;
                 VectorDims blocks = dims;
                 VectorDims order(blocks.size());
@@ -2463,9 +2571,9 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
                 portConfig.inPlace((!i && canBeInPlace() && inputPrecisions[i] == outputPrecision) ? 0 : -1);
             portConfig.constant(false);
 
-            const auto &srcShape = getInputShapeAtPort(i);
+            const auto& srcShape = getInputShapeAtPort(i);
             if (!isDynamicNode() && srcShape.getDims()[0] == 1) {
-                inputMask.reset(0); // accepts any stride on the batch axis
+                inputMask.reset(0);  // accepts any stride on the batch axis
             }
             portConfig.setMemDesc(createMemoryDesc(srcShape, inputPrecisions[i], offset), inputMask);
 
@@ -2476,10 +2584,10 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
         portConfig.inPlace(-1);
         portConfig.constant(false);
 
-        const auto &dstShape = getOutputShapeAtPort(0);
+        const auto& dstShape = getOutputShapeAtPort(0);
         BlockedMemoryDesc::CmpMask outputMask = BlockedMemoryDesc::SKIP_OFFSET_MASK;
         if (!isDynamicNode() && dstShape.getDims()[0] == 1) {
-            outputMask.reset(0); // accepts any stride on the batch axis
+            outputMask.reset(0);  // accepts any stride on the batch axis
         }
         portConfig.setMemDesc(createMemoryDesc(dstShape, outputPrecision, offset), outputMask);
 
@@ -2487,13 +2595,13 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
 
         if (useEltwiseExecutor || useJit) {
             impl_desc_type impl_type;
-            #if defined (OPENVINO_ARCH_ARM64)
+#if defined(OPENVINO_ARCH_ARM64)
             if (useJit) {
                 impl_type = impl_desc_type::jit_asimd;
             }
-            #else
+#else
             impl_type = impl_desc_type::undef;
-            #endif
+#endif
 
             std::vector<MemoryDescPtr> srcMemoryDescs;
             for (size_t i = 0; i < config.inConfs.size(); i++) {
@@ -2504,20 +2612,23 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
                 dstMemoryDescs.push_back(config.outConfs[i].getMemDesc());
             }
 
-            auto factory = std::make_shared<EltwiseExecutorFactory>(eltwiseAttrs, srcMemoryDescs, dstMemoryDescs,
-                                                                    std::make_shared<ExecutorContext>(context, getImplPriority()));
+            auto factory =
+                std::make_shared<EltwiseExecutorFactory>(eltwiseAttrs,
+                                                         srcMemoryDescs,
+                                                         dstMemoryDescs,
+                                                         std::make_shared<ExecutorContext>(context, getImplPriority()));
 
             return {config, impl_type, !factory->isEmpty() ? factory : nullptr};
         } else {
             impl_desc_type impl_type = impl_desc_type::ref;
             if (canUseOptimizedImpl) {
-                #if defined (OPENVINO_ARCH_ARM64)
+#if defined(OPENVINO_ARCH_ARM64)
                 if (mayiuse(dnnl::impl::cpu::aarch64::asimd)) {
                     impl_type = impl_desc_type::jit_asimd;
                 } else {
                     OPENVINO_THROW("not supported architecture");
                 }
-                #else
+#else
                 if (mayiuse(x64::avx512_core)) {
                     impl_type = impl_desc_type::jit_avx512;
                 } else if (mayiuse(x64::avx2)) {
@@ -2525,7 +2636,7 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
                 } else if (mayiuse(x64::sse41)) {
                     impl_type = impl_desc_type::jit_sse42;
                 }
-                #endif
+#endif
             }
 
             return {config, impl_type};
@@ -2534,10 +2645,11 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
 
     bool isChannelsFirstApplicable = one_of(getOutputShapeAtPort(0).getRank(), 1u, 2u, 3u, 4u, 5u);
     for (size_t i = 0; i < getParentEdges().size(); i++) {
-        isChannelsFirstApplicable = isChannelsFirstApplicable && one_of(getInputShapeAtPort(i).getRank(), 1u, 2u, 3u, 4u, 5u);
-        isChannelsFirstApplicable = isChannelsFirstApplicable && implication(getInputShapeAtPort(i).getRank() != 1,
-                                                                             getOutputShapeAtPort(0).getRank() ==
-                                                                                     getInputShapeAtPort(i).getRank());
+        isChannelsFirstApplicable =
+            isChannelsFirstApplicable && one_of(getInputShapeAtPort(i).getRank(), 1u, 2u, 3u, 4u, 5u);
+        isChannelsFirstApplicable = isChannelsFirstApplicable &&
+                                    implication(getInputShapeAtPort(i).getRank() != 1,
+                                                getOutputShapeAtPort(0).getRank() == getInputShapeAtPort(i).getRank());
     }
 
 #if defined(OPENVINO_ARCH_ARM64)
@@ -2547,13 +2659,14 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
 #endif
 
     for (size_t i = 0; i < getParentEdges().size(); i++) {
-        const auto &inShape = getInputShapeAtPort(i);
+        const auto& inShape = getInputShapeAtPort(i);
         isBlockedApplicable = isBlockedApplicable && one_of(inShape.getRank(), 1u, 3u, 4u, 5u);
-        isBlockedApplicable = isBlockedApplicable && implication(inShape.getRank() != 1,
-                                                                 getOutputShapeAtPort(0).getRank() ==
-                                                                 inShape.getRank());
+        isBlockedApplicable =
+            isBlockedApplicable &&
+            implication(inShape.getRank() != 1, getOutputShapeAtPort(0).getRank() == inShape.getRank());
         if (isDynamicNode() && inShape.getRank() != 1)
-            isBlockedApplicable = isBlockedApplicable && inShape.getMinDims()[1] != Shape::UNDEFINED_DIM && inShape.getMinDims()[1] > 1;
+            isBlockedApplicable =
+                isBlockedApplicable && inShape.getMinDims()[1] != Shape::UNDEFINED_DIM && inShape.getMinDims()[1] > 1;
     }
 
     inputNum = getParentEdges().size();
@@ -2561,28 +2674,29 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
 
 #if defined(OV_CPU_WITH_ACL)
     if (useAcl || useJit) {
-    eltwiseAttrs = {algorithm, alpha, beta, gamma};
+        eltwiseAttrs = {algorithm, alpha, beta, gamma};
 
-    auto addDesc = [&initDesc, &useJit](std::vector<NodeDesc>& supportedPrimitiveDescriptors, const LayoutType layoutType) {
-        auto nodeDesc = initDesc(layoutType, !useJit, useJit);
-        if (nodeDesc.getExecutorFactory())
-            supportedPrimitiveDescriptors.emplace_back(nodeDesc);
-    };
+        auto addDesc = [&initDesc, &useJit](std::vector<NodeDesc>& supportedPrimitiveDescriptors,
+                                            const LayoutType layoutType) {
+            auto nodeDesc = initDesc(layoutType, !useJit, useJit);
+            if (nodeDesc.getExecutorFactory())
+                supportedPrimitiveDescriptors.emplace_back(nodeDesc);
+        };
 
-    // @todo should be handled in scope of selectPreferPrimitiveDescriptor
-    if (context->getConfig().modelType == Config::ModelType::CNN) {
-        if (isChannelsFirstApplicable)
-            addDesc(supportedPrimitiveDescriptors, ChannelsFirst);
-        addDesc(supportedPrimitiveDescriptors, Planar);
-    } else {
-        addDesc(supportedPrimitiveDescriptors, Planar);
-        if (isChannelsFirstApplicable)
-            addDesc(supportedPrimitiveDescriptors, ChannelsFirst);
-    }
+        // @todo should be handled in scope of selectPreferPrimitiveDescriptor
+        if (context->getConfig().modelType == Config::ModelType::CNN) {
+            if (isChannelsFirstApplicable)
+                addDesc(supportedPrimitiveDescriptors, ChannelsFirst);
+            addDesc(supportedPrimitiveDescriptors, Planar);
+        } else {
+            addDesc(supportedPrimitiveDescriptors, Planar);
+            if (isChannelsFirstApplicable)
+                addDesc(supportedPrimitiveDescriptors, ChannelsFirst);
+        }
 
-    canUseEltwiseExecPtr = !supportedPrimitiveDescriptors.empty() && !useJit;
-    if (!supportedPrimitiveDescriptors.empty())
-        return;
+        canUseEltwiseExecPtr = !supportedPrimitiveDescriptors.empty() && !useJit;
+        if (!supportedPrimitiveDescriptors.empty())
+            return;
     }
 #endif
 
@@ -2652,15 +2766,18 @@ void Eltwise::prepareParams() {
         dstMemoryDescs.push_back(getDstMemoryAtPort(0)->getDescPtr());
 
         auto selectedPD = getSelectedPrimitiveDescriptor();
-        eltwiseExecPtr = selectedPD->getExecutorFactoryAs<EltwiseExecutorFactory>()->makeExecutor(eltwiseAttrs, srcMemoryDescs, dstMemoryDescs, {});
+        eltwiseExecPtr = selectedPD->getExecutorFactoryAs<EltwiseExecutorFactory>()->makeExecutor(eltwiseAttrs,
+                                                                                                  srcMemoryDescs,
+                                                                                                  dstMemoryDescs,
+                                                                                                  {});
         selectedPD->setImplementationType(eltwiseExecPtr->getImplType());
 
         return;
     }
 
     auto outBlockingDesc = getChildEdgeAt(0)->getMemory().getDescWithType<BlockedMemoryDesc>();
-    const auto &outOrder = outBlockingDesc->getOrder();
-    const auto &currentOutBlkDims = outBlockingDesc->getBlockDims();
+    const auto& outOrder = outBlockingDesc->getOrder();
+    const auto& currentOutBlkDims = outBlockingDesc->getBlockDims();
 
     size_t input_size = std::max(static_cast<size_t>(EltwiseJitExecutor::optimalTensorRank), currentOutBlkDims.size());
 
@@ -2679,13 +2796,16 @@ void Eltwise::prepareParams() {
         size_t inRank = currentInBlkDims[i].size();
 
         // WA to normalize blocked and planar layouts
-        const auto &inOrder = inBlockingDesc->getOrder();
+        const auto& inOrder = inBlockingDesc->getOrder();
         size_t startOff = outOrder.size() != outBlockingDesc->getShape().getRank() &&
-                          outOrder[outOrder.size() - 1] != inOrder[inOrder.size() - 1] ? 1 : 0;
+                                  outOrder[outOrder.size() - 1] != inOrder[inOrder.size() - 1]
+                              ? 1
+                              : 0;
 
         // WA to handle nspc layout with 1D tensors
         if (1 == inRank) {
-            if (outRank > 2 && 1 == outOrder.back()) startOff = 1;
+            if (outRank > 2 && 1 == outOrder.back())
+                startOff = 1;
         }
 
         for (size_t j = 0; j < inRank; j++) {
@@ -2718,14 +2838,18 @@ void Eltwise::prepareParams() {
 
     if (!canSkipSearchInCache) {
         EltwiseData thisOp{getAlgorithm(), getOneDnnAlgorithm(), getAlpha(), getBeta(), getGamma()};
-        EltwiseKey key = {{thisOp}, {getType()}, currentOutBlkDims, outOrder, dims_in, inpPrc, outPrc, dnnl::post_ops(), implType};
+        EltwiseKey key =
+            {{thisOp}, {getType()}, currentOutBlkDims, outOrder, dims_in, inpPrc, outPrc, dnnl::post_ops(), implType};
         fqDataPtrs.clear();
-        for (const auto &node : fusedWith) {
+        for (const auto& node : fusedWith) {
             key.ops_list.push_back(node->getType());
             if (node->getType() == Type::Eltwise) {
                 if (auto eltwise = std::dynamic_pointer_cast<Eltwise>(node)) {
-                    key.eltwise_data.push_back({eltwise->getAlgorithm(), eltwise->getOneDnnAlgorithm(), eltwise->getAlpha(),
-                                                eltwise->getBeta(), eltwise->getGamma()});
+                    key.eltwise_data.push_back({eltwise->getAlgorithm(),
+                                                eltwise->getOneDnnAlgorithm(),
+                                                eltwise->getAlpha(),
+                                                eltwise->getBeta(),
+                                                eltwise->getGamma()});
                 }
             } else if (node->getType() == Type::FakeQuantize) {
                 node->appendPostOps(key.postOps, {}, fqDataPtrs);
@@ -2745,9 +2869,9 @@ void Eltwise::prepareParams() {
 
     // update execParams for shape agnostic kernel
     if (implType == EltwiseImplType::optimizedShapeAgnostic) {
-        auto &outDims = execParams.outDims;
-        auto &inOffsets = execParams.inOffsets;
-        auto &outOffsets = execParams.outOffsets;
+        auto& outDims = execParams.outDims;
+        auto& inOffsets = execParams.inOffsets;
+        auto& outOffsets = execParams.outOffsets;
 
         // outDims recalculation
         outDims.resize(dims_in[0].size(), 1);
@@ -2805,7 +2929,8 @@ void Eltwise::selectOptimalPrimitiveDescriptor() {
 void Eltwise::execute(dnnl::stream strm) {
     if (execPtr) {
         jit_eltwise_call_args_ptrs args_ptrs = {};
-        VectorDims dims_out = implType == EltwiseImplType::optimizedShapeAgnostic ? execParams.outDims : execPtr->getOutDims();
+        VectorDims dims_out =
+            implType == EltwiseImplType::optimizedShapeAgnostic ? execParams.outDims : execPtr->getOutDims();
         for (size_t i = 0; i < memPtrs.size() - 1; i++)
             args_ptrs.src_ptr[i] = memPtrs[i]->getDataAs<const uint8_t>() + start_offset_in[i];
         args_ptrs.dst_ptr = memPtrs.back()->getDataAs<uint8_t>() + start_offset_out;
@@ -2873,15 +2998,14 @@ void Eltwise::fuseInto(NodePtr& parentNode) {
         getAlgorithm() == Algorithm::EltwiseAdd &&
         dimsEqualWeak(getInputShapeAtPort(0).getDims(), getInputShapeAtPort(1).getDims()) &&
         !getParentEdgeAt(0)->getParent()->isConstant() && !getParentEdgeAt(1)->getParent()->isConstant();
-    if ((scales.empty() && shifts.empty()) &&
-        !specialConvolutionAddFusing &&
+    if ((scales.empty() && shifts.empty()) && !specialConvolutionAddFusing &&
         canBePerformedAsScaleShift(parentNode.get())) {
         std::tie(scales, shifts) = getScalesAndShifts(parentNode.get());
     }
     Node::fuseInto(parentNode);
 }
 
-void Eltwise::appendMemory(const std::vector<float> &data, MemoryPtr &memPtr, std::vector<MemoryPtr>& postOpsMem) {
+void Eltwise::appendMemory(const std::vector<float>& data, MemoryPtr& memPtr, std::vector<MemoryPtr>& postOpsMem) {
     if (!memPtr) {
         DnnlBlockedMemoryDesc memoryDesc(ov::element::f32, {data.size()});
         memPtr = std::make_shared<Memory>(getEngine(), memoryDesc, data.data());
@@ -2889,12 +3013,15 @@ void Eltwise::appendMemory(const std::vector<float> &data, MemoryPtr &memPtr, st
     }
 }
 
-void Eltwise::appendMemory(const std::vector<float> &data, MemoryPtr &memPtr, std::vector<const void*>& postOpsMem) {
+void Eltwise::appendMemory(const std::vector<float>& data, MemoryPtr& memPtr, std::vector<const void*>& postOpsMem) {
     postOpsMem.push_back(data.data());
 }
 
 template <typename T>
-void Eltwise::appendPostOpsImpl(dnnl::post_ops& ops, const VectorDims &postOpDims, std::vector<T>& postOpsMem, const int channelAxis) {
+void Eltwise::appendPostOpsImpl(dnnl::post_ops& ops,
+                                const VectorDims& postOpDims,
+                                std::vector<T>& postOpsMem,
+                                const int channelAxis) {
     const std::string errorPrefix = "Appending Eltwise node with name '" + getName() + "' ";
 
     if (getOneDnnAlgorithm() != dnnl::algorithm::undef) {
@@ -2920,7 +3047,8 @@ void Eltwise::appendPostOpsImpl(dnnl::post_ops& ops, const VectorDims &postOpDim
         case dnnl::algorithm::eltwise_round_half_away_from_zero:
             ops.append_eltwise(getOneDnnAlgorithm(), getAlpha(), getBeta());
             break;
-        default: OPENVINO_THROW(errorPrefix, "as post operation is not supported");
+        default:
+            OPENVINO_THROW(errorPrefix, "as post operation is not supported");
         }
     } else {
         // per-tensor EltwisePowerStatic can be implemented with more well-supported eltwise postOps
@@ -2938,7 +3066,8 @@ void Eltwise::appendPostOpsImpl(dnnl::post_ops& ops, const VectorDims &postOpDim
             const auto chIdx = postOpDims.size() > 1 ? channelAxis : 0;
             channelSize = postOpDims[chIdx];
         }
-        // since legacy depthwise post ops mechanism requires broadcasted data we need to reinitilize it in case of changed shape
+        // since legacy depthwise post ops mechanism requires broadcasted data we need to reinitilize it in case of
+        // changed shape
         if (depthwiseData.empty() || depthwiseDataSize != 2 * channelSize) {
             depthwiseData.clear();
             depthwiseMemory.reset();
@@ -2995,7 +3124,10 @@ void Eltwise::appendPostOpsImpl(dnnl::post_ops& ops, const VectorDims &postOpDim
     }
 }
 
-void Eltwise::appendPostOps(dnnl::post_ops& ops, const VectorDims &postOpDims, std::unordered_map<int, MemoryPtr>& postOpsMem, const int channelAxis) {
+void Eltwise::appendPostOps(dnnl::post_ops& ops,
+                            const VectorDims& postOpDims,
+                            std::unordered_map<int, MemoryPtr>& postOpsMem,
+                            const int channelAxis) {
     std::vector<MemoryPtr> postOpsMemPtrs;
     appendPostOpsImpl(ops, postOpDims, postOpsMemPtrs, channelAxis);
 
@@ -3006,11 +3138,17 @@ void Eltwise::appendPostOps(dnnl::post_ops& ops, const VectorDims &postOpDims, s
     }
 }
 
-void Eltwise::appendPostOps(dnnl::post_ops& ops, const VectorDims &postOpDims, std::vector<const void*>& postOpsMem, const int channelAxis) {
+void Eltwise::appendPostOps(dnnl::post_ops& ops,
+                            const VectorDims& postOpDims,
+                            std::vector<const void*>& postOpsMem,
+                            const int channelAxis) {
     appendPostOpsImpl(ops, postOpDims, postOpsMem, channelAxis);
 }
 
-bool Eltwise::appendAttrPostOps(DnnlPostOpsComposerLegacy& dnnlpoc, bool isLastPostOp, dnnl::memory::data_type outDataType, bool allowBinary) {
+bool Eltwise::appendAttrPostOps(DnnlPostOpsComposerLegacy& dnnlpoc,
+                                bool isLastPostOp,
+                                dnnl::memory::data_type outDataType,
+                                bool allowBinary) {
     const std::string errorPrefix = "Appending Eltwise node with name '" + getName() + "' as binary post op ";
 
     if (getOneDnnAlgorithm() != dnnl::algorithm::undef) {
@@ -3039,7 +3177,8 @@ bool Eltwise::appendAttrPostOps(DnnlPostOpsComposerLegacy& dnnlpoc, bool isLastP
             // call dnnlpoc's specialized API to generate optimized postOps sequence
             dnnlpoc.appendLinear({getAlpha()}, {getBeta()}, isLastPostOp);
             break;
-        default: OPENVINO_THROW(errorPrefix, "as post operation is not supported");
+        default:
+            OPENVINO_THROW(errorPrefix, "as post operation is not supported");
         }
     } else {
         switch (getAlgorithm()) {
@@ -3054,9 +3193,9 @@ bool Eltwise::appendAttrPostOps(DnnlPostOpsComposerLegacy& dnnlpoc, bool isLastP
         case Algorithm::EltwisePowerStatic:
             if (beta != 1.0f && gamma != 0.0f) {
                 return dnnlpoc.appendLinear(scales, shifts, isLastPostOp, allowBinary);
-            } else if (beta != 1.0f) {// Multiply if has scales
+            } else if (beta != 1.0f) {  // Multiply if has scales
                 return dnnlpoc.appendScale(scales, isLastPostOp, allowBinary);
-            } else if (gamma != 0.0f) {// Add only if has shifts
+            } else if (gamma != 0.0f) {  // Add only if has shifts
                 return dnnlpoc.appendShift(shifts, allowBinary);
             }
             break;
@@ -3103,16 +3242,17 @@ bool Eltwise::canFuseParent(const NodePtr& parentNode) const {
 
 bool Eltwise::canFuse(const NodePtr& node) const {
     auto isIntegerComputeSupported = [](const Node* node) {
-        if (!one_of(node->getAlgorithm(), Algorithm::EltwiseAdd,
-                                          Algorithm::EltwiseMultiply,
-                                          Algorithm::EltwiseMulAdd,
-                                          Algorithm::EltwiseSubtract,
-                                          Algorithm::EltwiseDivide,
-                                          Algorithm::EltwiseSquaredDifference)) {
+        if (!one_of(node->getAlgorithm(),
+                    Algorithm::EltwiseAdd,
+                    Algorithm::EltwiseMultiply,
+                    Algorithm::EltwiseMulAdd,
+                    Algorithm::EltwiseSubtract,
+                    Algorithm::EltwiseDivide,
+                    Algorithm::EltwiseSquaredDifference)) {
             return false;
         }
 
-        for (const auto &originalInputPrecision : node->getOriginalInputPrecisions()) {
+        for (const auto& originalInputPrecision : node->getOriginalInputPrecisions()) {
             if (originalInputPrecision != ov::element::i32) {
                 return false;
             }
@@ -3121,7 +3261,7 @@ bool Eltwise::canFuse(const NodePtr& node) const {
         return true;
     };
 
-#if defined (OPENVINO_ARCH_ARM64)
+#if defined(OPENVINO_ARCH_ARM64)
     if (!mayiuse(dnnl::impl::cpu::aarch64::asimd) || (getInputShapeAtPort(0).getRank() > MAX_ELTWISE_DIM_RANK))
         return false;
 
@@ -3129,10 +3269,8 @@ bool Eltwise::canFuse(const NodePtr& node) const {
         return false;
     }
     const auto eltwise = dynamic_cast<const Eltwise*>(node.get());
-    if ((eltwise == nullptr) || (!jitIsSupported(eltwise,
-                                                 eltwise->getAlpha(),
-                                                 eltwise->getBeta(),
-                                                 eltwise->getGamma()))) {
+    if ((eltwise == nullptr) ||
+        (!jitIsSupported(eltwise, eltwise->getAlpha(), eltwise->getBeta(), eltwise->getGamma()))) {
         return false;
     }
 #else
@@ -3170,29 +3308,30 @@ bool Eltwise::canFuse(const NodePtr& node) const {
         return false;
 
     if (node->getType() == Type::Eltwise) {
-        // [WA] Since execution precision change from I32 to FP32 for arithmetic operations may lead to incorrect results
-        // we disable fusing cases which may lead to invalid precision conversions inside the kernel
-        // [TODO] We need to rewrite support for different precisions at all to avoid implicit conversions to FP32
-        // (all should be handled via explicit convert operations)
+        // [WA] Since execution precision change from I32 to FP32 for arithmetic operations may lead to incorrect
+        // results we disable fusing cases which may lead to invalid precision conversions inside the kernel [TODO] We
+        // need to rewrite support for different precisions at all to avoid implicit conversions to FP32 (all should be
+        // handled via explicit convert operations)
         bool isIntegerFusingNode = isIntegerComputeSupported(node.get());
-        if ((isIntegerNode && !isIntegerFusingNode) ||
-                (!isIntegerNode && isIntegerFusingNode)) {
+        if ((isIntegerNode && !isIntegerFusingNode) || (!isIntegerNode && isIntegerFusingNode)) {
             return false;
         }
 
         if (node->getParentEdgeAt(0)->getParent().get() != this) {
-            // Eltwise jitter doesn't respect commutative property, so fusing is disabled in case it applied not for 0-th port.
-            if (one_of(node->getAlgorithm(), Algorithm::EltwiseSubtract,
-                                             Algorithm::EltwiseDivide,
-                                             Algorithm::EltwiseFloorMod,
-                                             Algorithm::EltwiseMod,
-                                             Algorithm::EltwisePowerDynamic,
-                                             Algorithm::EltwiseGreater,
-                                             Algorithm::EltwiseGreaterEqual,
-                                             Algorithm::EltwiseLess,
-                                             Algorithm::EltwiseLessEqual,
-                                             Algorithm::EltwiseMulAdd,
-                                             Algorithm::EltwiseSelect)) {
+            // Eltwise jitter doesn't respect commutative property, so fusing is disabled in case it applied not for
+            // 0-th port.
+            if (one_of(node->getAlgorithm(),
+                       Algorithm::EltwiseSubtract,
+                       Algorithm::EltwiseDivide,
+                       Algorithm::EltwiseFloorMod,
+                       Algorithm::EltwiseMod,
+                       Algorithm::EltwisePowerDynamic,
+                       Algorithm::EltwiseGreater,
+                       Algorithm::EltwiseGreaterEqual,
+                       Algorithm::EltwiseLess,
+                       Algorithm::EltwiseLessEqual,
+                       Algorithm::EltwiseMulAdd,
+                       Algorithm::EltwiseSelect)) {
                 return false;
             }
 
@@ -3205,7 +3344,8 @@ bool Eltwise::canFuse(const NodePtr& node) const {
             }
         }
 
-        // We can use optimized execution with fusions only in cases when dim rank is less or equal to the maximum possible
+        // We can use optimized execution with fusions only in cases when dim rank is less or equal to the maximum
+        // possible
         if (node->getInputShapeAtPort(0).getRank() > MAX_ELTWISE_DIM_RANK)
             return false;
 
@@ -3224,13 +3364,15 @@ ov::element::Type Eltwise::getRuntimePrecision() const {
     // Don't take bias precision into account
     for (size_t i = 0; i < getParentEdges().size(); i++) {
         auto parentEdge = getParentEdgeAt(i);
-        if (parentEdge && parentEdge->getStatus() == Edge::Status::Validated && !parentEdge->getParent()->isConstant()) {
-            inputPrecisions.emplace_back(DnnlExtensionUtils::DataTypeToElementType((parentEdge->getMemoryPtr()->getDataType())));
+        if (parentEdge && parentEdge->getStatus() == Edge::Status::Validated &&
+            !parentEdge->getParent()->isConstant()) {
+            inputPrecisions.emplace_back(
+                DnnlExtensionUtils::DataTypeToElementType((parentEdge->getMemoryPtr()->getDataType())));
         }
     }
 
     return getMaxPrecision(inputPrecisions);
 }
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/eltwise.h b/src/plugins/intel_cpu/src/nodes/eltwise.h
index 6013ce732ee5fc..d0ca94e08824c8 100644
--- a/src/plugins/intel_cpu/src/nodes/eltwise.h
+++ b/src/plugins/intel_cpu/src/nodes/eltwise.h
@@ -5,17 +5,18 @@
 #pragma once
 
 #include <node.h>
+
+#include <memory>
 #include <string>
 #include <vector>
-#include <memory>
 
 #include "dnnl_postops_composer_legacy.h"
-#include "nodes/executors/eltwise.hpp"
 #include "executors/eltwise_list.hpp"
+#include "nodes/executors/eltwise.hpp"
 #include "nodes/kernels/jit_eltwise_call_args_ptrs.hpp"
 
 #if defined(OPENVINO_ARCH_ARM64)
-#include "kernels/aarch64/jit_uni_eltwise_generic.hpp"
+#    include "kernels/aarch64/jit_uni_eltwise_generic.hpp"
 #endif
 
 namespace ov {
@@ -68,18 +69,14 @@ struct jit_uni_eltwise_kernel {
 
 #endif
 
-enum class EltwiseImplType {
-    reference = 0,
-    optimized = 1,
-    optimizedShapeAgnostic = 2
-};
+enum class EltwiseImplType { reference = 0, optimized = 1, optimizedShapeAgnostic = 2 };
 
 class Eltwise : public Node {
 public:
     class IEltwiseExecutor {
     public:
         IEltwiseExecutor() = default;
-        virtual void exec(const jit_eltwise_call_args_ptrs &args_ptrs, const VectorDims &dims_out) = 0;
+        virtual void exec(const jit_eltwise_call_args_ptrs& args_ptrs, const VectorDims& dims_out) = 0;
         virtual size_t getBatchDimIdx() const = 0;
         virtual const VectorDims& getOutDims() const = 0;
         virtual ~IEltwiseExecutor() = default;
@@ -98,22 +95,45 @@ class Eltwise : public Node {
     bool canBeInPlace() const override;
     bool canFuseParent(const NodePtr& parentNode) const;
     bool canFuse(const NodePtr& node) const override;
-    void appendPostOps(dnnl::post_ops& ops, const VectorDims &postOpDims, std::unordered_map<int, MemoryPtr>& postOpsMem, const int channelAxis = 1) override;
-    void appendPostOps(dnnl::post_ops& ops, const VectorDims &postOpDims, std::vector<const void*>& postOpsMem, const int channelAxis = 1) override;
-    bool appendAttrPostOps(DnnlPostOpsComposerLegacy& dnnlpoc, bool isLastPostOp, dnnl::memory::data_type outDataType, bool allowBinary = true);
+    void appendPostOps(dnnl::post_ops& ops,
+                       const VectorDims& postOpDims,
+                       std::unordered_map<int, MemoryPtr>& postOpsMem,
+                       const int channelAxis = 1) override;
+    void appendPostOps(dnnl::post_ops& ops,
+                       const VectorDims& postOpDims,
+                       std::vector<const void*>& postOpsMem,
+                       const int channelAxis = 1) override;
+    bool appendAttrPostOps(DnnlPostOpsComposerLegacy& dnnlpoc,
+                           bool isLastPostOp,
+                           dnnl::memory::data_type outDataType,
+                           bool allowBinary = true);
     void fuseInto(NodePtr& parentNode) override;
     ov::element::Type getRuntimePrecision() const override;
 
-    float getAlpha() const { return alpha; }
-    float getBeta() const { return beta; }
-    float getGamma() const { return gamma; }
-    const std::vector<float>& getScales() const { return scales; }
-    const std::vector<float>& getShifts() const { return shifts; }
+    float getAlpha() const {
+        return alpha;
+    }
+    float getBeta() const {
+        return beta;
+    }
+    float getGamma() const {
+        return gamma;
+    }
+    const std::vector<float>& getScales() const {
+        return scales;
+    }
+    const std::vector<float>& getShifts() const {
+        return shifts;
+    }
 
-    dnnl::algorithm getOneDnnAlgorithm() const { return onednnAlgorithm; }
+    dnnl::algorithm getOneDnnAlgorithm() const {
+        return onednnAlgorithm;
+    }
 
     bool isWithBroadcast();
-    bool isSpecialConvolutionAddFusing() const { return specialConvolutionAddFusing; }
+    bool isSpecialConvolutionAddFusing() const {
+        return specialConvolutionAddFusing;
+    }
 
     bool needPrepareParams() const override;
     void prepareParams() override;
@@ -127,7 +147,9 @@ class Eltwise : public Node {
         Undefined,
     };
 
-    BroadcastingPolicy getBroadcastingPolicy() const { return broadcastingPolicy; }
+    BroadcastingPolicy getBroadcastingPolicy() const {
+        return broadcastingPolicy;
+    }
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
@@ -181,10 +203,13 @@ class Eltwise : public Node {
     size_t getOpInputsNum() const;
 
     template <typename T>
-    void appendPostOpsImpl(dnnl::post_ops& ops, const VectorDims &postOpDims, std::vector<T>& postOpsMem, const int channelAxis = 1);
+    void appendPostOpsImpl(dnnl::post_ops& ops,
+                           const VectorDims& postOpDims,
+                           std::vector<T>& postOpsMem,
+                           const int channelAxis = 1);
 
-    void appendMemory(const std::vector<float> &data, MemoryPtr &memPtr, std::vector<MemoryPtr>& postOpsMem);
-    void appendMemory(const std::vector<float> &data, MemoryPtr &memPtr, std::vector<const void*>& postOpsMem);
+    void appendMemory(const std::vector<float>& data, MemoryPtr& memPtr, std::vector<MemoryPtr>& postOpsMem);
+    void appendMemory(const std::vector<float>& data, MemoryPtr& memPtr, std::vector<const void*>& postOpsMem);
 
     bool canUseEltwiseExecPtr = false;
     EltwiseAttrs eltwiseAttrs;
@@ -201,6 +226,6 @@ class eltwise_precision_helper {
     static std::set<std::vector<element::Type>> get_supported_precisions(const Algorithm& algo);
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/embedding_bag.cpp b/src/plugins/intel_cpu/src/nodes/embedding_bag.cpp
index 8b144e90c865bc..2dcb93f9fc6c1b 100644
--- a/src/plugins/intel_cpu/src/nodes/embedding_bag.cpp
+++ b/src/plugins/intel_cpu/src/nodes/embedding_bag.cpp
@@ -18,10 +18,10 @@ namespace intel_cpu {
 namespace node {
 
 EmbeddingBag::EmbeddingBag(const std::shared_ptr<ov::Node>& op,
-                                 size_t requiredInputNum,
-                                 size_t indicesIdx,
-                                 size_t perSampleWeightsIdx,
-                                 size_t defaultIndexIdx)
+                           size_t requiredInputNum,
+                           size_t indicesIdx,
+                           size_t perSampleWeightsIdx,
+                           size_t defaultIndexIdx)
     : INDICES_IDX(indicesIdx),
       PER_SAMPLE_WEIGHTS_IDX(perSampleWeightsIdx),
       DEFAULT_INDEX_IDX(defaultIndexIdx) {
@@ -47,9 +47,9 @@ void EmbeddingBag::prepareParams(const VectorDims& indexStaticShape) {
 
 template <typename T>
 void EmbeddingBag::processData(const T* srcData,
-                                  const T* weightsData,
-                                  const VectorDims& inDataDims,
-                                  const MemoryPtr& outMemory) {
+                               const T* weightsData,
+                               const VectorDims& inDataDims,
+                               const MemoryPtr& outMemory) {
     std::string msgPrefix = std::string("Node EmbeddingBag with name '") + _layerName + "' ";
 
     initFromInputs();
@@ -127,10 +127,10 @@ void EmbeddingBag::processData(const T* srcData,
 }
 
 void EmbeddingBag::execute(const uint8_t* srcData,
-                              const uint8_t* weightsData,
-                              const ov::element::Type& srcPrc,
-                              const VectorDims& inDims,
-                              const MemoryPtr& outMemory) {
+                           const uint8_t* weightsData,
+                           const ov::element::Type& srcPrc,
+                           const VectorDims& inDims,
+                           const MemoryPtr& outMemory) {
     switch (srcPrc) {
     case ov::element::f32: {
         return processData<element_type_traits<ov::element::f32>::value_type>(
@@ -157,8 +157,7 @@ void EmbeddingBag::execute(const uint8_t* srcData,
             outMemory);
     }
     default: {
-        OPENVINO_THROW("EmbeddingBag layer does not support precision '" + std::string(srcPrc.get_type_name()) +
-                       "'");
+        OPENVINO_THROW("EmbeddingBag layer does not support precision '" + std::string(srcPrc.get_type_name()) + "'");
     }
     }
 }
diff --git a/src/plugins/intel_cpu/src/nodes/embedding_bag.h b/src/plugins/intel_cpu/src/nodes/embedding_bag.h
index 28c8666233fa1a..d804ea06c2b317 100644
--- a/src/plugins/intel_cpu/src/nodes/embedding_bag.h
+++ b/src/plugins/intel_cpu/src/nodes/embedding_bag.h
@@ -13,32 +13,32 @@ namespace node {
 class EmbeddingBag {
 public:
     enum class Reduction { SUM, MEAN };
-    EmbeddingBag(
-            const std::shared_ptr<ov::Node>&,
-            size_t requiredInputsNum,
-            size_t indicesIdx,
-            size_t perSampleWeightsIdx,
-            size_t defaultIndexIdx);
-
-    void execute(const uint8_t* srcData, const uint8_t* weightsData, const ov::element::Type &srcPrc,
-                 const VectorDims& inDims, const MemoryPtr& outMemory);
+    EmbeddingBag(const std::shared_ptr<ov::Node>&,
+                 size_t requiredInputsNum,
+                 size_t indicesIdx,
+                 size_t perSampleWeightsIdx,
+                 size_t defaultIndexIdx);
+
+    void execute(const uint8_t* srcData,
+                 const uint8_t* weightsData,
+                 const ov::element::Type& srcPrc,
+                 const VectorDims& inDims,
+                 const MemoryPtr& outMemory);
 
     ~EmbeddingBag() = default;
 
 protected:
     virtual void initFromInputs() = 0;
-    virtual void getIndices(
-            size_t embIndex,
-            const int*& indicesRef,
-            size_t& size,
-            int& weightsIdx,
-            bool& withWeights) = 0;
+    virtual void getIndices(size_t embIndex,
+                            const int*& indicesRef,
+                            size_t& size,
+                            int& weightsIdx,
+                            bool& withWeights) = 0;
 
     void prepareParams(const VectorDims& indexStaticShape);
 
-    template<typename T>
-    void processData(const T* srcData, const T* weightsData,
-                     const VectorDims& inDataDims, const MemoryPtr& outMemory);
+    template <typename T>
+    void processData(const T* srcData, const T* weightsData, const VectorDims& inDataDims, const MemoryPtr& outMemory);
 
     const size_t EMB_TABLE_IDX = 0lu;
     const size_t INDICES_IDX;
@@ -51,6 +51,6 @@ class EmbeddingBag {
     std::string _layerName;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/embedding_bag_offsets.cpp b/src/plugins/intel_cpu/src/nodes/embedding_bag_offsets.cpp
index b5fbaee982808d..8da557a823a948 100644
--- a/src/plugins/intel_cpu/src/nodes/embedding_bag_offsets.cpp
+++ b/src/plugins/intel_cpu/src/nodes/embedding_bag_offsets.cpp
@@ -2,24 +2,27 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "embedding_bag_offsets.h"
+
 #include <cmath>
-#include <vector>
 #include <string>
-#include "embedding_bag_offsets.h"
-#include "openvino/op/embeddingbag_offsets_sum.hpp"
-#include "openvino/op/embeddingbag_offsets.hpp"
+#include <vector>
 
+#include "openvino/op/embeddingbag_offsets.hpp"
+#include "openvino/op/embeddingbag_offsets_sum.hpp"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-bool EmbeddingBagOffset::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool EmbeddingBagOffset::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                              std::string& errorMessage) noexcept {
     try {
         const auto embBagOffsetSumOp = ov::as_type_ptr<const ov::op::v3::EmbeddingBagOffsetsSum>(op);
         const auto embBagOffsetOp = ov::as_type_ptr<const ov::op::v15::EmbeddingBagOffsets>(op);
         if (!embBagOffsetSumOp && !embBagOffsetOp) {
-            errorMessage = "Node is not an instance of the v3::EmbeddingBagOffsetsSum or v15::EmbeddingBagOffsets operation.";
+            errorMessage =
+                "Node is not an instance of the v3::EmbeddingBagOffsetsSum or v15::EmbeddingBagOffsets operation.";
             return false;
         }
     } catch (...) {
@@ -46,7 +49,8 @@ EmbeddingBagOffset::EmbeddingBagOffset(const std::shared_ptr<ov::Node>& op, cons
             _reduction = Reduction::MEAN;
             break;
         default:
-            THROW_CPU_NODE_ERR("EmbeddingBagOffsets does not support reduction mode: ", ov::as_string(offsets_op->get_reduction()));
+            THROW_CPU_NODE_ERR("EmbeddingBagOffsets does not support reduction mode: ",
+                               ov::as_string(offsets_op->get_reduction()));
         }
     }
     if (getInputShapeAtPort(INDICES_IDX).getRank() != 1ul)
@@ -61,8 +65,10 @@ void EmbeddingBagOffset::initSupportedPrimitiveDescriptors() {
         return;
 
     std::string logPrefix = std::string("Layer EmbeddingBag with name '") + _layerName + "' ";
-    static const std::set<ov::element::Type > supportedPrecisions =
-            {ov::element::f32, ov::element::i8, ov::element::u8, ov::element::i32};
+    static const std::set<ov::element::Type> supportedPrecisions = {ov::element::f32,
+                                                                    ov::element::i8,
+                                                                    ov::element::u8,
+                                                                    ov::element::i32};
 
     auto inDataPrecision = getOriginalInputPrecisionAtPort(EMB_TABLE_IDX);
     if (one_of(inDataPrecision, ov::element::bf16, ov::element::f16))
@@ -71,8 +77,10 @@ void EmbeddingBagOffset::initSupportedPrimitiveDescriptors() {
         if (supportedPrecisions.find(inDataPrecision) == supportedPrecisions.end())
             OPENVINO_THROW(logPrefix, "has unsupported precision: ", inDataPrecision.get_type_name());
     } else {
-        static const std::set<ov::element::Type> defaultSupportedPrecisions =
-                {ov::element::f32, ov::element::i8, ov::element::u8, ov::element::i32};
+        static const std::set<ov::element::Type> defaultSupportedPrecisions = {ov::element::f32,
+                                                                               ov::element::i8,
+                                                                               ov::element::u8,
+                                                                               ov::element::i32};
         if (defaultSupportedPrecisions.find(inDataPrecision) == defaultSupportedPrecisions.end())
             OPENVINO_THROW(logPrefix, "has unsupported precision: ", inDataPrecision.get_type_name());
     }
@@ -103,7 +111,11 @@ void EmbeddingBagOffset::initFromInputs() {
     }
 }
 
-void EmbeddingBagOffset::getIndices(size_t embIndex, const int*& indices, size_t& size, int& weightsIdx, bool& withWeight) {
+void EmbeddingBagOffset::getIndices(size_t embIndex,
+                                    const int*& indices,
+                                    size_t& size,
+                                    int& weightsIdx,
+                                    bool& withWeight) {
     if (static_cast<size_t>(embIndex) >= _offsetsLen) {
         OPENVINO_THROW("Invalid embedding bag index.");
     }
@@ -145,20 +157,23 @@ bool EmbeddingBagOffset::isExecutable() const {
 }
 
 void EmbeddingBagOffset::execute(dnnl::stream strm) {
-    const auto *srcData = getSrcDataAtPortAs<const uint8_t>(0);
+    const auto* srcData = getSrcDataAtPortAs<const uint8_t>(0);
     const uint8_t* weightsData = nullptr;
     if (_withWeights)
         weightsData = getSrcDataAtPortAs<const uint8_t>(PER_SAMPLE_WEIGHTS_IDX);
 
-    const auto &inputMem  = getParentEdgeAt(0)->getMemory();
-    EmbeddingBag::execute(srcData, weightsData, inputMem.getDesc().getPrecision(),
-                                       inputMem.getStaticDims(), getDstMemoryAtPort(0));
+    const auto& inputMem = getParentEdgeAt(0)->getMemory();
+    EmbeddingBag::execute(srcData,
+                          weightsData,
+                          inputMem.getDesc().getPrecision(),
+                          inputMem.getStaticDims(),
+                          getDstMemoryAtPort(0));
 }
 
 bool EmbeddingBagOffset::created() const {
     return getType() == Type::EmbeddingBagOffsets;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/embedding_bag_offsets.h b/src/plugins/intel_cpu/src/nodes/embedding_bag_offsets.h
index a31b518e7891a9..f8a28152a26642 100644
--- a/src/plugins/intel_cpu/src/nodes/embedding_bag_offsets.h
+++ b/src/plugins/intel_cpu/src/nodes/embedding_bag_offsets.h
@@ -15,7 +15,7 @@ class EmbeddingBagOffset : public Node, public EmbeddingBag {
 public:
     EmbeddingBagOffset(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -41,6 +41,6 @@ class EmbeddingBagOffset : public Node, public EmbeddingBag {
     size_t _offsetsLen = 0;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/embedding_bag_packed.cpp b/src/plugins/intel_cpu/src/nodes/embedding_bag_packed.cpp
index fd2e0b6141f1fc..c1a06835a67af3 100644
--- a/src/plugins/intel_cpu/src/nodes/embedding_bag_packed.cpp
+++ b/src/plugins/intel_cpu/src/nodes/embedding_bag_packed.cpp
@@ -2,23 +2,27 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "embedding_bag_packed.h"
+
 #include <cmath>
-#include <vector>
 #include <string>
-#include "embedding_bag_packed.h"
-#include "openvino/op/embeddingbag_packedsum.hpp"
+#include <vector>
+
 #include "openvino/op/embeddingbag_packed.hpp"
+#include "openvino/op/embeddingbag_packedsum.hpp"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-bool EmbeddingBagPacked::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool EmbeddingBagPacked::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                              std::string& errorMessage) noexcept {
     try {
         const auto embBagPackedSumOp = ov::as_type_ptr<const ov::op::v3::EmbeddingBagPackedSum>(op);
         const auto embBagPackedOp = ov::as_type_ptr<const ov::op::v15::EmbeddingBagPacked>(op);
         if (!embBagPackedSumOp && !embBagPackedOp) {
-            errorMessage = "Node is not an instance of the v3::EmbeddingBagPackedSum or v15::EmbeddingBagPacked operations.";
+            errorMessage =
+                "Node is not an instance of the v3::EmbeddingBagPackedSum or v15::EmbeddingBagPacked operations.";
             return false;
         }
     } catch (...) {
@@ -45,7 +49,8 @@ EmbeddingBagPacked::EmbeddingBagPacked(const std::shared_ptr<ov::Node>& op, cons
             _reduction = Reduction::MEAN;
             break;
         default:
-            THROW_CPU_NODE_ERR("EmbeddingBagPacked does not support reduction mode: ", ov::as_string(packed_op->get_reduction()));
+            THROW_CPU_NODE_ERR("EmbeddingBagPacked does not support reduction mode: ",
+                               ov::as_string(packed_op->get_reduction()));
         }
     }
     if (getInputShapeAtPort(INDICES_IDX).getRank() != 2ul)
@@ -57,8 +62,10 @@ void EmbeddingBagPacked::initSupportedPrimitiveDescriptors() {
         return;
 
     std::string logPrefix = std::string("Layer EmbeddingBag with name '") + _layerName + "' ";
-    static const std::set<ov::element::Type> supportedPrecisions =
-            {ov::element::f32, ov::element::i8, ov::element::u8, ov::element::i32};
+    static const std::set<ov::element::Type> supportedPrecisions = {ov::element::f32,
+                                                                    ov::element::i8,
+                                                                    ov::element::u8,
+                                                                    ov::element::i32};
 
     auto inDataPrecision = getOriginalInputPrecisionAtPort(EMB_TABLE_IDX);
     if (one_of(inDataPrecision, ov::element::bf16, ov::element::f16))
@@ -67,14 +74,16 @@ void EmbeddingBagPacked::initSupportedPrimitiveDescriptors() {
         if (supportedPrecisions.find(inDataPrecision) == supportedPrecisions.end())
             OPENVINO_THROW(logPrefix, "has unsupported precision: ", inDataPrecision.get_type_name());
     } else {
-        static const std::set<ov::element::Type> defaultSupportedPrecisions =
-                {ov::element::f32, ov::element::i8, ov::element::u8, ov::element::i32};
+        static const std::set<ov::element::Type> defaultSupportedPrecisions = {ov::element::f32,
+                                                                               ov::element::i8,
+                                                                               ov::element::u8,
+                                                                               ov::element::i32};
         if (defaultSupportedPrecisions.find(inDataPrecision) == defaultSupportedPrecisions.end())
             OPENVINO_THROW(logPrefix, "has unsupported precision: ", inDataPrecision.get_type_name());
     }
 
-    std::vector<PortConfigurator> inDataConfigurators({{LayoutType::ncsp, inDataPrecision},
-                                                       {LayoutType::ncsp, ov::element::i32}});
+    std::vector<PortConfigurator> inDataConfigurators(
+        {{LayoutType::ncsp, inDataPrecision}, {LayoutType::ncsp, ov::element::i32}});
     if (inputShapes.size() > PER_SAMPLE_WEIGHTS_IDX)
         inDataConfigurators.push_back({LayoutType::ncsp, inDataPrecision});
 
@@ -91,7 +100,11 @@ void EmbeddingBagPacked::initFromInputs() {
     _indices = getSrcDataAtPortAs<const int>(INDICES_IDX);
 }
 
-void EmbeddingBagPacked::getIndices(size_t embIndex, const int*& indices, size_t& size, int& weightsIdx, bool& withWeight) {
+void EmbeddingBagPacked::getIndices(size_t embIndex,
+                                    const int*& indices,
+                                    size_t& size,
+                                    int& weightsIdx,
+                                    bool& withWeight) {
     if (static_cast<size_t>(embIndex) >= _batch * _indicesPerBag)
         OPENVINO_THROW("Invalid embedding bag index.");
 
@@ -112,20 +125,23 @@ bool EmbeddingBagPacked::isExecutable() const {
 }
 
 void EmbeddingBagPacked::execute(dnnl::stream strm) {
-    const auto *srcData = getSrcDataAtPortAs<const uint8_t>(0);
+    const auto* srcData = getSrcDataAtPortAs<const uint8_t>(0);
     const uint8_t* weightsData = nullptr;
     if (_withWeights)
         weightsData = getSrcDataAtPortAs<const uint8_t>(PER_SAMPLE_WEIGHTS_IDX);
 
-    const auto &inputMem  = getParentEdgeAt(0)->getMemory();
-    EmbeddingBag::execute(srcData, weightsData, inputMem.getDesc().getPrecision(),
-                                       inputMem.getStaticDims(), getDstMemoryAtPort(0));
+    const auto& inputMem = getParentEdgeAt(0)->getMemory();
+    EmbeddingBag::execute(srcData,
+                          weightsData,
+                          inputMem.getDesc().getPrecision(),
+                          inputMem.getStaticDims(),
+                          getDstMemoryAtPort(0));
 }
 
 bool EmbeddingBagPacked::created() const {
     return getType() == Type::EmbeddingBagPacked;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/embedding_bag_packed.h b/src/plugins/intel_cpu/src/nodes/embedding_bag_packed.h
index 6a9d33fe3afccb..a018d1b48929e1 100644
--- a/src/plugins/intel_cpu/src/nodes/embedding_bag_packed.h
+++ b/src/plugins/intel_cpu/src/nodes/embedding_bag_packed.h
@@ -15,7 +15,7 @@ class EmbeddingBagPacked : public Node, public EmbeddingBag {
 public:
     EmbeddingBagPacked(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -36,6 +36,6 @@ class EmbeddingBagPacked : public Node, public EmbeddingBag {
     size_t _indicesPerBag = 0;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/embedding_segments_sum.cpp b/src/plugins/intel_cpu/src/nodes/embedding_segments_sum.cpp
index 2a012c6b941831..8bd91799834bad 100644
--- a/src/plugins/intel_cpu/src/nodes/embedding_segments_sum.cpp
+++ b/src/plugins/intel_cpu/src/nodes/embedding_segments_sum.cpp
@@ -2,17 +2,20 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "embedding_segments_sum.h"
+
 #include <cmath>
-#include <vector>
 #include <string>
-#include "embedding_segments_sum.h"
+#include <vector>
+
 #include "openvino/opsets/opset3.hpp"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-bool EmbeddingSegmentsSum::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool EmbeddingSegmentsSum::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                                std::string& errorMessage) noexcept {
     try {
         const auto embBagSegSumOp = ov::as_type_ptr<const ov::op::v3::EmbeddingSegmentsSum>(op);
         if (!embBagSegSumOp) {
@@ -46,8 +49,10 @@ void EmbeddingSegmentsSum::initSupportedPrimitiveDescriptors() {
         return;
 
     std::string logPrefix = std::string("Layer EmbeddingBag with name '") + _layerName + "' ";
-    static const std::set<ov::element::Type> supportedPrecisions =
-            {ov::element::f32, ov::element::i8, ov::element::u8, ov::element::i32};
+    static const std::set<ov::element::Type> supportedPrecisions = {ov::element::f32,
+                                                                    ov::element::i8,
+                                                                    ov::element::u8,
+                                                                    ov::element::i32};
 
     auto inDataPrecision = getOriginalInputPrecisionAtPort(EMB_TABLE_IDX);
     if (one_of(inDataPrecision, ov::element::bf16, ov::element::f16))
@@ -56,8 +61,10 @@ void EmbeddingSegmentsSum::initSupportedPrimitiveDescriptors() {
         if (supportedPrecisions.find(inDataPrecision) == supportedPrecisions.end())
             OPENVINO_THROW(logPrefix, "has unsupported precision: ", inDataPrecision.get_type_name());
     } else {
-        static const std::set<ov::element::Type> defaultSupportedPrecisions =
-                {ov::element::f32, ov::element::i8, ov::element::u8, ov::element::i32};
+        static const std::set<ov::element::Type> defaultSupportedPrecisions = {ov::element::f32,
+                                                                               ov::element::i8,
+                                                                               ov::element::u8,
+                                                                               ov::element::i32};
         if (defaultSupportedPrecisions.find(inDataPrecision) == defaultSupportedPrecisions.end())
             OPENVINO_THROW(logPrefix, "has unsupported precision: ", inDataPrecision.get_type_name());
     }
@@ -90,7 +97,11 @@ void EmbeddingSegmentsSum::initFromInputs() {
     }
 }
 
-void EmbeddingSegmentsSum::getIndices(size_t embIndex, const int*& indices, size_t& size, int& weightsIdx, bool& withWeight) {
+void EmbeddingSegmentsSum::getIndices(size_t embIndex,
+                                      const int*& indices,
+                                      size_t& size,
+                                      int& weightsIdx,
+                                      bool& withWeight) {
     if (embIndex >= static_cast<size_t>(lastNumSegments_))
         OPENVINO_THROW("Invalid embedding bag index.");
 
@@ -143,20 +154,23 @@ bool EmbeddingSegmentsSum::isExecutable() const {
 }
 
 void EmbeddingSegmentsSum::execute(dnnl::stream strm) {
-    const auto *srcData = getSrcDataAtPortAs<const uint8_t>(0);
+    const auto* srcData = getSrcDataAtPortAs<const uint8_t>(0);
     const uint8_t* weightsData = nullptr;
     if (_withWeights)
         weightsData = getSrcDataAtPortAs<const uint8_t>(PER_SAMPLE_WEIGHTS_IDX);
 
-    const auto &inputMem  = getParentEdgeAt(0)->getMemory();
-    EmbeddingBag::execute(srcData, weightsData, inputMem.getDesc().getPrecision(),
-                                       inputMem.getStaticDims(), getDstMemoryAtPort(0));
+    const auto& inputMem = getParentEdgeAt(0)->getMemory();
+    EmbeddingBag::execute(srcData,
+                          weightsData,
+                          inputMem.getDesc().getPrecision(),
+                          inputMem.getStaticDims(),
+                          getDstMemoryAtPort(0));
 }
 
 bool EmbeddingSegmentsSum::created() const {
     return getType() == Type::EmbeddingSegmentsSum;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/embedding_segments_sum.h b/src/plugins/intel_cpu/src/nodes/embedding_segments_sum.h
index bb312b4dd47246..984b9de68690b2 100644
--- a/src/plugins/intel_cpu/src/nodes/embedding_segments_sum.h
+++ b/src/plugins/intel_cpu/src/nodes/embedding_segments_sum.h
@@ -15,7 +15,7 @@ class EmbeddingSegmentsSum : public Node, public EmbeddingBag {
 public:
     EmbeddingSegmentsSum(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -45,6 +45,6 @@ class EmbeddingSegmentsSum : public Node, public EmbeddingBag {
     size_t indicesSize_ = 0;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/common/ref_convert.cpp b/src/plugins/intel_cpu/src/nodes/executors/common/ref_convert.cpp
index 2bba0f5e73c0fe..de65176fb72235 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/common/ref_convert.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/common/ref_convert.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "ref_convert.hpp"
+
 #include "nodes/common/cpu_convert.h"
 
 namespace ov {
@@ -13,9 +14,9 @@ bool CommonConvertExecutor::isSupported(ov::element::Type srcPrc, ov::element::T
 }
 
 bool CommonConvertExecutor::init(const ConvertParams& convertParams,
-                                                const MemoryDescPtr& srcDesc,
-                                                const MemoryDescPtr& dstDesc,
-                                                const dnnl::primitive_attr& attr) {
+                                 const MemoryDescPtr& srcDesc,
+                                 const MemoryDescPtr& dstDesc,
+                                 const dnnl::primitive_attr& attr) {
     commonConvertParams = convertParams;
     return true;
 }
@@ -32,5 +33,5 @@ void CommonConvertExecutor::exec(const std::vector<MemoryCPtr>& src, const std::
                 commonConvertParams.size);
 }
 
-} // namespace intel_cpu
-} // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/common/ref_convert.hpp b/src/plugins/intel_cpu/src/nodes/executors/common/ref_convert.hpp
index 337d377f3b3339..4bc3a709d2bcd2 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/common/ref_convert.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/common/ref_convert.hpp
@@ -15,9 +15,11 @@ class CommonConvertExecutor : public ConvertExecutor {
     bool init(const ConvertParams& convertParams,
               const MemoryDescPtr& srcDesc,
               const MemoryDescPtr& dstDesc,
-              const dnnl::primitive_attr &attr) override;
+              const dnnl::primitive_attr& attr) override;
     void exec(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst) override;
-    impl_desc_type implType() const override { return implDescType; };
+    impl_desc_type implType() const override {
+        return implDescType;
+    };
     static bool isSupported(ov::element::Type srcPrc, ov::element::Type dstPrc);
 
 protected:
@@ -26,7 +28,6 @@ class CommonConvertExecutor : public ConvertExecutor {
     const ExecutorContext::CPtr convertContext;
 };
 
-
 class CommonConvertExecutorBuilder : public ConvertExecutorBuilder {
 public:
     ~CommonConvertExecutorBuilder() = default;
@@ -40,5 +41,5 @@ class CommonConvertExecutorBuilder : public ConvertExecutorBuilder {
     }
 };
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/common/ref_opt_transpose.cpp b/src/plugins/intel_cpu/src/nodes/executors/common/ref_opt_transpose.cpp
index 0e1d43b48f6224..dd0cea3d238a4e 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/common/ref_opt_transpose.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/common/ref_opt_transpose.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "ref_opt_transpose.hpp"
+
 #include "openvino/core/parallel.hpp"
 
 namespace ov {
@@ -26,21 +27,15 @@ void transpose_to_0312(const int MB, const MemoryCPtr& srcMemPtr, MemoryPtr& dst
 
     parallel_for3d(MB, DIM1, DIM2, [&](const int n, const int dim1, const int dim2) {
         for (int dim3 = 0; dim3 < DIM3; ++dim3) {
-            const int src_off = n * DIM1 * DIM2 * DIM3 +
-                                dim1 * DIM2 * DIM3 +
-                                dim2 * DIM3 +
-                                dim3;
-            const int dst_off = n * DIM1 * DIM2 * DIM3 +
-                                dim3 * DIM1 * DIM2 +
-                                dim1 * DIM2 +
-                                dim2;
+            const int src_off = n * DIM1 * DIM2 * DIM3 + dim1 * DIM2 * DIM3 + dim2 * DIM3 + dim3;
+            const int dst_off = n * DIM1 * DIM2 * DIM3 + dim3 * DIM1 * DIM2 + dim1 * DIM2 + dim2;
 
             dst_data[dst_off] = src_data[src_off];
         }
     });
 }
 
-template<typename T>
+template <typename T>
 void transpose_to_04123(const int MB, const MemoryCPtr& srcMemPtr, MemoryPtr& dstMemPtr) {
     const auto src_data = srcMemPtr->getDataAs<const T>();
     auto dst_data = dstMemPtr->getDataAs<T>();
@@ -52,23 +47,17 @@ void transpose_to_04123(const int MB, const MemoryCPtr& srcMemPtr, MemoryPtr& ds
 
     parallel_for4d(MB, DIM1, DIM2, DIM3, [&](const int n, const int dim1, const int dim2, const int dim3) {
         for (int dim4 = 0; dim4 < DIM4; ++dim4) {
-            const int src_off = n * DIM1 * DIM2 * DIM3 * DIM4 +
-                                dim1 * DIM2 * DIM3 * DIM4 +
-                                dim2 * DIM3 * DIM4 +
-                                dim3 * DIM4 +
-                                dim4;
-            const int dst_off = n * DIM1 * DIM2 * DIM3 * DIM4 +
-                                dim4 * DIM1 * DIM2 * DIM3 +
-                                dim1 * DIM2 * DIM3 +
-                                dim2 * DIM3 +
-                                dim3;
+            const int src_off =
+                n * DIM1 * DIM2 * DIM3 * DIM4 + dim1 * DIM2 * DIM3 * DIM4 + dim2 * DIM3 * DIM4 + dim3 * DIM4 + dim4;
+            const int dst_off =
+                n * DIM1 * DIM2 * DIM3 * DIM4 + dim4 * DIM1 * DIM2 * DIM3 + dim1 * DIM2 * DIM3 + dim2 * DIM3 + dim3;
 
             dst_data[dst_off] = src_data[src_off];
         }
     });
 }
 
-template<typename T>
+template <typename T>
 void transpose_to_051234(const int MB, const MemoryCPtr& srcMemPtr, MemoryPtr& dstMemPtr) {
     const auto src_data = srcMemPtr->getDataAs<const T>();
     auto dst_data = dstMemPtr->getDataAs<T>();
@@ -79,61 +68,61 @@ void transpose_to_051234(const int MB, const MemoryCPtr& srcMemPtr, MemoryPtr& d
     const int DIM4 = srcMemPtr->getStaticDims()[4];
     const int DIM5 = srcMemPtr->getStaticDims()[5];
 
-    parallel_for5d(MB, DIM1, DIM2, DIM3, DIM4, [&](const int n, const int dim1, const int dim2, const int dim3, const int dim4) {
-        for (int dim5 = 0; dim5 < DIM5; ++dim5) {
-            const int src_off = n * DIM1 * DIM2 * DIM3 * DIM4 * DIM5 +
-                                dim1 * DIM2 * DIM3 * DIM4 * DIM5 +
-                                dim2 * DIM3 * DIM4 * DIM5 +
-                                dim3 * DIM4 * DIM5 +
-                                dim4 * DIM5 +
-                                dim5;
-            const int dst_off = n * DIM5 * DIM1 * DIM2 * DIM3 * DIM4 +
-                                dim5 * DIM1 * DIM2 * DIM3 * DIM4 +
-                                dim1 * DIM2 * DIM3 * DIM4 +
-                                dim2 * DIM3 * DIM4 +
-                                dim3 * DIM4 +
-                                dim4;
-
-            dst_data[dst_off] = src_data[src_off];
-        }
-    });
+    parallel_for5d(MB,
+                   DIM1,
+                   DIM2,
+                   DIM3,
+                   DIM4,
+                   [&](const int n, const int dim1, const int dim2, const int dim3, const int dim4) {
+                       for (int dim5 = 0; dim5 < DIM5; ++dim5) {
+                           const int src_off = n * DIM1 * DIM2 * DIM3 * DIM4 * DIM5 + dim1 * DIM2 * DIM3 * DIM4 * DIM5 +
+                                               dim2 * DIM3 * DIM4 * DIM5 + dim3 * DIM4 * DIM5 + dim4 * DIM5 + dim5;
+                           const int dst_off = n * DIM5 * DIM1 * DIM2 * DIM3 * DIM4 + dim5 * DIM1 * DIM2 * DIM3 * DIM4 +
+                                               dim1 * DIM2 * DIM3 * DIM4 + dim2 * DIM3 * DIM4 + dim3 * DIM4 + dim4;
+
+                           dst_data[dst_off] = src_data[src_off];
+                       }
+                   });
 }
 
-template<typename T>
+template <typename T>
 struct TransposeOptimizedEmitter {
     void operator()(TransposeContext& ctx) {
         switch (ctx.srcMemPtr->getStaticDims().size()) {
-            case 4:
-                transpose_to_0312<T>(ctx.MB, ctx.srcMemPtr, ctx.dstMemPtr);
-                break;
-            case 5:
-                transpose_to_04123<T>(ctx.MB, ctx.srcMemPtr, ctx.dstMemPtr);
-                break;
-            case 6:
-                transpose_to_051234<T>(ctx.MB, ctx.srcMemPtr, ctx.dstMemPtr);
-                break;
-            default:
-                OPENVINO_THROW("Transpose supports optimized execution with only 4D, 5D and 6D shapes");
+        case 4:
+            transpose_to_0312<T>(ctx.MB, ctx.srcMemPtr, ctx.dstMemPtr);
+            break;
+        case 5:
+            transpose_to_04123<T>(ctx.MB, ctx.srcMemPtr, ctx.dstMemPtr);
+            break;
+        case 6:
+            transpose_to_051234<T>(ctx.MB, ctx.srcMemPtr, ctx.dstMemPtr);
+            break;
+        default:
+            OPENVINO_THROW("Transpose supports optimized execution with only 4D, 5D and 6D shapes");
         }
     }
 };
-}   // namespace
+}  // namespace
 void RefOptimizedTransposeExecutor::exec(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst) {
     const size_t dataSize = src[0]->getDesc().getPrecision().size();
     const int MB = src[0]->getStaticDims()[0];
     TransposeContext ctx = {src[0], dst[0], MB};
-    OV_SWITCH(intel_cpu, TransposeOptimizedEmitter, ctx, dataSize,
+    OV_SWITCH(intel_cpu,
+              TransposeOptimizedEmitter,
+              ctx,
+              dataSize,
               OV_CASE(1u, element_type_traits<ov::element::u8>::value_type),
               OV_CASE(2u, element_type_traits<ov::element::u16>::value_type),
               OV_CASE(4u, element_type_traits<ov::element::i32>::value_type));
 }
 
-bool RefOptimizedTransposeExecutor::init(const TransposeParams &transposeParams,
-                                const std::vector<MemoryDescPtr> &srcDescs,
-                                const std::vector<MemoryDescPtr> &dstDescs,
-                                const dnnl::primitive_attr &attr) {
+bool RefOptimizedTransposeExecutor::init(const TransposeParams& transposeParams,
+                                         const std::vector<MemoryDescPtr>& srcDescs,
+                                         const std::vector<MemoryDescPtr>& dstDescs,
+                                         const dnnl::primitive_attr& attr) {
     return true;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/common/ref_opt_transpose.hpp b/src/plugins/intel_cpu/src/nodes/executors/common/ref_opt_transpose.hpp
index be420bfb009e5a..65da099caa0f33 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/common/ref_opt_transpose.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/common/ref_opt_transpose.hpp
@@ -13,12 +13,14 @@ class RefOptimizedTransposeExecutor : public TransposeExecutor {
 public:
     using TransposeExecutor::TransposeExecutor;
 
-    bool init(const TransposeParams &transposeParams,
-              const std::vector<MemoryDescPtr> &srcDescs,
-              const std::vector<MemoryDescPtr> &dstDescs,
-              const dnnl::primitive_attr &attr) override;
-    void exec(const std::vector<MemoryCPtr> &src, const std::vector<MemoryPtr> &dst) override;
-    impl_desc_type implType() const override { return impl_desc_type::ref; }
+    bool init(const TransposeParams& transposeParams,
+              const std::vector<MemoryDescPtr>& srcDescs,
+              const std::vector<MemoryDescPtr>& dstDescs,
+              const dnnl::primitive_attr& attr) override;
+    void exec(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst) override;
+    impl_desc_type implType() const override {
+        return impl_desc_type::ref;
+    }
 };
 
 class RefOptimizedTransposeExecutorBuilder : public TransposeExecutorBuilder {
@@ -27,12 +29,13 @@ class RefOptimizedTransposeExecutorBuilder : public TransposeExecutorBuilder {
                      const std::vector<MemoryDescPtr>& srcDescs,
                      const std::vector<MemoryDescPtr>& dstDescs) const override {
         static const std::vector<std::vector<size_t>> optimizedOrders = {
-                std::vector<size_t>{0, 3, 1, 2},
-                std::vector<size_t>{0, 4, 1, 2, 3},
-                std::vector<size_t>{0, 5, 1, 2, 3, 4},
+            std::vector<size_t>{0, 3, 1, 2},
+            std::vector<size_t>{0, 4, 1, 2, 3},
+            std::vector<size_t>{0, 5, 1, 2, 3, 4},
         };
         if (srcDescs[0]->hasLayoutType(LayoutType::ncsp) &&
-            std::find(optimizedOrders.begin(), optimizedOrders.end(), transposeParams.permuteParams.order) != optimizedOrders.end()) {
+            std::find(optimizedOrders.begin(), optimizedOrders.end(), transposeParams.permuteParams.order) !=
+                optimizedOrders.end()) {
             return true;
         }
         DEBUG_LOG("RefOptimizedTransposeExecutor is not supported, because passed order is not optimized");
@@ -44,5 +47,5 @@ class RefOptimizedTransposeExecutorBuilder : public TransposeExecutorBuilder {
     }
 };
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/common/ref_transpose.cpp b/src/plugins/intel_cpu/src/nodes/executors/common/ref_transpose.cpp
index 8db8798ef8eaff..1716f008027fe9 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/common/ref_transpose.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/common/ref_transpose.cpp
@@ -3,8 +3,9 @@
 //
 
 #include "ref_transpose.hpp"
-#include "openvino/core/parallel.hpp"
+
 #include "nodes/common/cpu_memcpy.h"
+#include "openvino/core/parallel.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -27,7 +28,10 @@ static inline void parallel_step(size_t nDims, const VectorDims& dims, VectorDim
     }
 }
 
-void RefTransposeExecutor::referenceExecute(const uint8_t* src_data, uint8_t* dst_data, jit_permute_config_params jcp, const int mb) {
+void RefTransposeExecutor::referenceExecute(const uint8_t* src_data,
+                                            uint8_t* dst_data,
+                                            jit_permute_config_params jcp,
+                                            const int mb) {
     VectorDims dst_dims = jcp.dst_block_dims;
     const VectorDims dst_strides = jcp.dst_strides;
     const VectorDims src_strides = jcp.src_strides;
@@ -70,13 +74,13 @@ void RefTransposeExecutor::exec(const std::vector<MemoryCPtr>& src, const std::v
     referenceExecute(src_data, dst_data, jcp, MB);
 }
 
-bool RefTransposeExecutor::init(const TransposeParams &transposeParams,
-                                const std::vector<MemoryDescPtr> &srcDescs,
-                                const std::vector<MemoryDescPtr> &dstDescs,
-                                const dnnl::primitive_attr &attr) {
+bool RefTransposeExecutor::init(const TransposeParams& transposeParams,
+                                const std::vector<MemoryDescPtr>& srcDescs,
+                                const std::vector<MemoryDescPtr>& dstDescs,
+                                const dnnl::primitive_attr& attr) {
     jcp = TransposeExecutor::prepareParams(transposeParams.permuteParams);
     return true;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/common/ref_transpose.hpp b/src/plugins/intel_cpu/src/nodes/executors/common/ref_transpose.hpp
index 206d610368a9df..00c1602c0bd119 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/common/ref_transpose.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/common/ref_transpose.hpp
@@ -11,13 +11,19 @@ namespace intel_cpu {
 class RefTransposeExecutor : public TransposeExecutor {
 public:
     using TransposeExecutor::TransposeExecutor;
-    static void referenceExecute(const uint8_t* src_data, uint8_t* dst_data, jit_permute_config_params jcp, const int mb);
-    bool init(const TransposeParams &transposeParams,
-              const std::vector<MemoryDescPtr> &srcDescs,
-              const std::vector<MemoryDescPtr> &dstDescs,
-              const dnnl::primitive_attr &attr) override;
-    void exec(const std::vector<MemoryCPtr> &src, const std::vector<MemoryPtr> &dst) override;
-    impl_desc_type implType() const override { return impl_desc_type::ref; }
+    static void referenceExecute(const uint8_t* src_data,
+                                 uint8_t* dst_data,
+                                 jit_permute_config_params jcp,
+                                 const int mb);
+    bool init(const TransposeParams& transposeParams,
+              const std::vector<MemoryDescPtr>& srcDescs,
+              const std::vector<MemoryDescPtr>& dstDescs,
+              const dnnl::primitive_attr& attr) override;
+    void exec(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst) override;
+    impl_desc_type implType() const override {
+        return impl_desc_type::ref;
+    }
+
 private:
     jit_permute_config_params jcp;
 };
@@ -35,5 +41,5 @@ class RefTransposeExecutorBuilder : public TransposeExecutorBuilder {
     }
 };
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/convert.cpp b/src/plugins/intel_cpu/src/nodes/executors/convert.cpp
index c8d7ce8addaf22..32141d53b10ee5 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/convert.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/convert.cpp
@@ -4,4 +4,5 @@
 
 #include "convert.hpp"
 
-ov::intel_cpu::ConvertExecutor::ConvertExecutor(const ov::intel_cpu::ExecutorContext::CPtr context) : convertContext(context) {}
\ No newline at end of file
+ov::intel_cpu::ConvertExecutor::ConvertExecutor(const ov::intel_cpu::ExecutorContext::CPtr context)
+    : convertContext(context) {}
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/convert.hpp b/src/plugins/intel_cpu/src/nodes/executors/convert.hpp
index ce766663a0b653..dcb0bdde2ce219 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/convert.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/convert.hpp
@@ -5,8 +5,8 @@
 #pragma once
 
 #include "cpu_memory.h"
-#include "onednn/iml_type_mapper.h"
 #include "executor.hpp"
+#include "onednn/iml_type_mapper.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -24,8 +24,9 @@ class ConvertExecutor : public Executor {
     virtual bool init(const ConvertParams& convertParams,
                       const MemoryDescPtr& srcDesc,
                       const MemoryDescPtr& dstDesc,
-                      const dnnl::primitive_attr &attr) = 0;
+                      const dnnl::primitive_attr& attr) = 0;
     virtual ~ConvertExecutor() = default;
+
 protected:
     ConvertParams convertParams;
     const ExecutorContext::CPtr convertContext;
@@ -45,5 +46,5 @@ class ConvertExecutorBuilder {
 using ConvertExecutorBuilderPtr = std::shared_ptr<ConvertExecutorBuilder>;
 using ConvertExecutorBuilderCPtr = std::shared_ptr<const ConvertExecutorBuilder>;
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/convert_list.cpp b/src/plugins/intel_cpu/src/nodes/executors/convert_list.cpp
index 504c310ca15124..5375bd21166cc4 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/convert_list.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/convert_list.cpp
@@ -9,9 +9,8 @@ namespace intel_cpu {
 
 const std::vector<ConvertExecutorDesc>& getConvertExecutorsList() {
     static std::vector<ConvertExecutorDesc> descs = {
-            OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<ACLConvertExecutorBuilder>())
-            OV_CPU_INSTANCE_COMMON(ExecutorType::Common, std::make_shared<CommonConvertExecutorBuilder>())
-    };
+        OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<ACLConvertExecutorBuilder>())
+            OV_CPU_INSTANCE_COMMON(ExecutorType::Common, std::make_shared<CommonConvertExecutorBuilder>())};
 
     return descs;
 }
@@ -45,5 +44,5 @@ ConvertExecutorPtr ConvertExecutorFactory::makeExecutor(const ConvertParams& con
     OPENVINO_THROW("Supported executor is not found");
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/convert_list.hpp b/src/plugins/intel_cpu/src/nodes/executors/convert_list.hpp
index a7ed05ceb634e4..9ea47f916d859f 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/convert_list.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/convert_list.hpp
@@ -4,17 +4,15 @@
 
 #pragma once
 
-#include "executor.hpp"
-
 #include "convert.hpp"
+#include "executor.hpp"
 #if defined(OV_CPU_WITH_ACL)
-#include "acl/acl_convert.hpp"
+#    include "acl/acl_convert.hpp"
 #endif
 
+#include "common/primitive_cache.hpp"
 #include "common/ref_convert.hpp"
-
 #include "onednn/iml_type_mapper.h"
-#include "common/primitive_cache.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -31,7 +29,8 @@ class ConvertExecutorFactory : public ExecutorFactoryLegacy {
     ConvertExecutorFactory(const ConvertParams& convertParams,
                            const MemoryDescPtr& srcDesc,
                            const MemoryDescPtr& dstDesc,
-                           const ExecutorContext::CPtr context) : ExecutorFactoryLegacy(context) {
+                           const ExecutorContext::CPtr context)
+        : ExecutorFactoryLegacy(context) {
         for (auto& desc : getConvertExecutorsList()) {
             if (desc.builder->isSupported(convertParams, srcDesc, dstDesc)) {
                 supportedDescs.push_back(desc);
@@ -43,7 +42,7 @@ class ConvertExecutorFactory : public ExecutorFactoryLegacy {
     virtual ConvertExecutorPtr makeExecutor(const ConvertParams& convertParams,
                                             const MemoryDescPtr& srcDesc,
                                             const MemoryDescPtr& dstDesc,
-                                            const dnnl::primitive_attr &attr);
+                                            const dnnl::primitive_attr& attr);
 
 private:
     std::vector<ConvertExecutorDesc> supportedDescs;
@@ -53,5 +52,5 @@ class ConvertExecutorFactory : public ExecutorFactoryLegacy {
 using ConvertExecutorFactoryPtr = std::shared_ptr<ConvertExecutorFactory>;
 using ConvertExecutorFactoryCPtr = std::shared_ptr<const ConvertExecutorFactory>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/debug_messages.hpp b/src/plugins/intel_cpu/src/nodes/executors/debug_messages.hpp
index 26ae6ace59631b..222779a00ee18f 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/debug_messages.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/debug_messages.hpp
@@ -4,25 +4,25 @@
 
 #pragma once
 
-#define UNSUPPORTED_SPARSE_WEIGHTS " sparse weights are not supported"
+#define UNSUPPORTED_SPARSE_WEIGHTS        " sparse weights are not supported"
 #define UNSUPPORTED_WEIGHTS_DECOMPRESSION " weights decompression is not supported"
-#define UNSUPPORTED_POST_OPS " post ops are not supported"
-#define UNSUPPORTED_NUMBER_OF_POSTOPS " the number of post ops is not supported"
-#define UNSUPPORTED_TYPE_OF_POSTOPS " the type of post ops is not supported"
-#define UNSUPPORTED_SRC_PRECISIONS " unsupported src precisions"
-#define UNSUPPORTED_WEI_PRECISIONS " unsupported wei precisions"
-#define UNSUPPORTED_DST_PRECISIONS " unsupported dst precisions"
-#define UNSUPPORTED_ISA " unsupported isa"
-#define UNSUPPORTED_SRC_RANK " unsupported src rank"
-#define UNSUPPORTED_WEI_RANK " unsupported wei rank"
-#define UNSUPPORTED_DST_RANK " unsupported dst rank"
-#define UNSUPPORTED_DST_STRIDES " unsupported dst strides"
-#define HEURISTICS_MISMATCH " heuristics mismatch"
+#define UNSUPPORTED_POST_OPS              " post ops are not supported"
+#define UNSUPPORTED_NUMBER_OF_POSTOPS     " the number of post ops is not supported"
+#define UNSUPPORTED_TYPE_OF_POSTOPS       " the type of post ops is not supported"
+#define UNSUPPORTED_SRC_PRECISIONS        " unsupported src precisions"
+#define UNSUPPORTED_WEI_PRECISIONS        " unsupported wei precisions"
+#define UNSUPPORTED_DST_PRECISIONS        " unsupported dst precisions"
+#define UNSUPPORTED_ISA                   " unsupported isa"
+#define UNSUPPORTED_SRC_RANK              " unsupported src rank"
+#define UNSUPPORTED_WEI_RANK              " unsupported wei rank"
+#define UNSUPPORTED_DST_RANK              " unsupported dst rank"
+#define UNSUPPORTED_DST_STRIDES           " unsupported dst strides"
+#define HEURISTICS_MISMATCH               " heuristics mismatch"
 
-#define VERIFY(condition, ...) \
-    do { \
-        if (!(condition)) { \
+#define VERIFY(condition, ...)      \
+    do {                            \
+        if (!(condition)) {         \
             DEBUG_LOG(__VA_ARGS__); \
-            return false; \
-        } \
+            return false;           \
+        }                           \
     } while (0)
diff --git a/src/plugins/intel_cpu/src/nodes/executors/deconv.cpp b/src/plugins/intel_cpu/src/nodes/executors/deconv.cpp
index 23e0910bd0c82c..e485815e950af4 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/deconv.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/deconv.cpp
@@ -5,8 +5,5 @@
 #include "deconv.hpp"
 
 namespace ov {
-namespace intel_cpu {
-
-
-}   // namespace intel_cpu
-}   // namespace ov
+namespace intel_cpu {}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/deconv.hpp b/src/plugins/intel_cpu/src/nodes/executors/deconv.hpp
index c632cc0cf99ad1..11920c0ab35b49 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/deconv.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/deconv.hpp
@@ -34,11 +34,11 @@ class DeconvExecutor {
     virtual bool init(const DeconvAttrs& deconvAttrs,
                       const std::vector<MemoryDescPtr>& srcDescs,
                       const std::vector<MemoryDescPtr>& dstDescs,
-                      const dnnl::primitive_attr &attr) = 0;
+                      const dnnl::primitive_attr& attr) = 0;
 
     virtual void exec(const std::vector<MemoryCPtr>& src,
                       const std::vector<MemoryPtr>& dst,
-                      const void *post_ops_data_) = 0;
+                      const void* post_ops_data_) = 0;
     virtual ~DeconvExecutor() = default;
     virtual impl_desc_type getImplType() const = 0;
 
@@ -53,12 +53,14 @@ using DeconvExecutorCPtr = std::shared_ptr<const DeconvExecutor>;
 class DeconvExecutorBuilder {
 public:
     ~DeconvExecutorBuilder() = default;
-    virtual bool isSupported(const DeconvAttrs& convAttrs, const std::vector<MemoryDescPtr>& srcDescs, const std::vector<MemoryDescPtr>& dstDescs) const = 0;
+    virtual bool isSupported(const DeconvAttrs& convAttrs,
+                             const std::vector<MemoryDescPtr>& srcDescs,
+                             const std::vector<MemoryDescPtr>& dstDescs) const = 0;
     virtual DeconvExecutorPtr makeExecutor(const ExecutorContext::CPtr context) const = 0;
 };
 
 using DeconvExecutorBuilderPtr = std::shared_ptr<DeconvExecutorBuilder>;
 using DeconvExecutorBuilderCPtr = std::shared_ptr<const DeconvExecutorBuilder>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/deconv_list.cpp b/src/plugins/intel_cpu/src/nodes/executors/deconv_list.cpp
index f5b897c2d1b6e1..c093057e47413f 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/deconv_list.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/deconv_list.cpp
@@ -9,11 +9,10 @@ namespace intel_cpu {
 
 const std::vector<DeconvExecutorDesc>& getDeconvExecutorsList() {
     static std::vector<DeconvExecutorDesc> descs = {
-            OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<AclDeconvExecutorBuilder>())
-    };
+        OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<AclDeconvExecutorBuilder>())};
 
     return descs;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/deconv_list.hpp b/src/plugins/intel_cpu/src/nodes/executors/deconv_list.hpp
index 4c63a565aac2e0..fd114094303808 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/deconv_list.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/deconv_list.hpp
@@ -4,15 +4,14 @@
 
 #pragma once
 
-#include "executor.hpp"
-
 #include "deconv.hpp"
+#include "executor.hpp"
 #if defined(OV_CPU_WITH_ACL)
-#include "acl/acl_deconv.hpp"
+#    include "acl/acl_deconv.hpp"
 #endif
 
-#include "onednn/iml_type_mapper.h"
 #include "common/primitive_cache.hpp"
+#include "onednn/iml_type_mapper.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -29,7 +28,8 @@ class DeconvExecutorFactory : public ExecutorFactoryLegacy {
     DeconvExecutorFactory(const DeconvAttrs& deconvAttrs,
                           const std::vector<MemoryDescPtr>& srcDescs,
                           const std::vector<MemoryDescPtr>& dstDescs,
-                          const ExecutorContext::CPtr context) : ExecutorFactoryLegacy(context) {
+                          const ExecutorContext::CPtr context)
+        : ExecutorFactoryLegacy(context) {
         for (auto& desc : getDeconvExecutorsList()) {
             if (desc.builder->isSupported(deconvAttrs, srcDescs, dstDescs)) {
                 supportedDescs.push_back(desc);
@@ -41,7 +41,7 @@ class DeconvExecutorFactory : public ExecutorFactoryLegacy {
     virtual DeconvExecutorPtr makeExecutor(const DeconvAttrs& deconvAttrs,
                                            const std::vector<MemoryDescPtr>& srcDescs,
                                            const std::vector<MemoryDescPtr>& dstDescs,
-                                           const dnnl::primitive_attr &attr) {
+                                           const dnnl::primitive_attr& attr) {
         auto build = [&](const DeconvExecutorDesc* desc) {
             auto executor = desc->builder->makeExecutor(context);
             if (executor->init(deconvAttrs, srcDescs, dstDescs, attr)) {
@@ -75,5 +75,5 @@ class DeconvExecutorFactory : public ExecutorFactoryLegacy {
 using DeconvExecutorFactoryPtr = std::shared_ptr<DeconvExecutorFactory>;
 using DeconvExecutorFactoryCPtr = std::shared_ptr<const DeconvExecutorFactory>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_aliases.hpp b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_aliases.hpp
index a611e94f617e44..27fa7dd38d7a99 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_aliases.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_aliases.hpp
@@ -4,8 +4,8 @@
 
 #pragma once
 
-#include <unordered_map>
 #include <dnnl.hpp>
+#include <unordered_map>
 
 namespace ov {
 namespace intel_cpu {
diff --git a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_fullyconnected.hpp b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_fullyconnected.hpp
index 1d078feaa6549b..db5c8bed2e43e1 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_fullyconnected.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_fullyconnected.hpp
@@ -8,10 +8,10 @@
 #include <oneapi/dnnl/dnnl.hpp>
 
 #include "cpu_memory.h"
+#include "memory_desc/cpu_memory_desc_utils.h"
 #include "nodes/executors/dnnl/dnnl_aliases.hpp"
 #include "nodes/executors/dnnl/dnnl_utils.hpp"
 #include "nodes/executors/executor.hpp"
-#include "memory_desc/cpu_memory_desc_utils.h"
 #include "nodes/executors/memory_arguments.hpp"
 #include "post_ops.hpp"
 
@@ -123,7 +123,8 @@ class DnnlFCExecutor : public Executor {
         if (currentPrimitive && currentPrimitive->weightsDesc()->isCompatible(*newPrimMemDesc))
             return;
 
-        originalMemDesc = Primitive::makeTransposedWeightDescriptor(originalMemDesc, newPrimMemDesc, m_attrs.weightsNonTransposed);
+        originalMemDesc =
+            Primitive::makeTransposedWeightDescriptor(originalMemDesc, newPrimMemDesc, m_attrs.weightsNonTransposed);
 
         const auto weiMemory = utils::prepareWeightsMemory(originalMemDesc, newPrimMemDesc, memory, m_context, true);
         m_primArgs[DNNL_ARG_WEIGHTS] = weiMemory->getPrimitive();
@@ -143,9 +144,7 @@ class DnnlFCExecutor : public Executor {
         m_primArgs[DNNL_ARG_SCRATCHPAD] = m_scratchPadMemory->getPrimitive();
     }
 
-    void updateMemory(const PrimitivePtr currentPrimitive,
-                      const PrimitivePtr newPrimitive,
-                      const MemoryArgs& memory) {
+    void updateMemory(const PrimitivePtr currentPrimitive, const PrimitivePtr newPrimitive, const MemoryArgs& memory) {
         const auto& srcDesc = MemoryDescUtils::convertToDnnlMemoryDesc(memory.at(ARG_SRC)->getDescPtr());
         const auto& weiDesc = MemoryDescUtils::convertToDnnlMemoryDesc(memory.at(ARG_WEI)->getDescPtr());
         const auto& dstDesc = MemoryDescUtils::convertToDnnlMemoryDesc(memory.at(ARG_DST)->getDescPtr());
diff --git a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_fullyconnected_primitive.cpp b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_fullyconnected_primitive.cpp
index 780dbb6f2f3f11..52434a1eeb8461 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_fullyconnected_primitive.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_fullyconnected_primitive.cpp
@@ -74,9 +74,8 @@ bool DnnlFCPrimitive::Key::operator==(const Key& rhs) const {
         result = result && dst && rhs.dst && dst->getDnnlDesc() == rhs.dst->getDnnlDesc();
     }
 
-    result = result && *attr.get() == *rhs.attr.get() &&
-        sparseWeights == rhs.sparseWeights &&
-        modelType == rhs.modelType;
+    result =
+        result && *attr.get() == *rhs.attr.get() && sparseWeights == rhs.sparseWeights && modelType == rhs.modelType;
 
     return result;
 }
@@ -158,7 +157,8 @@ static bool useDynamicQuantizationImpl(size_t dqGroupSize,
     if (srcDesc->getPrecision() != ov::element::f32)
         return false;
 
-    MemoryCPtr zpPtr = memory.count(ARG_WEI | ARG_ATTR_ZERO_POINTS) ? memory.at(ARG_WEI | ARG_ATTR_ZERO_POINTS) : nullptr;
+    MemoryCPtr zpPtr =
+        memory.count(ARG_WEI | ARG_ATTR_ZERO_POINTS) ? memory.at(ARG_WEI | ARG_ATTR_ZERO_POINTS) : nullptr;
     // For dynamic quantization, VNNI accumulation requires weight to be unsigned.
     // To support dynamic quantization with weights symmetrically quantized as i8/i4
     // w/o zero-point, we will transform weight to u8/u4 weight with zp 128/8.
@@ -220,14 +220,8 @@ static DnnlPrimitiveAttrs createPrimitiveAttrs(const FCAttrs& attrs,
         one_of(srcDesc->getPrecision(), ov::element::u8, ov::element::i8) && weiDesc->getPrecision() == ov::element::i8;
     auto outputDataType = DnnlExtensionUtils::ElementTypeToDataType(dstDesc->getPrecision());
 
-    DnnlPostOpsComposer dnnlpoc(postOps,
-                                context->getEngine(),
-                                dims,
-                                dims.size() - 1,
-                                isINT8,
-                                1 << 0,
-                                memory,
-                                outputDataType);
+    DnnlPostOpsComposer
+        dnnlpoc(postOps, context->getEngine(), dims, dims.size() - 1, isINT8, 1 << 0, memory, outputDataType);
 
     if (memory.count(ARG_WEI | ARG_ATTR_SCALES)) {
         auto dstPrc = memory.at(ARG_WEI | ARG_ATTR_SCALES)->getPrecision();
@@ -239,7 +233,9 @@ static DnnlPrimitiveAttrs createPrimitiveAttrs(const FCAttrs& attrs,
 
     if (memory.count(ARG_WEI | ARG_ATTR_ZERO_POINTS)) {
         auto dstPrc = useDynamicQuantization ? ov::element::u8 : ov::element::f32;
-        dnnlpoc.appendDecompressionZeroPoints(memory.at(ARG_WEI | ARG_ATTR_ZERO_POINTS), !attrs.weightsNonTransposed, dstPrc);
+        dnnlpoc.appendDecompressionZeroPoints(memory.at(ARG_WEI | ARG_ATTR_ZERO_POINTS),
+                                              !attrs.weightsNonTransposed,
+                                              dstPrc);
     }
 
     if (useDynamicQuantization) {
diff --git a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_matmul_primitive.cpp b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_matmul_primitive.cpp
index 40c365ee5f4da5..86b22607111833 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_matmul_primitive.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_matmul_primitive.cpp
@@ -129,14 +129,8 @@ static DnnlPrimitiveAttrs createPrimitiveAttrs(const MatMulAttrs& attrs,
         one_of(srcDesc->getPrecision(), ov::element::u8, ov::element::i8) && weiDesc->getPrecision() == ov::element::i8;
     auto outputDataType = DnnlExtensionUtils::ElementTypeToDataType(dstDesc->getPrecision());
 
-    DnnlPostOpsComposer dnnlpoc(postOps,
-                                context->getEngine(),
-                                dims,
-                                dims.size() - 1,
-                                isINT8,
-                                1 << 0,
-                                memory,
-                                outputDataType);
+    DnnlPostOpsComposer
+        dnnlpoc(postOps, context->getEngine(), dims, dims.size() - 1, isINT8, 1 << 0, memory, outputDataType);
 
     return dnnlpoc.compose();
 }
@@ -185,8 +179,7 @@ static dnnl::matmul::primitive_desc createDescriptorInternal(const dnnl::memory:
         wdt = memory::data_type::s8;
     }
 
-    const dnnl::memory::desc weightsDesc =
-        dnnl::memory::desc(weiDims, wdt, memory::format_tag::any);
+    const dnnl::memory::desc weightsDesc = dnnl::memory::desc(weiDims, wdt, memory::format_tag::any);
 
     return dnnl::matmul::primitive_desc(engine, inputsDesc, weightsDesc, newBiasDesc, outputsDesc, attr);
 }
@@ -335,7 +328,8 @@ DnnlMatMulPrimitive::DnnlMatMulPrimitive(const Key& key,
       m_prim(primitive(m_primDesc)) {}
 
 void DnnlMatMulPrimitive::execute(const dnnl_primitive_args& primArgs) const {
-    std::cout << "Executing MM primitive" << "\n";
+    std::cout << "Executing MM primitive"
+              << "\n";
     m_prim.execute(m_stream, primArgs);
 }
 
diff --git a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_shape_agnostic_data.hpp b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_shape_agnostic_data.hpp
index d76e1984bd87d9..6a1b128be307ce 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_shape_agnostic_data.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_shape_agnostic_data.hpp
@@ -12,8 +12,7 @@ namespace ov {
 namespace intel_cpu {
 
 struct DnnlShapeAgnosticData {
-    DnnlShapeAgnosticData(DnnlPrimitiveAttrs primAttrs)
-        : primAttrs(std::move(primAttrs)) {}
+    DnnlShapeAgnosticData(DnnlPrimitiveAttrs primAttrs) : primAttrs(std::move(primAttrs)) {}
 
     DnnlPrimitiveAttrs primAttrs;
 };
diff --git a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_utils.cpp b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_utils.cpp
index fa273ac3d6c3ff..f23fd317d3546d 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_utils.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/dnnl/dnnl_utils.cpp
@@ -8,8 +8,8 @@
 #include <oneapi/dnnl/dnnl.hpp>
 
 #include "cpu_memory.h"
-#include "memory_desc/dnnl_memory_desc.h"
 #include "memory_desc/cpu_memory_desc_utils.h"
+#include "memory_desc/dnnl_memory_desc.h"
 #include "nodes/executors/executor.hpp"
 #include "nodes/reorder.h"
 #include "utils/cpu_utils.hpp"
@@ -79,9 +79,9 @@ MemoryPtr prepareWeightsMemory(const DnnlMemoryDescPtr srcWeightDesc,
 
     auto globalWeightCache = context->getWeightsCache();
     MemoryPtr ptr;
-    if (globalWeightCache &&
-        dnnl::memory::format_kind::blocked == dstWeightDesc->getDnnlDesc().get_format_kind()) {
-        ptr = *globalWeightCache->findOrCreate(DnnlExtensionUtils::computeWeightsStringHash(weightsMem, dstWeightDesc), create);
+    if (globalWeightCache && dnnl::memory::format_kind::blocked == dstWeightDesc->getDnnlDesc().get_format_kind()) {
+        ptr = *globalWeightCache->findOrCreate(DnnlExtensionUtils::computeWeightsStringHash(weightsMem, dstWeightDesc),
+                                               create);
     } else {
         ptr = create();
     }
diff --git a/src/plugins/intel_cpu/src/nodes/executors/eltwise.cpp b/src/plugins/intel_cpu/src/nodes/executors/eltwise.cpp
index 12bce382424e5c..8e7c470984b4f2 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/eltwise.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/eltwise.cpp
@@ -9,5 +9,5 @@ namespace intel_cpu {
 
 EltwiseExecutor::EltwiseExecutor(const ExecutorContext::CPtr context) : context(context) {}
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/eltwise.hpp b/src/plugins/intel_cpu/src/nodes/executors/eltwise.hpp
index 4b1271c49d5df0..b33c0eca10dae7 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/eltwise.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/eltwise.hpp
@@ -5,8 +5,8 @@
 #pragma once
 
 #include "cpu_memory.h"
-#include "onednn/iml_type_mapper.h"
 #include "executor.hpp"
+#include "onednn/iml_type_mapper.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -19,10 +19,7 @@ struct EltwiseData {
     float gamma;
 
     bool operator==(const EltwiseData& rhs) const noexcept {
-        return algo == rhs.algo &&
-               onednnAlgorithm == rhs.onednnAlgorithm &&
-               alpha == rhs.alpha &&
-               beta == rhs.beta &&
+        return algo == rhs.algo && onednnAlgorithm == rhs.onednnAlgorithm && alpha == rhs.alpha && beta == rhs.beta &&
                gamma == rhs.gamma;
     }
 };
@@ -34,24 +31,21 @@ struct EltwiseAttrs {
     float gamma;
 
     EltwiseAttrs() : algorithm(Algorithm::Default), alpha(0), beta(0), gamma(0) {}
-    EltwiseAttrs(Algorithm algorithm, float alpha, float beta, float gamma) : algorithm(algorithm), alpha(alpha), beta(beta), gamma(gamma) {}
+    EltwiseAttrs(Algorithm algorithm, float alpha, float beta, float gamma)
+        : algorithm(algorithm),
+          alpha(alpha),
+          beta(beta),
+          gamma(gamma) {}
 
     bool operator==(const EltwiseAttrs& rhs) const {
         bool retVal = true;
-        retVal = algorithm == rhs.algorithm &&
-                 alpha == rhs.alpha &&
-                 beta == rhs.beta &&
-                 gamma == rhs.gamma;
+        retVal = algorithm == rhs.algorithm && alpha == rhs.alpha && beta == rhs.beta && gamma == rhs.gamma;
 
         return retVal;
     }
 };
 
-enum class EltwisePostOpType {
-    Undefined,
-    Eltwise,
-    Dnnl
-};
+enum class EltwisePostOpType { Undefined, Eltwise, Dnnl };
 
 class EltwisePostOp {
 public:
@@ -72,17 +66,20 @@ class EltwisePostOp {
 
     EltwisePostOpType type = EltwisePostOpType::Undefined;
 
-    bool operator==(const EltwisePostOp &rhs) const {
-        if (type != rhs.type) { return false; }
+    bool operator==(const EltwisePostOp& rhs) const {
+        if (type != rhs.type) {
+            return false;
+        }
         bool ret = true;
         switch (type) {
-            case EltwisePostOpType::Eltwise:
-                ret = eltwise == rhs.eltwise;
-                break;
-            case EltwisePostOpType::Dnnl:
-                ret = dnnlPostOps == rhs.dnnlPostOps;
-                break;
-            default: assert(!"unsupported eltwise post operation type");
+        case EltwisePostOpType::Eltwise:
+            ret = eltwise == rhs.eltwise;
+            break;
+        case EltwisePostOpType::Dnnl:
+            ret = dnnlPostOps == rhs.dnnlPostOps;
+            break;
+        default:
+            assert(!"unsupported eltwise post operation type");
         }
         return ret;
     }
@@ -96,7 +93,9 @@ class EltwiseExecutor {
                       const std::vector<MemoryDescPtr>& dstDescs,
                       const std::vector<EltwisePostOp>& postOps) = 0;
 
-    virtual void exec(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst, const void *post_ops_data_) = 0;
+    virtual void exec(const std::vector<MemoryCPtr>& src,
+                      const std::vector<MemoryPtr>& dst,
+                      const void* post_ops_data_) = 0;
     virtual ~EltwiseExecutor() = default;
 
     virtual impl_desc_type getImplType() const = 0;
@@ -121,5 +120,5 @@ class EltwiseExecutorBuilder {
 using EltwiseExecutorBuilderPtr = std::shared_ptr<EltwiseExecutorBuilder>;
 using EltwiseExecutorBuilderCPtr = std::shared_ptr<const EltwiseExecutorBuilder>;
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.cpp b/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.cpp
index 1bd6647310d387..5b9479bdf502b6 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.cpp
@@ -10,11 +10,10 @@ namespace intel_cpu {
 const std::vector<EltwiseExecutorDesc>& getEltwiseExecutorsList() {
     static std::vector<EltwiseExecutorDesc> descs = {
         OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<AclEltwiseExecutorBuilder>())
-        OV_CPU_INSTANCE_SHL(ExecutorType::Shl, std::make_shared<ShlEltwiseExecutorBuilder>())
-    };
+            OV_CPU_INSTANCE_SHL(ExecutorType::Shl, std::make_shared<ShlEltwiseExecutorBuilder>())};
 
     return descs;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.hpp b/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.hpp
index 618e3499dc10a7..ac5c27c0ad36dc 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/eltwise_list.hpp
@@ -4,19 +4,18 @@
 
 #pragma once
 
-#include "executor.hpp"
-
 #include "eltwise.hpp"
+#include "executor.hpp"
 #if defined(OV_CPU_WITH_ACL)
-#include "aarch64/jit_eltwise.hpp"
-#include "acl/acl_eltwise.hpp"
+#    include "aarch64/jit_eltwise.hpp"
+#    include "acl/acl_eltwise.hpp"
 #endif
 #if defined(OV_CPU_WITH_SHL)
-#include "shl/shl_eltwise.hpp"
+#    include "shl/shl_eltwise.hpp"
 #endif
 
-#include "onednn/iml_type_mapper.h"
 #include "common/primitive_cache.hpp"
+#include "onednn/iml_type_mapper.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -31,9 +30,10 @@ const std::vector<EltwiseExecutorDesc>& getEltwiseExecutorsList();
 class EltwiseExecutorFactory : public ExecutorFactoryLegacy {
 public:
     EltwiseExecutorFactory(const EltwiseAttrs& eltwiseAttrs,
-                       const std::vector<MemoryDescPtr>& srcDescs,
-                       const std::vector<MemoryDescPtr>& dstDescs,
-                       const ExecutorContext::CPtr context) : ExecutorFactoryLegacy(context) {
+                           const std::vector<MemoryDescPtr>& srcDescs,
+                           const std::vector<MemoryDescPtr>& dstDescs,
+                           const ExecutorContext::CPtr context)
+        : ExecutorFactoryLegacy(context) {
         for (auto& desc : getEltwiseExecutorsList()) {
             if (desc.builder->isSupported(eltwiseAttrs, srcDescs, dstDescs)) {
                 supportedDescs.push_back(desc);
@@ -43,9 +43,9 @@ class EltwiseExecutorFactory : public ExecutorFactoryLegacy {
 
     ~EltwiseExecutorFactory() = default;
     virtual EltwiseExecutorPtr makeExecutor(const EltwiseAttrs& eltwiseAttrs,
-                                        const std::vector<MemoryDescPtr>& srcDescs,
-                                        const std::vector<MemoryDescPtr>& dstDescs,
-                                        const std::vector<EltwisePostOp>& postOps) {
+                                            const std::vector<MemoryDescPtr>& srcDescs,
+                                            const std::vector<MemoryDescPtr>& dstDescs,
+                                            const std::vector<EltwisePostOp>& postOps) {
         auto build = [&](const EltwiseExecutorDesc* desc) {
             auto executor = desc->builder->makeExecutor(context);
             if (executor->init(eltwiseAttrs, srcDescs, dstDescs, postOps)) {
@@ -84,5 +84,5 @@ class EltwiseExecutorFactory : public ExecutorFactoryLegacy {
 using EltwiseExecutorFactoryPtr = std::shared_ptr<EltwiseExecutorFactory>;
 using EltwiseExecutorFactoryCPtr = std::shared_ptr<const EltwiseExecutorFactory>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/executor.cpp b/src/plugins/intel_cpu/src/nodes/executors/executor.cpp
index 236f51c6d16149..399dab3d5499b9 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/executor.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/executor.cpp
@@ -2,15 +2,17 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <string>
-
 #include "executor.hpp"
 
+#include <string>
+
 namespace ov {
 namespace intel_cpu {
 
 std::string ExecutorTypeToString(const ExecutorType type) {
-#define CASE(_type) case ExecutorType::_type: return #_type;
+#define CASE(_type)           \
+    case ExecutorType::_type: \
+        return #_type;
     switch (type) {
         CASE(Undefined);
         CASE(Graph);
@@ -27,7 +29,10 @@ std::string ExecutorTypeToString(const ExecutorType type) {
 }
 
 ExecutorType ExecutorTypeFromString(const std::string& typeStr) {
-#define CASE(_type) if (typeStr == #_type) { return ExecutorType::_type; }
+#define CASE(_type)                 \
+    if (typeStr == #_type) {        \
+        return ExecutorType::_type; \
+    }
     CASE(Undefined);
     CASE(Graph);
     CASE(Common);
@@ -41,5 +46,5 @@ ExecutorType ExecutorTypeFromString(const std::string& typeStr) {
     return ExecutorType::Undefined;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/executor.hpp b/src/plugins/intel_cpu/src/nodes/executors/executor.hpp
index 2016e8f5820dee..16a419c95d5efc 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/executor.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/executor.hpp
@@ -4,15 +4,15 @@
 
 #pragma once
 
-#include "openvino/core/except.hpp"
-#include "openvino/core/visibility.hpp"
 #include <memory>
 
 #include "cache/multi_cache.h"
 #include "cpu_memory.h"
 #include "graph_context.h"
-#include "onednn/iml_type_mapper.h"
 #include "memory_arguments.hpp"
+#include "onednn/iml_type_mapper.h"
+#include "openvino/core/except.hpp"
+#include "openvino/core/visibility.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -24,25 +24,25 @@ namespace intel_cpu {
 #endif
 
 #if defined(OV_CPU_WITH_ACL)
-#   if defined(OPENVINO_ARCH_ARM)
-#       define OV_CPU_INSTANCE_ACL32(...) {__VA_ARGS__},
-#   else
-#       define OV_CPU_INSTANCE_ACL32(...)
-#   endif
-#   if defined(OPENVINO_ARCH_ARM64)
-#       define OV_CPU_INSTANCE_ACL64(...) {__VA_ARGS__},
-#   else
-#       define OV_CPU_INSTANCE_ACL64(...)
-#   endif
-#   if defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)
-#       define OV_CPU_INSTANCE_ACL(...) {__VA_ARGS__},
-#   else
-#       define OV_CPU_INSTANCE_ACL(...)
-#   endif
+#    if defined(OPENVINO_ARCH_ARM)
+#        define OV_CPU_INSTANCE_ACL32(...) {__VA_ARGS__},
+#    else
+#        define OV_CPU_INSTANCE_ACL32(...)
+#    endif
+#    if defined(OPENVINO_ARCH_ARM64)
+#        define OV_CPU_INSTANCE_ACL64(...) {__VA_ARGS__},
+#    else
+#        define OV_CPU_INSTANCE_ACL64(...)
+#    endif
+#    if defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)
+#        define OV_CPU_INSTANCE_ACL(...) {__VA_ARGS__},
+#    else
+#        define OV_CPU_INSTANCE_ACL(...)
+#    endif
 #else
-#   define OV_CPU_INSTANCE_ACL32(...)
-#   define OV_CPU_INSTANCE_ACL64(...)
-#   define OV_CPU_INSTANCE_ACL(...)
+#    define OV_CPU_INSTANCE_ACL32(...)
+#    define OV_CPU_INSTANCE_ACL64(...)
+#    define OV_CPU_INSTANCE_ACL(...)
 #endif
 
 #if defined(OV_CPU_WITH_DNNL)
@@ -72,28 +72,11 @@ namespace intel_cpu {
 #define OV_CPU_INSTANCE_COMMON(...) {__VA_ARGS__},
 
 // @todo another option is to determine shape relation by executor type
-enum class ShapeTolerance {
-    Agnostic,
-    Dependant
-};
+enum class ShapeTolerance { Agnostic, Dependant };
 
-enum class ExecutorType {
-    Undefined,
-    Graph,
-    Common,
-    jit_x64,
-    Dnnl,
-    Acl,
-    Mlas,
-    jit_aarch64,
-    Shl
-};
+enum class ExecutorType { Undefined, Graph, Common, jit_x64, Dnnl, Acl, Mlas, jit_aarch64, Shl };
 
-enum class OperationType {
-    FullyConnected,
-    MatMul,
-    Convolution
-};
+enum class OperationType { FullyConnected, MatMul, Convolution };
 
 std::string ExecutorTypeToString(const ExecutorType type);
 ExecutorType ExecutorTypeFromString(const std::string& typeStr);
diff --git a/src/plugins/intel_cpu/src/nodes/executors/executor_config.hpp b/src/plugins/intel_cpu/src/nodes/executors/executor_config.hpp
index d08c4ad8127325..cd9bcaf7a119f7 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/executor_config.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/executor_config.hpp
@@ -4,8 +4,8 @@
 
 #pragma once
 
-#include "post_ops.hpp"
 #include "memory_arguments.hpp"
+#include "post_ops.hpp"
 
 namespace ov {
 namespace intel_cpu {
diff --git a/src/plugins/intel_cpu/src/nodes/executors/executor_implementation.hpp b/src/plugins/intel_cpu/src/nodes/executors/executor_implementation.hpp
index 3459d1fe35e19e..07a58b0fa6cfa7 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/executor_implementation.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/executor_implementation.hpp
@@ -19,22 +19,22 @@ template <typename Attrs>
 class ExecutorImplementation {
 public:
     using SupportsPredicate = std::function<bool(const executor::Config<Attrs>&)>;
-    using RequiresFallbackPredicate = std::function<ov::optional<executor::Config<Attrs>>(const executor::Config<Attrs>&)>;
+    using RequiresFallbackPredicate =
+        std::function<ov::optional<executor::Config<Attrs>>(const executor::Config<Attrs>&)>;
     using AcceptsShapePredicate = std::function<bool(const MemoryArgs& memory)>;
     using CreateFunction = std::function<ExecutorPtr(const Attrs& attrs,
                                                      const PostOps& postOps,
                                                      const MemoryArgs& memory,
                                                      const ExecutorContext::CPtr context)>;
 
-    ExecutorImplementation(
-        const char* name,
-        const ExecutorType type,
-        const OperationType operationType,
-        const ShapeTolerance shapeRelation,
-        SupportsPredicate supports,
-        RequiresFallbackPredicate requiresFallback,
-        AcceptsShapePredicate acceptsShape,
-        CreateFunction create)
+    ExecutorImplementation(const char* name,
+                           const ExecutorType type,
+                           const OperationType operationType,
+                           const ShapeTolerance shapeRelation,
+                           SupportsPredicate supports,
+                           RequiresFallbackPredicate requiresFallback,
+                           AcceptsShapePredicate acceptsShape,
+                           CreateFunction create)
         : m_name(name),
           m_type(type),
           m_operationType(operationType),
diff --git a/src/plugins/intel_cpu/src/nodes/executors/fullyconnected_implementations.cpp b/src/plugins/intel_cpu/src/nodes/executors/fullyconnected_implementations.cpp
index 10f472ddcd7283..42101ce3fca257 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/fullyconnected_implementations.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/fullyconnected_implementations.cpp
@@ -11,14 +11,14 @@
 #include "memory_desc/cpu_memory_desc.h"
 #include "nodes/executors/convolution_config.hpp"
 #include "nodes/executors/dnnl/dnnl_convolution_primitive.hpp"
-#include "nodes/executors/dnnl/dnnl_fullyconnected_primitive.hpp"
 #include "nodes/executors/dnnl/dnnl_fullyconnected.hpp"
+#include "nodes/executors/dnnl/dnnl_fullyconnected_primitive.hpp"
 #include "nodes/executors/dnnl/dnnl_matmul_primitive.hpp"
 #include "nodes/executors/dnnl/dnnl_shape_agnostic_data.hpp"
 #include "nodes/executors/executor.hpp"
 #include "nodes/executors/executor_implementation.hpp"
-#include "nodes/executors/implementations.hpp"
 #include "nodes/executors/fullyconnected_config.hpp"
+#include "nodes/executors/implementations.hpp"
 #include "nodes/executors/memory_arguments.hpp"
 #include "nodes/executors/mlas/mlas_gemm.hpp"
 #include "nodes/executors/precision_matcher.hpp"
@@ -30,7 +30,7 @@
 #include "utils/debug_capabilities.h"
 
 #if defined(OV_CPU_WITH_ACL)
-#include "nodes/executors/acl/acl_fullyconnected.hpp"
+#    include "nodes/executors/acl/acl_fullyconnected.hpp"
 #endif
 
 #if defined(OV_CPU_WITH_SHL)
@@ -50,7 +50,7 @@ using LayoutConfig = std::vector<LayoutType>;
 static const LayoutConfig dnnlFCLayoutConfig{LayoutType::ncsp, LayoutType::ncsp, LayoutType::ncsp, LayoutType::ncsp};
 static const LayoutConfig aclFCLayoutConfig{LayoutType::ncsp, LayoutType::ncsp, LayoutType::ncsp, LayoutType::ncsp};
 
-template<dnnl::impl::cpu::x64::cpu_isa_t ISA>
+template <dnnl::impl::cpu::x64::cpu_isa_t ISA>
 struct Require {
     bool operator()() {
         return dnnl::impl::cpu::x64::mayiuse(ISA);
@@ -144,10 +144,10 @@ static bool fullyMatchConfiguration(const MemoryDescArgs& currentDescriptors,
             continue;
 
         if (desc->getPrecision() != type)
-            return false; // type mismatch
+            return false;  // type mismatch
 
         if (!desc->hasLayoutType(layoutConfig[i]))
-            return false; // layout mismatch
+            return false;  // layout mismatch
     }
 
     return true;
@@ -207,6 +207,8 @@ OV_CPU_MAYBE_UNUSED_FUNCTION static inline bool noPostOps(const FCConfig& config
     return config.postOps.empty();
 }
 
+// to keep OV_CPU_INSTANCE macros aligned
+// clang-format off
 template <>
 const std::vector<ExecutorImplementation<FCAttrs>>& getImplementations() {
     static const std::vector<ExecutorImplementation<FCAttrs>> fullyconnectedImplementations {
@@ -492,5 +494,7 @@ const std::vector<ExecutorImplementation<FCAttrs>>& getImplementations() {
 
     return fullyconnectedImplementations;
 }
+// clang-format on
+
 }  // namespace intel_cpu
 }  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/graph_emitter.hpp b/src/plugins/intel_cpu/src/nodes/executors/graph_emitter.hpp
index 784ed8bc778840..347ac4c981f4f1 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/graph_emitter.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/graph_emitter.hpp
@@ -82,9 +82,7 @@ class GraphEmitter {
         return memoryDescs;
     }
 
-    static executor::Config<Attrs> createConfig(const MemoryArgs& memory,
-                                                const Attrs& attrs,
-                                                const PostOps& postOps) {
+    static executor::Config<Attrs> createConfig(const MemoryArgs& memory, const Attrs& attrs, const PostOps& postOps) {
         return executor::Config<Attrs>{memoryDescsFromMemory(memory), attrs, postOps};
     }
 
@@ -104,11 +102,11 @@ class GraphEmitter {
 
         const auto& graphExecutor =
             graphEmitter.createGraph(fallbackConfig.descs, fallbackConfig.attrs, fallbackConfig.postOps, context)
-            .ensureAttrsMatch()
-            .ensureSrcDescsMatch()
-            .ensureDstDescsMatch()
-            .ensurePostOpsMatch()
-            .emit();
+                .ensureAttrsMatch()
+                .ensureSrcDescsMatch()
+                .ensureDstDescsMatch()
+                .ensurePostOpsMatch()
+                .emit();
         (void)graphExecutor;
 
         OPENVINO_THROW("Fallback logic is not implemented yet");  // return graphExecutor;
diff --git a/src/plugins/intel_cpu/src/nodes/executors/implementation_utils.hpp b/src/plugins/intel_cpu/src/nodes/executors/implementation_utils.hpp
index cd029283a09c50..bee82af305c9d2 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/implementation_utils.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/implementation_utils.hpp
@@ -5,6 +5,7 @@
 #pragma once
 
 #include <cstdlib>
+
 #include "cpu_types.h"
 #include "memory_desc/cpu_memory_desc.h"
 #include "nodes/executors/memory_arguments.hpp"
@@ -13,80 +14,80 @@
 namespace ov {
 namespace intel_cpu {
 
-template<typename Config, int idx>
+template <typename Config, int idx>
 ov::element::Type memoryDescType(const Config& config) {
     return config.descs.at(idx)->getPrecision();
 }
 
-template<typename Config>
+template <typename Config>
 ov::element::Type srcType(const Config& config) {
     return memoryDescType<Config, ARG_SRC>(config);
 }
 
-template<typename Config>
+template <typename Config>
 ov::element::Type weiType(const Config& config) {
     return memoryDescType<Config, ARG_WEI>(config);
 }
 
-template<typename Config>
+template <typename Config>
 ov::element::Type biaType(const Config& config) {
     return memoryDescType<Config, ARG_BIAS>(config);
 }
 
-template<typename Config, int idx = 0>
+template <typename Config, int idx = 0>
 ov::element::Type dstType(const Config& config) {
     return memoryDescType<Config, ARG_DST>(config);
 }
 
-template<typename Config, int idx>
+template <typename Config, int idx>
 ov::element::Type dims(const Config& config) {
     return config.descs.at(idx)->getShape().getDims();
 }
 
-template<typename Config>
+template <typename Config>
 const VectorDims& srcDims(const Config& config) {
     return dims<Config, ARG_SRC>(config);
 }
 
-template<typename Config>
+template <typename Config>
 const VectorDims& weiDims(const Config& config) {
     return dims<Config, ARG_WEI>(config);
 }
 
-template<typename Config, int idx>
+template <typename Config, int idx>
 size_t rank(const Config& config) {
     return config.descs.at(idx)->getShape().getRank();
 }
 
-template<typename Config>
+template <typename Config>
 size_t srcRank(const Config& config) {
     return rank<Config, ARG_SRC>(config);
 }
 
-template<typename Config>
+template <typename Config>
 size_t weiRank(const Config& config) {
     return rank<Config, ARG_WEI>(config);
 }
 
-template<typename Config, int idx>
+template <typename Config, int idx>
 size_t memSize(const Config& config) {
     return config.descs.at(idx)->getCurrentMemSize();
 }
 
-template<typename Config>
+template <typename Config>
 size_t srcMemSize(const Config& config) {
     return memSize<Config, ARG_SRC>(config);
 }
 
-template<typename Config>
+template <typename Config>
 size_t weiMemSize(const Config& config) {
     return memSize<Config, ARG_WEI>(config);
 }
 
-template<typename Config>
+template <typename Config>
 size_t postOpsNumbers(const Config& config) {
     return config.postOps.size();
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/interpolate.cpp b/src/plugins/intel_cpu/src/nodes/executors/interpolate.cpp
index d0a006b1bea0fa..cb830a36f03cb1 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/interpolate.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/interpolate.cpp
@@ -3,18 +3,19 @@
 //
 
 #include "interpolate.hpp"
-#include "openvino/core/parallel.hpp"
-#include "nodes/common/cpu_memcpy.h"
+
 #include "emitters/plugin/x64/jit_load_store_emitters.hpp"
+#include "nodes/common/cpu_memcpy.h"
+#include "openvino/core/parallel.hpp"
 
 using namespace ov::intel_cpu;
 
 bool ov::intel_cpu::InterpolateExecutor::init(const InterpolateAttrs& interpolateAttrs,
-                                         const std::vector<MemoryDescPtr>& srcDescs,
-                                         const std::vector<MemoryDescPtr>& dstDescs,
-                                         const dnnl::primitive_attr &attr) {
-    const auto &srcDims = srcDescs[0]->getShape().getStaticDims();
-    const auto &dstDims = dstDescs[0]->getShape().getStaticDims();
+                                              const std::vector<MemoryDescPtr>& srcDescs,
+                                              const std::vector<MemoryDescPtr>& dstDescs,
+                                              const dnnl::primitive_attr& attr) {
+    const auto& srcDims = srcDescs[0]->getShape().getStaticDims();
+    const auto& dstDims = dstDescs[0]->getShape().getStaticDims();
     interpAttrs = interpolateAttrs;
     srcDimPad5d = to5Dim(getPaddedInputShape(srcDims, interpolateAttrs.padBegin, interpolateAttrs.padEnd));
     dstDim5d = to5Dim(dstDims);
@@ -24,38 +25,49 @@ bool ov::intel_cpu::InterpolateExecutor::init(const InterpolateAttrs& interpolat
     spatialDimSize = getSpatialDimsNum(dataRank);
 
     switch (interpAttrs.mode) {
-        case InterpolateMode::nearest: {
-            buildTblNN(srcDimPad5d, dstDim5d, interpAttrs.dataScales, interpolateAttrs.layout, interpolateAttrs.nearestMode);
-            break;
-        }
-        case InterpolateMode::linear_onnx: {
-            buildTblLinearOnnx(srcDimPad5d, dstDim5d, interpAttrs.dataScales, interpolateAttrs.layout);
-            break;
-        }
-        case InterpolateMode::linear: {
-            static constexpr int LINEAR_KERNEL = 2;
-            buildTblLinear(srcDimPad5d, dstDim5d, interpAttrs.dataScales, LINEAR_KERNEL, interpolateAttrs.antialias);
-            break;
-        }
-        case InterpolateMode::cubic: {
-            buildTblCubic(srcDimPad5d, dstDim5d, interpAttrs.dataScales, interpolateAttrs.cubeCoeff, interpolateAttrs.layout);
-            break;
-        }
-        default: {
-            OPENVINO_THROW("Interpolate executor does not support interpolate mode: ", interpAttrs.mode);
-            break;
-        }
+    case InterpolateMode::nearest: {
+        buildTblNN(srcDimPad5d,
+                   dstDim5d,
+                   interpAttrs.dataScales,
+                   interpolateAttrs.layout,
+                   interpolateAttrs.nearestMode);
+        break;
+    }
+    case InterpolateMode::linear_onnx: {
+        buildTblLinearOnnx(srcDimPad5d, dstDim5d, interpAttrs.dataScales, interpolateAttrs.layout);
+        break;
+    }
+    case InterpolateMode::linear: {
+        static constexpr int LINEAR_KERNEL = 2;
+        buildTblLinear(srcDimPad5d, dstDim5d, interpAttrs.dataScales, LINEAR_KERNEL, interpolateAttrs.antialias);
+        break;
+    }
+    case InterpolateMode::cubic: {
+        buildTblCubic(srcDimPad5d,
+                      dstDim5d,
+                      interpAttrs.dataScales,
+                      interpolateAttrs.cubeCoeff,
+                      interpolateAttrs.layout);
+        break;
+    }
+    default: {
+        OPENVINO_THROW("Interpolate executor does not support interpolate mode: ", interpAttrs.mode);
+        break;
+    }
     }
     return true;
 }
 // =====================================================================================================================
 // index layout:
 // d_0............d_OD-1, h_0..............h_OH-1, w_0................w_OW-1
-void ov::intel_cpu::InterpolateExecutor::buildTblNN(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d,
-                                                  const std::vector<float>& dataScales, InterpolateLayoutType layout, InterpolateNearestMode nearestMode) {
+void ov::intel_cpu::InterpolateExecutor::buildTblNN(const VectorDims& srcDimPad5d,
+                                                    const VectorDims& dstDim5d,
+                                                    const std::vector<float>& dataScales,
+                                                    InterpolateLayoutType layout,
+                                                    InterpolateNearestMode nearestMode) {
     const int dimSize = dataRank;
     float fz = (dimSize == 5) ? dataScales[dimSize - 3] : 1.f;
-     float fy = dataScales[dimSize - 2];
+    float fy = dataScales[dimSize - 2];
     float fx = dataScales[dimSize - 1];
     size_t ID = srcDimPad5d[2], IH = srcDimPad5d[3], IW = srcDimPad5d[4];
     size_t OD = dstDim5d[2], OH = dstDim5d[3], OW = dstDim5d[4];
@@ -84,80 +96,91 @@ void ov::intel_cpu::InterpolateExecutor::buildTblNN(const VectorDims& srcDimPad5
 // scale is float(outShape) / float(inShape)
 // strictly consistent with onnx calc manner(div scale, not multiply inverse), given this is done offline
 // the slight precison diff can produce obvious wrong value due to "nearest round" behavior for NN mode
-float ov::intel_cpu::InterpolateExecutor::coordTransToInput(int outCoord, float scale, int inShape, int outShape) const {
+float ov::intel_cpu::InterpolateExecutor::coordTransToInput(int outCoord,
+                                                            float scale,
+                                                            int inShape,
+                                                            int outShape) const {
     if (scale == 1.0f || (inShape == outShape)) {
         return outCoord;
     }
     switch (interpAttrs.coordTransMode) {
-        case InterpolateCoordTransMode::half_pixel: {
+    case InterpolateCoordTransMode::half_pixel: {
+        return (outCoord + 0.5f) / scale - 0.5f;
+        break;
+    }
+    case InterpolateCoordTransMode::pytorch_half_pixel: {
+        if (outShape > 1)
             return (outCoord + 0.5f) / scale - 0.5f;
-            break;
-        }
-        case InterpolateCoordTransMode::pytorch_half_pixel: {
-            if (outShape > 1)
-                return (outCoord + 0.5f) / scale - 0.5f;
-            else
-                return 0;
-            break;
-        }
-        case InterpolateCoordTransMode::asymmetric: {
-            return static_cast<float>(outCoord) / scale;
-            break;
-        }
-        case InterpolateCoordTransMode::tf_half_pixel_for_nn: {
-            return (outCoord + 0.5f) / scale;
-            break;
-        }
-        case InterpolateCoordTransMode::align_corners: {
-            if (outShape > 1)
-                return outCoord * (static_cast<float>(inShape - 1) / static_cast<float>(outShape - 1));
-            else
-                return 0;
-            break;
-        }
-        default: {
-            OPENVINO_THROW("errorPrefix", " does not support specified coordinate transformation mode");
-            break;
-        }
+        else
+            return 0;
+        break;
+    }
+    case InterpolateCoordTransMode::asymmetric: {
+        return static_cast<float>(outCoord) / scale;
+        break;
+    }
+    case InterpolateCoordTransMode::tf_half_pixel_for_nn: {
+        return (outCoord + 0.5f) / scale;
+        break;
+    }
+    case InterpolateCoordTransMode::align_corners: {
+        if (outShape > 1)
+            return outCoord * (static_cast<float>(inShape - 1) / static_cast<float>(outShape - 1));
+        else
+            return 0;
+        break;
+    }
+    default: {
+        OPENVINO_THROW("errorPrefix", " does not support specified coordinate transformation mode");
+        break;
+    }
     }
 }
 
-int ov::intel_cpu::InterpolateExecutor::nearestRound(float originCoord, bool isDownsample, InterpolateNearestMode nearestMode) const {
+int ov::intel_cpu::InterpolateExecutor::nearestRound(float originCoord,
+                                                     bool isDownsample,
+                                                     InterpolateNearestMode nearestMode) const {
     switch (nearestMode) {
-        case InterpolateNearestMode::round_prefer_floor: {
-            if (originCoord == (static_cast<int>(originCoord) + 0.5f))
-                return static_cast<int>(std::floor(originCoord));
-            else
-                return static_cast<int>(std::round(originCoord));
-            break;
-        }
-        case InterpolateNearestMode::round_prefer_ceil: {
-            return static_cast<int>(std::round(originCoord));
-            break;
-        }
-        case InterpolateNearestMode::floor: {
+    case InterpolateNearestMode::round_prefer_floor: {
+        if (originCoord == (static_cast<int>(originCoord) + 0.5f))
             return static_cast<int>(std::floor(originCoord));
-            break;
-        }
-        case InterpolateNearestMode::ceil: {
+        else
+            return static_cast<int>(std::round(originCoord));
+        break;
+    }
+    case InterpolateNearestMode::round_prefer_ceil: {
+        return static_cast<int>(std::round(originCoord));
+        break;
+    }
+    case InterpolateNearestMode::floor: {
+        return static_cast<int>(std::floor(originCoord));
+        break;
+    }
+    case InterpolateNearestMode::ceil: {
+        return static_cast<int>(std::ceil(originCoord));
+        break;
+    }
+    case InterpolateNearestMode::simple: {
+        if (isDownsample)
             return static_cast<int>(std::ceil(originCoord));
-            break;
-        }
-        case InterpolateNearestMode::simple: {
-            if (isDownsample)
-                return static_cast<int>(std::ceil(originCoord));
-            else
-                return static_cast<int>(originCoord);
-        }
-        default: {
-            OPENVINO_THROW("errorPrefix", " does not support specified nearest round mode");
-            break;
-        }
+        else
+            return static_cast<int>(originCoord);
+    }
+    default: {
+        OPENVINO_THROW("errorPrefix", " does not support specified nearest round mode");
+        break;
+    }
     }
 }
 
-void ov::intel_cpu::InterpolateExecutor::linearOnnxCF(int outCoord, float scale, int inShape, int outShape,
-                                                    int& index0, int& index1, float& weight0, float& weight1) {
+void ov::intel_cpu::InterpolateExecutor::linearOnnxCF(int outCoord,
+                                                      float scale,
+                                                      int inShape,
+                                                      int outShape,
+                                                      int& index0,
+                                                      int& index1,
+                                                      float& weight0,
+                                                      float& weight1) {
     float inCoord = coordTransToInput(outCoord, scale, inShape, outShape);
     inCoord = std::max(0.0f, std::min(inCoord, static_cast<float>(inShape - 1)));
     index0 = std::min(static_cast<int>(inCoord), inShape - 1);
@@ -171,8 +194,10 @@ void ov::intel_cpu::InterpolateExecutor::linearOnnxCF(int outCoord, float scale,
     }
 }
 
-void ov::intel_cpu::InterpolateExecutor::buildTblLinearOnnx(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d,
-                                                          const std::vector<float>& dataScales, InterpolateLayoutType layout) {
+void ov::intel_cpu::InterpolateExecutor::buildTblLinearOnnx(const VectorDims& srcDimPad5d,
+                                                            const VectorDims& dstDim5d,
+                                                            const std::vector<float>& dataScales,
+                                                            InterpolateLayoutType layout) {
     int dimSize = dataRank;
     float fz = (spatialDimSize > 2) ? dataScales[dimSize - 3] : 1.f;
     float fy = (spatialDimSize > 1) ? dataScales[dimSize - 2] : 1.f;
@@ -231,7 +256,7 @@ void ov::intel_cpu::InterpolateExecutor::buildTblLinearOnnx(const VectorDims& sr
                     indexPtr[1][idxOzOyOx] = (izF * IH * IW + iyT * IW + ixR) * scale;
                     weightPtr[0][idxOzOyOx] = weightL;
                     weightPtr[1][idxOzOyOx] = weightR;
-                    if (spatialDimSize  > 1) {
+                    if (spatialDimSize > 1) {
                         indexPtr[2][idxOzOyOx] = (izF * IH * IW + iyB * IW + ixL) * scale;
                         indexPtr[3][idxOzOyOx] = (izF * IH * IW + iyB * IW + ixR) * scale;
                         weightPtr[2][idxOzOyOx] = weightT;
@@ -284,8 +309,11 @@ void ov::intel_cpu::InterpolateExecutor::buildTblLinearOnnx(const VectorDims& sr
 // wd .........wd, wh............wh, ww.............ww, id...........id, ih............ih, iw..............iw
 //                        |                                                      |
 //                   wh0.....wh_diameter                                    ih0.....ih_diameter
-void ov::intel_cpu::InterpolateExecutor::buildTblLinear(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d,
-                                                      const std::vector<float>& dataScales, int kernel_width, bool antialias) {
+void ov::intel_cpu::InterpolateExecutor::buildTblLinear(const VectorDims& srcDimPad5d,
+                                                        const VectorDims& dstDim5d,
+                                                        const std::vector<float>& dataScales,
+                                                        int kernel_width,
+                                                        bool antialias) {
     int dimSize = dataRank;
     float fz = (dimSize == 5) ? dataScales[dimSize - 3] : 1.f;
     float fy = dataScales[dimSize - 2];
@@ -309,15 +337,15 @@ void ov::intel_cpu::InterpolateExecutor::buildTblLinear(const VectorDims& srcDim
         int sizeOH = OH * diaOH;
         int sizeOW = OW * diaOW;
         indexTable.resize((sizeOD + sizeOH + sizeOW) * 2);
-        float *weightTable = reinterpret_cast<float*>(&indexTable[0]);
-        float *weightOD = static_cast<float*>(&weightTable[0]);
-        float *weightOH = static_cast<float*>(&weightTable[sizeOD]);
-        float *weightOW = static_cast<float*>(&weightTable[sizeOD + sizeOH]);
+        float* weightTable = reinterpret_cast<float*>(&indexTable[0]);
+        float* weightOD = static_cast<float*>(&weightTable[0]);
+        float* weightOH = static_cast<float*>(&weightTable[sizeOD]);
+        float* weightOW = static_cast<float*>(&weightTable[sizeOD + sizeOH]);
 
-        int *idxTable = static_cast<int*>(&indexTable[sizeOD + sizeOH + sizeOW]);
-        int *idxOD = static_cast<int*>(&idxTable[0]);
-        int *idxOH = static_cast<int*>(&idxTable[sizeOD]);
-        int *idxOW = static_cast<int*>(&idxTable[sizeOD + sizeOH]);
+        int* idxTable = static_cast<int*>(&indexTable[sizeOD + sizeOH + sizeOW]);
+        int* idxOD = static_cast<int*>(&idxTable[0]);
+        int* idxOH = static_cast<int*>(&idxTable[sizeOD]);
+        int* idxOW = static_cast<int*>(&idxTable[sizeOD + sizeOH]);
 
         for (int oz = 0; oz < static_cast<int>(OD); oz++) {
             float iz = coordTransToInput(oz, fz, ID, OD);
@@ -375,8 +403,11 @@ std::vector<float> ov::intel_cpu::InterpolateExecutor::getCubicCoeffs(float mant
 // table layout:
 // OW      OW         OW         OW         OW          OH       OH           OH           OH           OH
 // x_idx   x_weight0  x_weight1  x_weight2  x_weight3   y_idx    y_weight0    y_weight1    y_weight2    y_weight3
-void ov::intel_cpu::InterpolateExecutor::buildTblCubic(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d, const std::vector<float>& dataScales,
-                                                     float cubicCoeff, InterpolateLayoutType layout) {
+void ov::intel_cpu::InterpolateExecutor::buildTblCubic(const VectorDims& srcDimPad5d,
+                                                       const VectorDims& dstDim5d,
+                                                       const std::vector<float>& dataScales,
+                                                       float cubicCoeff,
+                                                       InterpolateLayoutType layout) {
     int dimSize = dataRank;
     float fy = dataScales[dimSize - 2];
     float fx = dataScales[dimSize - 1];
@@ -394,9 +425,9 @@ void ov::intel_cpu::InterpolateExecutor::buildTblCubic(const VectorDims& srcDimP
     }
 
     int tblAdvance = 0;
-    int *xOrigin = static_cast<int*>(&indexTable[tblAdvance]);
+    int* xOrigin = static_cast<int*>(&indexTable[tblAdvance]);
     tblAdvance += OW;
-    float *xFactor = reinterpret_cast<float*>(&indexTable[tblAdvance]);
+    float* xFactor = reinterpret_cast<float*>(&indexTable[tblAdvance]);
     for (int ox = 0; ox < OW; ox++) {
         float ix = coordTransToInput(ox, fx, IW, OW);
         int ix_r = static_cast<int>(std::floor(ix));
@@ -410,9 +441,9 @@ void ov::intel_cpu::InterpolateExecutor::buildTblCubic(const VectorDims& srcDimP
     }
 
     tblAdvance += CUBIC_GRID_LEN * OW;
-    int *yOrigin = static_cast<int*>(&indexTable[tblAdvance]);
+    int* yOrigin = static_cast<int*>(&indexTable[tblAdvance]);
     tblAdvance += OH;
-    float *yFactor = reinterpret_cast<float*>(&indexTable[tblAdvance]);
+    float* yFactor = reinterpret_cast<float*>(&indexTable[tblAdvance]);
     for (int oy = 0; oy < OH; oy++) {
         float iy = coordTransToInput(oy, fy, IH, OH);
         int iy_r = static_cast<int>(std::floor(iy));
@@ -427,9 +458,9 @@ void ov::intel_cpu::InterpolateExecutor::buildTblCubic(const VectorDims& srcDimP
 
     if (layout == InterpolateLayoutType::planar) {
         tblAdvance += CUBIC_GRID_LEN * OH;
-        int *sequenceOH = static_cast<int*>(&indexTable[tblAdvance]);
+        int* sequenceOH = static_cast<int*>(&indexTable[tblAdvance]);
         tblAdvance += OH * OW;
-        int *sequenceOW = static_cast<int*>(&indexTable[tblAdvance]);
+        int* sequenceOW = static_cast<int*>(&indexTable[tblAdvance]);
         for (int h = 0; h < OH; ++h) {
             int offset = h * OW;
             for (int w = 0; w < OW; ++w) {
@@ -447,16 +478,17 @@ inline VectorDims getBlockND(const VectorDims& shape) {
     int shapeRank = shape.size();
     VectorDims blockND(shapeRank + 1, 1);
     for (int i = shapeRank - 1; i >= 0; i--) {
-        blockND[i] = shape[i] * blockND[i+1];
+        blockND[i] = shape[i] * blockND[i + 1];
     }
     return blockND;
 }
 
-const uint8_t* ov::intel_cpu::InterpolateExecutor::padPreprocess(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst) {
-    const uint8_t *src_data_origin = src[0]->getDataAs<uint8_t>();
+const uint8_t* ov::intel_cpu::InterpolateExecutor::padPreprocess(const std::vector<MemoryCPtr>& src,
+                                                                 const std::vector<MemoryPtr>& dst) {
+    const uint8_t* src_data_origin = src[0]->getDataAs<uint8_t>();
 
-    const auto &srcDim = src[0]->getStaticDims();
-    const auto &dstDim = dst[0]->getStaticDims();
+    const auto& srcDim = src[0]->getStaticDims();
+    const auto& dstDim = dst[0]->getStaticDims();
     size_t dimSize = srcDim.size();
     auto srcDimPad = getSrcDimPad5d();
 
@@ -465,7 +497,7 @@ const uint8_t* ov::intel_cpu::InterpolateExecutor::padPreprocess(const std::vect
     const auto dstDim5d = to5Dim(dstDim);
     const auto srcDataSize = src[0]->getDesc().getPrecision().size();
 
-    const uint8_t *src_data = nullptr;
+    const uint8_t* src_data = nullptr;
     std::vector<uint8_t> srcPadded;
     if (interpAttrs.hasPad) {
         int padB0 = (dimSize > 2) ? interpAttrs.padBegin[0] : 0;
@@ -479,23 +511,32 @@ const uint8_t* ov::intel_cpu::InterpolateExecutor::padPreprocess(const std::vect
 
         if (interpAttrs.layout == InterpolateLayoutType::planar) {
             srcPadded.resize(inShapePadBlock[0] * srcDataSize, 0);
-            uint8_t *src_data_pad = static_cast<uint8_t *>(&srcPadded[0]);
+            uint8_t* src_data_pad = static_cast<uint8_t*>(&srcPadded[0]);
             parallel_for4d(srcDim5d[0], srcDim5d[1], srcDim5d[2], srcDim5d[3], [&](int n, int c, int d, int h) {
-                const uint8_t *src = src_data_origin + (inShapeBlock[1] * n + inShapeBlock[2] * c + inShapeBlock[3] * d + inShapeBlock[4] * h) * srcDataSize;
-                uint8_t *srcPad = src_data_pad + (inShapePadBlock[1] * (n + padB0) + inShapePadBlock[2] * (c + padB1) +
-                                                  inShapePadBlock[3] * (d + padB2) + inShapePadBlock[4] * (h + padB3) + padB4) * srcDataSize;
+                const uint8_t* src = src_data_origin + (inShapeBlock[1] * n + inShapeBlock[2] * c +
+                                                        inShapeBlock[3] * d + inShapeBlock[4] * h) *
+                                                           srcDataSize;
+                uint8_t* srcPad =
+                    src_data_pad + (inShapePadBlock[1] * (n + padB0) + inShapePadBlock[2] * (c + padB1) +
+                                    inShapePadBlock[3] * (d + padB2) + inShapePadBlock[4] * (h + padB3) + padB4) *
+                                       srcDataSize;
                 cpu_memcpy(srcPad, src, srcDim5d[4] * srcDataSize);
             });
             src_data = src_data_pad;
         } else if (interpAttrs.layout == InterpolateLayoutType::by_channel) {
             srcPadded.resize(inShapePadBlock[0] * srcDataSize, 0);
-            uint8_t *src_data_pad = static_cast<uint8_t *>(&srcPadded[0]);
+            uint8_t* src_data_pad = static_cast<uint8_t*>(&srcPadded[0]);
             parallel_for4d(srcDim5d[0], srcDim5d[2], srcDim5d[3], srcDim5d[4], [&](int n, int d, int h, int w) {
-                const uint8_t *src = src_data_origin + (inShapeBlock[1] * n +
-                                                        (inShapeBlock[3] * d + inShapeBlock[4] * h + inShapeBlock[5] * w) * srcDim5d[1]) * srcDataSize;
-                uint8_t *srcPad = src_data_pad + (inShapePadBlock[1] * (n + padB0) + (inShapePadBlock[3] * (d + padB2) +
-                                                                                      inShapePadBlock[4] * (h + padB3) +
-                                                                                      inShapePadBlock[5] * (w + padB4)) * srcDimPad5d[1] + padB1) * srcDataSize;
+                const uint8_t* src = src_data_origin +
+                                     (inShapeBlock[1] * n +
+                                      (inShapeBlock[3] * d + inShapeBlock[4] * h + inShapeBlock[5] * w) * srcDim5d[1]) *
+                                         srcDataSize;
+                uint8_t* srcPad = src_data_pad + (inShapePadBlock[1] * (n + padB0) +
+                                                  (inShapePadBlock[3] * (d + padB2) + inShapePadBlock[4] * (h + padB3) +
+                                                   inShapePadBlock[5] * (w + padB4)) *
+                                                      srcDimPad5d[1] +
+                                                  padB1) *
+                                                     srcDataSize;
                 cpu_memcpy(srcPad, src, srcDim5d[1] * srcDataSize);
             });
             src_data = src_data_pad;
@@ -504,23 +545,30 @@ const uint8_t* ov::intel_cpu::InterpolateExecutor::padPreprocess(const std::vect
             size_t CB = div_up(srcDimPad5d[1], blkSize);
             size_t eltsTotal = srcDimPad5d[0] * CB * srcDimPad5d[2] * srcDimPad5d[3] * srcDimPad5d[4] * blkSize;
             srcPadded.resize(eltsTotal * srcDataSize, 0x0);
-            uint8_t *src_data_pad = static_cast<uint8_t *>(&srcPadded[0]);
+            uint8_t* src_data_pad = static_cast<uint8_t*>(&srcPadded[0]);
             if ((srcDim5d[0] != srcDimPad5d[0]) || (srcDim5d[1] != srcDimPad5d[1])) {
                 OPENVINO_THROW("Interpolate layer with name does not support padding on batch and channel dimensions");
             }
-            parallel_for5d(srcDim5d[0], CB, srcDim5d[2], srcDim5d[3], srcDim5d[4], [&](int n, int cb, int d, int h, int w) {
-                const uint8_t *src = src_data_origin + (n * CB * srcDim5d[2] * srcDim5d[3] * srcDim5d[4] * blkSize) * srcDataSize
-                                     + (cb * srcDim5d[2] * srcDim5d[3] * srcDim5d[4] * blkSize) * srcDataSize
-                                     + (d * srcDim5d[3] * srcDim5d[4] * blkSize) * srcDataSize
-                                     + (h * srcDim5d[4] * blkSize) * srcDataSize
-                                     + (w * blkSize) * srcDataSize;
-                uint8_t *srcPad = src_data_pad + (n * CB * srcDimPad5d[2] * srcDimPad5d[3] * srcDimPad5d[4] * blkSize) * srcDataSize
-                                  + (cb * srcDimPad5d[2] * srcDimPad5d[3] * srcDimPad5d[4] * blkSize) * srcDataSize
-                                  + ((d + padB2) * srcDimPad5d[3] * srcDimPad5d[4] * blkSize) * srcDataSize
-                                  + ((h + padB3) * srcDimPad5d[4] * blkSize) * srcDataSize
-                                  + ((w + padB4) * blkSize) * srcDataSize;
-                cpu_memcpy(srcPad, src, blkSize * srcDataSize);
-            });
+            parallel_for5d(
+                srcDim5d[0],
+                CB,
+                srcDim5d[2],
+                srcDim5d[3],
+                srcDim5d[4],
+                [&](int n, int cb, int d, int h, int w) {
+                    const uint8_t* src = src_data_origin +
+                                         (n * CB * srcDim5d[2] * srcDim5d[3] * srcDim5d[4] * blkSize) * srcDataSize +
+                                         (cb * srcDim5d[2] * srcDim5d[3] * srcDim5d[4] * blkSize) * srcDataSize +
+                                         (d * srcDim5d[3] * srcDim5d[4] * blkSize) * srcDataSize +
+                                         (h * srcDim5d[4] * blkSize) * srcDataSize + (w * blkSize) * srcDataSize;
+                    uint8_t* srcPad =
+                        src_data_pad +
+                        (n * CB * srcDimPad5d[2] * srcDimPad5d[3] * srcDimPad5d[4] * blkSize) * srcDataSize +
+                        (cb * srcDimPad5d[2] * srcDimPad5d[3] * srcDimPad5d[4] * blkSize) * srcDataSize +
+                        ((d + padB2) * srcDimPad5d[3] * srcDimPad5d[4] * blkSize) * srcDataSize +
+                        ((h + padB3) * srcDimPad5d[4] * blkSize) * srcDataSize + ((w + padB4) * blkSize) * srcDataSize;
+                    cpu_memcpy(srcPad, src, blkSize * srcDataSize);
+                });
             src_data = src_data_pad;
         }
     } else {
diff --git a/src/plugins/intel_cpu/src/nodes/executors/interpolate.hpp b/src/plugins/intel_cpu/src/nodes/executors/interpolate.hpp
index 15df4eed5f0471..041589c0ab9f6a 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/interpolate.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/interpolate.hpp
@@ -11,41 +11,15 @@
 namespace ov {
 namespace intel_cpu {
 
-enum InterpolateLayoutType {
-    planar,
-    block,
-    by_channel
-};
+enum InterpolateLayoutType { planar, block, by_channel };
 
-enum InterpolateMode {
-    nearest,
-    linear,
-    linear_onnx,
-    cubic,
-    bilinear_pillow,
-    bicubic_pillow
-};
+enum InterpolateMode { nearest, linear, linear_onnx, cubic, bilinear_pillow, bicubic_pillow };
 
-enum InterpolateCoordTransMode {
-    half_pixel,
-    pytorch_half_pixel,
-    asymmetric,
-    tf_half_pixel_for_nn,
-    align_corners
-};
+enum InterpolateCoordTransMode { half_pixel, pytorch_half_pixel, asymmetric, tf_half_pixel_for_nn, align_corners };
 
-enum class InterpolateNearestMode {
-    round_prefer_floor,
-    round_prefer_ceil,
-    floor,
-    ceil,
-    simple
-};
+enum class InterpolateNearestMode { round_prefer_floor, round_prefer_ceil, floor, ceil, simple };
 
-enum class InterpolateShapeCalcMode {
-    sizes,
-    scales
-};
+enum class InterpolateShapeCalcMode { sizes, scales };
 
 struct InterpolateAttrs {
     InterpolateShapeCalcMode shapeCalcMode = InterpolateShapeCalcMode::sizes;
@@ -63,9 +37,9 @@ struct InterpolateAttrs {
     bool hasPad = false;
 };
 
-inline VectorDims getPaddedInputShape(const VectorDims &srcDims,
-                                const std::vector<int> &padBegin,
-                                const std::vector<int> &padEnd) {
+inline VectorDims getPaddedInputShape(const VectorDims& srcDims,
+                                      const std::vector<int>& padBegin,
+                                      const std::vector<int>& padEnd) {
     VectorDims paddedShape;
     int dataRank = srcDims.size();
     for (int i = 0; i < dataRank; i++) {
@@ -80,16 +54,16 @@ inline int clipCoord(int pos, int length) {
 
 inline size_t getSpatialDimsNum(const Dim rank) {
     switch (rank) {
-        case 1:
-        case 3:
-            return 1;
-        case 2:
-        case 4:
-            return 2;
-        case 5:
-            return 3;
-        default:
-            OPENVINO_THROW("Can't define number spatial");
+    case 1:
+    case 3:
+        return 1;
+    case 2:
+    case 4:
+        return 2;
+    case 5:
+        return 3;
+    default:
+        OPENVINO_THROW("Can't define number spatial");
     }
 }
 
@@ -133,27 +107,49 @@ class InterpolateExecutor {
     virtual bool init(const InterpolateAttrs& interpolateAttrs,
                       const std::vector<MemoryDescPtr>& srcDescs,
                       const std::vector<MemoryDescPtr>& dstDescs,
-                      const dnnl::primitive_attr &attr);
-    virtual void exec(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst, const void *post_ops_data_) = 0;
+                      const dnnl::primitive_attr& attr);
+    virtual void exec(const std::vector<MemoryCPtr>& src,
+                      const std::vector<MemoryPtr>& dst,
+                      const void* post_ops_data_) = 0;
     virtual impl_desc_type getImplType() const = 0;
 
     virtual ~InterpolateExecutor() = default;
-    VectorDims getSrcDimPad5d() const { return srcDimPad5d; }
+    VectorDims getSrcDimPad5d() const {
+        return srcDimPad5d;
+    }
     const uint8_t* padPreprocess(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst);
 
 private:
-    void buildTblNN(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d, const std::vector<float>& dataScales,
-                    InterpolateLayoutType layout, InterpolateNearestMode nearestMode);
-    void buildTblLinearOnnx(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d, const std::vector<float>& dataScales,
+    void buildTblNN(const VectorDims& srcDimPad5d,
+                    const VectorDims& dstDim5d,
+                    const std::vector<float>& dataScales,
+                    InterpolateLayoutType layout,
+                    InterpolateNearestMode nearestMode);
+    void buildTblLinearOnnx(const VectorDims& srcDimPad5d,
+                            const VectorDims& dstDim5d,
+                            const std::vector<float>& dataScales,
                             InterpolateLayoutType layout);
-    void buildTblLinear(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d, const std::vector<float>& dataScales, int kernel_width,
+    void buildTblLinear(const VectorDims& srcDimPad5d,
+                        const VectorDims& dstDim5d,
+                        const std::vector<float>& dataScales,
+                        int kernel_width,
                         bool antialias);
-    void buildTblCubic(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d, const std::vector<float>& dataScales, float cubicCoeff,
+    void buildTblCubic(const VectorDims& srcDimPad5d,
+                       const VectorDims& dstDim5d,
+                       const std::vector<float>& dataScales,
+                       float cubicCoeff,
                        InterpolateLayoutType layout);
 
     float coordTransToInput(int outCoord, float scale, int inShape, int outShape) const;
     int nearestRound(float origin, bool isDownsample, InterpolateNearestMode nearestMode) const;
-    void linearOnnxCF(int outCoord, float scale, int inShape, int outShape, int& index0, int& index1, float& weight0, float& weight1);
+    void linearOnnxCF(int outCoord,
+                      float scale,
+                      int inShape,
+                      int outShape,
+                      int& index0,
+                      int& index1,
+                      float& weight0,
+                      float& weight1);
     std::vector<float> getCubicCoeffs(float mantissa, float a);
 
 protected:
@@ -180,5 +176,5 @@ class InterpolateExecutorBuilder {
 
 using InterpolateExecutorBuilderPtr = std::shared_ptr<InterpolateExecutorBuilder>;
 using InterpolateExecutorBuilderCPtr = std::shared_ptr<const InterpolateExecutorBuilder>;
-} // namespace intel_cpu
-} // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/interpolate_list.cpp b/src/plugins/intel_cpu/src/nodes/executors/interpolate_list.cpp
index 2362b644583763..21ae249757bf9c 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/interpolate_list.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/interpolate_list.cpp
@@ -9,11 +9,10 @@ namespace intel_cpu {
 
 const std::vector<InterpolateExecutorDesc>& getInterpolateExecutorsList() {
     static std::vector<InterpolateExecutorDesc> descs = {
-            OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<ACLInterpolateExecutorBuilder>())
-    };
+        OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<ACLInterpolateExecutorBuilder>())};
 
     return descs;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/interpolate_list.hpp b/src/plugins/intel_cpu/src/nodes/executors/interpolate_list.hpp
index 2ed16ea04b1852..a0c1fc240731fb 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/interpolate_list.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/interpolate_list.hpp
@@ -5,14 +5,13 @@
 #pragma once
 
 #include "executor.hpp"
-
 #include "interpolate.hpp"
 #if defined(OV_CPU_WITH_ACL)
-#include "acl/acl_interpolate.hpp"
+#    include "acl/acl_interpolate.hpp"
 #endif
 
-#include "onednn/iml_type_mapper.h"
 #include "common/primitive_cache.hpp"
+#include "onednn/iml_type_mapper.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -27,9 +26,10 @@ const std::vector<InterpolateExecutorDesc>& getInterpolateExecutorsList();
 class InterpolateExecutorFactory : public ExecutorFactoryLegacy {
 public:
     InterpolateExecutorFactory(const InterpolateAttrs& InterpolateAttrs,
-                          const std::vector<MemoryDescPtr>& srcDescs,
-                          const std::vector<MemoryDescPtr>& dstDescs,
-                          const ExecutorContext::CPtr context) : ExecutorFactoryLegacy(context) {
+                               const std::vector<MemoryDescPtr>& srcDescs,
+                               const std::vector<MemoryDescPtr>& dstDescs,
+                               const ExecutorContext::CPtr context)
+        : ExecutorFactoryLegacy(context) {
         for (auto& desc : getInterpolateExecutorsList()) {
             if (desc.builder->isSupported(InterpolateAttrs, srcDescs, dstDescs)) {
                 supportedDescs.push_back(desc);
@@ -39,9 +39,9 @@ class InterpolateExecutorFactory : public ExecutorFactoryLegacy {
 
     ~InterpolateExecutorFactory() = default;
     virtual InterpolateExecutorPtr makeExecutor(const InterpolateAttrs& interpolateAttrs,
-                                               const std::vector<MemoryDescPtr>& srcDescs,
-                                               const std::vector<MemoryDescPtr>& dstDescs,
-                                               const dnnl::primitive_attr &attr) {
+                                                const std::vector<MemoryDescPtr>& srcDescs,
+                                                const std::vector<MemoryDescPtr>& dstDescs,
+                                                const dnnl::primitive_attr& attr) {
         auto build = [&](const InterpolateExecutorDesc* desc) {
             auto executor = desc->builder->makeExecutor(context);
             if (executor->init(interpolateAttrs, srcDescs, dstDescs, attr)) {
@@ -52,7 +52,6 @@ class InterpolateExecutorFactory : public ExecutorFactoryLegacy {
             return ptr;
         };
 
-
         if (chosenDesc) {
             if (auto executor = build(chosenDesc)) {
                 return executor;
@@ -81,5 +80,5 @@ class InterpolateExecutorFactory : public ExecutorFactoryLegacy {
 using InterpolateExecutorFactoryPtr = std::shared_ptr<InterpolateExecutorFactory>;
 using InterpolateExecutorFactoryCPtr = std::shared_ptr<const InterpolateExecutorFactory>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/memory_arguments.hpp b/src/plugins/intel_cpu/src/nodes/executors/memory_arguments.hpp
index 7150226d27c601..05c3cf0d5df259 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/memory_arguments.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/memory_arguments.hpp
@@ -12,7 +12,7 @@ namespace ov {
 namespace intel_cpu {
 
 using MemoryDescArgs = std::unordered_map<int, MemoryDescPtr>;
-using MemoryArgs     = std::unordered_map<int, MemoryPtr>;
+using MemoryArgs = std::unordered_map<int, MemoryPtr>;
 
 // basic inputs
 #define ARG_SRC_0 1
diff --git a/src/plugins/intel_cpu/src/nodes/executors/mlas/mlas_gemm.cpp b/src/plugins/intel_cpu/src/nodes/executors/mlas/mlas_gemm.cpp
index 8fd945b773f262..7e50c8086789a0 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/mlas/mlas_gemm.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/mlas/mlas_gemm.cpp
@@ -104,8 +104,7 @@ MlasGemmExecutor::MlasGemmExecutor(const FCAttrs& attrs,
       m_memoryArgs(memory),
       packedWeights(prepareWeightMemory(memory.at(ARG_WEI), context, !attrs.weightsNonTransposed)),
       N(batchDim(memory.at(ARG_WEI)->getStaticDims())),
-      K(memory.at(ARG_WEI)->getStaticDims().back())
-{}
+      K(memory.at(ARG_WEI)->getStaticDims().back()) {}
 
 bool MlasGemmExecutor::update(const MemoryArgs& memory) {
     const auto& dstDesc = memory.at(ARG_DST)->getDescPtr();
diff --git a/src/plugins/intel_cpu/src/nodes/executors/mlas/mlas_transpose.cpp b/src/plugins/intel_cpu/src/nodes/executors/mlas/mlas_transpose.cpp
index 678fe5a5c22176..2b8b71bfbced0b 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/mlas/mlas_transpose.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/mlas/mlas_transpose.cpp
@@ -3,9 +3,10 @@
 //
 
 #include "mlas_transpose.hpp"
-#include "openvino/core/parallel.hpp"
-#include "nodes/common/cpu_memcpy.h"
+
 #include "mlas.h"
+#include "nodes/common/cpu_memcpy.h"
+#include "openvino/core/parallel.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -24,7 +25,12 @@ struct has_mlas_transpose<uint32_t> : std::true_type {};
 
 template <typename T>
 typename std::enable_if<!has_mlas_transpose<T>::value, void>::type SimpleTransposeSingleAxisOutwards(
-    const T* input_data, T* output_data, int64_t num_loops, int64_t num_writers, int64_t writes_per_loop, int64_t writes_per_writer_per_loop) {
+    const T* input_data,
+    T* output_data,
+    int64_t num_loops,
+    int64_t num_writers,
+    int64_t writes_per_loop,
+    int64_t writes_per_writer_per_loop) {
     const T* end;
     for (int64_t l = 0; l < num_loops; ++l) {
         T* output_for_first_writer = output_data;
@@ -44,9 +50,17 @@ typename std::enable_if<!has_mlas_transpose<T>::value, void>::type SimpleTranspo
 
 template <typename T>
 typename std::enable_if<has_mlas_transpose<T>::value, void>::type SimpleTransposeSingleAxisOutwards(
-        const T* input_data, T* output_data, int64_t num_loops, int64_t num_writers, int64_t writes_per_loop, int64_t writes_per_writer_per_loop) {
+    const T* input_data,
+    T* output_data,
+    int64_t num_loops,
+    int64_t num_writers,
+    int64_t writes_per_loop,
+    int64_t writes_per_writer_per_loop) {
     for (int64_t l = 0; l < num_loops; ++l) {
-        MlasTranspose(input_data, output_data, static_cast<size_t>(writes_per_writer_per_loop), static_cast<size_t>(num_writers));
+        MlasTranspose(input_data,
+                      output_data,
+                      static_cast<size_t>(writes_per_writer_per_loop),
+                      static_cast<size_t>(num_writers));
         input_data += writes_per_loop;
         output_data += writes_per_loop;
     }
@@ -54,7 +68,12 @@ typename std::enable_if<has_mlas_transpose<T>::value, void>::type SimpleTranspos
 
 template <typename T>
 typename std::enable_if<!has_mlas_transpose<T>::value, void>::type SimpleTransposeSingleAxisInwards(
-        const T* input_data, T* output_data, int64_t num_loops, int64_t num_readers, int64_t reads_per_loop, int64_t reads_per_reader_per_loop) {
+    const T* input_data,
+    T* output_data,
+    int64_t num_loops,
+    int64_t num_readers,
+    int64_t reads_per_loop,
+    int64_t reads_per_reader_per_loop) {
     T* end;
     for (int64_t l = 0; l < num_loops; ++l) {
         const T* input_for_first_reader = input_data;
@@ -74,9 +93,17 @@ typename std::enable_if<!has_mlas_transpose<T>::value, void>::type SimpleTranspo
 
 template <typename T>
 typename std::enable_if<has_mlas_transpose<T>::value, void>::type SimpleTransposeSingleAxisInwards(
-        const T* input_data, T* output_data, int64_t num_loops, int64_t num_readers, int64_t reads_per_loop, int64_t reads_per_reader_per_loop) {
+    const T* input_data,
+    T* output_data,
+    int64_t num_loops,
+    int64_t num_readers,
+    int64_t reads_per_loop,
+    int64_t reads_per_reader_per_loop) {
     for (int64_t l = 0; l < num_loops; ++l) {
-        MlasTranspose(input_data, output_data, static_cast<size_t>(num_readers), static_cast<size_t>(reads_per_reader_per_loop));
+        MlasTranspose(input_data,
+                      output_data,
+                      static_cast<size_t>(num_readers),
+                      static_cast<size_t>(reads_per_reader_per_loop));
         input_data += reads_per_loop;
         output_data += reads_per_loop;
     }
@@ -148,7 +175,10 @@ bool MlasTransposeExecutor::IsTransposeMovingSingleAxis(VectorDims permutations,
     return single_axis_moved;
 }
 
-void MlasTransposeExecutor::TransposeSingleAxisOutwards(const MemoryCPtr& input, const MemoryPtr& output, size_t from, size_t to) {
+void MlasTransposeExecutor::TransposeSingleAxisOutwards(const MemoryCPtr& input,
+                                                        const MemoryPtr& output,
+                                                        size_t from,
+                                                        size_t to) {
     const auto& input_shape = input->getShape();
     const auto& input_dims = input_shape.getDims();
     const auto element_size = input->getDesc().getPrecision().size();
@@ -165,52 +195,68 @@ void MlasTransposeExecutor::TransposeSingleAxisOutwards(const MemoryCPtr& input,
     const size_t bytes_per_write = static_cast<size_t>(block_size) * element_size;
 
     switch (bytes_per_write) {
-        case (sizeof(uint8_t)): {
-            SimpleTransposeSingleAxisOutwards(input_data, output_data, num_loops, num_writers, writes_per_loop,
-                                                                                writes_per_writer_per_loop);
-            break;
-        }
-        case (sizeof(uint16_t)): {
-            SimpleTransposeSingleAxisOutwards(reinterpret_cast<const uint16_t*>(input_data),
-                                                                                reinterpret_cast<uint16_t*>(output_data), num_loops, num_writers,
-                                                                                writes_per_loop, writes_per_writer_per_loop);
-            break;
-        }
-        case (sizeof(uint32_t)): {
-            SimpleTransposeSingleAxisOutwards(reinterpret_cast<const uint32_t*>(input_data),
-                                                                                reinterpret_cast<uint32_t*>(output_data), num_loops, num_writers,
-                                                                                writes_per_loop, writes_per_writer_per_loop);
-            break;
-        }
-        case (sizeof(uint64_t)): {
-            SimpleTransposeSingleAxisOutwards(reinterpret_cast<const uint64_t*>(input_data),
-                                                                                reinterpret_cast<uint64_t*>(output_data), num_loops, num_writers,
-                                                                                writes_per_loop, writes_per_writer_per_loop);
-            break;
-        }
-        default: {
-            // we need to use memcpy for each block
-            for (int64_t l = 0; l < num_loops; ++l) {
-                uint8_t* output_for_first_writer = output_data;
+    case (sizeof(uint8_t)): {
+        SimpleTransposeSingleAxisOutwards(input_data,
+                                          output_data,
+                                          num_loops,
+                                          num_writers,
+                                          writes_per_loop,
+                                          writes_per_writer_per_loop);
+        break;
+    }
+    case (sizeof(uint16_t)): {
+        SimpleTransposeSingleAxisOutwards(reinterpret_cast<const uint16_t*>(input_data),
+                                          reinterpret_cast<uint16_t*>(output_data),
+                                          num_loops,
+                                          num_writers,
+                                          writes_per_loop,
+                                          writes_per_writer_per_loop);
+        break;
+    }
+    case (sizeof(uint32_t)): {
+        SimpleTransposeSingleAxisOutwards(reinterpret_cast<const uint32_t*>(input_data),
+                                          reinterpret_cast<uint32_t*>(output_data),
+                                          num_loops,
+                                          num_writers,
+                                          writes_per_loop,
+                                          writes_per_writer_per_loop);
+        break;
+    }
+    case (sizeof(uint64_t)): {
+        SimpleTransposeSingleAxisOutwards(reinterpret_cast<const uint64_t*>(input_data),
+                                          reinterpret_cast<uint64_t*>(output_data),
+                                          num_loops,
+                                          num_writers,
+                                          writes_per_loop,
+                                          writes_per_writer_per_loop);
+        break;
+    }
+    default: {
+        // we need to use memcpy for each block
+        for (int64_t l = 0; l < num_loops; ++l) {
+            uint8_t* output_for_first_writer = output_data;
 
-                for (auto wwpl = 0; wwpl < writes_per_writer_per_loop; ++wwpl) {
-                    uint8_t* output_for_current_writer = output_for_first_writer;
+            for (auto wwpl = 0; wwpl < writes_per_writer_per_loop; ++wwpl) {
+                uint8_t* output_for_current_writer = output_for_first_writer;
 
-                    for (uint64_t w = 0; w < num_writers; ++w) {
-                        memcpy(output_for_current_writer, input_data, bytes_per_write);
-                        // skip to output position for next writer
-                        output_for_current_writer += (writes_per_writer_per_loop * bytes_per_write);
-                        input_data += bytes_per_write;
-                    }
-                    output_for_first_writer += bytes_per_write;
+                for (uint64_t w = 0; w < num_writers; ++w) {
+                    memcpy(output_for_current_writer, input_data, bytes_per_write);
+                    // skip to output position for next writer
+                    output_for_current_writer += (writes_per_writer_per_loop * bytes_per_write);
+                    input_data += bytes_per_write;
                 }
-                output_data += writes_per_loop * bytes_per_write;
+                output_for_first_writer += bytes_per_write;
             }
+            output_data += writes_per_loop * bytes_per_write;
         }
     }
+    }
 }
 
-void MlasTransposeExecutor::TransposeSingleAxisInwards(const MemoryCPtr& input, const MemoryPtr& output, size_t from, size_t to) {
+void MlasTransposeExecutor::TransposeSingleAxisInwards(const MemoryCPtr& input,
+                                                       const MemoryPtr& output,
+                                                       size_t from,
+                                                       size_t to) {
     const auto& input_shape = input->getShape();
     const auto& input_dims = input_shape.getDims();
 
@@ -227,61 +273,74 @@ void MlasTransposeExecutor::TransposeSingleAxisInwards(const MemoryCPtr& input,
     const size_t bytes_per_read = static_cast<size_t>(block_size) * element_size;
 
     switch (bytes_per_read) {
-        case (sizeof(uint8_t)): {
-            SimpleTransposeSingleAxisInwards(input_data, output_data, num_loops, num_readers, reads_per_loop,
-                                                                             reads_per_reader_per_loop);
-            break;
-        }
-        case (sizeof(uint16_t)): {
-            SimpleTransposeSingleAxisInwards(reinterpret_cast<const uint16_t*>(input_data),
-                                                                             reinterpret_cast<uint16_t*>(output_data), num_loops, num_readers, reads_per_loop,
-                                                                             reads_per_reader_per_loop);
-            break;
-        }
-        case (sizeof(uint32_t)): {
-            SimpleTransposeSingleAxisInwards(reinterpret_cast<const uint32_t*>(input_data),
-                                                                             reinterpret_cast<uint32_t*>(output_data), num_loops, num_readers, reads_per_loop,
-                                                                             reads_per_reader_per_loop);
-            break;
-        }
-        case (sizeof(uint64_t)): {
-            SimpleTransposeSingleAxisInwards(reinterpret_cast<const uint64_t*>(input_data),
-                                                                             reinterpret_cast<uint64_t*>(output_data), num_loops, num_readers, reads_per_loop,
-                                                                             reads_per_reader_per_loop);
-            break;
-        }
-        default: {
-            // we need to use memcpy for each block
-            for (int64_t l = 0; l < num_loops; ++l) {
-                const uint8_t* input_for_first_reader = input_data;
-                for (auto rrpl = 0; rrpl < reads_per_reader_per_loop; ++rrpl) {
-                    const uint8_t* input_for_current_reader = input_for_first_reader;
-                    for (uint64_t r = 0; r < num_readers; ++r) {
-                        memcpy(output_data, input_for_current_reader, bytes_per_read);
-                        output_data += bytes_per_read;
-                        // skip to input position for next reader
-                        input_for_current_reader += (reads_per_reader_per_loop * bytes_per_read);
-                    }
-                    input_for_first_reader += bytes_per_read;
+    case (sizeof(uint8_t)): {
+        SimpleTransposeSingleAxisInwards(input_data,
+                                         output_data,
+                                         num_loops,
+                                         num_readers,
+                                         reads_per_loop,
+                                         reads_per_reader_per_loop);
+        break;
+    }
+    case (sizeof(uint16_t)): {
+        SimpleTransposeSingleAxisInwards(reinterpret_cast<const uint16_t*>(input_data),
+                                         reinterpret_cast<uint16_t*>(output_data),
+                                         num_loops,
+                                         num_readers,
+                                         reads_per_loop,
+                                         reads_per_reader_per_loop);
+        break;
+    }
+    case (sizeof(uint32_t)): {
+        SimpleTransposeSingleAxisInwards(reinterpret_cast<const uint32_t*>(input_data),
+                                         reinterpret_cast<uint32_t*>(output_data),
+                                         num_loops,
+                                         num_readers,
+                                         reads_per_loop,
+                                         reads_per_reader_per_loop);
+        break;
+    }
+    case (sizeof(uint64_t)): {
+        SimpleTransposeSingleAxisInwards(reinterpret_cast<const uint64_t*>(input_data),
+                                         reinterpret_cast<uint64_t*>(output_data),
+                                         num_loops,
+                                         num_readers,
+                                         reads_per_loop,
+                                         reads_per_reader_per_loop);
+        break;
+    }
+    default: {
+        // we need to use memcpy for each block
+        for (int64_t l = 0; l < num_loops; ++l) {
+            const uint8_t* input_for_first_reader = input_data;
+            for (auto rrpl = 0; rrpl < reads_per_reader_per_loop; ++rrpl) {
+                const uint8_t* input_for_current_reader = input_for_first_reader;
+                for (uint64_t r = 0; r < num_readers; ++r) {
+                    memcpy(output_data, input_for_current_reader, bytes_per_read);
+                    output_data += bytes_per_read;
+                    // skip to input position for next reader
+                    input_for_current_reader += (reads_per_reader_per_loop * bytes_per_read);
                 }
-                input_data += reads_per_loop * bytes_per_read;
+                input_for_first_reader += bytes_per_read;
             }
+            input_data += reads_per_loop * bytes_per_read;
         }
     }
+    }
 }
 
 void MlasTransposeExecutor::exec(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst) {
     if (from > to) {
-            TransposeSingleAxisOutwards(src[0], dst[0], from, to);
+        TransposeSingleAxisOutwards(src[0], dst[0], from, to);
     } else {
-            TransposeSingleAxisInwards(src[0], dst[0], from, to);
+        TransposeSingleAxisInwards(src[0], dst[0], from, to);
     }
 }
 
-bool MlasTransposeExecutor::init(const TransposeParams &transposeParams,
-                                 const std::vector<MemoryDescPtr> &srcDescs,
-                                 const std::vector<MemoryDescPtr> &dstDescs,
-                                 const dnnl::primitive_attr &attr) {
+bool MlasTransposeExecutor::init(const TransposeParams& transposeParams,
+                                 const std::vector<MemoryDescPtr>& srcDescs,
+                                 const std::vector<MemoryDescPtr>& dstDescs,
+                                 const dnnl::primitive_attr& attr) {
     if (!IsTransposeMovingSingleAxis(transposeParams.permuteParams.order, from, to)) {
         DEBUG_LOG("MLAS Transpose executor supports moving single axis only");
         return false;
@@ -292,8 +351,7 @@ bool MlasTransposeExecutor::init(const TransposeParams &transposeParams,
 bool MlasTransposeExecutorBuilder::isSupported(const TransposeParams& transposeParams,
                                                const std::vector<MemoryDescPtr>& srcDescs,
                                                const std::vector<MemoryDescPtr>& dstDescs) const {
-    if (!srcDescs[0]->hasLayoutType(LayoutType::ncsp) ||
-        !dstDescs[0]->hasLayoutType(LayoutType::ncsp)) {
+    if (!srcDescs[0]->hasLayoutType(LayoutType::ncsp) || !dstDescs[0]->hasLayoutType(LayoutType::ncsp)) {
         DEBUG_LOG("MLAS Transpose executor supports NCHW layout only");
         return false;
     }
@@ -308,5 +366,5 @@ TransposeExecutorPtr MlasTransposeExecutorBuilder::makeExecutor(const ExecutorCo
     return std::make_shared<MlasTransposeExecutor>(context);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/mlas/mlas_transpose.hpp b/src/plugins/intel_cpu/src/nodes/executors/mlas/mlas_transpose.hpp
index d7e0307414aac9..8f7cd1bf8c22bd 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/mlas/mlas_transpose.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/mlas/mlas_transpose.hpp
@@ -11,13 +11,16 @@ namespace intel_cpu {
 class MlasTransposeExecutor : public TransposeExecutor {
 public:
     using TransposeExecutor::TransposeExecutor;
-    bool init(const TransposeParams &transposeParams,
-              const std::vector<MemoryDescPtr> &srcDescs,
-              const std::vector<MemoryDescPtr> &dstDescs,
-              const dnnl::primitive_attr &attr) override;
-    void exec(const std::vector<MemoryCPtr> &src, const std::vector<MemoryPtr> &dst) override;
+    bool init(const TransposeParams& transposeParams,
+              const std::vector<MemoryDescPtr>& srcDescs,
+              const std::vector<MemoryDescPtr>& dstDescs,
+              const dnnl::primitive_attr& attr) override;
+    void exec(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst) override;
+
+    impl_desc_type implType() const override {
+        return impl_desc_type::mlas;
+    }
 
-    impl_desc_type implType() const override { return impl_desc_type::mlas; }
 private:
     static int64_t calcShapeSize(const Shape& shape, size_t start, size_t end);
     static bool IsTransposeMovingSingleAxis(VectorDims permutations, size_t& from, size_t& to);
@@ -37,5 +40,5 @@ class MlasTransposeExecutorBuilder : public TransposeExecutorBuilder {
     TransposeExecutorPtr makeExecutor(const ExecutorContext::CPtr context) const override;
 };
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/mvn.cpp b/src/plugins/intel_cpu/src/nodes/executors/mvn.cpp
index 9b522ed9887344..eec9d2a8947975 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/mvn.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/mvn.cpp
@@ -11,26 +11,34 @@ MVNExecutor::MVNExecutor(const ExecutorContext::CPtr context) : context(context)
 
 VectorDims MVNExecutor::transformTo5DCase(const VectorDims& shape, bool initAcrossChannels) {
     switch (shape.size()) {
-        // for 1 and 2 rank, if initAcrossChannels_ is true, adjust shape to fully vectorize under unified 5d procedure.
-        // otherwise there are not enough data in spatial dimension to process in one kernel.
-        case 1 :  // C
-            if (initAcrossChannels) {
-                return VectorDims({1, 1, 1, 1, shape[0]});
-            } else {
-                return VectorDims({1, shape[0], 1, 1, 1});
-            }
-        case 2 :  // NC
-            if (initAcrossChannels) {
-                return VectorDims({1, shape[0], 1, shape[1], 1});
-            } else {
-                return VectorDims({shape[0], shape[1], 1, 1, 1});
-            }
-        case 3 : { return VectorDims({shape[0], shape[1], 1, shape[2], 1}); }
-        case 4 : { return VectorDims({shape[0], shape[1], 1, shape[2], shape[3]}); }
-        case 5 : { return VectorDims({shape[0], shape[1], shape[2], shape[3], shape[4]}); }
-        default : { OPENVINO_THROW("MVN executor doesn't support planar layout with rank: ", shape.size()); }
+    // for 1 and 2 rank, if initAcrossChannels_ is true, adjust shape to fully vectorize under unified 5d procedure.
+    // otherwise there are not enough data in spatial dimension to process in one kernel.
+    case 1:  // C
+        if (initAcrossChannels) {
+            return VectorDims({1, 1, 1, 1, shape[0]});
+        } else {
+            return VectorDims({1, shape[0], 1, 1, 1});
+        }
+    case 2:  // NC
+        if (initAcrossChannels) {
+            return VectorDims({1, shape[0], 1, shape[1], 1});
+        } else {
+            return VectorDims({shape[0], shape[1], 1, 1, 1});
+        }
+    case 3: {
+        return VectorDims({shape[0], shape[1], 1, shape[2], 1});
+    }
+    case 4: {
+        return VectorDims({shape[0], shape[1], 1, shape[2], shape[3]});
+    }
+    case 5: {
+        return VectorDims({shape[0], shape[1], shape[2], shape[3], shape[4]});
+    }
+    default: {
+        OPENVINO_THROW("MVN executor doesn't support planar layout with rank: ", shape.size());
+    }
     }
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/mvn.hpp b/src/plugins/intel_cpu/src/nodes/executors/mvn.hpp
index 759115a4b4b794..da51b5d1ef67e9 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/mvn.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/mvn.hpp
@@ -5,29 +5,22 @@
 #pragma once
 
 #include "cpu_memory.h"
-#include "onednn/iml_type_mapper.h"
 #include "executor.hpp"
+#include "onednn/iml_type_mapper.h"
 
 namespace ov {
 namespace intel_cpu {
 
-enum MVNLayoutType {
-    mvn_planar,
-    mvn_block,
-    mvn_by_channel
-};
+enum MVNLayoutType { mvn_planar, mvn_block, mvn_by_channel };
 
 // Defines way to add epsilon: inside sqrt or outside.
-enum MVNEpsMode {
-    INSIDE_SQRT,
-    OUTSIDE_SQRT
-};
+enum MVNEpsMode { INSIDE_SQRT, OUTSIDE_SQRT };
 
 struct MVNAttrs {
     MVNLayoutType layout = mvn_planar;
     bool initAcrossChannels_ = false;
     bool execAcrossChannels_ = false;
-    bool normalizeVariance_  = false;
+    bool normalizeVariance_ = false;
     float epsValue_ = 0.0f;
     MVNEpsMode epsMode_ = INSIDE_SQRT;
     ov::element::Type src_prc;
@@ -40,9 +33,11 @@ class MVNExecutor {
     virtual bool init(const MVNAttrs& mvnAttrs,
                       const std::vector<MemoryDescPtr>& srcDescs,
                       const std::vector<MemoryDescPtr>& dstDescs,
-                      const dnnl::primitive_attr &attr) = 0;
+                      const dnnl::primitive_attr& attr) = 0;
 
-    virtual void exec(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst, const void *post_ops_data_) = 0;
+    virtual void exec(const std::vector<MemoryCPtr>& src,
+                      const std::vector<MemoryPtr>& dst,
+                      const void* post_ops_data_) = 0;
     virtual ~MVNExecutor() = default;
 
     virtual impl_desc_type getImplType() const = 0;
@@ -60,12 +55,14 @@ using MVNExecutorCPtr = std::shared_ptr<const MVNExecutor>;
 class MVNExecutorBuilder {
 public:
     ~MVNExecutorBuilder() = default;
-    virtual bool isSupported(const MVNAttrs& mvnAttrs, const std::vector<MemoryDescPtr>& srcDescs, const std::vector<MemoryDescPtr>& dstDescs) const = 0;
+    virtual bool isSupported(const MVNAttrs& mvnAttrs,
+                             const std::vector<MemoryDescPtr>& srcDescs,
+                             const std::vector<MemoryDescPtr>& dstDescs) const = 0;
     virtual MVNExecutorPtr makeExecutor(const ExecutorContext::CPtr context) const = 0;
 };
 
 using MVNExecutorBuilderPtr = std::shared_ptr<MVNExecutorBuilder>;
 using MVNExecutorBuilderCPtr = std::shared_ptr<const MVNExecutorBuilder>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/mvn_list.cpp b/src/plugins/intel_cpu/src/nodes/executors/mvn_list.cpp
index c27751b7a2d2b4..99a55d79f58177 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/mvn_list.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/mvn_list.cpp
@@ -9,11 +9,10 @@ namespace intel_cpu {
 
 const std::vector<MVNExecutorDesc>& getMVNExecutorsList() {
     static std::vector<MVNExecutorDesc> descs = {
-        OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<AclMVNExecutorBuilder>())
-    };
+        OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<AclMVNExecutorBuilder>())};
 
     return descs;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/mvn_list.hpp b/src/plugins/intel_cpu/src/nodes/executors/mvn_list.hpp
index 3a8d3cc61fe585..82f8e868ac2d81 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/mvn_list.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/mvn_list.hpp
@@ -5,14 +5,13 @@
 #pragma once
 
 #include "executor.hpp"
-
 #include "mvn.hpp"
 #if defined(OV_CPU_WITH_ACL)
-#include "acl/acl_mvn.hpp"
+#    include "acl/acl_mvn.hpp"
 #endif
 
-#include "onednn/iml_type_mapper.h"
 #include "common/primitive_cache.hpp"
+#include "onednn/iml_type_mapper.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -29,7 +28,8 @@ class MVNExecutorFactory : public ExecutorFactoryLegacy {
     MVNExecutorFactory(const MVNAttrs& mvnAttrs,
                        const std::vector<MemoryDescPtr>& srcDescs,
                        const std::vector<MemoryDescPtr>& dstDescs,
-                       const ExecutorContext::CPtr context) : ExecutorFactoryLegacy(context) {
+                       const ExecutorContext::CPtr context)
+        : ExecutorFactoryLegacy(context) {
         for (auto& desc : getMVNExecutorsList()) {
             if (desc.builder->isSupported(mvnAttrs, srcDescs, dstDescs)) {
                 supportedDescs.push_back(desc);
@@ -41,7 +41,7 @@ class MVNExecutorFactory : public ExecutorFactoryLegacy {
     virtual MVNExecutorPtr makeExecutor(const MVNAttrs& mvnAttrs,
                                         const std::vector<MemoryDescPtr>& srcDescs,
                                         const std::vector<MemoryDescPtr>& dstDescs,
-                                        const dnnl::primitive_attr &attr) {
+                                        const dnnl::primitive_attr& attr) {
         auto build = [&](const MVNExecutorDesc* desc) {
             auto executor = desc->builder->makeExecutor(context);
             if (executor->init(mvnAttrs, srcDescs, dstDescs, attr)) {
@@ -80,5 +80,5 @@ class MVNExecutorFactory : public ExecutorFactoryLegacy {
 using MVNExecutorFactoryPtr = std::shared_ptr<MVNExecutorFactory>;
 using MVNExecutorFactoryCPtr = std::shared_ptr<const MVNExecutorFactory>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/pooling.cpp b/src/plugins/intel_cpu/src/nodes/executors/pooling.cpp
index e15d1a4ef15b8d..95448640e3b125 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/pooling.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/pooling.cpp
@@ -9,5 +9,5 @@ namespace intel_cpu {
 
 PoolingExecutor::PoolingExecutor(const ExecutorContext::CPtr context) : context(context) {}
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/pooling.hpp b/src/plugins/intel_cpu/src/nodes/executors/pooling.hpp
index 5ea358c68afc8e..e826d3a37250db 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/pooling.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/pooling.hpp
@@ -5,8 +5,8 @@
 #pragma once
 
 #include "cpu_memory.h"
-#include "onednn/iml_type_mapper.h"
 #include "executor.hpp"
+#include "onednn/iml_type_mapper.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -44,9 +44,11 @@ class PoolingExecutor {
     virtual bool init(const PoolingAttrs& poolingAttrs,
                       const std::vector<MemoryDescPtr>& srcDescs,
                       const std::vector<MemoryDescPtr>& dstDescs,
-                      const dnnl::primitive_attr &attr) = 0;
+                      const dnnl::primitive_attr& attr) = 0;
 
-    virtual void exec(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst, std::unordered_map<int, MemoryPtr> postOpsArgs) = 0;
+    virtual void exec(const std::vector<MemoryCPtr>& src,
+                      const std::vector<MemoryPtr>& dst,
+                      std::unordered_map<int, MemoryPtr> postOpsArgs) = 0;
     virtual ~PoolingExecutor() = default;
 
     virtual impl_desc_type getImplType() const = 0;
@@ -71,5 +73,5 @@ class PoolingExecutorBuilder {
 using PoolingExecutorBuilderPtr = std::shared_ptr<PoolingExecutorBuilder>;
 using PoolingExecutorBuilderCPtr = std::shared_ptr<const PoolingExecutorBuilder>;
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/pooling_list.cpp b/src/plugins/intel_cpu/src/nodes/executors/pooling_list.cpp
index 4b130f37bfff57..d0ee9f7da574c6 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/pooling_list.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/pooling_list.cpp
@@ -9,11 +9,10 @@ namespace intel_cpu {
 
 const std::vector<PoolingExecutorDesc>& getPoolingExecutorsList() {
     static std::vector<PoolingExecutorDesc> descs = {
-        OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<AclPoolingExecutorBuilder>())
-    };
+        OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<AclPoolingExecutorBuilder>())};
 
     return descs;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/pooling_list.hpp b/src/plugins/intel_cpu/src/nodes/executors/pooling_list.hpp
index d6ce5489105b19..1c051ae7d2959d 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/pooling_list.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/pooling_list.hpp
@@ -5,10 +5,9 @@
 #pragma once
 
 #include "executor.hpp"
-
 #include "pooling.hpp"
 #if defined(OV_CPU_WITH_ACL)
-#include "acl/acl_pooling.hpp"
+#    include "acl/acl_pooling.hpp"
 #endif
 
 namespace ov {
@@ -24,9 +23,10 @@ const std::vector<PoolingExecutorDesc>& getPoolingExecutorsList();
 class PoolingExecutorFactory : public ExecutorFactoryLegacy {
 public:
     PoolingExecutorFactory(const PoolingAttrs& poolingAttrs,
-                          const std::vector<MemoryDescPtr>& srcDescs,
-                          const std::vector<MemoryDescPtr>& dstDescs,
-                          const ExecutorContext::CPtr context) : ExecutorFactoryLegacy(context) {
+                           const std::vector<MemoryDescPtr>& srcDescs,
+                           const std::vector<MemoryDescPtr>& dstDescs,
+                           const ExecutorContext::CPtr context)
+        : ExecutorFactoryLegacy(context) {
         for (auto& desc : getPoolingExecutorsList()) {
             if (desc.builder->isSupported(poolingAttrs, srcDescs, dstDescs)) {
                 supportedDescs.push_back(desc);
@@ -36,9 +36,9 @@ class PoolingExecutorFactory : public ExecutorFactoryLegacy {
 
     ~PoolingExecutorFactory() = default;
     virtual PoolingExecutorPtr makeExecutor(const PoolingAttrs& poolingAttrs,
-                                        const std::vector<MemoryDescPtr>& srcDescs,
-                                        const std::vector<MemoryDescPtr>& dstDescs,
-                                        const dnnl::primitive_attr &attr) {
+                                            const std::vector<MemoryDescPtr>& srcDescs,
+                                            const std::vector<MemoryDescPtr>& dstDescs,
+                                            const dnnl::primitive_attr& attr) {
         auto build = [&](const PoolingExecutorDesc* desc) {
             auto executor = desc->builder->makeExecutor(context);
             if (executor->init(poolingAttrs, srcDescs, dstDescs, attr)) {
@@ -49,7 +49,6 @@ class PoolingExecutorFactory : public ExecutorFactoryLegacy {
             return ptr;
         };
 
-
         if (chosenDesc) {
             if (auto executor = build(chosenDesc)) {
                 return executor;
@@ -74,5 +73,5 @@ class PoolingExecutorFactory : public ExecutorFactoryLegacy {
 using PoolingExecutorFactoryPtr = std::shared_ptr<PoolingExecutorFactory>;
 using PoolingExecutorFactoryCPtr = std::shared_ptr<const PoolingExecutorFactory>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/precision_matcher.cpp b/src/plugins/intel_cpu/src/nodes/executors/precision_matcher.cpp
index 95044a9e205595..ced50dd2ec3dd5 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/precision_matcher.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/precision_matcher.cpp
@@ -15,9 +15,12 @@ namespace intel_cpu {
 bool match(const InOutTypeMask& patterns, const InOutTypes& values) {
     assert(patterns.size() == values.size());
 
-    return std::equal(values.begin(), values.end(), patterns.begin(), [](const ov::element::Type value, const TypeMask pattern) {
-        return pattern & value;
-    });
+    return std::equal(values.begin(),
+                      values.end(),
+                      patterns.begin(),
+                      [](const ov::element::Type value, const TypeMask pattern) {
+                          return pattern & value;
+                      });
 
     return true;
 }
diff --git a/src/plugins/intel_cpu/src/nodes/executors/precision_translation.cpp b/src/plugins/intel_cpu/src/nodes/executors/precision_translation.cpp
index 73aac151843b08..36aab4f8fddc77 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/precision_translation.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/precision_translation.cpp
@@ -14,7 +14,9 @@
 namespace ov {
 namespace intel_cpu {
 
-InOutTypes getTypeConfiguration(const MemoryDescArgs& descriptors, const TypeMapping& mapping, const MappingNotation& notation) {
+InOutTypes getTypeConfiguration(const MemoryDescArgs& descriptors,
+                                const TypeMapping& mapping,
+                                const MappingNotation& notation) {
     InOutTypes types;
     std::transform(notation.begin(), notation.end(), std::back_inserter(types), [&descriptors](int id) {
         return descriptors.at(id)->getPrecision();
diff --git a/src/plugins/intel_cpu/src/nodes/executors/precision_translation.hpp b/src/plugins/intel_cpu/src/nodes/executors/precision_translation.hpp
index 374b584dd0ffb5..20e613eea2c236 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/precision_translation.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/precision_translation.hpp
@@ -18,24 +18,21 @@ namespace intel_cpu {
 
 template <size_t bypassId>
 struct use {
-    ov::element::Type operator()(const std::vector<ov::element::Type>& types,
-                                 size_t idx) const {
+    ov::element::Type operator()(const std::vector<ov::element::Type>& types, size_t idx) const {
         assert(bypassId < types.size());
         return types[bypassId];
     }
 };
 
 struct bypass {
-    ov::element::Type operator()(const std::vector<ov::element::Type>& types,
-                                 size_t idx) const {
+    ov::element::Type operator()(const std::vector<ov::element::Type>& types, size_t idx) const {
         return types[idx];
     }
 };
 
 template <ov::element::Type_t type>
 struct just {
-    ov::element::Type operator()(const std::vector<ov::element::Type>& types,
-                                 size_t idx) const {
+    ov::element::Type operator()(const std::vector<ov::element::Type>& types, size_t idx) const {
         // ignore everything
         (void)types;
         (void)idx;
@@ -45,8 +42,7 @@ struct just {
 
 template <>
 struct just<TypeMaskAlias::fxx> {
-    ov::element::Type operator()(const std::vector<ov::element::Type>& types,
-                                 size_t idx) const {
+    ov::element::Type operator()(const std::vector<ov::element::Type>& types, size_t idx) const {
         // ignore everything
         (void)types;
         (void)idx;
@@ -58,11 +54,9 @@ using policy = std::function<ov::element::Type(const std::vector<ov::element::Ty
 
 struct PortsTranslation {
     template <typename... Policies>
-    PortsTranslation(Policies... policies) :
-        m_policies{policies...} {}
+    PortsTranslation(Policies... policies) : m_policies{policies...} {}
 
-    std::vector<ov::element::Type> operator()(
-        const std::vector<ov::element::Type>& types) const {
+    std::vector<ov::element::Type> operator()(const std::vector<ov::element::Type>& types) const {
         assert(types.size() == m_policies.size());
 
         std::vector<ov::element::Type> result;
@@ -73,6 +67,7 @@ struct PortsTranslation {
 
         return result;
     }
+
 private:
     std::vector<policy> m_policies;
 };
@@ -88,9 +83,7 @@ class TypeMappingEntry {
 public:
     using EnabledPredicate = std::function<bool(void)>;
 
-    TypeMappingEntry(InOutTypeMask mask,
-                     TypeTranslationFunction translation,
-                     EnabledPredicate enabled = {})
+    TypeMappingEntry(InOutTypeMask mask, TypeTranslationFunction translation, EnabledPredicate enabled = {})
         : m_mask(std::move(mask)),
           m_translation(std::move(translation)),
           m_enabled(std::move(enabled)) {}
@@ -121,7 +114,9 @@ using TypeMapping = std::vector<TypeMappingEntry>;
 using MappingNotation = std::vector<int>;
 using pt = PortsTranslation;
 
-InOutTypes getTypeConfiguration(const MemoryDescArgs& descriptors, const TypeMapping& mapping, const MappingNotation& notation);
+InOutTypes getTypeConfiguration(const MemoryDescArgs& descriptors,
+                                const TypeMapping& mapping,
+                                const MappingNotation& notation);
 
 }  // namespace intel_cpu
 }  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/printers.cpp b/src/plugins/intel_cpu/src/nodes/executors/printers.cpp
index ac52b25a069541..1bce932225827d 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/printers.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/printers.cpp
@@ -4,25 +4,27 @@
 
 #ifdef CPU_DEBUG_CAPS
 
-#include <ostream>
-#include "printers.hpp"
-#include "post_ops.hpp"
-#include "fullyconnected_config.hpp"
+#    include "printers.hpp"
+
+#    include <ostream>
+
+#    include "fullyconnected_config.hpp"
+#    include "post_ops.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
-std::ostream & operator<<(std::ostream & os, const FCAttrs& attrs) {
+std::ostream& operator<<(std::ostream& os, const FCAttrs& attrs) {
     // @todo print Attrs
     return os;
 }
 
-std::ostream & operator<<(std::ostream & os, const PostOps& postOps) {
+std::ostream& operator<<(std::ostream& os, const PostOps& postOps) {
     // @todo print PostOps
     return os;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
-#endif // CPU_DEBUG_CAPS
+#endif  // CPU_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/nodes/executors/printers.hpp b/src/plugins/intel_cpu/src/nodes/executors/printers.hpp
index d37ab633ba8036..7a96550b3f225c 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/printers.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/printers.hpp
@@ -3,25 +3,27 @@
 //
 
 #ifdef CPU_DEBUG_CAPS
-#pragma once
+#    pragma once
 
-#include <ostream>
-#include "executor_config.hpp"
+#    include <ostream>
+
+#    include "executor_config.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
 namespace executor {
-template<typename Attrs> struct Config;
+template <typename Attrs>
+struct Config;
 }
 
 struct FCAttrs;
 
-std::ostream & operator<<(std::ostream & os, const FCAttrs& attrs);
-std::ostream & operator<<(std::ostream & os, const PostOps& postOps);
+std::ostream& operator<<(std::ostream& os, const FCAttrs& attrs);
+std::ostream& operator<<(std::ostream& os, const PostOps& postOps);
 
-template<typename Attrs>
-std::ostream & operator<<(std::ostream & os, const executor::Config<Attrs>& config) {
+template <typename Attrs>
+std::ostream& operator<<(std::ostream& os, const executor::Config<Attrs>& config) {
     for (const auto& desc : config.descs) {
         const auto id = desc.first;
         const auto descPtr = desc.second;
@@ -34,7 +36,7 @@ std::ostream & operator<<(std::ostream & os, const executor::Config<Attrs>& conf
     return os;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
-#endif // CPU_DEBUG_CAPS
+#endif  // CPU_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/nodes/executors/reduce.cpp b/src/plugins/intel_cpu/src/nodes/executors/reduce.cpp
index 8e091f0282eb5d..6039813d8fdd28 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/reduce.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/reduce.cpp
@@ -9,5 +9,5 @@ namespace intel_cpu {
 
 ReduceExecutor::ReduceExecutor(const ExecutorContext::CPtr context) : context(context) {}
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/reduce.hpp b/src/plugins/intel_cpu/src/nodes/executors/reduce.hpp
index 8aa6e8f0aaa4ac..21b730a197df3a 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/reduce.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/reduce.hpp
@@ -5,9 +5,9 @@
 #pragma once
 
 #include "cpu_memory.h"
-#include "onednn/iml_type_mapper.h"
 #include "dnnl_scratch_pad.h"
 #include "executor.hpp"
+#include "onednn/iml_type_mapper.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -24,9 +24,11 @@ class ReduceExecutor {
     virtual bool init(const ReduceAttrs& reduceAttrs,
                       const std::vector<MemoryDescPtr>& srcDescs,
                       const std::vector<MemoryDescPtr>& dstDescs,
-                      const dnnl::primitive_attr &attr) = 0;
+                      const dnnl::primitive_attr& attr) = 0;
 
-    virtual void exec(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst, const void *post_ops_data_) = 0;
+    virtual void exec(const std::vector<MemoryCPtr>& src,
+                      const std::vector<MemoryPtr>& dst,
+                      const void* post_ops_data_) = 0;
     virtual ~ReduceExecutor() = default;
 
     virtual impl_desc_type getImplType() const = 0;
@@ -51,5 +53,5 @@ class ReduceExecutorBuilder {
 using ReduceExecutorBuilderPtr = std::shared_ptr<ReduceExecutorBuilder>;
 using ReduceExecutorBuilderCPtr = std::shared_ptr<const ReduceExecutorBuilder>;
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/reduce_list.cpp b/src/plugins/intel_cpu/src/nodes/executors/reduce_list.cpp
index aec5c7eb905865..e6f035879a2cc6 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/reduce_list.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/reduce_list.cpp
@@ -9,11 +9,10 @@ namespace intel_cpu {
 
 const std::vector<ReduceExecutorDesc>& getReduceExecutorsList() {
     static std::vector<ReduceExecutorDesc> descs = {
-        OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<AclReduceExecutorBuilder>())
-    };
+        OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<AclReduceExecutorBuilder>())};
 
     return descs;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/reduce_list.hpp b/src/plugins/intel_cpu/src/nodes/executors/reduce_list.hpp
index ea2543a495e64c..faffdebc947c02 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/reduce_list.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/reduce_list.hpp
@@ -5,14 +5,13 @@
 #pragma once
 
 #include "executor.hpp"
-
 #include "reduce.hpp"
 #if defined(OV_CPU_WITH_ACL)
-#include "acl/acl_reduce.hpp"
+#    include "acl/acl_reduce.hpp"
 #endif
 
-#include "onednn/iml_type_mapper.h"
 #include "common/primitive_cache.hpp"
+#include "onednn/iml_type_mapper.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -27,9 +26,10 @@ const std::vector<ReduceExecutorDesc>& getReduceExecutorsList();
 class ReduceExecutorFactory : public ExecutorFactoryLegacy {
 public:
     ReduceExecutorFactory(const ReduceAttrs& reduceAttrs,
-                       const std::vector<MemoryDescPtr>& srcDescs,
-                       const std::vector<MemoryDescPtr>& dstDescs,
-                       const ExecutorContext::CPtr context) : ExecutorFactoryLegacy(context) {
+                          const std::vector<MemoryDescPtr>& srcDescs,
+                          const std::vector<MemoryDescPtr>& dstDescs,
+                          const ExecutorContext::CPtr context)
+        : ExecutorFactoryLegacy(context) {
         for (auto& desc : getReduceExecutorsList()) {
             if (desc.builder->isSupported(reduceAttrs, srcDescs, dstDescs)) {
                 supportedDescs.push_back(desc);
@@ -39,9 +39,9 @@ class ReduceExecutorFactory : public ExecutorFactoryLegacy {
 
     ~ReduceExecutorFactory() = default;
     virtual ReduceExecutorPtr makeExecutor(const ReduceAttrs& reduceAttrs,
-                                        const std::vector<MemoryDescPtr>& srcDescs,
-                                        const std::vector<MemoryDescPtr>& dstDescs,
-                                        const dnnl::primitive_attr &attr) {
+                                           const std::vector<MemoryDescPtr>& srcDescs,
+                                           const std::vector<MemoryDescPtr>& dstDescs,
+                                           const dnnl::primitive_attr& attr) {
         auto build = [&](const ReduceExecutorDesc* desc) {
             auto executor = desc->builder->makeExecutor(context);
             if (executor->init(reduceAttrs, srcDescs, dstDescs, attr)) {
@@ -52,7 +52,6 @@ class ReduceExecutorFactory : public ExecutorFactoryLegacy {
             return ptr;
         };
 
-
         if (chosenDesc) {
             if (auto executor = build(chosenDesc)) {
                 return executor;
@@ -81,5 +80,5 @@ class ReduceExecutorFactory : public ExecutorFactoryLegacy {
 using ReduceExecutorFactoryPtr = std::shared_ptr<ReduceExecutorFactory>;
 using ReduceExecutorFactoryCPtr = std::shared_ptr<const ReduceExecutorFactory>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/transpose.cpp b/src/plugins/intel_cpu/src/nodes/executors/transpose.cpp
index 57e2e028827a62..b63e32e39ebf8d 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/transpose.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/transpose.cpp
@@ -2,9 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "transpose.hpp"
+
 #include <vector>
+
 #include "openvino/core/parallel.hpp"
-#include "transpose.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -33,27 +35,27 @@ jit_permute_config_params TransposeExecutor::prepareParams(const PermuteParams&
     }
 
     for (int i = tmp_order.size() - 1; i >= 0; i--) {
-        int pos = std::distance(std::find(
-                src_block_order.rbegin(), src_block_order.rend(), tmp_order[i]), src_block_order.rend() - 1);
+        int pos = std::distance(std::find(src_block_order.rbegin(), src_block_order.rend(), tmp_order[i]),
+                                src_block_order.rend() - 1);
         if (pos != -1) {
             new_src_block_strides[i] = src_block_strides[pos];
             src_block_order.erase(src_block_order.begin() + pos);
             src_block_strides.erase(src_block_strides.begin() + pos);
             mask[i] = 0;
         } else {
-            new_src_block_strides[i] = new_src_block_strides[tmp_order.size() - 1] * params.dst_block_dims[tmp_order.size() - 1];
+            new_src_block_strides[i] =
+                new_src_block_strides[tmp_order.size() - 1] * params.dst_block_dims[tmp_order.size() - 1];
             mask[i] = 1;
             mask[tmp_order.size() - 1] = 1;
         }
     }
     if (!src_block_order.empty()) {
         int pos = std::distance(tmp_order.begin(), std::find(tmp_order.begin(), tmp_order.end(), src_block_order[0]));
-        new_src_block_strides.insert(new_src_block_strides.begin() + pos,
-                                     src_block_strides[0]);
-        new_dst_block_strides.insert(new_dst_block_strides.begin() + pos,
-                                  new_dst_block_strides[pos] * params.src_block_dims[params.src_block_dims.size() - 1]);
-        new_dst_block_order.insert(new_dst_block_order.begin() + pos,
-                                   new_dst_block_order[pos]);
+        new_src_block_strides.insert(new_src_block_strides.begin() + pos, src_block_strides[0]);
+        new_dst_block_strides.insert(
+            new_dst_block_strides.begin() + pos,
+            new_dst_block_strides[pos] * params.src_block_dims[params.src_block_dims.size() - 1]);
+        new_dst_block_order.insert(new_dst_block_order.begin() + pos, new_dst_block_order[pos]);
         new_dst_block_dims.insert(new_dst_block_dims.begin() + pos + 1,
                                   params.src_block_dims[params.src_block_dims.size() - 1]);
         new_dst_block_dims[pos] = div_up(new_dst_block_dims[pos], new_dst_block_dims[pos + 1]);
@@ -107,12 +109,12 @@ jit_permute_config_params TransposeExecutor::prepareParams(const PermuteParams&
     }
 
     int max_threads = parallel_get_max_threads();
-    const int n_max = 3;    //  max count dims for parallel
+    const int n_max = 3;  //  max count dims for parallel
     int n = 0;
     int work_amount = sorted_dst_dims[0];
     for (size_t i = 1; i < sorted_dst_dims.size() && n < n_max; i++) {
         n++;
-        if (work_amount >= 4 * max_threads) {   //  4 * max_threads is a specially selected value for best performance
+        if (work_amount >= 4 * max_threads) {  //  4 * max_threads is a specially selected value for best performance
             break;
         }
         work_amount *= sorted_dst_dims[i];
@@ -128,5 +130,5 @@ jit_permute_config_params TransposeExecutor::prepareParams(const PermuteParams&
     return jcp;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/executors/transpose.hpp b/src/plugins/intel_cpu/src/nodes/executors/transpose.hpp
index 15f2d5085cd5ad..99e0b0a2742a78 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/transpose.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/transpose.hpp
@@ -5,9 +5,9 @@
 #pragma once
 
 #include "cpu_memory.h"
-#include "onednn/iml_type_mapper.h"
 #include "executor.hpp"
 #include "nodes/common/permute_kernel.h"
+#include "onednn/iml_type_mapper.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -23,8 +23,9 @@ class TransposeExecutor : public Executor {
     virtual bool init(const TransposeParams& transposeParams,
                       const std::vector<MemoryDescPtr>& srcDescs,
                       const std::vector<MemoryDescPtr>& dstDescs,
-                      const dnnl::primitive_attr &attr) = 0;
+                      const dnnl::primitive_attr& attr) = 0;
     virtual ~TransposeExecutor() = default;
+
 protected:
     PermuteParams permuteParams;
     const ExecutorContext::CPtr context;
@@ -44,5 +45,5 @@ class TransposeExecutorBuilder {
 using TransposeExecutorBuilderPtr = std::shared_ptr<TransposeExecutorBuilder>;
 using TransposeExecutorBuilderCPtr = std::shared_ptr<const TransposeExecutorBuilder>;
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/transpose_list.cpp b/src/plugins/intel_cpu/src/nodes/executors/transpose_list.cpp
index 31db070d04ffe3..f0e72f4bec1ae2 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/transpose_list.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/transpose_list.cpp
@@ -9,20 +9,19 @@ namespace intel_cpu {
 
 const std::vector<TransposeExecutorDesc>& getTransposeExecutorsList() {
     static const std::vector<TransposeExecutorDesc> descs = {
-            OV_CPU_INSTANCE_COMMON(ExecutorType::Common, std::make_shared<RefOptimizedTransposeExecutorBuilder>())
+        OV_CPU_INSTANCE_COMMON(ExecutorType::Common, std::make_shared<RefOptimizedTransposeExecutorBuilder>())
             OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<ACLTransposeExecutorBuilder>())
-            OV_CPU_INSTANCE_MLAS_ARM64(ExecutorType::Mlas, std::make_shared<MlasTransposeExecutorBuilder>())
-            OV_CPU_INSTANCE_X64(ExecutorType::jit_x64, std::make_shared<JitTransposeExecutorBuilder>())
-            OV_CPU_INSTANCE_COMMON(ExecutorType::Common, std::make_shared<RefTransposeExecutorBuilder>())
-    };
+                OV_CPU_INSTANCE_MLAS_ARM64(ExecutorType::Mlas, std::make_shared<MlasTransposeExecutorBuilder>())
+                    OV_CPU_INSTANCE_X64(ExecutorType::jit_x64, std::make_shared<JitTransposeExecutorBuilder>())
+                        OV_CPU_INSTANCE_COMMON(ExecutorType::Common, std::make_shared<RefTransposeExecutorBuilder>())};
 
     return descs;
 }
 
 TransposeExecutorPtr TransposeExecutorFactory::makeExecutor(const TransposeParams& transposeParams,
-                                                           const std::vector<MemoryDescPtr>& srcDescs,
-                                                           const std::vector<MemoryDescPtr>& dstDescs,
-                                                           const dnnl::primitive_attr &attr) {
+                                                            const std::vector<MemoryDescPtr>& srcDescs,
+                                                            const std::vector<MemoryDescPtr>& dstDescs,
+                                                            const dnnl::primitive_attr& attr) {
     auto build = [&](const TransposeExecutorDesc* desc) {
         auto executor = desc->builder->makeExecutor(context);
         if (executor->init(transposeParams, srcDescs, dstDescs, attr)) {
@@ -48,5 +47,5 @@ TransposeExecutorPtr TransposeExecutorFactory::makeExecutor(const TransposeParam
     OPENVINO_THROW("Supported executor is not found");
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/transpose_list.hpp b/src/plugins/intel_cpu/src/nodes/executors/transpose_list.hpp
index 90141a6194592e..c81769fd1d0539 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/transpose_list.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/transpose_list.hpp
@@ -5,19 +5,17 @@
 #pragma once
 
 #include "executor.hpp"
-
 #include "transpose.hpp"
 #if defined(OV_CPU_WITH_ACL)
-#include "acl/acl_transpose.hpp"
+#    include "acl/acl_transpose.hpp"
 #endif
 
+#include "common/primitive_cache.hpp"
 #include "common/ref_opt_transpose.hpp"
 #include "common/ref_transpose.hpp"
 #include "mlas/mlas_transpose.hpp"
-#include "x64/jit_transpose.hpp"
-
 #include "onednn/iml_type_mapper.h"
-#include "common/primitive_cache.hpp"
+#include "x64/jit_transpose.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -31,22 +29,23 @@ const std::vector<TransposeExecutorDesc>& getTransposeExecutorsList();
 
 class TransposeExecutorFactory : public ExecutorFactoryLegacy {
 public:
-TransposeExecutorFactory(const TransposeParams& transposeParams,
-                         const std::vector<MemoryDescPtr>& srcDescs,
-                         const std::vector<MemoryDescPtr>& dstDescs,
-                         const ExecutorContext::CPtr context) : ExecutorFactoryLegacy(context) {
-    for (auto& desc : getTransposeExecutorsList()) {
-        if (desc.builder->isSupported(transposeParams, srcDescs, dstDescs)) {
-            supportedDescs.push_back(desc);
+    TransposeExecutorFactory(const TransposeParams& transposeParams,
+                             const std::vector<MemoryDescPtr>& srcDescs,
+                             const std::vector<MemoryDescPtr>& dstDescs,
+                             const ExecutorContext::CPtr context)
+        : ExecutorFactoryLegacy(context) {
+        for (auto& desc : getTransposeExecutorsList()) {
+            if (desc.builder->isSupported(transposeParams, srcDescs, dstDescs)) {
+                supportedDescs.push_back(desc);
+            }
         }
     }
-}
 
-~TransposeExecutorFactory() = default;
-virtual TransposeExecutorPtr makeExecutor(const TransposeParams& transposeParams,
-                                          const std::vector<MemoryDescPtr>& srcDescs,
-                                          const std::vector<MemoryDescPtr>& dstDescs,
-                                          const dnnl::primitive_attr &attr);
+    ~TransposeExecutorFactory() = default;
+    virtual TransposeExecutorPtr makeExecutor(const TransposeParams& transposeParams,
+                                              const std::vector<MemoryDescPtr>& srcDescs,
+                                              const std::vector<MemoryDescPtr>& dstDescs,
+                                              const dnnl::primitive_attr& attr);
 
 private:
     std::vector<TransposeExecutorDesc> supportedDescs;
@@ -56,5 +55,5 @@ virtual TransposeExecutorPtr makeExecutor(const TransposeParams& transposeParams
 using TransposeExecutorFactoryPtr = std::shared_ptr<TransposeExecutorFactory>;
 using TransposeExecutorFactoryCPtr = std::shared_ptr<const TransposeExecutorFactory>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/type_mask.hpp b/src/plugins/intel_cpu/src/nodes/executors/type_mask.hpp
index d492bd6b6f368a..ef9fdac7f19208 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/type_mask.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/type_mask.hpp
@@ -14,29 +14,29 @@ namespace intel_cpu {
 struct TypeMask {
     enum Value : uint64_t {
         _undefined = 1 << 0,
-        _dynamic   = 1 << 1,
-        _boolean   = 1 << 2,
-        _bf16      = 1 << 3,
-        _f16       = 1 << 4,
-        _f32       = 1 << 5,
-        _f64       = 1 << 6,
-        _i4        = 1 << 7,
-        _i8        = 1 << 8,
-        _i16       = 1 << 9,
-        _i32       = 1 << 10,
-        _i64       = 1 << 11,
-        _u1        = 1 << 12,
-        _u4        = 1 << 13,
-        _u8        = 1 << 14,
-        _u16       = 1 << 15,
-        _u32       = 1 << 16,
-        _u64       = 1 << 17,
-        _nf4       = 1 << 18,
-        _f8e4m3    = 1 << 19,
-        _f8e5m2    = 1 << 20,
-        _string    = 1 << 21,
-        _f4e2m1    = 1 << 22,
-        _f8e8m0    = 1 << 23,
+        _dynamic = 1 << 1,
+        _boolean = 1 << 2,
+        _bf16 = 1 << 3,
+        _f16 = 1 << 4,
+        _f32 = 1 << 5,
+        _f64 = 1 << 6,
+        _i4 = 1 << 7,
+        _i8 = 1 << 8,
+        _i16 = 1 << 9,
+        _i32 = 1 << 10,
+        _i64 = 1 << 11,
+        _u1 = 1 << 12,
+        _u4 = 1 << 13,
+        _u8 = 1 << 14,
+        _u16 = 1 << 15,
+        _u32 = 1 << 16,
+        _u64 = 1 << 17,
+        _nf4 = 1 << 18,
+        _f8e4m3 = 1 << 19,
+        _f8e5m2 = 1 << 20,
+        _string = 1 << 21,
+        _f4e2m1 = 1 << 22,
+        _f8e8m0 = 1 << 23,
     };
 
     TypeMask(const ov::element::Type precision) : value(generateMask(precision)), precision(precision) {}
diff --git a/src/plugins/intel_cpu/src/nodes/executors/x64/jit_transpose.cpp b/src/plugins/intel_cpu/src/nodes/executors/x64/jit_transpose.cpp
index bfcc7ad4ae672a..79c578aaacda61 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/x64/jit_transpose.cpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/x64/jit_transpose.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "jit_transpose.hpp"
+
 #include "cpu/x64/cpu_isa_traits.hpp"
 
 using namespace dnnl::impl::cpu;
@@ -21,9 +22,10 @@ void JitTransposeExecutor::exec(const std::vector<MemoryCPtr>& src, const std::v
     pKernel->execute(srcData, dstData, MB);
 }
 
-bool JitTransposeExecutor::init(const TransposeParams &transposeParams,
-                                const std::vector<MemoryDescPtr> &srcDescs,
-                                const std::vector<MemoryDescPtr> &dstDescs, const dnnl::primitive_attr &attr) {
+bool JitTransposeExecutor::init(const TransposeParams& transposeParams,
+                                const std::vector<MemoryDescPtr>& srcDescs,
+                                const std::vector<MemoryDescPtr>& dstDescs,
+                                const dnnl::primitive_attr& attr) {
     pKernel = std::make_shared<PermuteKernel>(transposeParams.permuteParams);
     return true;
 }
@@ -35,9 +37,9 @@ bool JitTransposeExecutorBuilder::isSupported(const TransposeParams& transposePa
     if (mayiuse(x64::sse41)) {
         return true;
     }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
     return false;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/executors/x64/jit_transpose.hpp b/src/plugins/intel_cpu/src/nodes/executors/x64/jit_transpose.hpp
index d37ac9e5db5ef5..fd6d54257f1489 100644
--- a/src/plugins/intel_cpu/src/nodes/executors/x64/jit_transpose.hpp
+++ b/src/plugins/intel_cpu/src/nodes/executors/x64/jit_transpose.hpp
@@ -16,9 +16,12 @@ class JitTransposeExecutor : public TransposeExecutor {
     bool init(const TransposeParams& transposeParams,
               const std::vector<MemoryDescPtr>& srcDescs,
               const std::vector<MemoryDescPtr>& dstDescs,
-              const dnnl::primitive_attr &attr) override;
+              const dnnl::primitive_attr& attr) override;
     void exec(const std::vector<MemoryCPtr>& src, const std::vector<MemoryPtr>& dst) override;
-    impl_desc_type implType() const override { return impl_desc_type::jit; }
+    impl_desc_type implType() const override {
+        return impl_desc_type::jit;
+    }
+
 private:
     std::shared_ptr<PermuteKernel> pKernel;
 };
@@ -33,5 +36,5 @@ class JitTransposeExecutorBuilder : public TransposeExecutorBuilder {
     }
 };
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/experimental_detectron_detection_output.cpp b/src/plugins/intel_cpu/src/nodes/experimental_detectron_detection_output.cpp
index 441e013af2cbbf..dc58aabe26635d 100644
--- a/src/plugins/intel_cpu/src/nodes/experimental_detectron_detection_output.cpp
+++ b/src/plugins/intel_cpu/src/nodes/experimental_detectron_detection_output.cpp
@@ -2,12 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "openvino/op/experimental_detectron_detection_output.hpp"
+
 #include <string>
 #include <vector>
 
-#include "openvino/op/experimental_detectron_detection_output.hpp"
-#include "openvino/core/parallel.hpp"
 #include "experimental_detectron_detection_output.h"
+#include "openvino/core/parallel.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -36,13 +37,19 @@ struct Indexer {
     }
 };
 
-static
-void refine_boxes(const float* boxes, const float* deltas, const float* weights, const float* scores,
-                  float* refined_boxes, float* refined_boxes_areas, float* refined_scores,
-                  const int rois_num, const int classes_num,
-                  const float img_H, const float img_W,
-                  const float max_delta_log_wh,
-                  float coordinates_offset) {
+static void refine_boxes(const float* boxes,
+                         const float* deltas,
+                         const float* weights,
+                         const float* scores,
+                         float* refined_boxes,
+                         float* refined_boxes_areas,
+                         float* refined_scores,
+                         const int rois_num,
+                         const int classes_num,
+                         const float img_H,
+                         const float img_W,
+                         const float max_delta_log_wh,
+                         float coordinates_offset) {
     Indexer box_idx({rois_num, 4});
     Indexer delta_idx({rois_num, classes_num, 4});
     Indexer score_idx({rois_num, classes_num});
@@ -114,21 +121,22 @@ static bool SortScorePairDescend(const std::pair<float, std::pair<int, int>>& pa
     return (pair1.first > pair2.first) || ((pair1.first == pair2.first) && (pair1.second.second < pair2.second.second));
 }
 
-
 struct ConfidenceComparator {
     explicit ConfidenceComparator(const float* conf_data) : _conf_data(conf_data) {}
 
     bool operator()(int idx1, int idx2) {
-        if (_conf_data[idx1] > _conf_data[idx2]) return true;
-        if (_conf_data[idx1] < _conf_data[idx2]) return false;
+        if (_conf_data[idx1] > _conf_data[idx2])
+            return true;
+        if (_conf_data[idx1] < _conf_data[idx2])
+            return false;
         return idx1 < idx2;
     }
 
     const float* _conf_data;
 };
 
-static inline float JaccardOverlap(const float *decoded_bbox,
-                                   const float *bbox_sizes,
+static inline float JaccardOverlap(const float* decoded_bbox,
+                                   const float* bbox_sizes,
                                    const int idx1,
                                    const int idx2,
                                    const float coordinates_offset = 1) {
@@ -151,7 +159,7 @@ static inline float JaccardOverlap(const float *decoded_bbox,
     float intersect_xmax = (std::min)(xmax1, xmax2);
     float intersect_ymax = (std::min)(ymax1, ymax2);
 
-    float intersect_width  = intersect_xmax - intersect_xmin + coordinates_offset;
+    float intersect_width = intersect_xmax - intersect_xmin + coordinates_offset;
     float intersect_height = intersect_ymax - intersect_ymin + coordinates_offset;
 
     if (intersect_width <= 0 || intersect_height <= 0) {
@@ -165,7 +173,6 @@ static inline float JaccardOverlap(const float *decoded_bbox,
     return intersect_size / (bbox1_size + bbox2_size - intersect_size);
 }
 
-
 static void nms_cf(const float* conf_data,
                    const float* bboxes,
                    const float* sizes,
@@ -187,8 +194,10 @@ static void nms_cf(const float* conf_data,
 
     int num_output_scores = (pre_nms_topn == -1 ? count : (std::min)(pre_nms_topn, count));
 
-    std::partial_sort_copy(indices, indices + count,
-                           buffer, buffer + num_output_scores,
+    std::partial_sort_copy(indices,
+                           indices + count,
+                           buffer,
+                           buffer + num_output_scores,
                            ConfidenceComparator(conf_data));
 
     detections = 0;
@@ -221,11 +230,13 @@ bool ExperimentalDetectronDetectionOutput::needPrepareParams() const {
     return false;
 }
 
-bool ExperimentalDetectronDetectionOutput::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool ExperimentalDetectronDetectionOutput::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                                                std::string& errorMessage) noexcept {
     try {
         const auto doOp = ov::as_type_ptr<const ov::op::v6::ExperimentalDetectronDetectionOutput>(op);
         if (!doOp) {
-            errorMessage = "Node is not an instance of the ExperimentalDetectronDetectionOutput from the operations set v6.";
+            errorMessage =
+                "Node is not an instance of the ExperimentalDetectronDetectionOutput from the operations set v6.";
             return false;
         }
     } catch (...) {
@@ -294,10 +305,17 @@ void ExperimentalDetectronDetectionOutput::execute(dnnl::stream strm) {
     Indexer refined_box_idx({classes_num_, rois_num, 4});
     Indexer refined_score_idx({classes_num_, rois_num});
 
-    refine_boxes(boxes, deltas, &deltas_weights_[0], scores,
-                 &refined_boxes[0], &refined_boxes_areas[0], &refined_scores[0],
-                 rois_num, classes_num_,
-                 img_H, img_W,
+    refine_boxes(boxes,
+                 deltas,
+                 &deltas_weights_[0],
+                 scores,
+                 &refined_boxes[0],
+                 &refined_boxes_areas[0],
+                 &refined_scores[0],
+                 rois_num,
+                 classes_num_,
+                 img_H,
+                 img_W,
                  max_delta_log_wh_,
                  1.0f);
 
@@ -353,7 +371,7 @@ void ExperimentalDetectronDetectionOutput::execute(dnnl::stream strm) {
     memset(output_classes, 0, max_detections_per_image_ * sizeof(output_classes[0]));
 
     int i = 0;
-    for (const auto & detection : conf_index_class_map) {
+    for (const auto& detection : conf_index_class_map) {
         float score = detection.first;
         int cls = detection.second.first;
         int idx = detection.second.second;
@@ -371,6 +389,6 @@ bool ExperimentalDetectronDetectionOutput::created() const {
     return getType() == Type::ExperimentalDetectronDetectionOutput;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/experimental_detectron_detection_output.h b/src/plugins/intel_cpu/src/nodes/experimental_detectron_detection_output.h
index 2f76f1004face5..206f807585de7d 100644
--- a/src/plugins/intel_cpu/src/nodes/experimental_detectron_detection_output.h
+++ b/src/plugins/intel_cpu/src/nodes/experimental_detectron_detection_output.h
@@ -14,25 +14,27 @@ class ExperimentalDetectronDetectionOutput : public Node {
 public:
     ExperimentalDetectronDetectionOutput(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
 
     bool needShapeInfer() const override;
     bool needPrepareParams() const override;
-    void executeDynamicImpl(dnnl::stream strm) override { execute(strm); }
+    void executeDynamicImpl(dnnl::stream strm) override {
+        execute(strm);
+    }
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
 private:
-    const int INPUT_ROIS {0};
-    const int INPUT_DELTAS {1};
-    const int INPUT_SCORES {2};
-    const int INPUT_IM_INFO {3};
+    const int INPUT_ROIS{0};
+    const int INPUT_DELTAS{1};
+    const int INPUT_SCORES{2};
+    const int INPUT_IM_INFO{3};
 
-    const int OUTPUT_BOXES {0};
-    const int OUTPUT_CLASSES {1};
-    const int OUTPUT_SCORES {2};
+    const int OUTPUT_BOXES{0};
+    const int OUTPUT_CLASSES{1};
+    const int OUTPUT_SCORES{2};
 
     float score_threshold_;
     float nms_threshold_;
@@ -44,6 +46,6 @@ class ExperimentalDetectronDetectionOutput : public Node {
     std::vector<float> deltas_weights_;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/experimental_detectron_generate_proposals_single_image.cpp b/src/plugins/intel_cpu/src/nodes/experimental_detectron_generate_proposals_single_image.cpp
index 33f17c8d95f093..778e796aacc11a 100644
--- a/src/plugins/intel_cpu/src/nodes/experimental_detectron_generate_proposals_single_image.cpp
+++ b/src/plugins/intel_cpu/src/nodes/experimental_detectron_generate_proposals_single_image.cpp
@@ -2,22 +2,22 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <cstring>
+#include <algorithm>
 #include <cassert>
 #include <cmath>
+#include <cstring>
 #include <string>
-#include <vector>
 #include <utility>
-#include <algorithm>
+#include <vector>
 
 #if defined(HAVE_AVX2)
-#include <immintrin.h>
+#    include <immintrin.h>
 #endif
 
-#include "openvino/op/experimental_detectron_generate_proposals.hpp"
-#include "openvino/core/parallel.hpp"
 #include "common/cpu_memcpy.h"
 #include "experimental_detectron_generate_proposals_single_image.h"
+#include "openvino/core/parallel.hpp"
+#include "openvino/op/experimental_detectron_generate_proposals.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -29,20 +29,29 @@ struct Indexer4d {
     int dim23_;
     int dim123_;
 
-    explicit Indexer4d(int dim0, int dim1, int dim2, int dim3):
-            dim3_(dim3), dim23_(dim2 * dim3), dim123_(dim1 * dim2 * dim3) {
+    explicit Indexer4d(int dim0, int dim1, int dim2, int dim3)
+        : dim3_(dim3),
+          dim23_(dim2 * dim3),
+          dim123_(dim1 * dim2 * dim3) {
         (void)dim0;
     }
 
     int operator()(int i, int j, int k, int n) const {
-        return  i * dim123_ + j * dim23_ + k * dim3_ + n;
+        return i * dim123_ + j * dim23_ + k * dim3_ + n;
     }
 };
 
-void refine_anchors(const float* deltas, const float* scores, const float* anchors,
-                    float* proposals, const int anchors_num, const int bottom_H,
-                    const int bottom_W, const float img_H, const float img_W,
-                    const float min_box_H, const float min_box_W,
+void refine_anchors(const float* deltas,
+                    const float* scores,
+                    const float* anchors,
+                    float* proposals,
+                    const int anchors_num,
+                    const int bottom_H,
+                    const int bottom_W,
+                    const float img_H,
+                    const float img_W,
+                    const float min_box_H,
+                    const float min_box_W,
                     const float max_delta_log_wh,
                     float coordinates_offset) {
     Indexer4d delta_idx(anchors_num, 4, bottom_H, bottom_W);
@@ -108,17 +117,22 @@ void refine_anchors(const float* deltas, const float* scores, const float* ancho
 
 void unpack_boxes(const float* p_proposals, float* unpacked_boxes, int pre_nms_topn) {
     parallel_for(pre_nms_topn, [&](size_t i) {
-        unpacked_boxes[0*pre_nms_topn + i] = p_proposals[5*i + 0];
-        unpacked_boxes[1*pre_nms_topn + i] = p_proposals[5*i + 1];
-        unpacked_boxes[2*pre_nms_topn + i] = p_proposals[5*i + 2];
-        unpacked_boxes[3*pre_nms_topn + i] = p_proposals[5*i + 3];
-        unpacked_boxes[4*pre_nms_topn + i] = p_proposals[5*i + 4];
+        unpacked_boxes[0 * pre_nms_topn + i] = p_proposals[5 * i + 0];
+        unpacked_boxes[1 * pre_nms_topn + i] = p_proposals[5 * i + 1];
+        unpacked_boxes[2 * pre_nms_topn + i] = p_proposals[5 * i + 2];
+        unpacked_boxes[3 * pre_nms_topn + i] = p_proposals[5 * i + 3];
+        unpacked_boxes[4 * pre_nms_topn + i] = p_proposals[5 * i + 4];
     });
 }
 
-void nms_cpu(const int num_boxes, int is_dead[],
-             const float* boxes, int index_out[], int* const num_out,
-             const int base_index, const float nms_thresh, const int max_num_out,
+void nms_cpu(const int num_boxes,
+             int is_dead[],
+             const float* boxes,
+             int index_out[],
+             int* const num_out,
+             const int base_index,
+             const float nms_thresh,
+             const int max_num_out,
              float coordinates_offset) {
     const int num_proposals = num_boxes;
     int count = 0;
@@ -131,9 +145,9 @@ void nms_cpu(const int num_boxes, int is_dead[],
     std::memset(is_dead, 0, num_boxes * sizeof(int));
 
 #if defined(HAVE_AVX2)
-    __m256  vc_fone = _mm256_set1_ps(coordinates_offset);
+    __m256 vc_fone = _mm256_set1_ps(coordinates_offset);
     __m256i vc_ione = _mm256_set1_epi32(1);
-    __m256  vc_zero = _mm256_set1_ps(0.0f);
+    __m256 vc_zero = _mm256_set1_ps(0.0f);
 
     __m256 vc_nms_thresh = _mm256_set1_ps(nms_thresh);
 #endif
@@ -154,13 +168,13 @@ void nms_cpu(const int num_boxes, int is_dead[],
         __m256 vx1i = _mm256_set1_ps(x1[box]);
         __m256 vy1i = _mm256_set1_ps(y1[box]);
 
-        __m256 vA_width  = _mm256_sub_ps(vx1i, vx0i);
+        __m256 vA_width = _mm256_sub_ps(vx1i, vx0i);
         __m256 vA_height = _mm256_sub_ps(vy1i, vy0i);
-        __m256 vA_area   = _mm256_mul_ps(_mm256_add_ps(vA_width, vc_fone), _mm256_add_ps(vA_height, vc_fone));
+        __m256 vA_area = _mm256_mul_ps(_mm256_add_ps(vA_width, vc_fone), _mm256_add_ps(vA_height, vc_fone));
 
         for (; tail <= num_boxes - 8; tail += 8) {
-            __m256i *pdst = reinterpret_cast<__m256i*>(is_dead + tail);
-            __m256i  vdst = _mm256_loadu_si256(pdst);
+            __m256i* pdst = reinterpret_cast<__m256i*>(is_dead + tail);
+            __m256i vdst = _mm256_loadu_si256(pdst);
 
             __m256 vx0j = _mm256_loadu_ps(x0 + tail);
             __m256 vy0j = _mm256_loadu_ps(y0 + tail);
@@ -172,13 +186,13 @@ void nms_cpu(const int num_boxes, int is_dead[],
             __m256 vx1 = _mm256_min_ps(vx1i, vx1j);
             __m256 vy1 = _mm256_min_ps(vy1i, vy1j);
 
-            __m256 vwidth  = _mm256_add_ps(_mm256_sub_ps(vx1, vx0), vc_fone);
+            __m256 vwidth = _mm256_add_ps(_mm256_sub_ps(vx1, vx0), vc_fone);
             __m256 vheight = _mm256_add_ps(_mm256_sub_ps(vy1, vy0), vc_fone);
             __m256 varea = _mm256_mul_ps(_mm256_max_ps(vc_zero, vwidth), _mm256_max_ps(vc_zero, vheight));
 
-            __m256 vB_width  = _mm256_sub_ps(vx1j, vx0j);
+            __m256 vB_width = _mm256_sub_ps(vx1j, vx0j);
             __m256 vB_height = _mm256_sub_ps(vy1j, vy0j);
-            __m256 vB_area   = _mm256_mul_ps(_mm256_add_ps(vB_width, vc_fone), _mm256_add_ps(vB_height, vc_fone));
+            __m256 vB_area = _mm256_mul_ps(_mm256_add_ps(vB_width, vc_fone), _mm256_add_ps(vB_height, vc_fone));
 
             __m256 vdivisor = _mm256_sub_ps(_mm256_add_ps(vA_area, vB_area), varea);
             __m256 vintersection_area = _mm256_div_ps(varea, vdivisor);
@@ -219,9 +233,9 @@ void nms_cpu(const int num_boxes, int is_dead[],
                 const float y1 = std::min<float>(y1i, y1j);
 
                 // intersection area
-                const float width  = std::max<float>(0.0f,  x1 - x0 + coordinates_offset);
-                const float height = std::max<float>(0.0f,  y1 - y0 + coordinates_offset);
-                const float area   = width * height;
+                const float width = std::max<float>(0.0f, x1 - x0 + coordinates_offset);
+                const float height = std::max<float>(0.0f, y1 - y0 + coordinates_offset);
+                const float area = width * height;
 
                 // area of A, B
                 const float A_area = (x1i - x0i + coordinates_offset) * (y1i - y0i + coordinates_offset);
@@ -239,14 +253,18 @@ void nms_cpu(const int num_boxes, int is_dead[],
     *num_out = count;
 }
 
-void fill_output_blobs(const float* proposals, const int* roi_indices,
-                       float* rois, float* scores,
-                       const int num_proposals, const int num_rois, const int post_nms_topn) {
-    const float *src_x0 = proposals + 0 * num_proposals;
-    const float *src_y0 = proposals + 1 * num_proposals;
-    const float *src_x1 = proposals + 2 * num_proposals;
-    const float *src_y1 = proposals + 3 * num_proposals;
-    const float *src_score = proposals + 4 * num_proposals;
+void fill_output_blobs(const float* proposals,
+                       const int* roi_indices,
+                       float* rois,
+                       float* scores,
+                       const int num_proposals,
+                       const int num_rois,
+                       const int post_nms_topn) {
+    const float* src_x0 = proposals + 0 * num_proposals;
+    const float* src_y0 = proposals + 1 * num_proposals;
+    const float* src_x1 = proposals + 2 * num_proposals;
+    const float* src_y1 = proposals + 3 * num_proposals;
+    const float* src_score = proposals + 4 * num_proposals;
 
     parallel_for(num_rois, [&](size_t i) {
         int index = roi_indices[i];
@@ -269,10 +287,11 @@ void fill_output_blobs(const float* proposals, const int* roi_indices,
 
 }  // namespace
 
-bool ExperimentalDetectronGenerateProposalsSingleImage::isSupportedOperation
-            (const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool ExperimentalDetectronGenerateProposalsSingleImage::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                                                             std::string& errorMessage) noexcept {
     try {
-        const auto proposalOp = ov::as_type_ptr<const ov::op::v6::ExperimentalDetectronGenerateProposalsSingleImage>(op);
+        const auto proposalOp =
+            ov::as_type_ptr<const ov::op::v6::ExperimentalDetectronGenerateProposalsSingleImage>(op);
         if (!proposalOp) {
             errorMessage = "Node is not an instance of the Proposal from the operations set v0.";
             return false;
@@ -313,8 +332,7 @@ void ExperimentalDetectronGenerateProposalsSingleImage::initSupportedPrimitiveDe
                           {LayoutType::ncsp, ov::element::f32},
                           {LayoutType::ncsp, ov::element::f32},
                           {LayoutType::ncsp, ov::element::f32}},
-                         {{LayoutType::ncsp, ov::element::f32},
-                          {LayoutType::ncsp, ov::element::f32}},
+                         {{LayoutType::ncsp, ov::element::f32}, {LayoutType::ncsp, ov::element::f32}},
                          impl_desc_type::ref_any);
 }
 
@@ -325,13 +343,13 @@ void ExperimentalDetectronGenerateProposalsSingleImage::execute(dnnl::stream str
         }
 
         size_t anchor_dims_size = 1;
-        const auto &anchorDims = getParentEdgeAt(INPUT_ANCHORS)->getMemory().getStaticDims();
+        const auto& anchorDims = getParentEdgeAt(INPUT_ANCHORS)->getMemory().getStaticDims();
         for (size_t i = 0; i < anchorDims.size(); i++) {
             anchor_dims_size *= anchorDims[i];
         }
 
         size_t deltas_dims_size = 1;
-        const auto &deltaDims = getParentEdgeAt(INPUT_DELTAS)->getMemory().getStaticDims();
+        const auto& deltaDims = getParentEdgeAt(INPUT_DELTAS)->getMemory().getStaticDims();
         for (size_t i = 0; i < deltaDims.size(); i++) {
             deltas_dims_size *= deltaDims[i];
         }
@@ -339,7 +357,7 @@ void ExperimentalDetectronGenerateProposalsSingleImage::execute(dnnl::stream str
             OPENVINO_THROW("'Anchors' blob size for ONNXProposal is incompatible with 'deltas' blob size!");
 
         size_t score_dims_size = 1;
-        const auto &scoreDims = getParentEdgeAt(INPUT_SCORES)->getMemory().getStaticDims();
+        const auto& scoreDims = getParentEdgeAt(INPUT_SCORES)->getMemory().getStaticDims();
         for (size_t i = 0; i < scoreDims.size(); i++) {
             score_dims_size *= scoreDims[i];
         }
@@ -347,13 +365,13 @@ void ExperimentalDetectronGenerateProposalsSingleImage::execute(dnnl::stream str
             OPENVINO_THROW("'Deltas' blob size for ONNXProposal is incompatible with 'scores' blob size!");
 
         // Prepare memory
-        const float *p_deltas_item  = getSrcDataAtPortAs<const float>(INPUT_DELTAS);
-        const float *p_scores_item  = getSrcDataAtPortAs<const float>(INPUT_SCORES);
-        const float *p_anchors_item = getSrcDataAtPortAs<const float>(INPUT_ANCHORS);
-        const float *p_img_info_cpu = getSrcDataAtPortAs<const float>(INPUT_IM_INFO);
+        const float* p_deltas_item = getSrcDataAtPortAs<const float>(INPUT_DELTAS);
+        const float* p_scores_item = getSrcDataAtPortAs<const float>(INPUT_SCORES);
+        const float* p_anchors_item = getSrcDataAtPortAs<const float>(INPUT_ANCHORS);
+        const float* p_img_info_cpu = getSrcDataAtPortAs<const float>(INPUT_IM_INFO);
 
-        float *p_roi_item       = getDstDataAtPortAs<float>(OUTPUT_ROIS);
-        float *p_roi_score_item = getDstDataAtPortAs<float>(OUTPUT_SCORES);
+        float* p_roi_item = getDstDataAtPortAs<float>(OUTPUT_ROIS);
+        float* p_roi_score_item = getDstDataAtPortAs<float>(OUTPUT_SCORES);
 
         const int anchors_num = scoreDims[0];
 
@@ -398,24 +416,45 @@ void ExperimentalDetectronGenerateProposalsSingleImage::execute(dnnl::stream str
         // Execute
         int batch_size = 1;  // inputs[INPUT_DELTAS]->getTensorDesc().getDims()[0];
         for (int n = 0; n < batch_size; ++n) {
-            refine_anchors(p_deltas_item, p_scores_item, p_anchors_item,
-                           reinterpret_cast<float *>(&proposals_[0]), anchors_num, bottom_H,
-                           bottom_W, img_H, img_W,
-                           min_box_H, min_box_W,
+            refine_anchors(p_deltas_item,
+                           p_scores_item,
+                           p_anchors_item,
+                           reinterpret_cast<float*>(&proposals_[0]),
+                           anchors_num,
+                           bottom_H,
+                           bottom_W,
+                           img_H,
+                           img_W,
+                           min_box_H,
+                           min_box_W,
                            static_cast<const float>(std::log(1000. / 16.)),
                            1.0f);
-            std::partial_sort(proposals_.begin(), proposals_.begin() + pre_nms_topn, proposals_.end(),
-                              [](const ProposalBox &struct1, const ProposalBox &struct2) {
+            std::partial_sort(proposals_.begin(),
+                              proposals_.begin() + pre_nms_topn,
+                              proposals_.end(),
+                              [](const ProposalBox& struct1, const ProposalBox& struct2) {
                                   return (struct1.score > struct2.score);
                               });
 
-            unpack_boxes(reinterpret_cast<float *>(&proposals_[0]), &unpacked_boxes[0], pre_nms_topn);
-            nms_cpu(pre_nms_topn, &is_dead[0], &unpacked_boxes[0], &roi_indices_[0], &num_rois, 0,
-                    nms_thresh_, post_nms_topn_, coordinates_offset);
-            fill_output_blobs(&unpacked_boxes[0], &roi_indices_[0], p_roi_item, p_roi_score_item,
-                              pre_nms_topn, num_rois, post_nms_topn_);
+            unpack_boxes(reinterpret_cast<float*>(&proposals_[0]), &unpacked_boxes[0], pre_nms_topn);
+            nms_cpu(pre_nms_topn,
+                    &is_dead[0],
+                    &unpacked_boxes[0],
+                    &roi_indices_[0],
+                    &num_rois,
+                    0,
+                    nms_thresh_,
+                    post_nms_topn_,
+                    coordinates_offset);
+            fill_output_blobs(&unpacked_boxes[0],
+                              &roi_indices_[0],
+                              p_roi_item,
+                              p_roi_score_item,
+                              pre_nms_topn,
+                              num_rois,
+                              post_nms_topn_);
         }
-    } catch (const std::exception &e) {
+    } catch (const std::exception& e) {
         std::string errorMsg = e.what();
         OPENVINO_THROW(errorMsg);
     }
@@ -433,6 +472,6 @@ bool ExperimentalDetectronGenerateProposalsSingleImage::needPrepareParams() cons
     return false;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/experimental_detectron_generate_proposals_single_image.h b/src/plugins/intel_cpu/src/nodes/experimental_detectron_generate_proposals_single_image.h
index 41aaf63f637e76..d747813e10b258 100644
--- a/src/plugins/intel_cpu/src/nodes/experimental_detectron_generate_proposals_single_image.h
+++ b/src/plugins/intel_cpu/src/nodes/experimental_detectron_generate_proposals_single_image.h
@@ -13,16 +13,18 @@ namespace node {
 class ExperimentalDetectronGenerateProposalsSingleImage : public Node {
 public:
     ExperimentalDetectronGenerateProposalsSingleImage(const std::shared_ptr<ov::Node>& op,
-        const GraphContext::CPtr context);
+                                                      const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
 
     bool needShapeInfer() const override;
     bool needPrepareParams() const override;
-    void executeDynamicImpl(dnnl::stream strm) override { execute(strm); }
+    void executeDynamicImpl(dnnl::stream strm) override {
+        execute(strm);
+    }
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
 private:
@@ -32,12 +34,12 @@ class ExperimentalDetectronGenerateProposalsSingleImage : public Node {
     // Outputs:
     //      top_rois, shape [max_rois, 4]
 
-    const int INPUT_IM_INFO {0};
-    const int INPUT_ANCHORS {1};
-    const int INPUT_DELTAS {2};
-    const int INPUT_SCORES {3};
-    const int OUTPUT_ROIS {0};
-    const int OUTPUT_SCORES {1};
+    const int INPUT_IM_INFO{0};
+    const int INPUT_ANCHORS{1};
+    const int INPUT_DELTAS{2};
+    const int INPUT_SCORES{3};
+    const int OUTPUT_ROIS{0};
+    const int OUTPUT_SCORES{1};
 
     float min_size_;
     int pre_nms_topn_;
@@ -48,6 +50,6 @@ class ExperimentalDetectronGenerateProposalsSingleImage : public Node {
     std::vector<int> roi_indices_;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/experimental_detectron_priorgridgenerator.cpp b/src/plugins/intel_cpu/src/nodes/experimental_detectron_priorgridgenerator.cpp
index eead95def0a8fb..f7df0e533778ed 100644
--- a/src/plugins/intel_cpu/src/nodes/experimental_detectron_priorgridgenerator.cpp
+++ b/src/plugins/intel_cpu/src/nodes/experimental_detectron_priorgridgenerator.cpp
@@ -2,20 +2,22 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <string>
+#include "experimental_detectron_priorgridgenerator.h"
 
 #include <openvino/opsets/opset6.hpp>
+#include <string>
+
 #include "openvino/core/parallel.hpp"
-#include "experimental_detectron_priorgridgenerator.h"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
 bool ExperimentalDetectronPriorGridGenerator::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
-                                                                             std::string& errorMessage) noexcept {
+                                                                   std::string& errorMessage) noexcept {
     try {
-        const auto priorGridGen = std::dynamic_pointer_cast<const ov::opset6::ExperimentalDetectronPriorGridGenerator>(op);
+        const auto priorGridGen =
+            std::dynamic_pointer_cast<const ov::opset6::ExperimentalDetectronPriorGridGenerator>(op);
         if (!priorGridGen) {
             errorMessage = "Only opset6 ExperimentalDetectronPriorGridGenerator operation is supported";
             return false;
@@ -39,7 +41,7 @@ ExperimentalDetectronPriorGridGenerator::ExperimentalDetectronPriorGridGenerator
     if (getOriginalInputsNumber() != 3 || getOriginalOutputsNumber() != 1)
         OPENVINO_THROW(errorPrefix, " has incorrect number of input/output edges!");
 
-    const auto &attr = priorGridGen->get_attrs();
+    const auto& attr = priorGridGen->get_attrs();
     grid_w_ = attr.w;
     grid_h_ = attr.h;
     stride_h_ = attr.stride_y;
@@ -64,11 +66,15 @@ void ExperimentalDetectronPriorGridGenerator::execute(dnnl::stream strm) {
     // Execute
     const int layer_width = grid_w_ ? grid_w_ : getParentEdgeAt(INPUT_FEATUREMAP)->getMemory().getStaticDims()[3];
     const int layer_height = grid_h_ ? grid_h_ : getParentEdgeAt(INPUT_FEATUREMAP)->getMemory().getStaticDims()[2];
-    const float step_w = stride_w_ ? stride_w_ : static_cast<float>(getParentEdgeAt(INPUT_IMAGE)->getMemory().getStaticDims()[3]) / layer_width;
-    const float step_h = stride_h_ ? stride_h_ : static_cast<float>(getParentEdgeAt(INPUT_IMAGE)->getMemory().getStaticDims()[2]) / layer_height;
+    const float step_w =
+        stride_w_ ? stride_w_
+                  : static_cast<float>(getParentEdgeAt(INPUT_IMAGE)->getMemory().getStaticDims()[3]) / layer_width;
+    const float step_h =
+        stride_h_ ? stride_h_
+                  : static_cast<float>(getParentEdgeAt(INPUT_IMAGE)->getMemory().getStaticDims()[2]) / layer_height;
 
-    const auto *bottom_data_0 = getSrcDataAtPortAs<const float>(0);
-    auto *top_data_0 = getDstDataAtPortAs<float>(OUTPUT_ROIS);
+    const auto* bottom_data_0 = getSrcDataAtPortAs<const float>(0);
+    auto* top_data_0 = getDstDataAtPortAs<float>(OUTPUT_ROIS);
 
     for (int h = 0; h < layer_height; ++h) {
         for (int w = 0; w < layer_width; ++w) {
@@ -91,6 +97,6 @@ bool ExperimentalDetectronPriorGridGenerator::needPrepareParams() const {
     return false;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/experimental_detectron_priorgridgenerator.h b/src/plugins/intel_cpu/src/nodes/experimental_detectron_priorgridgenerator.h
index cf52b4e5c9b934..47c2c16dc558b9 100644
--- a/src/plugins/intel_cpu/src/nodes/experimental_detectron_priorgridgenerator.h
+++ b/src/plugins/intel_cpu/src/nodes/experimental_detectron_priorgridgenerator.h
@@ -14,13 +14,15 @@ class ExperimentalDetectronPriorGridGenerator : public Node {
 public:
     ExperimentalDetectronPriorGridGenerator(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
 
     bool needPrepareParams() const override;
-    void executeDynamicImpl(dnnl::stream strm) override { execute(strm); }
+    void executeDynamicImpl(dnnl::stream strm) override {
+        execute(strm);
+    }
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
 private:
@@ -31,11 +33,11 @@ class ExperimentalDetectronPriorGridGenerator : public Node {
     // Outputs:
     //      priors_grid, shape [m, 4]
 
-    const int INPUT_PRIORS {0};
-    const int INPUT_FEATUREMAP {1};
-    const int INPUT_IMAGE {2};
+    const int INPUT_PRIORS{0};
+    const int INPUT_FEATUREMAP{1};
+    const int INPUT_IMAGE{2};
 
-    const int OUTPUT_ROIS {0};
+    const int OUTPUT_ROIS{0};
 
     int grid_w_;
     int grid_h_;
@@ -45,6 +47,6 @@ class ExperimentalDetectronPriorGridGenerator : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/experimental_detectron_roifeatureextractor.cpp b/src/plugins/intel_cpu/src/nodes/experimental_detectron_roifeatureextractor.cpp
index c92e3c2594d4a9..05f2202537f986 100644
--- a/src/plugins/intel_cpu/src/nodes/experimental_detectron_roifeatureextractor.cpp
+++ b/src/plugins/intel_cpu/src/nodes/experimental_detectron_roifeatureextractor.cpp
@@ -2,14 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "experimental_detectron_roifeatureextractor.h"
+
+#include <algorithm>
+#include <openvino/opsets/opset6.hpp>
 #include <string>
 #include <vector>
-#include <algorithm>
 
-#include <openvino/opsets/opset6.hpp>
-#include "openvino/core/parallel.hpp"
 #include "common/cpu_memcpy.h"
-#include "experimental_detectron_roifeatureextractor.h"
+#include "openvino/core/parallel.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -30,31 +31,28 @@ struct PreCalc {
 };
 
 template <typename T>
-void pre_calc_for_bilinear_interpolate(
-        const int height,
-        const int width,
-        const int pooled_height,
-        const int pooled_width,
-        const int iy_upper,
-        const int ix_upper,
-        T roi_start_h,
-        T roi_start_w,
-        T bin_size_h,
-        T bin_size_w,
-        int roi_bin_grid_h,
-        int roi_bin_grid_w,
-        std::vector<PreCalc<T>>& pre_calc) {
+void pre_calc_for_bilinear_interpolate(const int height,
+                                       const int width,
+                                       const int pooled_height,
+                                       const int pooled_width,
+                                       const int iy_upper,
+                                       const int ix_upper,
+                                       T roi_start_h,
+                                       T roi_start_w,
+                                       T bin_size_h,
+                                       T bin_size_w,
+                                       int roi_bin_grid_h,
+                                       int roi_bin_grid_w,
+                                       std::vector<PreCalc<T>>& pre_calc) {
     int pre_calc_index = 0;
     for (int ph = 0; ph < pooled_height; ph++) {
         for (int pw = 0; pw < pooled_width; pw++) {
             for (int iy = 0; iy < iy_upper; iy++) {
                 const T yy = roi_start_h + ph * bin_size_h +
-                             static_cast<T>(iy + .5f) * bin_size_h /
-                             static_cast<T>(roi_bin_grid_h);  // e.g., 0.5, 1.5
+                             static_cast<T>(iy + .5f) * bin_size_h / static_cast<T>(roi_bin_grid_h);  // e.g., 0.5, 1.5
                 for (int ix = 0; ix < ix_upper; ix++) {
                     const T xx = roi_start_w + pw * bin_size_w +
-                                 static_cast<T>(ix + .5f) * bin_size_w /
-                                 static_cast<T>(roi_bin_grid_w);
+                                 static_cast<T>(ix + .5f) * bin_size_w / static_cast<T>(roi_bin_grid_w);
 
                     T x = xx;
                     T y = yy;
@@ -126,19 +124,18 @@ void pre_calc_for_bilinear_interpolate(
 }
 
 template <typename T>
-void ROIAlignForward_cpu_kernel(
-        const int nthreads,
-        const T* bottom_data,
-        const T& spatial_scale,
-        const int channels,
-        const int height,
-        const int width,
-        const int pooled_height,
-        const int pooled_width,
-        const int sampling_ratio,
-        const T* bottom_rois,
-        const bool aligned,
-        T* top_data) {
+void ROIAlignForward_cpu_kernel(const int nthreads,
+                                const T* bottom_data,
+                                const T& spatial_scale,
+                                const int channels,
+                                const int height,
+                                const int width,
+                                const int pooled_height,
+                                const int pooled_width,
+                                const int sampling_ratio,
+                                const T* bottom_rois,
+                                const bool aligned,
+                                T* top_data) {
     int roi_cols = 4;
 
     int n_rois = nthreads / channels / pooled_width / pooled_height;
@@ -168,38 +165,33 @@ void ROIAlignForward_cpu_kernel(
         T bin_size_w = static_cast<T>(roi_width) / static_cast<T>(pooled_width);
 
         // We use roi_bin_grid to sample the grid and mimic integral
-        int roi_bin_grid_h = (sampling_ratio > 0)
-                             ? sampling_ratio
-                             : static_cast<int>(ceil(roi_height / pooled_height));  // e.g., = 2
-        int roi_bin_grid_w =
-                (sampling_ratio > 0) ? sampling_ratio : static_cast<int>(ceil(roi_width / pooled_width));
+        int roi_bin_grid_h =
+            (sampling_ratio > 0) ? sampling_ratio : static_cast<int>(ceil(roi_height / pooled_height));  // e.g., = 2
+        int roi_bin_grid_w = (sampling_ratio > 0) ? sampling_ratio : static_cast<int>(ceil(roi_width / pooled_width));
 
         // We do average (integral) pooling inside a bin
         const T count = static_cast<T>(roi_bin_grid_h * roi_bin_grid_w);  // e.g. = 4
 
         // we want to precalculate indices and weights shared by all chanels,
         // this is the key point of optimiation
-        std::vector<PreCalc<T>> pre_calc(
-                roi_bin_grid_h * roi_bin_grid_w * pooled_width * pooled_height);
-        pre_calc_for_bilinear_interpolate(
-                height,
-                width,
-                pooled_height,
-                pooled_width,
-                roi_bin_grid_h,
-                roi_bin_grid_w,
-                roi_start_h,
-                roi_start_w,
-                bin_size_h,
-                bin_size_w,
-                roi_bin_grid_h,
-                roi_bin_grid_w,
-                pre_calc);
+        std::vector<PreCalc<T>> pre_calc(roi_bin_grid_h * roi_bin_grid_w * pooled_width * pooled_height);
+        pre_calc_for_bilinear_interpolate(height,
+                                          width,
+                                          pooled_height,
+                                          pooled_width,
+                                          roi_bin_grid_h,
+                                          roi_bin_grid_w,
+                                          roi_start_h,
+                                          roi_start_w,
+                                          bin_size_h,
+                                          bin_size_w,
+                                          roi_bin_grid_h,
+                                          roi_bin_grid_w,
+                                          pre_calc);
 
         for (int c = 0; c < channels; c++) {
             int index_n_c = index_n + c * pooled_width * pooled_height;
-            const T* offset_bottom_data =
-                    bottom_data + (roi_batch_ind * channels + c) * height * width;
+            const T* offset_bottom_data = bottom_data + (roi_batch_ind * channels + c) * height * width;
             int pre_calc_index = 0;
 
             for (int ph = 0; ph < pooled_height; ph++) {
@@ -210,10 +202,8 @@ void ROIAlignForward_cpu_kernel(
                     for (int iy = 0; iy < roi_bin_grid_h; iy++) {
                         for (int ix = 0; ix < roi_bin_grid_w; ix++) {
                             PreCalc<T> pc = pre_calc[pre_calc_index];
-                            output_val += pc.w1 * offset_bottom_data[pc.pos1] +
-                                          pc.w2 * offset_bottom_data[pc.pos2] +
-                                          pc.w3 * offset_bottom_data[pc.pos3] +
-                                          pc.w4 * offset_bottom_data[pc.pos4];
+                            output_val += pc.w1 * offset_bottom_data[pc.pos1] + pc.w2 * offset_bottom_data[pc.pos2] +
+                                          pc.w3 * offset_bottom_data[pc.pos3] + pc.w4 * offset_bottom_data[pc.pos4];
 
                             pre_calc_index += 1;
                         }
@@ -222,14 +212,12 @@ void ROIAlignForward_cpu_kernel(
 
                     top_data[index] = output_val;
                 }  // for pw
-            }  // for ph
-        }  // for c
+            }      // for ph
+        }          // for c
     });
 }
 
-
-void redistribute_rois(const float* rois, int* level_ids,
-                       const int num_rois, const int levels_num) {
+void redistribute_rois(const float* rois, int* level_ids, const int num_rois, const int levels_num) {
     const float canonical_scale = 224.0f;
     const int canonical_level = 2;
 
@@ -252,11 +240,11 @@ void redistribute_rois(const float* rois, int* level_ids,
     }
 }
 
-
-void reord(const float* src_data, const int* ranks, const int n, const int step, float* dst_data,
-             int* dst_mapping) {
+void reord(const float* src_data, const int* ranks, const int n, const int step, float* dst_data, int* dst_mapping) {
     std::iota(dst_mapping, dst_mapping + n, 0);
-    std::sort(dst_mapping, dst_mapping + n, [&ranks](size_t i1, size_t i2) {return ranks[i1] < ranks[i2];});
+    std::sort(dst_mapping, dst_mapping + n, [&ranks](size_t i1, size_t i2) {
+        return ranks[i1] < ranks[i2];
+    });
     for (int i = 0; i < n; ++i) {
         const int j = dst_mapping[i];
         assert(0 <= j && j < n);
@@ -277,12 +265,13 @@ void split_points(const std::vector<int>& ids, std::vector<int>& rois_per_level,
     rois_per_level.insert(rois_per_level.begin(), 0);
 }
 
-} // namespace
+}  // namespace
 
 bool ExperimentalDetectronROIFeatureExtractor::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
-                                                                              std::string& errorMessage) noexcept {
+                                                                    std::string& errorMessage) noexcept {
     try {
-        const auto roiFeatureExtractor = std::dynamic_pointer_cast<const ov::opset6::ExperimentalDetectronROIFeatureExtractor>(op);
+        const auto roiFeatureExtractor =
+            std::dynamic_pointer_cast<const ov::opset6::ExperimentalDetectronROIFeatureExtractor>(op);
         if (!roiFeatureExtractor) {
             errorMessage = "Only opset6 ExperimentalDetectronROIFeatureExtractor operation is supported";
             return false;
@@ -301,8 +290,9 @@ ExperimentalDetectronROIFeatureExtractor::ExperimentalDetectronROIFeatureExtract
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
     }
 
-    const auto roiFeatureExtractor = std::dynamic_pointer_cast<const ov::opset6::ExperimentalDetectronROIFeatureExtractor>(op);
-    const auto &attr = roiFeatureExtractor->get_attrs();
+    const auto roiFeatureExtractor =
+        std::dynamic_pointer_cast<const ov::opset6::ExperimentalDetectronROIFeatureExtractor>(op);
+    const auto& attr = roiFeatureExtractor->get_attrs();
     output_dim_ = attr.output_size;
     pyramid_scales_ = attr.pyramid_scales;
     sampling_ratio_ = attr.sampling_ratio;
@@ -321,8 +311,7 @@ void ExperimentalDetectronROIFeatureExtractor::initSupportedPrimitiveDescriptors
         inDataConf.emplace_back(LayoutType::ncsp, ov::element::f32);
 
     addSupportedPrimDesc(inDataConf,
-                         {{LayoutType::ncsp, ov::element::f32},
-                          {LayoutType::ncsp, ov::element::f32}},
+                         {{LayoutType::ncsp, ov::element::f32}, {LayoutType::ncsp, ov::element::f32}},
                          impl_desc_type::ref_any);
 }
 
@@ -332,15 +321,15 @@ void ExperimentalDetectronROIFeatureExtractor::execute(dnnl::stream strm) {
     const int channels_num = getParentEdgeAt(INPUT_FEATURES_START)->getMemory().getStaticDims()[1];
     const int feaxels_per_roi = pooled_height_ * pooled_width_ * channels_num;
 
-    auto *input_rois = getSrcDataAtPortAs<const float>(INPUT_ROIS);
-    auto *output_rois_features = getDstDataAtPortAs<float>(OUTPUT_ROI_FEATURES);
-    float *output_rois = nullptr;
+    auto* input_rois = getSrcDataAtPortAs<const float>(INPUT_ROIS);
+    auto* output_rois_features = getDstDataAtPortAs<float>(OUTPUT_ROI_FEATURES);
+    float* output_rois = nullptr;
     if (OUTPUT_ROIS < outputShapes.size()) {
         output_rois = getDstDataAtPortAs<float>(OUTPUT_ROIS);
     }
 
     std::vector<int> level_ids(num_rois, 0);
-    redistribute_rois(input_rois, reinterpret_cast<int *>(&level_ids[0]), num_rois, levels_num);
+    redistribute_rois(input_rois, reinterpret_cast<int*>(&level_ids[0]), num_rois, levels_num);
 
     std::vector<float> reordered_rois(4 * num_rois, 0);
     std::vector<int> original_rois_mapping(num_rois, 0);
@@ -354,7 +343,7 @@ void ExperimentalDetectronROIFeatureExtractor::execute(dnnl::stream strm) {
         const int level_rois_offset = rois_per_level[i];
         const int level_rois_num = rois_per_level[i + 1] - level_rois_offset;
         if (level_rois_num > 0) {
-            auto *featuremap = getSrcDataAtPortAs<const float>(INPUT_FEATURES_START + i);
+            auto* featuremap = getSrcDataAtPortAs<const float>(INPUT_FEATURES_START + i);
             const int featuremap_height = getParentEdgeAt(INPUT_FEATURES_START + i)->getMemory().getStaticDims()[2];
             const int featuremap_width = getParentEdgeAt(INPUT_FEATURES_START + i)->getMemory().getStaticDims()[3];
             ROIAlignForward_cpu_kernel<float>(feaxels_per_roi * level_rois_num,
@@ -373,8 +362,12 @@ void ExperimentalDetectronROIFeatureExtractor::execute(dnnl::stream strm) {
     }
 
     std::vector<int> dummy_mapping(num_rois, 0);
-    reord(&output_rois_features_temp[0], &original_rois_mapping[0], num_rois, feaxels_per_roi,
-            output_rois_features, &dummy_mapping[0]);
+    reord(&output_rois_features_temp[0],
+          &original_rois_mapping[0],
+          num_rois,
+          feaxels_per_roi,
+          output_rois_features,
+          &dummy_mapping[0]);
     if (output_rois != nullptr) {
         cpu_memcpy(output_rois, input_rois, 4 * num_rois * sizeof(float));
     }
@@ -384,6 +377,6 @@ bool ExperimentalDetectronROIFeatureExtractor::created() const {
     return getType() == Type::ExperimentalDetectronROIFeatureExtractor;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/experimental_detectron_roifeatureextractor.h b/src/plugins/intel_cpu/src/nodes/experimental_detectron_roifeatureextractor.h
index 94bfdfd224d0c5..374fd62c61b776 100644
--- a/src/plugins/intel_cpu/src/nodes/experimental_detectron_roifeatureextractor.h
+++ b/src/plugins/intel_cpu/src/nodes/experimental_detectron_roifeatureextractor.h
@@ -14,22 +14,26 @@ class ExperimentalDetectronROIFeatureExtractor : public Node {
 public:
     ExperimentalDetectronROIFeatureExtractor(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
 
-    bool needPrepareParams() const override { return false; };
-    void executeDynamicImpl(dnnl::stream strm) override { execute(strm); };
+    bool needPrepareParams() const override {
+        return false;
+    };
+    void executeDynamicImpl(dnnl::stream strm) override {
+        execute(strm);
+    };
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
 private:
-    const int INPUT_ROIS {0};
-    const int INPUT_FEATURES_START {1};
+    const int INPUT_ROIS{0};
+    const int INPUT_FEATURES_START{1};
 
-    const int OUTPUT_ROI_FEATURES {0};
-    const size_t OUTPUT_ROIS {1};
+    const int OUTPUT_ROI_FEATURES{0};
+    const size_t OUTPUT_ROIS{1};
 
     int output_dim_ = 0;
     int pooled_height_ = 0;
@@ -39,6 +43,6 @@ class ExperimentalDetectronROIFeatureExtractor : public Node {
     bool aligned_ = false;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/experimental_detectron_topkrois.cpp b/src/plugins/intel_cpu/src/nodes/experimental_detectron_topkrois.cpp
index 46b60fcdb83efd..f09d96ac7a7f7e 100644
--- a/src/plugins/intel_cpu/src/nodes/experimental_detectron_topkrois.cpp
+++ b/src/plugins/intel_cpu/src/nodes/experimental_detectron_topkrois.cpp
@@ -2,20 +2,22 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "experimental_detectron_topkrois.h"
+
+#include <algorithm>
+#include <openvino/opsets/opset6.hpp>
 #include <string>
 #include <vector>
-#include <algorithm>
 
-#include <openvino/opsets/opset6.hpp>
-#include "openvino/core/parallel.hpp"
 #include "common/cpu_memcpy.h"
-#include "experimental_detectron_topkrois.h"
+#include "openvino/core/parallel.hpp"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-bool ExperimentalDetectronTopKROIs::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool ExperimentalDetectronTopKROIs::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                                         std::string& errorMessage) noexcept {
     try {
         const auto topKROI = std::dynamic_pointer_cast<const ov::opset6::ExperimentalDetectronTopKROIs>(op);
         if (!topKROI) {
@@ -56,8 +58,7 @@ void ExperimentalDetectronTopKROIs::initSupportedPrimitiveDescriptors() {
     if (!supportedPrimitiveDescriptors.empty())
         return;
 
-    addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32},
-                          {LayoutType::ncsp, ov::element::f32}},
+    addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32}, {LayoutType::ncsp, ov::element::f32}},
                          {{LayoutType::ncsp, ov::element::f32}},
                          impl_desc_type::ref_any);
 }
@@ -66,14 +67,16 @@ void ExperimentalDetectronTopKROIs::execute(dnnl::stream strm) {
     const int input_rois_num = getParentEdgeAt(INPUT_ROIS)->getMemory().getStaticDims()[0];
     const int top_rois_num = (std::min)(max_rois_num_, input_rois_num);
 
-    auto *input_rois = getSrcDataAtPortAs<const float>(INPUT_ROIS);
-    auto *input_probs = getSrcDataAtPortAs<const float>(INPUT_PROBS);
-    auto *output_rois = getDstDataAtPortAs<float>(OUTPUT_ROIS);
+    auto* input_rois = getSrcDataAtPortAs<const float>(INPUT_ROIS);
+    auto* input_probs = getSrcDataAtPortAs<const float>(INPUT_PROBS);
+    auto* output_rois = getDstDataAtPortAs<float>(OUTPUT_ROIS);
 
     std::vector<size_t> idx(input_rois_num);
     iota(idx.begin(), idx.end(), 0);
     // FIXME. partial_sort is enough here.
-    sort(idx.begin(), idx.end(), [&input_probs](size_t i1, size_t i2) {return input_probs[i1] > input_probs[i2];});
+    sort(idx.begin(), idx.end(), [&input_probs](size_t i1, size_t i2) {
+        return input_probs[i1] > input_probs[i2];
+    });
 
     for (int i = 0; i < top_rois_num; ++i) {
         cpu_memcpy(output_rois + 4 * i, input_rois + 4 * idx[i], 4 * sizeof(float));
@@ -84,6 +87,6 @@ bool ExperimentalDetectronTopKROIs::created() const {
     return getType() == Type::ExperimentalDetectronTopKROIs;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/experimental_detectron_topkrois.h b/src/plugins/intel_cpu/src/nodes/experimental_detectron_topkrois.h
index 5c2db1fa2303ea..3fe134948d5e45 100644
--- a/src/plugins/intel_cpu/src/nodes/experimental_detectron_topkrois.h
+++ b/src/plugins/intel_cpu/src/nodes/experimental_detectron_topkrois.h
@@ -14,14 +14,20 @@ class ExperimentalDetectronTopKROIs : public Node {
 public:
     ExperimentalDetectronTopKROIs(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
 
-    bool needShapeInfer() const override { return false; };
-    bool needPrepareParams() const override { return false; };
-    void executeDynamicImpl(dnnl::stream strm) override { execute(strm); };
+    bool needShapeInfer() const override {
+        return false;
+    };
+    bool needPrepareParams() const override {
+        return false;
+    };
+    void executeDynamicImpl(dnnl::stream strm) override {
+        execute(strm);
+    };
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
@@ -32,15 +38,15 @@ class ExperimentalDetectronTopKROIs : public Node {
     // Outputs:
     //      top_rois, shape [max_rois, 4]
 
-    const int INPUT_ROIS {0};
-    const int INPUT_PROBS {1};
+    const int INPUT_ROIS{0};
+    const int INPUT_PROBS{1};
 
-    const int OUTPUT_ROIS {0};
+    const int OUTPUT_ROIS{0};
     int max_rois_num_;
 
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/extract_image_patches.cpp b/src/plugins/intel_cpu/src/nodes/extract_image_patches.cpp
index 8b5d0b510614e1..51ae2123bbd382 100644
--- a/src/plugins/intel_cpu/src/nodes/extract_image_patches.cpp
+++ b/src/plugins/intel_cpu/src/nodes/extract_image_patches.cpp
@@ -3,15 +3,16 @@
 //
 
 #include "extract_image_patches.h"
-#include "common/primitive_hashing_utils.hpp"
-#include "cpu/x64/jit_generator.hpp"
-#include "openvino/core/parallel.hpp"
-#include "openvino/opsets/opset3.hpp"
 
 #include <cmath>
 #include <cstring>
 #include <string>
 
+#include "common/primitive_hashing_utils.hpp"
+#include "cpu/x64/jit_generator.hpp"
+#include "openvino/core/parallel.hpp"
+#include "openvino/opsets/opset3.hpp"
+
 using namespace dnnl::impl::cpu;
 using namespace dnnl::impl::cpu::x64;
 using namespace dnnl::impl::utils;
@@ -21,13 +22,15 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 #if defined(OPENVINO_ARCH_X86_64)
-#define GET_OFF(field) offsetof(jit_extract_image_patches_args, field)
+#    define GET_OFF(field) offsetof(jit_extract_image_patches_args, field)
 
 template <cpu_isa_t isa>
 struct jit_extract_image_patches_kernel : public jit_uni_extract_image_patches_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_extract_image_patches_kernel)
 
-    explicit jit_extract_image_patches_kernel(jit_extract_image_patches_params jpp) : jit_uni_extract_image_patches_kernel(jpp), jit_generator(jit_name()) {}
+    explicit jit_extract_image_patches_kernel(jit_extract_image_patches_params jpp)
+        : jit_uni_extract_image_patches_kernel(jpp),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -92,35 +95,47 @@ struct jit_extract_image_patches_kernel : public jit_uni_extract_image_patches_k
 
     Vmm vmm = Vmm(0);
     Xmm xmm = Xmm(0);
-    Vmm vmm_zero = Vmm(1); // reserved for pad
+    Vmm vmm_zero = Vmm(1);  // reserved for pad
     Xbyak::Xmm xmm_aux = Xbyak::Xmm(2);
     Vmm vmm_gather_index = Vmm(3);
     Vmm vmm_gather_mask = Vmm(4);
     Opmask k_mask = Xbyak::Opmask(1);
     Xbyak::Label gather_index_table;
 
-    inline void load_scalar(Vmm vmm_arg, const Xbyak::Address &op) {
+    inline void load_scalar(Vmm vmm_arg, const Xbyak::Address& op) {
         Xbyak::Xmm xmm_src = Xmm(vmm_arg.getIdx());
         switch (jpp.dtype_size) {
-            case 4: uni_vmovss(vmm_arg, op); break;
-            case 2: uni_vpinsrw(xmm_src, xmm_src, op, 0x0); break;
-            case 1: uni_vpinsrb(xmm_src, xmm_src, op, 0x0); break;
-            default:
-                OPENVINO_THROW("The data type of size '", jpp.dtype_size, "' is not supported.");
+        case 4:
+            uni_vmovss(vmm_arg, op);
+            break;
+        case 2:
+            uni_vpinsrw(xmm_src, xmm_src, op, 0x0);
+            break;
+        case 1:
+            uni_vpinsrb(xmm_src, xmm_src, op, 0x0);
+            break;
+        default:
+            OPENVINO_THROW("The data type of size '", jpp.dtype_size, "' is not supported.");
         }
     }
-    inline void store_scalar(const Xbyak::Address &op, Vmm vmm_arg) {
+    inline void store_scalar(const Xbyak::Address& op, Vmm vmm_arg) {
         Xbyak::Xmm xmm_dst = Xmm(vmm_arg.getIdx());
         switch (jpp.dtype_size) {
-            case 4: uni_vmovss(op, vmm_arg); break;
-            case 2: uni_vpextrw(op, xmm_dst, 0x0); break;
-            case 1: uni_vpextrb(op, xmm_dst, 0x0); break;
-            default:
-                OPENVINO_THROW("The data type of size '", jpp.dtype_size, "' is not supported.");
+        case 4:
+            uni_vmovss(op, vmm_arg);
+            break;
+        case 2:
+            uni_vpextrw(op, xmm_dst, 0x0);
+            break;
+        case 1:
+            uni_vpextrb(op, xmm_dst, 0x0);
+            break;
+        default:
+            OPENVINO_THROW("The data type of size '", jpp.dtype_size, "' is not supported.");
         }
     }
 
-    inline void pad_with_zeros(reg64_t &reg_num_pads_arg, reg64_t &reg_dst_arg) {
+    inline void pad_with_zeros(reg64_t& reg_num_pads_arg, reg64_t& reg_dst_arg) {
         Xbyak::Label main, tail, exit;
         L(main);
         {
@@ -143,57 +158,67 @@ struct jit_extract_image_patches_kernel : public jit_uni_extract_image_patches_k
         L(exit);
     }
 
-    inline void custom_uni_vgatherdps(const Vmm &vmm_arg, reg64_t &mem_base, const Vmm &mem_offset, Vmm &vmm_mask) {
+    inline void custom_uni_vgatherdps(const Vmm& vmm_arg, reg64_t& mem_base, const Vmm& mem_offset, Vmm& vmm_mask) {
         switch (isa) {
-            case x64::avx2:
-                uni_vpcmpeqd(vmm_mask, vmm_mask, vmm_mask);
-                vgatherdps(vmm_arg, ptr[mem_base + mem_offset], vmm_mask);
-                break;
-            case x64::avx512_core:
-                kxnord(k_mask, k_mask, k_mask);
-                vgatherdps(vmm_arg | k_mask, ptr[mem_base + mem_offset]);
-                break;
-            case x64::sse41:
-                emulate_gather(vmm_arg, mem_base);
-                break;
-            default:
-                OPENVINO_THROW("Got unsupported instruction set.");
+        case x64::avx2:
+            uni_vpcmpeqd(vmm_mask, vmm_mask, vmm_mask);
+            vgatherdps(vmm_arg, ptr[mem_base + mem_offset], vmm_mask);
+            break;
+        case x64::avx512_core:
+            kxnord(k_mask, k_mask, k_mask);
+            vgatherdps(vmm_arg | k_mask, ptr[mem_base + mem_offset]);
+            break;
+        case x64::sse41:
+            emulate_gather(vmm_arg, mem_base);
+            break;
+        default:
+            OPENVINO_THROW("Got unsupported instruction set.");
         }
     }
 
-    inline void gather_src2vmm(const Vmm &vmm_arg, reg64_t &mem_base) {
+    inline void gather_src2vmm(const Vmm& vmm_arg, reg64_t& mem_base) {
         switch (jpp.dtype_size) {
-            case 4: custom_uni_vgatherdps(vmm, mem_base, vmm_gather_index, vmm_gather_mask); break;
-            case 2:
-            case 1: emulate_gather(vmm_arg, mem_base); break;
-            default:
-                OPENVINO_THROW("The data type of size '", jpp.dtype_size, "' is not supported.");
+        case 4:
+            custom_uni_vgatherdps(vmm, mem_base, vmm_gather_index, vmm_gather_mask);
+            break;
+        case 2:
+        case 1:
+            emulate_gather(vmm_arg, mem_base);
+            break;
+        default:
+            OPENVINO_THROW("The data type of size '", jpp.dtype_size, "' is not supported.");
         }
     }
 
-    inline void emulate_gather(const Xbyak::Xmm &xmm_arg, reg64_t &mem_base, int xmm_offset = 0) {
-        const int xmm_size = 16; // bytes
+    inline void emulate_gather(const Xbyak::Xmm& xmm_arg, reg64_t& mem_base, int xmm_offset = 0) {
+        const int xmm_size = 16;  // bytes
         const int xmm_block_size = xmm_size / jpp.dtype_size;
         const int offset = xmm_offset * jpp.SW * jpp.dtype_size * xmm_block_size;
         for (int i = 0; i < xmm_block_size; i++) {
             Xbyak::Address addr = ptr[mem_base + i * jpp.SW * jpp.dtype_size + offset];
             switch (jpp.dtype_size) {
-                case 4: uni_vpinsrd(xmm_arg, xmm_arg, addr, i); break;
-                case 2: uni_vpinsrw(xmm_arg, xmm_arg, addr, i); break;
-                case 1: uni_vpinsrb(xmm_arg, xmm_arg, addr, i); break;
-                default:
-                    OPENVINO_THROW("The data type of size '", jpp.dtype_size, "' is not supported.");
+            case 4:
+                uni_vpinsrd(xmm_arg, xmm_arg, addr, i);
+                break;
+            case 2:
+                uni_vpinsrw(xmm_arg, xmm_arg, addr, i);
+                break;
+            case 1:
+                uni_vpinsrb(xmm_arg, xmm_arg, addr, i);
+                break;
+            default:
+                OPENVINO_THROW("The data type of size '", jpp.dtype_size, "' is not supported.");
             }
         }
     }
-    inline void emulate_gather(const Xbyak::Ymm &ymm_arg, reg64_t &mem_base) {
+    inline void emulate_gather(const Xbyak::Ymm& ymm_arg, reg64_t& mem_base) {
         Xbyak::Xmm low_xmm = Xbyak::Xmm(ymm_arg.getIdx());
         emulate_gather(low_xmm, mem_base, 0);
         emulate_gather(xmm_aux, mem_base, 1);
         vinserti128(ymm_arg, ymm_arg, xmm_aux, 1);
     }
 
-    inline void emulate_gather(const Xbyak::Zmm &zmm_arg, reg64_t &mem_base) {
+    inline void emulate_gather(const Xbyak::Zmm& zmm_arg, reg64_t& mem_base) {
         Xbyak::Xmm low_xmm = Xbyak::Xmm(zmm_arg.getIdx());
         emulate_gather(low_xmm, mem_base, 0);
         for (int i = 1; i < 4; i++) {
@@ -270,9 +295,10 @@ struct jit_extract_image_patches_kernel : public jit_uni_extract_image_patches_k
             dd(i * jpp.SW * jpp.dtype_size);
     }
 };
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
-bool ExtractImagePatches::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool ExtractImagePatches::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                               std::string& errorMessage) noexcept {
     try {
         auto extImgPatcher = ov::as_type_ptr<const ov::opset3::ExtractImagePatches>(op);
         if (!extImgPatcher) {
@@ -284,7 +310,10 @@ bool ExtractImagePatches::isSupportedOperation(const std::shared_ptr<const ov::N
             errorMessage = "Does not support pad type: " + ov::as_string(padValue);
             return false;
         }
-        if (!everyone_is(2u, extImgPatcher->get_sizes().size(), extImgPatcher->get_strides().size(), extImgPatcher->get_rates().size())) {
+        if (!everyone_is(2u,
+                         extImgPatcher->get_sizes().size(),
+                         extImgPatcher->get_strides().size(),
+                         extImgPatcher->get_rates().size())) {
             errorMessage = "Doesn't support 'sizes', 'strides', 'rates', attributes with rank != 2";
             return false;
         }
@@ -323,7 +352,7 @@ size_t ExtractImagePatchesKey::hash() const {
 
 bool ExtractImagePatchesKey::operator==(const ExtractImagePatchesKey& rhs) const {
     bool result = inDims == rhs.inDims && outDims == rhs.outDims && kSizes == rhs.kSizes && strides == rhs.strides &&
-           rates == rhs.rates && padType == rhs.padType && prcSize == rhs.prcSize;
+                  rates == rhs.rates && padType == rhs.padType && prcSize == rhs.prcSize;
     return result;
 }
 }  // namespace
@@ -362,7 +391,8 @@ ExtractImagePatches::ExtractImagePatches(const std::shared_ptr<ov::Node>& op, co
         OPENVINO_THROW(errorPrefix, "has unsupported pad type: ", extImgPatcher->get_auto_pad());
     }
 
-    _ksizes = extImgPatcher->get_sizes();;
+    _ksizes = extImgPatcher->get_sizes();
+    ;
     _strides = extImgPatcher->get_strides();
     _rates = extImgPatcher->get_rates();
     if (_ksizes.size() != 2 || _strides.size() != 2 || _rates.size() != 2)
@@ -416,9 +446,7 @@ void ExtractImagePatches::initSupportedPrimitiveDescriptors() {
     if (_supported_precisions_sizes.find(precision.size()) == _supported_precisions_sizes.end())
         OPENVINO_THROW(errorPrefix, "has unsupported precision: ", precision.get_type_name());
 
-    addSupportedPrimDesc({{LayoutType::ncsp, precision}},
-                         {{LayoutType::ncsp, precision}},
-                         impl_desc_type::ref_any);
+    addSupportedPrimDesc({{LayoutType::ncsp, precision}}, {{LayoutType::ncsp, precision}}, impl_desc_type::ref_any);
 }
 
 void ExtractImagePatches::execute(dnnl::stream strm) {
@@ -437,12 +465,17 @@ void ExtractImagePatches::executeDynamicImpl(dnnl::stream strm) {
     execute(strm);
 }
 
-void ExtractImagePatches::ExtractImagePatchesRefExecutor::executeReference(
-    void* src, void* dst, const VectorDims& istrides, const VectorDims& ostrides) const {
+void ExtractImagePatches::ExtractImagePatchesRefExecutor::executeReference(void* src,
+                                                                           void* dst,
+                                                                           const VectorDims& istrides,
+                                                                           const VectorDims& ostrides) const {
     const char* src_data = reinterpret_cast<const char*>(src);
     char* dst_data = reinterpret_cast<char*>(dst);
 
-    const std::vector<size_t> ostrides_partial = { ostrides[0], jpp.KW * IC * ostrides[1], IC * ostrides[1], ostrides[1] };
+    const std::vector<size_t> ostrides_partial = {ostrides[0],
+                                                  jpp.KW * IC * ostrides[1],
+                                                  IC * ostrides[1],
+                                                  ostrides[1]};
 
     parallel_for4d(OB, jpp.KH, jpp.KW, IC, [&](const size_t ob, const size_t kh, const size_t kw, const size_t ic) {
         const int64_t iw_start = static_cast<int64_t>(kw * RW) - PL;
@@ -450,12 +483,17 @@ void ExtractImagePatches::ExtractImagePatchesRefExecutor::executeReference(
         const size_t ih_lpad = ih_start >= 0 ? 0 : std::ceil(-1.f * ih_start / jpp.SH);
         const size_t iw_lpad = iw_start >= 0 ? 0 : std::ceil(-1.f * iw_start / jpp.SW);
 
-        const size_t ih_hpad = std::ceil((IH - 1.f * ih_start) / jpp.SH) > jpp.OH ? jpp.OH : std::ceil((IH + -1.f * ih_start) / jpp.SH);
-        const size_t iw_hpad = std::ceil((jpp.IW - 1.f * iw_start) / jpp.SW) > jpp.OW ? jpp.OW : std::ceil((jpp.IW - 1.f * iw_start) / jpp.SW);
+        const size_t ih_hpad =
+            std::ceil((IH - 1.f * ih_start) / jpp.SH) > jpp.OH ? jpp.OH : std::ceil((IH + -1.f * ih_start) / jpp.SH);
+        const size_t iw_hpad = std::ceil((jpp.IW - 1.f * iw_start) / jpp.SW) > jpp.OW
+                                   ? jpp.OW
+                                   : std::ceil((jpp.IW - 1.f * iw_start) / jpp.SW);
 
-        char* my_dst_ptr = dst_data +
-            (ob * ostrides_partial[0] + kh * ostrides_partial[1] + kw * ostrides_partial[2] + ic * ostrides_partial[3]) * jpp.dtype_size;
-        const char* my_src_ptr = src_data + (ob * istrides[0] + ic * istrides[1] + ih_start * istrides[2] + iw_start) * jpp.dtype_size;
+        char* my_dst_ptr = dst_data + (ob * ostrides_partial[0] + kh * ostrides_partial[1] + kw * ostrides_partial[2] +
+                                       ic * ostrides_partial[3]) *
+                                          jpp.dtype_size;
+        const char* my_src_ptr =
+            src_data + (ob * istrides[0] + ic * istrides[1] + ih_start * istrides[2] + iw_start) * jpp.dtype_size;
 
         size_t num_bytes_to_set = ih_lpad * jpp.OW * jpp.dtype_size;
         memset(my_dst_ptr, 0, num_bytes_to_set);
@@ -463,14 +501,15 @@ void ExtractImagePatches::ExtractImagePatchesRefExecutor::executeReference(
 
         const char* src_ptr_h_stop = my_src_ptr + ih_hpad * jpp.SH * jpp.IW * jpp.dtype_size;
         for (const char* src_h_ptr = my_src_ptr + ih_lpad * jpp.SH * jpp.IW * jpp.dtype_size;
-            src_h_ptr < src_ptr_h_stop; src_h_ptr += jpp.SH * jpp.IW * jpp.dtype_size) {
+             src_h_ptr < src_ptr_h_stop;
+             src_h_ptr += jpp.SH * jpp.IW * jpp.dtype_size) {
             num_bytes_to_set = iw_lpad * jpp.dtype_size;
             memset(my_dst_ptr, 0, num_bytes_to_set);
             my_dst_ptr += num_bytes_to_set;
 
             const char* src_ptr_w_stop = src_h_ptr + iw_hpad * jpp.SW * jpp.dtype_size;
-            for (const char* src_w_ptr = src_h_ptr + iw_lpad * jpp.SW * jpp.dtype_size;
-                src_w_ptr < src_ptr_w_stop; src_w_ptr += jpp.SW * jpp.dtype_size) {
+            for (const char* src_w_ptr = src_h_ptr + iw_lpad * jpp.SW * jpp.dtype_size; src_w_ptr < src_ptr_w_stop;
+                 src_w_ptr += jpp.SW * jpp.dtype_size) {
                 num_bytes_to_set = jpp.dtype_size;
                 memcpy(my_dst_ptr, src_w_ptr, num_bytes_to_set);
                 my_dst_ptr += num_bytes_to_set;
@@ -484,25 +523,35 @@ void ExtractImagePatches::ExtractImagePatchesRefExecutor::executeReference(
     });
 }
 
-void ExtractImagePatches::ExtractImagePatchesJitExecutor::executeOptimizedGeneric(
-    void* src, void* dst, const VectorDims& istrides, const VectorDims& ostrides) const {
+void ExtractImagePatches::ExtractImagePatchesJitExecutor::executeOptimizedGeneric(void* src,
+                                                                                  void* dst,
+                                                                                  const VectorDims& istrides,
+                                                                                  const VectorDims& ostrides) const {
 #if defined(OPENVINO_ARCH_X86_64)
     const char* src_data = reinterpret_cast<const char*>(src);
     char* dst_data = reinterpret_cast<char*>(dst);
     const auto& jpp = pKernel->jpp;
 
-    const std::vector<size_t> ostrides_partial = { ostrides[0], jpp.KW * IC * ostrides[1], IC * ostrides[1], ostrides[1] };
+    const std::vector<size_t> ostrides_partial = {ostrides[0],
+                                                  jpp.KW * IC * ostrides[1],
+                                                  IC * ostrides[1],
+                                                  ostrides[1]};
 
     parallel_for4d(OB, jpp.KH, jpp.KW, IC, [&](const size_t ob, const size_t kh, const size_t kw, const size_t ic) {
         const int64_t ih_start = kh * RH - PT;
         const int64_t iw_start = kw * RW - PL;
         const size_t ih_lpad = ih_start >= 0 ? 0 : std::ceil(-1.f * ih_start / jpp.SH);
         const size_t iw_lpad = iw_start >= 0 ? 0 : std::ceil(-1.f * iw_start / jpp.SW);
-        const size_t ih_hpad = std::ceil((IH - 1.f * ih_start) / jpp.SH) > jpp.OH ? jpp.OH : std::ceil((IH - 1.f * ih_start) / jpp.SH);
-        const size_t iw_hpad = std::ceil((jpp.IW - 1.f * iw_start) / jpp.SW) > jpp.OW ? jpp.OW : std::ceil((jpp.IW - 1.f * iw_start) / jpp.SW);
+        const size_t ih_hpad =
+            std::ceil((IH - 1.f * ih_start) / jpp.SH) > jpp.OH ? jpp.OH : std::ceil((IH - 1.f * ih_start) / jpp.SH);
+        const size_t iw_hpad = std::ceil((jpp.IW - 1.f * iw_start) / jpp.SW) > jpp.OW
+                                   ? jpp.OW
+                                   : std::ceil((jpp.IW - 1.f * iw_start) / jpp.SW);
 
-        size_t dst_offset = ob * ostrides_partial[0] + kh * ostrides_partial[1] + kw * ostrides_partial[2] + ic * ostrides_partial[3];
-        size_t src_offset = ob * istrides[0] + ic * istrides[1] + ih_start * istrides[2] + iw_start + ih_lpad * jpp.SH * jpp.IW;
+        size_t dst_offset =
+            ob * ostrides_partial[0] + kh * ostrides_partial[1] + kw * ostrides_partial[2] + ic * ostrides_partial[3];
+        size_t src_offset =
+            ob * istrides[0] + ic * istrides[1] + ih_start * istrides[2] + iw_start + ih_lpad * jpp.SH * jpp.IW;
 
         auto args = jit_extract_image_patches_args();
         args.src = src_data + src_offset * jpp.dtype_size;
@@ -513,7 +562,7 @@ void ExtractImagePatches::ExtractImagePatchesJitExecutor::executeOptimizedGeneri
         args.w_hi_pad = iw_hpad;
         (*pKernel)(&args);
     });
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 }
 
 jit_extract_image_patches_params ExtractImagePatches::ExtractImagePatchesExecutor::fillJpp(
@@ -584,14 +633,13 @@ jit_extract_image_patches_params ExtractImagePatches::ExtractImagePatchesExecuto
     return jpp;
 }
 
-ExtractImagePatches::ExtractImagePatchesJitExecutor::ExtractImagePatchesJitExecutor(
-    const VectorDims& inDims,
-    const VectorDims& outDims,
-    const VectorDims& kSizes,
-    const VectorDims& strides,
-    const VectorDims& rates,
-    const ExtImgPatcherPadType& padType,
-    const size_t prcSize) {
+ExtractImagePatches::ExtractImagePatchesJitExecutor::ExtractImagePatchesJitExecutor(const VectorDims& inDims,
+                                                                                    const VectorDims& outDims,
+                                                                                    const VectorDims& kSizes,
+                                                                                    const VectorDims& strides,
+                                                                                    const VectorDims& rates,
+                                                                                    const ExtImgPatcherPadType& padType,
+                                                                                    const size_t prcSize) {
 #if defined(OPENVINO_ARCH_X86_64)
     auto jpp = fillJpp(inDims, outDims, kSizes, strides, rates, padType, prcSize);
     if (mayiuse(x64::avx512_core)) {
@@ -606,27 +654,31 @@ ExtractImagePatches::ExtractImagePatchesJitExecutor::ExtractImagePatchesJitExecu
 
     if (pKernel)
         pKernel->create_ker();
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 }
 
-void ExtractImagePatches::ExtractImagePatchesJitExecutor::exec(
-    void* src, void* dst, const VectorDims& istrides, const VectorDims& ostrides) {
+void ExtractImagePatches::ExtractImagePatchesJitExecutor::exec(void* src,
+                                                               void* dst,
+                                                               const VectorDims& istrides,
+                                                               const VectorDims& ostrides) {
     if (!pKernel)
         OPENVINO_THROW("Can't execute, kernel for extract image patches node is not compiled");
     executeOptimizedGeneric(src, dst, istrides, ostrides);
 }
 
-ExtractImagePatches::ExtractImagePatchesRefExecutor::ExtractImagePatchesRefExecutor(
-    const VectorDims& inDims,
-    const VectorDims& outDims,
-    const VectorDims& kSizes,
-    const VectorDims& strides,
-    const VectorDims& rates,
-    const ExtImgPatcherPadType& padType,
-    const size_t prcSize) : jpp(fillJpp(inDims, outDims, kSizes, strides, rates, padType, prcSize)) {}
-
-void ExtractImagePatches::ExtractImagePatchesRefExecutor::exec(
-    void* src, void* dst, const VectorDims& istrides, const VectorDims& ostrides) {
+ExtractImagePatches::ExtractImagePatchesRefExecutor::ExtractImagePatchesRefExecutor(const VectorDims& inDims,
+                                                                                    const VectorDims& outDims,
+                                                                                    const VectorDims& kSizes,
+                                                                                    const VectorDims& strides,
+                                                                                    const VectorDims& rates,
+                                                                                    const ExtImgPatcherPadType& padType,
+                                                                                    const size_t prcSize)
+    : jpp(fillJpp(inDims, outDims, kSizes, strides, rates, padType, prcSize)) {}
+
+void ExtractImagePatches::ExtractImagePatchesRefExecutor::exec(void* src,
+                                                               void* dst,
+                                                               const VectorDims& istrides,
+                                                               const VectorDims& ostrides) {
     executeReference(src, dst, istrides, ostrides);
 }
 
@@ -636,6 +688,6 @@ bool ExtractImagePatches::created() const {
     return getType() == Type::ExtractImagePatches;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/extract_image_patches.h b/src/plugins/intel_cpu/src/nodes/extract_image_patches.h
index 15220fd51a4285..1844b5cafeeb07 100644
--- a/src/plugins/intel_cpu/src/nodes/extract_image_patches.h
+++ b/src/plugins/intel_cpu/src/nodes/extract_image_patches.h
@@ -30,8 +30,11 @@ struct jit_extract_image_patches_args {
 };
 
 struct jit_uni_extract_image_patches_kernel {
-    void (*ker_)(const jit_extract_image_patches_args *);
-    void operator()(const jit_extract_image_patches_args *args) { assert(ker_); ker_(args); }
+    void (*ker_)(const jit_extract_image_patches_args*);
+    void operator()(const jit_extract_image_patches_args* args) {
+        assert(ker_);
+        ker_(args);
+    }
     jit_extract_image_patches_params jpp;
     virtual void create_ker() = 0;
     explicit jit_uni_extract_image_patches_kernel(jit_extract_image_patches_params jpp) : ker_(nullptr), jpp(jpp) {}
@@ -42,7 +45,7 @@ class ExtractImagePatches : public Node {
 public:
     ExtractImagePatches(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -51,11 +54,7 @@ class ExtractImagePatches : public Node {
     void prepareParams() override;
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
-    enum class ExtImgPatcherPadType {
-        VALID,
-        SAME_LOWER,
-        SAME_UPPER
-    };
+    enum class ExtImgPatcherPadType { VALID, SAME_LOWER, SAME_UPPER };
 
 private:
     std::vector<size_t> _ksizes;
@@ -69,14 +68,13 @@ class ExtractImagePatches : public Node {
     struct ExtractImagePatchesExecutor {
         ExtractImagePatchesExecutor() = default;
         virtual void exec(void* src, void* dst, const VectorDims& istrides, const VectorDims& ostrides) = 0;
-        jit_extract_image_patches_params fillJpp(
-            const VectorDims& inDims,
-            const VectorDims& outDims,
-            const VectorDims& kSizes,
-            const VectorDims& strides,
-            const VectorDims& rates,
-            const ExtImgPatcherPadType& padType,
-            const size_t prcSize);
+        jit_extract_image_patches_params fillJpp(const VectorDims& inDims,
+                                                 const VectorDims& outDims,
+                                                 const VectorDims& kSizes,
+                                                 const VectorDims& strides,
+                                                 const VectorDims& rates,
+                                                 const ExtImgPatcherPadType& padType,
+                                                 const size_t prcSize);
         virtual ~ExtractImagePatchesExecutor() = default;
 
     protected:
@@ -93,30 +91,31 @@ class ExtractImagePatches : public Node {
     executorPtr execPtr = nullptr;
 
     struct ExtractImagePatchesJitExecutor : public ExtractImagePatchesExecutor {
-        ExtractImagePatchesJitExecutor(
-            const VectorDims& inDims,
-            const VectorDims& outDims,
-            const VectorDims& kSizes,
-            const VectorDims& strides,
-            const VectorDims& rates,
-            const ExtImgPatcherPadType& padType,
-            const size_t prcSize);
+        ExtractImagePatchesJitExecutor(const VectorDims& inDims,
+                                       const VectorDims& outDims,
+                                       const VectorDims& kSizes,
+                                       const VectorDims& strides,
+                                       const VectorDims& rates,
+                                       const ExtImgPatcherPadType& padType,
+                                       const size_t prcSize);
         void exec(void* src, void* dst, const VectorDims& istrides, const VectorDims& ostrides) override;
-        void executeOptimizedGeneric(void* src, void* dst, const VectorDims& istrides, const VectorDims& ostrides) const;
+        void executeOptimizedGeneric(void* src,
+                                     void* dst,
+                                     const VectorDims& istrides,
+                                     const VectorDims& ostrides) const;
 
     private:
         std::unique_ptr<jit_uni_extract_image_patches_kernel> pKernel;
     };
 
     struct ExtractImagePatchesRefExecutor : public ExtractImagePatchesExecutor {
-        ExtractImagePatchesRefExecutor(
-            const VectorDims& inDims,
-            const VectorDims& outDims,
-            const VectorDims& kSizes,
-            const VectorDims& strides,
-            const VectorDims& rates,
-            const ExtImgPatcherPadType& padType,
-            const size_t prcSize);
+        ExtractImagePatchesRefExecutor(const VectorDims& inDims,
+                                       const VectorDims& outDims,
+                                       const VectorDims& kSizes,
+                                       const VectorDims& strides,
+                                       const VectorDims& rates,
+                                       const ExtImgPatcherPadType& padType,
+                                       const size_t prcSize);
         void exec(void* src, void* dst, const VectorDims& istrides, const VectorDims& ostrides) override;
         void executeReference(void* src, void* dst, const VectorDims& istrides, const VectorDims& ostrides) const;
 
@@ -125,6 +124,6 @@ class ExtractImagePatches : public Node {
     };
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/eye.cpp b/src/plugins/intel_cpu/src/nodes/eye.cpp
index 19e466ad68751a..deb47abdba2dee 100644
--- a/src/plugins/intel_cpu/src/nodes/eye.cpp
+++ b/src/plugins/intel_cpu/src/nodes/eye.cpp
@@ -3,9 +3,11 @@
 //
 
 #include "eye.h"
-#include "openvino/op/eye.hpp"
+
 #include <utils/bfloat16.hpp>
+
 #include "openvino/core/parallel.hpp"
+#include "openvino/op/eye.hpp"
 #include "shape_inference/shape_inference.hpp"
 #include "utils/bfloat16.hpp"
 
@@ -36,20 +38,21 @@ class EyeShapeInferFactory : public ShapeInferFactory {
         return (m_op->get_input_size() == 4) ? make_shape_inference(m_op)
                                              : make_shape_inference(m_op, PortMask(Eye::ROWS_NUM, Eye::COLS_NUM));
     }
+
 private:
     std::shared_ptr<ov::Node> m_op;
 };
-} // namespace
+}  // namespace
 
-Eye::Eye(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) : Node(op, context, EyeShapeInferFactory(op)) {
+Eye::Eye(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, EyeShapeInferFactory(op)) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
-            OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
+        OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
     }
     outType = op->get_output_element_type(0);
     withBatchShape = (op->get_input_size() == 4);
-    if (!one_of(outType, ov::element::f32, ov::element::bf16,
-        ov::element::i32, ov::element::i8, ov::element::u8)) {
+    if (!one_of(outType, ov::element::f32, ov::element::bf16, ov::element::i32, ov::element::i8, ov::element::u8)) {
         THROW_ERROR(errorPrefix, "doesn't support demanded output precision");
     }
 }
@@ -61,16 +64,19 @@ void Eye::getSupportedDescriptors() {
         THROW_ERROR(errorPrefix, "has incorrect number of output edges: ", getChildEdges().size());
 }
 
-template<typename T>
+template <typename T>
 struct Eye::EyeExecute {
-    void operator()(Eye *node) {
+    void operator()(Eye* node) {
         node->executeSpecified<T>();
     }
 };
 
 void Eye::execute(dnnl::stream strm) {
     auto outputPrec = getChildEdgeAt(0)->getMemory().getDesc().getPrecision();
-    OV_SWITCH(intel_cpu, EyeExecute, this, outputPrec,
+    OV_SWITCH(intel_cpu,
+              EyeExecute,
+              this,
+              outputPrec,
               OV_CASE(ov::element::f32, float),
               OV_CASE(ov::element::bf16, bfloat16_t),
               OV_CASE(ov::element::i32, int),
@@ -99,9 +105,9 @@ void Eye::executeSpecified() {
     const size_t colNum = getColNum();
     const int64_t shift = getDiagIndex();
     auto outPtr = getDstMemoryAtPort(0);
-    if (!outPtr || !outPtr ->isDefined())
+    if (!outPtr || !outPtr->isDefined())
         THROW_ERROR(errorPrefix, "Destination memory is undefined.");
-    T *dst = outPtr->getDataAs<T>();
+    T* dst = outPtr->getDataAs<T>();
 
     const size_t batchVolume = getBatchVolume(getBatchShape());
     const size_t spatialCount = colNum * rowNum;
@@ -111,8 +117,8 @@ void Eye::executeSpecified() {
 
     const int64_t countByColumns = std::max(int64_t(colNum) - std::abs(shift), int64_t(0));
     const int64_t countByRows = std::max(int64_t(rowNum) - std::abs(shift), int64_t(0));
-    const size_t onesPerBatchNum =
-        static_cast<size_t>(shift > 0 ? std::min(countByColumns, int64_t(rowNum)) : std::min(countByRows, int64_t(colNum)));
+    const size_t onesPerBatchNum = static_cast<size_t>(shift > 0 ? std::min(countByColumns, int64_t(rowNum))
+                                                                 : std::min(countByRows, int64_t(colNum)));
     const size_t dataShift = static_cast<size_t>(shift >= 0 ? shift : -shift * colNum);
 
     if (spatialSize >= l2CacheSize) {
@@ -121,7 +127,8 @@ void Eye::executeSpecified() {
             splitter(elementsCount, nthr, ithr, start, end);
             memset(dst + start, 0, (end - start) * sizeof(T));
         });
-        if (onesPerBatchNum == 0) return;
+        if (onesPerBatchNum == 0)
+            return;
         for (size_t bShift = 0; bShift < batchVolume * spatialCount; bShift += spatialCount) {
             parallel_nt(0, [&](const size_t ithr, const size_t nthr) {
                 size_t start = 0, end = 0;
@@ -136,7 +143,8 @@ void Eye::executeSpecified() {
             size_t start = 0, end = 0;
             splitter(batchVolume, nthr, ithr, start, end);
             memset(dst + start * spatialCount, 0, (end - start) * spatialSize);
-            if (onesPerBatchNum == 0) return;
+            if (onesPerBatchNum == 0)
+                return;
             for (size_t spShift = start * spatialCount; spShift < end * spatialCount; spShift += spatialCount) {
                 for (size_t j = 0; j < onesPerBatchNum; j++) {
                     dst[dataShift + j * (colNum + 1) + spShift] = static_cast<T>(1);
@@ -149,6 +157,6 @@ void Eye::executeSpecified() {
 bool Eye::created() const {
     return getType() == Type::Eye;
 }
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/eye.h b/src/plugins/intel_cpu/src/nodes/eye.h
index 7978c45d8a05d1..fc2b42a18bdbe9 100644
--- a/src/plugins/intel_cpu/src/nodes/eye.h
+++ b/src/plugins/intel_cpu/src/nodes/eye.h
@@ -5,9 +5,11 @@
 #pragma once
 
 #include <node.h>
-#include <string>
+
 #include <memory>
+#include <string>
 #include <vector>
+
 #include "dnnl_extension_utils.h"
 
 namespace ov {
@@ -28,9 +30,15 @@ class Eye : public Node {
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
-    bool needPrepareParams() const override {return false;};
-    bool needShapeInfer() const override {return true;};
-    void executeDynamicImpl(dnnl::stream strm) override { execute(strm); }
+    bool needPrepareParams() const override {
+        return false;
+    };
+    bool needShapeInfer() const override {
+        return true;
+    };
+    void executeDynamicImpl(dnnl::stream strm) override {
+        execute(strm);
+    }
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
@@ -39,13 +47,13 @@ class Eye : public Node {
     ov::element::Type outType = ov::element::Type_t::undefined;
     template <typename inputType>
     void executeSpecified();
-    template<typename T>
+    template <typename T>
     struct EyeExecute;
     inline const size_t getRowNum() const {
         auto rowMem = getSrcMemoryAtPort(ROWS_NUM);
         if (rowMem == nullptr)
             OPENVINO_THROW(errorPrefix, " doesn't contain row_count data");
-        const int *rowPtr = rowMem->getDataAs<const int>();
+        const int* rowPtr = rowMem->getDataAs<const int>();
 
         return rowPtr[0];
     }
@@ -53,7 +61,7 @@ class Eye : public Node {
         auto colMem = getSrcMemoryAtPort(COLS_NUM);
         if (colMem == nullptr)
             OPENVINO_THROW(errorPrefix, " doesn't contain col_count data");
-        const int *colPtr =  colMem->getDataAs<const int>();
+        const int* colPtr = colMem->getDataAs<const int>();
 
         return colPtr[0];
     }
@@ -61,28 +69,29 @@ class Eye : public Node {
         auto diagIndMem = getSrcMemoryAtPort(DIAGONAL_INDEX);
         if (diagIndMem == nullptr)
             OPENVINO_THROW(errorPrefix, " doesn't contain diag_index data");
-        const int *diagIndexPtr = diagIndMem->getDataAs<const int>();
+        const int* diagIndexPtr = diagIndMem->getDataAs<const int>();
 
         return diagIndexPtr[0];
     }
     inline const std::vector<int> getBatchShape() const {
         if (withBatchShape) {
-            const int batchShapeSize = static_cast<const int>(getSrcMemoryAtPort(BATCH_SHAPE)->getShape().getElementsCount());
+            const int batchShapeSize =
+                static_cast<const int>(getSrcMemoryAtPort(BATCH_SHAPE)->getShape().getElementsCount());
             std::vector<int> batchShape(batchShapeSize);
-            const int *batchShapePtr = getSrcDataAtPortAs<const int>(BATCH_SHAPE);
+            const int* batchShapePtr = getSrcDataAtPortAs<const int>(BATCH_SHAPE);
             batchShape.assign(batchShapePtr, batchShapePtr + batchShapeSize);
             return batchShape;
         } else {
-            return std::vector<int> {};
+            return std::vector<int>{};
         }
     }
 
-    inline const size_t getBatchVolume(const std::vector<int> &batchShape) {
+    inline const size_t getBatchVolume(const std::vector<int>& batchShape) {
         return std::accumulate(begin(batchShape), end(batchShape), 1, std::multiplies<size_t>());
     }
     bool withBatchShape = false;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/fake_quantize.cpp b/src/plugins/intel_cpu/src/nodes/fake_quantize.cpp
index f12ab40cf5643b..9951c5176f0ad1 100644
--- a/src/plugins/intel_cpu/src/nodes/fake_quantize.cpp
+++ b/src/plugins/intel_cpu/src/nodes/fake_quantize.cpp
@@ -4,28 +4,27 @@
 
 #include "fake_quantize.h"
 
-#include <string>
-#include <vector>
 #include <math.h>
+#include <memory_desc/cpu_memory_desc_utils.h>
+
 #include <algorithm>
-#include <set>
 #include <cmath>
-
-#include "dnnl_types.h"
-#include "dnnl_extension_utils.h"
-#include "cpu/x64/jit_generator.hpp"
 #include <common/dnnl_thread.hpp>
+#include <set>
+#include <shape_inference/shape_inference_pass_through.hpp>
+#include <string>
+#include <vector>
 
-#include "openvino/core/parallel.hpp"
-#include "utils/general_utils.h"
-#include "utils/cpu_utils.hpp"
-#include <memory_desc/cpu_memory_desc_utils.h>
-#include "memory_desc/dnnl_blocked_memory_desc.h"
 #include "common/cpu_memcpy.h"
 #include "common/primitive_hashing_utils.hpp"
-#include <shape_inference/shape_inference_pass_through.hpp>
-
+#include "cpu/x64/jit_generator.hpp"
+#include "dnnl_extension_utils.h"
+#include "dnnl_types.h"
+#include "memory_desc/dnnl_blocked_memory_desc.h"
+#include "openvino/core/parallel.hpp"
 #include "openvino/opsets/opset1.hpp"
+#include "utils/cpu_utils.hpp"
+#include "utils/general_utils.h"
 #include "utils/ngraph_utils.hpp"
 
 // Quantization ranges validation is switched off by default in order to avoid regressions on user side
@@ -45,13 +44,15 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 #if defined(OPENVINO_ARCH_X86_64)
-#define GET_OFF(field) offsetof(jit_quantize_call_args, field)
+#    define GET_OFF(field) offsetof(jit_quantize_call_args, field)
 
 template <cpu_isa_t isa>
 struct jit_uni_binarization_kernel : public jit_uni_quantize_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_binarization_kernel)
 
-    explicit jit_uni_binarization_kernel(const jit_quantize_params& jqp) : jit_uni_quantize_kernel(jqp), jit_generator(jit_name()) {}
+    explicit jit_uni_binarization_kernel(const jit_quantize_params& jqp)
+        : jit_uni_quantize_kernel(jqp),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -77,7 +78,8 @@ struct jit_uni_binarization_kernel : public jit_uni_quantize_kernel, public jit_
         Label tail_label;
         Label exit_label;
 
-        L(unrolled_loop_label); {
+        L(unrolled_loop_label);
+        {
             int step = isa == cpu::x64::sse41 ? nbits / 2 : isa == cpu::x64::avx2 ? nbits : 2 * nbits;
             const int ur_ch = isa == cpu::x64::sse41 ? nbits : isa == cpu::x64::avx2 ? nbits / 2 : nbits / 4;
             const int unrolled_loop_step = ur_ch * step;
@@ -87,9 +89,9 @@ struct jit_uni_binarization_kernel : public jit_uni_quantize_kernel, public jit_
 
             xor_(reg_bin_32, reg_bin_32);
             for (int ch = 0; ch < ur_ch; ch++) {
-                uni_vmovups(vmm_src(0), ptr[reg_from + ch*step*sizeof(float)]);
-                uni_vmovups(vmm_wei(0), ptr[reg_thresholds + ch*step*sizeof(float)]);
-                uni_vmovups(vmm_mask(0), ptr[reg_output_mask + ch*step*sizeof(float)]);
+                uni_vmovups(vmm_src(0), ptr[reg_from + ch * step * sizeof(float)]);
+                uni_vmovups(vmm_wei(0), ptr[reg_thresholds + ch * step * sizeof(float)]);
+                uni_vmovups(vmm_mask(0), ptr[reg_output_mask + ch * step * sizeof(float)]);
                 if (isa == avx512_core) {
                     vcmpps(k_mask0, vmm_src(0), vmm_wei(0), _cmp_gt_os);
                     vptestmd(k_mask1, vmm_mask(0), vmm_mask(0));
@@ -105,16 +107,17 @@ struct jit_uni_binarization_kernel : public jit_uni_quantize_kernel, public jit_
             }
             mov(ptr[reg_to], reg_bin_32);
 
-            add(reg_from, unrolled_loop_step*sizeof(float));
-            add(reg_thresholds, unrolled_loop_step*sizeof(float));
-            add(reg_output_mask, unrolled_loop_step*sizeof(float));
+            add(reg_from, unrolled_loop_step * sizeof(float));
+            add(reg_thresholds, unrolled_loop_step * sizeof(float));
+            add(reg_output_mask, unrolled_loop_step * sizeof(float));
             add(reg_to, sizeof(uint32_t));
             sub(reg_work_amount, unrolled_loop_step);
 
             jmp(unrolled_loop_label, T_NEAR);
         }
 
-        L(main_loop_label); {
+        L(main_loop_label);
+        {
             int repeats = isa == cpu::x64::sse41 ? 2 : 1;
             int step = isa == cpu::x64::sse41 ? nbits / 2 : isa == cpu::x64::avx2 ? nbits : nbits * 2;
             const int main_loop_step = step * repeats;
@@ -124,9 +127,9 @@ struct jit_uni_binarization_kernel : public jit_uni_quantize_kernel, public jit_
 
             xor_(reg_bin_32, reg_bin_32);
             for (int i = 0; i < repeats; i++) {
-                uni_vmovups(vmm_src(0), ptr[reg_from + i*step*sizeof(float)]);
-                uni_vmovups(vmm_wei(0), ptr[reg_thresholds + i*step*sizeof(float)]);
-                uni_vmovups(vmm_mask(0), ptr[reg_output_mask + i*step*sizeof(float)]);
+                uni_vmovups(vmm_src(0), ptr[reg_from + i * step * sizeof(float)]);
+                uni_vmovups(vmm_wei(0), ptr[reg_thresholds + i * step * sizeof(float)]);
+                uni_vmovups(vmm_mask(0), ptr[reg_output_mask + i * step * sizeof(float)]);
                 if (isa == avx512_core) {
                     vcmpps(k_mask0, vmm_src(0), vmm_wei(0), _cmp_gt_os);
                     vptestmd(k_mask1, vmm_mask(0), vmm_mask(0));
@@ -145,16 +148,17 @@ struct jit_uni_binarization_kernel : public jit_uni_quantize_kernel, public jit_
             else
                 mov(ptr[reg_to], reg_bin_8);
 
-            add(reg_from, main_loop_step*sizeof(float));
-            add(reg_thresholds, main_loop_step*sizeof(float));
-            add(reg_output_mask, main_loop_step*sizeof(float));
+            add(reg_from, main_loop_step * sizeof(float));
+            add(reg_thresholds, main_loop_step * sizeof(float));
+            add(reg_output_mask, main_loop_step * sizeof(float));
             add(reg_to, isa == avx512_core ? sizeof(uint16_t) : sizeof(uint8_t));
             sub(reg_work_amount, main_loop_step);
 
             jmp(main_loop_label, T_NEAR);
         }
 
-        L(tail_label); {
+        L(tail_label);
+        {
             if (tail_size != 0) {
                 xor_(reg_bin_32, reg_bin_32);
                 mov(reg_mask, 1);
@@ -188,15 +192,27 @@ struct jit_uni_binarization_kernel : public jit_uni_quantize_kernel, public jit_
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
 
-    inline Vmm vmm_src(int idx) { return Vmm(idx); }
-    inline Xmm xmm_src(int idx) { return Xmm(idx); }
-    inline Vmm vmm_wei(int idx) { return Vmm(idx + 4); }
-    inline Vmm vmm_mask(int idx) { return Vmm(idx + 5); }
-    inline Xmm xmm_wei(int idx) { return Xmm(idx + 4); }
-    inline Xmm xmm_mask(int idx) { return Xmm(idx + 5); }
+    inline Vmm vmm_src(int idx) {
+        return Vmm(idx);
+    }
+    inline Xmm xmm_src(int idx) {
+        return Xmm(idx);
+    }
+    inline Vmm vmm_wei(int idx) {
+        return Vmm(idx + 4);
+    }
+    inline Vmm vmm_mask(int idx) {
+        return Vmm(idx + 5);
+    }
+    inline Xmm xmm_wei(int idx) {
+        return Xmm(idx + 4);
+    }
+    inline Xmm xmm_mask(int idx) {
+        return Xmm(idx + 5);
+    }
 
     Reg64 param = abi_param1;
     Reg64 reg_from = r8;
@@ -219,7 +235,9 @@ template <cpu_isa_t isa>
 struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_quantization_kernel)
 
-    explicit jit_uni_quantization_kernel(const jit_quantize_params& jqp) : jit_uni_quantize_kernel(jqp), jit_generator(jit_name()) {}
+    explicit jit_uni_quantization_kernel(const jit_quantize_params& jqp)
+        : jit_uni_quantize_kernel(jqp),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -237,37 +255,78 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
         else
             compute_generic();
 
-
         this->postamble();
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
-
-    inline Vmm vmm_val(int idx) { return Vmm(idx + 0); }
-    inline Vmm vmm_crop_low(int idx) { return Vmm(idx + 2); }
-    inline Vmm vmm_crop_high(int idx) { return Vmm(idx + 4); }
-    inline Vmm vmm_input_scale(int idx) { return Vmm(idx + 6); }
-    inline Vmm vmm_input_shift(int idx) { return Vmm(idx + 8); }
-    inline Vmm vmm_output_scale(int idx) { return Vmm(idx + 10); }
-    inline Vmm vmm_output_shift(int idx) { return Vmm(idx + 12); }
-
-    inline Ymm ymm_val(int idx) { return Ymm(idx + 0); }
-    inline Ymm ymm_crop_low(int idx) { return Ymm(idx + 2); }
-    inline Ymm ymm_crop_high(int idx) { return Ymm(idx + 4); }
-    inline Ymm ymm_input_scale(int idx) { return Ymm(idx + 6); }
-    inline Ymm ymm_input_shift(int idx) { return Ymm(idx + 8); }
-    inline Ymm ymm_output_scale(int idx) { return Ymm(idx + 10); }
-    inline Ymm ymm_output_shift(int idx) { return Ymm(idx + 12); }
-
-    inline Xmm xmm_val(int idx) { return Xmm(idx + 0); }
-    inline Xmm xmm_crop_low(int idx) { return Xmm(idx + 2); }
-    inline Xmm xmm_crop_high(int idx) { return Xmm(idx + 4); }
-    inline Xmm xmm_input_scale(int idx) { return Xmm(idx + 6); }
-    inline Xmm xmm_input_shift(int idx) { return Xmm(idx + 8); }
-    inline Xmm xmm_output_scale(int idx) { return Xmm(idx + 10); }
-    inline Xmm xmm_output_shift(int idx) { return Xmm(idx + 12); }
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
+
+    inline Vmm vmm_val(int idx) {
+        return Vmm(idx + 0);
+    }
+    inline Vmm vmm_crop_low(int idx) {
+        return Vmm(idx + 2);
+    }
+    inline Vmm vmm_crop_high(int idx) {
+        return Vmm(idx + 4);
+    }
+    inline Vmm vmm_input_scale(int idx) {
+        return Vmm(idx + 6);
+    }
+    inline Vmm vmm_input_shift(int idx) {
+        return Vmm(idx + 8);
+    }
+    inline Vmm vmm_output_scale(int idx) {
+        return Vmm(idx + 10);
+    }
+    inline Vmm vmm_output_shift(int idx) {
+        return Vmm(idx + 12);
+    }
+
+    inline Ymm ymm_val(int idx) {
+        return Ymm(idx + 0);
+    }
+    inline Ymm ymm_crop_low(int idx) {
+        return Ymm(idx + 2);
+    }
+    inline Ymm ymm_crop_high(int idx) {
+        return Ymm(idx + 4);
+    }
+    inline Ymm ymm_input_scale(int idx) {
+        return Ymm(idx + 6);
+    }
+    inline Ymm ymm_input_shift(int idx) {
+        return Ymm(idx + 8);
+    }
+    inline Ymm ymm_output_scale(int idx) {
+        return Ymm(idx + 10);
+    }
+    inline Ymm ymm_output_shift(int idx) {
+        return Ymm(idx + 12);
+    }
+
+    inline Xmm xmm_val(int idx) {
+        return Xmm(idx + 0);
+    }
+    inline Xmm xmm_crop_low(int idx) {
+        return Xmm(idx + 2);
+    }
+    inline Xmm xmm_crop_high(int idx) {
+        return Xmm(idx + 4);
+    }
+    inline Xmm xmm_input_scale(int idx) {
+        return Xmm(idx + 6);
+    }
+    inline Xmm xmm_input_shift(int idx) {
+        return Xmm(idx + 8);
+    }
+    inline Xmm xmm_output_scale(int idx) {
+        return Xmm(idx + 10);
+    }
+    inline Xmm xmm_output_shift(int idx) {
+        return Xmm(idx + 12);
+    }
 
     Vmm vmm_zero = Vmm(14);
 
@@ -296,24 +355,34 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
     bool do_dequantization = true;
 
     inline void load_broadcasted_vectors_only(size_t idx) {
-        const auto &broadcasted = jqp_.broadcasted;
-        if (broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_LOW)]) uni_vbroadcastss(vmm_crop_low(idx), ptr[reg_crop_low]);
-        if (broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)]) uni_vbroadcastss(vmm_crop_high(idx), ptr[reg_crop_high]);
-        if (broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)]) uni_vbroadcastss(vmm_input_scale(idx), ptr[reg_input_scale]);
-        if (broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)]) uni_vbroadcastss(vmm_input_shift(idx), ptr[reg_input_shift]);
+        const auto& broadcasted = jqp_.broadcasted;
+        if (broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_LOW)])
+            uni_vbroadcastss(vmm_crop_low(idx), ptr[reg_crop_low]);
+        if (broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)])
+            uni_vbroadcastss(vmm_crop_high(idx), ptr[reg_crop_high]);
+        if (broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)])
+            uni_vbroadcastss(vmm_input_scale(idx), ptr[reg_input_scale]);
+        if (broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)])
+            uni_vbroadcastss(vmm_input_shift(idx), ptr[reg_input_shift]);
         if (do_dequantization) {
-            if (broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)]) uni_vbroadcastss(vmm_output_scale(idx), ptr[reg_output_scale]);
-            if (broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)]) uni_vbroadcastss(vmm_output_shift(idx), ptr[reg_output_shift]);
+            if (broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)])
+                uni_vbroadcastss(vmm_output_scale(idx), ptr[reg_output_scale]);
+            if (broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)])
+                uni_vbroadcastss(vmm_output_shift(idx), ptr[reg_output_shift]);
         }
     }
 
     template <typename T>
     inline void load_not_broadcasted_vectors_only(size_t idx, size_t offset) {
-        const auto &broadcasted = jqp_.broadcasted;
-        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_LOW)]) uni_vmovups(T(vmm_crop_low(idx).getIdx()), ptr[reg_crop_low + offset]);
-        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)]) uni_vmovups(T(vmm_crop_high(idx).getIdx()), ptr[reg_crop_high + offset]);
-        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)]) uni_vmovups(T(vmm_input_scale(idx).getIdx()), ptr[reg_input_scale + offset]);
-        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)]) uni_vmovups(T(vmm_input_shift(idx).getIdx()), ptr[reg_input_shift + offset]);
+        const auto& broadcasted = jqp_.broadcasted;
+        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_LOW)])
+            uni_vmovups(T(vmm_crop_low(idx).getIdx()), ptr[reg_crop_low + offset]);
+        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)])
+            uni_vmovups(T(vmm_crop_high(idx).getIdx()), ptr[reg_crop_high + offset]);
+        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)])
+            uni_vmovups(T(vmm_input_scale(idx).getIdx()), ptr[reg_input_scale + offset]);
+        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)])
+            uni_vmovups(T(vmm_input_shift(idx).getIdx()), ptr[reg_input_shift + offset]);
         if (do_dequantization) {
             if (!broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)])
                 uni_vmovups(T(vmm_output_scale(idx).getIdx()), ptr[reg_output_scale + offset]);
@@ -323,14 +392,20 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
     }
 
     inline void increase_ptrs_if_not_broadcasted(size_t offset) {
-        const auto &broadcasted = jqp_.broadcasted;
-        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_LOW)]) add(reg_crop_low, offset);
-        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)]) add(reg_crop_high, offset);
-        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)]) add(reg_input_scale, offset);
-        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)]) add(reg_input_shift, offset);
+        const auto& broadcasted = jqp_.broadcasted;
+        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_LOW)])
+            add(reg_crop_low, offset);
+        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)])
+            add(reg_crop_high, offset);
+        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)])
+            add(reg_input_scale, offset);
+        if (!broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)])
+            add(reg_input_shift, offset);
         if (do_dequantization) {
-            if (!broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)]) add(reg_output_scale, offset);
-            if (!broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)]) add(reg_output_shift, offset);
+            if (!broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)])
+                add(reg_output_scale, offset);
+            if (!broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)])
+                add(reg_output_shift, offset);
         }
     }
 
@@ -373,7 +448,8 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
             uni_vbroadcastss(vmm_output_shift(0), ptr[reg_output_shift]);
         }
 
-        L(main_loop_label); {
+        L(main_loop_label);
+        {
             cmp(reg_work_amount, simd_w);
             jl(tail_blk4_label, T_NEAR);
 
@@ -383,8 +459,10 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
                 uni_vminps(vmm_val(i), vmm_val(i), vmm_crop_high(0));
                 uni_vmaxps(vmm_val(i), vmm_val(i), vmm_crop_low(0));
                 uni_vfmadd213ps(vmm_val(i), vmm_input_scale(0), vmm_input_shift(0));
-                if (do_rounding) uni_vroundps(vmm_val(i), vmm_val(i), 0);
-                if (do_dequantization) uni_vfmadd213ps(vmm_val(i), vmm_output_scale(0), vmm_output_shift(0));
+                if (do_rounding)
+                    uni_vroundps(vmm_val(i), vmm_val(i), 0);
+                if (do_dequantization)
+                    uni_vfmadd213ps(vmm_val(i), vmm_output_scale(0), vmm_output_shift(0));
 
                 store_vector(ptr[reg_to + i * (simd_w / 2) * dst_type_size], vmm_val(i), jqp_.dst_prc);
             }
@@ -396,7 +474,8 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
             jmp(main_loop_label, T_NEAR);
         }
 
-        L(tail_blk4_label); {
+        L(tail_blk4_label);
+        {
             cmp(reg_work_amount, tail_simd_w);
             jl(tail_blk4_exit_label, T_NEAR);
 
@@ -405,8 +484,10 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
             uni_vminps(xmm_val(0), xmm_val(0), xmm_crop_high(0));
             uni_vmaxps(xmm_val(0), xmm_val(0), xmm_crop_low(0));
             uni_vfmadd213ps(xmm_val(0), xmm_input_scale(0), xmm_input_shift(0));
-            if (do_rounding) uni_vroundps(xmm_val(0), xmm_val(0), 0);
-            if (do_dequantization) uni_vfmadd213ps(xmm_val(0), xmm_output_scale(0), xmm_output_shift(0));
+            if (do_rounding)
+                uni_vroundps(xmm_val(0), xmm_val(0), 0);
+            if (do_dequantization)
+                uni_vfmadd213ps(xmm_val(0), xmm_output_scale(0), xmm_output_shift(0));
 
             store_vector(ptr[reg_to], xmm_val(0), jqp_.dst_prc);
 
@@ -420,7 +501,8 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
         mov(aux_reg_from, reg_from);
         mov(aux_reg_to, reg_to);
 
-        L(tail_loop_label); {
+        L(tail_loop_label);
+        {
             cmp(reg_work_amount, 0);
             jle(exit_label, T_NEAR);
 
@@ -429,8 +511,10 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
             uni_vminps(xmm_val(0), xmm_val(0), xmm_crop_high(0));
             uni_vmaxps(xmm_val(0), xmm_val(0), xmm_crop_low(0));
             uni_vfmadd213ps(xmm_val(0), xmm_input_scale(0), xmm_input_shift(0));
-            if (do_rounding) uni_vroundps(xmm_val(0), xmm_val(0), 0);
-            if (do_dequantization) uni_vfmadd213ps(xmm_val(0), xmm_output_scale(0), xmm_output_shift(0));
+            if (do_rounding)
+                uni_vroundps(xmm_val(0), xmm_val(0), 0);
+            if (do_dequantization)
+                uni_vfmadd213ps(xmm_val(0), xmm_output_scale(0), xmm_output_shift(0));
 
             store_scalar(ptr[aux_reg_to], xmm_val(0), jqp_.dst_prc);
 
@@ -496,7 +580,8 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
             load_not_broadcasted_vectors_only<Vmm>(i, i * (simd_w / 2) * sizeof(float));
         }
 
-        L(main_loop_label); {
+        L(main_loop_label);
+        {
             cmp(reg_work_amount, 0);
             jle(exit_label, T_NEAR);
 
@@ -506,8 +591,10 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
                 uni_vminps(vmm_val(i), vmm_val(i), vmm_crop_high(i));
                 uni_vmaxps(vmm_val(i), vmm_val(i), vmm_crop_low(i));
                 uni_vfmadd213ps(vmm_val(i), vmm_input_scale(i), vmm_input_shift(i));
-                if (do_rounding) uni_vroundps(vmm_val(i), vmm_val(i), 0);
-                if (do_dequantization) uni_vfmadd213ps(vmm_val(i), vmm_output_scale(i), vmm_output_shift(i));
+                if (do_rounding)
+                    uni_vroundps(vmm_val(i), vmm_val(i), 0);
+                if (do_dequantization)
+                    uni_vfmadd213ps(vmm_val(i), vmm_output_scale(i), vmm_output_shift(i));
 
                 store_vector(ptr[reg_to + i * (simd_w / 2) * dst_type_size], vmm_val(i), jqp_.dst_prc);
             }
@@ -531,7 +618,8 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
 
             load_not_broadcasted_vectors_only<Ymm>(0, 0);
 
-            L(tail_blk8_loop_label); {
+            L(tail_blk8_loop_label);
+            {
                 cmp(reg_work_amount, 0);
                 jle(tail_blk8_exit_label, T_NEAR);
 
@@ -540,8 +628,10 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
                 uni_vminps(ymm_val(0), ymm_val(0), ymm_crop_high(0));
                 uni_vmaxps(ymm_val(0), ymm_val(0), ymm_crop_low(0));
                 uni_vfmadd213ps(ymm_val(0), ymm_input_scale(0), ymm_input_shift(0));
-                if (do_rounding) uni_vroundps(ymm_val(0), ymm_val(0), 0);
-                if (do_dequantization) uni_vfmadd213ps(ymm_val(0), ymm_output_scale(0), ymm_output_shift(0));
+                if (do_rounding)
+                    uni_vroundps(ymm_val(0), ymm_val(0), 0);
+                if (do_dequantization)
+                    uni_vfmadd213ps(ymm_val(0), ymm_output_scale(0), ymm_output_shift(0));
 
                 store_vector(ptr[aux_reg_to], ymm_val(0), jqp_.dst_prc);
 
@@ -571,7 +661,8 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
 
         load_not_broadcasted_vectors_only<Xmm>(0, 0);
 
-        L(tail_blk4_loop_label); {
+        L(tail_blk4_loop_label);
+        {
             cmp(reg_work_amount, 0);
             jle(tail_blk4_exit_label, T_NEAR);
 
@@ -580,8 +671,10 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
             uni_vminps(xmm_val(0), xmm_val(0), xmm_crop_high(0));
             uni_vmaxps(xmm_val(0), xmm_val(0), xmm_crop_low(0));
             uni_vfmadd213ps(xmm_val(0), xmm_input_scale(0), xmm_input_shift(0));
-            if (do_rounding) uni_vroundps(xmm_val(0), xmm_val(0), 0);
-            if (do_dequantization) uni_vfmadd213ps(xmm_val(0), xmm_output_scale(0), xmm_output_shift(0));
+            if (do_rounding)
+                uni_vroundps(xmm_val(0), xmm_val(0), 0);
+            if (do_dequantization)
+                uni_vfmadd213ps(xmm_val(0), xmm_output_scale(0), xmm_output_shift(0));
 
             store_vector(ptr[aux_reg_to], xmm_val(0), jqp_.dst_prc);
 
@@ -608,13 +701,14 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
         mov(aux_reg_from, reg_from);
         mov(reg_work_amount, ptr[param + GET_OFF(work_amount)]);
 
-        L(tail_loop_label); {
+        L(tail_loop_label);
+        {
             cmp(reg_work_amount, 0);
             jle(exit_label, T_NEAR);
             Label end_unroll;
 
             auto tail_unroll = [&](size_t iter) {
-                const auto &broadcasted = jqp_.broadcasted;
+                const auto& broadcasted = jqp_.broadcasted;
                 for (size_t i = 0; i < iter; i++) {
                     if (!broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_LOW)])
                         uni_vmovss(xmm_crop_low(0), ptr[reg_crop_low + i * wei_type_size]);
@@ -636,8 +730,10 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
                     uni_vminps(xmm_val(0), xmm_val(0), xmm_crop_high(0));
                     uni_vmaxps(xmm_val(0), xmm_val(0), xmm_crop_low(0));
                     uni_vfmadd213ps(xmm_val(0), xmm_input_scale(0), xmm_input_shift(0));
-                    if (do_rounding) uni_vroundps(xmm_val(0), xmm_val(0), 0);
-                    if (do_dequantization) uni_vfmadd213ps(xmm_val(0), xmm_output_scale(0), xmm_output_shift(0));
+                    if (do_rounding)
+                        uni_vroundps(xmm_val(0), xmm_val(0), 0);
+                    if (do_dequantization)
+                        uni_vfmadd213ps(xmm_val(0), xmm_output_scale(0), xmm_output_shift(0));
 
                     store_scalar(ptr[aux_reg_to + i * dst_type_size], xmm_val(0), jqp_.dst_prc);
                 }
@@ -667,20 +763,20 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
         L(exit_label);
     }
 
-    inline void load_vector(Zmm zmm_src, const Xbyak::Address &op, ov::element::Type src_prc) {
+    inline void load_vector(Zmm zmm_src, const Xbyak::Address& op, ov::element::Type src_prc) {
         switch (src_prc) {
-            case ov::element::f32:
-            case ov::element::i32:
-                uni_vmovups(zmm_src, op);
-                break;
-            case ov::element::i8:
-                uni_vpmovsxbd(zmm_src, op);
-                break;
-            case ov::element::u8:
-                uni_vpmovzxbd(zmm_src, op);
-                break;
-            default:
-                assert(!"unknown src_prc");
+        case ov::element::f32:
+        case ov::element::i32:
+            uni_vmovups(zmm_src, op);
+            break;
+        case ov::element::i8:
+            uni_vpmovsxbd(zmm_src, op);
+            break;
+        case ov::element::u8:
+            uni_vpmovzxbd(zmm_src, op);
+            break;
+        default:
+            assert(!"unknown src_prc");
         }
 
         if (src_prc != ov::element::f32) {
@@ -688,20 +784,20 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
         }
     }
 
-    inline void load_vector(Ymm ymm_src, const Xbyak::Address &op, ov::element::Type src_prc) {
+    inline void load_vector(Ymm ymm_src, const Xbyak::Address& op, ov::element::Type src_prc) {
         switch (src_prc) {
-            case ov::element::f32:
-            case ov::element::i32:
-                uni_vmovups(ymm_src, op);
-                break;
-            case ov::element::i8:
-                uni_vpmovsxbd(ymm_src, op);
-                break;
-            case ov::element::u8:
-                uni_vpmovzxbd(ymm_src, op);
-                break;
-            default:
-                assert(!"unknown src_prc");
+        case ov::element::f32:
+        case ov::element::i32:
+            uni_vmovups(ymm_src, op);
+            break;
+        case ov::element::i8:
+            uni_vpmovsxbd(ymm_src, op);
+            break;
+        case ov::element::u8:
+            uni_vpmovzxbd(ymm_src, op);
+            break;
+        default:
+            assert(!"unknown src_prc");
         }
 
         if (src_prc != ov::element::f32) {
@@ -709,20 +805,20 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
         }
     }
 
-    inline void load_vector(Xmm xmm_src, const Xbyak::Address &op, ov::element::Type src_prc) {
+    inline void load_vector(Xmm xmm_src, const Xbyak::Address& op, ov::element::Type src_prc) {
         switch (src_prc) {
-            case ov::element::f32:
-            case ov::element::i32:
-                uni_vmovups(xmm_src, op);
-                break;
-            case ov::element::i8:
-                uni_vpmovsxbd(xmm_src, op);
-                break;
-            case ov::element::u8:
-                uni_vpmovzxbd(xmm_src, op);
-                break;
-            default:
-                assert(!"unknown src_prc");
+        case ov::element::f32:
+        case ov::element::i32:
+            uni_vmovups(xmm_src, op);
+            break;
+        case ov::element::i8:
+            uni_vpmovsxbd(xmm_src, op);
+            break;
+        case ov::element::u8:
+            uni_vpmovzxbd(xmm_src, op);
+            break;
+        default:
+            assert(!"unknown src_prc");
         }
 
         if (src_prc != ov::element::f32) {
@@ -730,22 +826,22 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
         }
     }
 
-    inline void load_scalar(Xmm xmm_src, const Xbyak::Address &op, ov::element::Type src_prc) {
+    inline void load_scalar(Xmm xmm_src, const Xbyak::Address& op, ov::element::Type src_prc) {
         switch (src_prc) {
-            case ov::element::f32:
-            case ov::element::i32:
-                uni_vmovss(xmm_src, op);
-                break;
-            case ov::element::i8:
-                movsx(reg_tmp_32, op);
-                uni_vmovq(xmm_src, reg_tmp_64);
-                break;
-            case ov::element::u8:
-                movzx(reg_tmp_32, op);
-                uni_vmovq(xmm_src, reg_tmp_64);
-                break;
-            default:
-                assert(!"unknown src_prc");
+        case ov::element::f32:
+        case ov::element::i32:
+            uni_vmovss(xmm_src, op);
+            break;
+        case ov::element::i8:
+            movsx(reg_tmp_32, op);
+            uni_vmovq(xmm_src, reg_tmp_64);
+            break;
+        case ov::element::u8:
+            movzx(reg_tmp_32, op);
+            uni_vmovq(xmm_src, reg_tmp_64);
+            break;
+        default:
+            assert(!"unknown src_prc");
         }
 
         if (src_prc != ov::element::f32) {
@@ -753,29 +849,29 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
         }
     }
 
-    inline void store_vector(const Xbyak::Address &op, Zmm zmm_dst, ov::element::Type dst_prc) {
+    inline void store_vector(const Xbyak::Address& op, Zmm zmm_dst, ov::element::Type dst_prc) {
         if (dst_prc != ov::element::f32) {
             uni_vcvtps2dq(zmm_dst, zmm_dst);
         }
 
         switch (dst_prc) {
-            case ov::element::f32:
-            case ov::element::i32:
-                uni_vmovups(op, zmm_dst);
-                break;
-            case ov::element::i8:
-                vpmovsdb(op, zmm_dst);
-                break;
-            case ov::element::u8:
-                vpmaxsd(zmm_dst, zmm_dst, vmm_zero);
-                vpmovusdb(op, zmm_dst);
-                break;
-            default:
-                assert(!"unknown dst_prc");
-        }
-    }
-
-    inline void store_vector(const Xbyak::Address &op, Ymm ymm_dst, ov::element::Type dst_prc) {
+        case ov::element::f32:
+        case ov::element::i32:
+            uni_vmovups(op, zmm_dst);
+            break;
+        case ov::element::i8:
+            vpmovsdb(op, zmm_dst);
+            break;
+        case ov::element::u8:
+            vpmaxsd(zmm_dst, zmm_dst, vmm_zero);
+            vpmovusdb(op, zmm_dst);
+            break;
+        default:
+            assert(!"unknown dst_prc");
+        }
+    }
+
+    inline void store_vector(const Xbyak::Address& op, Ymm ymm_dst, ov::element::Type dst_prc) {
         Xmm xmm_dst = Xmm(ymm_dst.getIdx());
 
         if (dst_prc != ov::element::f32) {
@@ -783,82 +879,82 @@ struct jit_uni_quantization_kernel : public jit_uni_quantize_kernel, public jit_
         }
 
         switch (dst_prc) {
-            case ov::element::f32:
-            case ov::element::i32:
-                uni_vmovups(op, ymm_dst);
-                break;
-            case ov::element::i8:
-                uni_vpackssdw(ymm_dst, ymm_dst, ymm_dst);
+        case ov::element::f32:
+        case ov::element::i32:
+            uni_vmovups(op, ymm_dst);
+            break;
+        case ov::element::i8:
+            uni_vpackssdw(ymm_dst, ymm_dst, ymm_dst);
 
-                vpermq(ymm_dst, ymm_dst, 0x08);
+            vpermq(ymm_dst, ymm_dst, 0x08);
 
-                uni_vpacksswb(ymm_dst, ymm_dst, ymm_dst);
+            uni_vpacksswb(ymm_dst, ymm_dst, ymm_dst);
 
-                vmovq(op, xmm_dst);
-                break;
-            case ov::element::u8:
-                uni_vpackusdw(ymm_dst, ymm_dst, ymm_dst);
+            vmovq(op, xmm_dst);
+            break;
+        case ov::element::u8:
+            uni_vpackusdw(ymm_dst, ymm_dst, ymm_dst);
 
-                vpermq(ymm_dst, ymm_dst, 0x08);
+            vpermq(ymm_dst, ymm_dst, 0x08);
 
-                uni_vpackuswb(ymm_dst, ymm_dst, ymm_dst);
+            uni_vpackuswb(ymm_dst, ymm_dst, ymm_dst);
 
-                vmovq(op, xmm_dst);
-                break;
-            default:
-                assert(!"unknown dst_prc");
+            vmovq(op, xmm_dst);
+            break;
+        default:
+            assert(!"unknown dst_prc");
         }
     }
 
-    inline void store_vector(const Xbyak::Address &op, Xmm xmm_dst, ov::element::Type dst_prc) {
+    inline void store_vector(const Xbyak::Address& op, Xmm xmm_dst, ov::element::Type dst_prc) {
         if (dst_prc != ov::element::f32) {
             uni_vcvtps2dq(xmm_dst, xmm_dst);
         }
 
         switch (dst_prc) {
-            case ov::element::f32:
-            case ov::element::i32:
-                uni_vmovups(op, xmm_dst);
-                break;
-            case ov::element::i8:
-                uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
-                uni_vmovd(op, xmm_dst);
-                break;
-            case ov::element::u8:
-                uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
-                uni_vmovd(op, xmm_dst);
-                break;
-            default:
-                assert(!"unknown dst_prc");
-        }
-    }
-
-    inline void store_scalar(const Xbyak::Address &op, Xmm xmm_dst, ov::element::Type dst_prc) {
+        case ov::element::f32:
+        case ov::element::i32:
+            uni_vmovups(op, xmm_dst);
+            break;
+        case ov::element::i8:
+            uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
+            uni_vmovd(op, xmm_dst);
+            break;
+        case ov::element::u8:
+            uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
+            uni_vmovd(op, xmm_dst);
+            break;
+        default:
+            assert(!"unknown dst_prc");
+        }
+    }
+
+    inline void store_scalar(const Xbyak::Address& op, Xmm xmm_dst, ov::element::Type dst_prc) {
         if (dst_prc != ov::element::f32) {
             uni_vcvtps2dq(xmm_dst, xmm_dst);
         }
 
         switch (dst_prc) {
-            case ov::element::f32:
-            case ov::element::i32:
-                uni_vmovss(op, xmm_dst);
-                break;
-            case ov::element::i8:
-                uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
-                uni_vmovq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_8);
-                break;
-            case ov::element::u8:
-                uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
-                uni_vmovq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_8);
-                break;
-            default:
-                assert(!"unknown dst_prc");
+        case ov::element::f32:
+        case ov::element::i32:
+            uni_vmovss(op, xmm_dst);
+            break;
+        case ov::element::i8:
+            uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
+            uni_vmovq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_8);
+            break;
+        case ov::element::u8:
+            uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
+            uni_vmovq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_8);
+            break;
+        default:
+            assert(!"unknown dst_prc");
         }
     }
 };
@@ -877,7 +973,8 @@ bool FakeQuantize::isSupportedOperation(const std::shared_ptr<const ov::Node>& o
         }
         for (size_t i = 1; i < fq->get_input_size(); i++) {
             if (fq->get_input_partial_shape(i).rank().get_length() > 5) {
-                errorMessage = "Doesn't support 'range' input with rank: " + std::to_string(fq->get_input_partial_shape(i).rank().get_length());
+                errorMessage = "Doesn't support 'range' input with rank: " +
+                               std::to_string(fq->get_input_partial_shape(i).rank().get_length());
                 return false;
             }
         }
@@ -935,7 +1032,7 @@ struct FakeQuantKey {
         seed = hash_combine(seed, jqp.wei_prc.hash());
         seed = hash_combine(seed, jqp.dst_prc.hash());
         seed = hash_combine(seed, jqp.op_type);
-        if (jqp.op_type ==  Algorithm::FQBinarization) {
+        if (jqp.op_type == Algorithm::FQBinarization) {
             seed = hash_combine(seed, jqp.c);
         } else {
             seed = hash_combine(seed, jqp.broadcasted);
@@ -959,8 +1056,8 @@ struct FakeQuantKey {
 };
 }  // namespace
 
-FakeQuantize::FakeQuantize(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) :
-        Node(op, context, PassThroughShapeInferFactory()) {
+FakeQuantize::FakeQuantize(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, PassThroughShapeInferFactory()) {
     std::string errorMessage;
     if (isSupportedOperation(op, errorMessage)) {
         algorithm = Algorithm::FQCommon;
@@ -1032,16 +1129,20 @@ FakeQuantize::FakeQuantize(const std::shared_ptr<ov::Node>& op, const GraphConte
             OPENVINO_THROW(errorPrefix, "has different quantization axis size on 'data' and 'range' inputs");
         }
 
-        const auto inputLowNode = std::dynamic_pointer_cast<const ov::opset1::Constant>(fq->get_input_node_shared_ptr(1));
+        const auto inputLowNode =
+            std::dynamic_pointer_cast<const ov::opset1::Constant>(fq->get_input_node_shared_ptr(1));
         auto inputLowData = inputLowNode->cast_vector<float>();
 
-        const auto inputHighNode = std::dynamic_pointer_cast<const ov::opset1::Constant>(fq->get_input_node_shared_ptr(2));
+        const auto inputHighNode =
+            std::dynamic_pointer_cast<const ov::opset1::Constant>(fq->get_input_node_shared_ptr(2));
         auto inputHighData = inputHighNode->cast_vector<float>();
 
-        const auto outputLowNode = std::dynamic_pointer_cast<const ov::opset1::Constant>(fq->get_input_node_shared_ptr(3));
+        const auto outputLowNode =
+            std::dynamic_pointer_cast<const ov::opset1::Constant>(fq->get_input_node_shared_ptr(3));
         auto outputLowData = outputLowNode->cast_vector<float>();
 
-        const auto outputHighNode = std::dynamic_pointer_cast<const ov::opset1::Constant>(fq->get_input_node_shared_ptr(4));
+        const auto outputHighNode =
+            std::dynamic_pointer_cast<const ov::opset1::Constant>(fq->get_input_node_shared_ptr(4));
         auto outputHighData = outputHighNode->cast_vector<float>();
 
         binarization = levels == 2;
@@ -1092,7 +1193,7 @@ FakeQuantize::FakeQuantize(const std::shared_ptr<ov::Node>& op, const GraphConte
                 }
             }
         } else {
-            auto allElementsAreEqual = [&](const std::vector<float> &data, size_t size) {
+            auto allElementsAreEqual = [&](const std::vector<float>& data, size_t size) {
                 if (size == 0)
                     return true;
 
@@ -1146,9 +1247,21 @@ FakeQuantize::FakeQuantize(const std::shared_ptr<ov::Node>& op, const GraphConte
             broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)] = outputScaleSize == 1;
             broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)] = outputShiftSize == 1;
 
-            if (everyone_is(1u, cropLowSize, cropHighSize, inputScaleSize, inputShiftSize, outputScaleSize, outputShiftSize))
+            if (everyone_is(1u,
+                            cropLowSize,
+                            cropHighSize,
+                            inputScaleSize,
+                            inputShiftSize,
+                            outputScaleSize,
+                            outputShiftSize))
                 broadcastingPolicy = PerTensor;
-            else if (one_of(1u, cropLowSize, cropHighSize, inputScaleSize, inputShiftSize, outputScaleSize, outputShiftSize))
+            else if (one_of(1u,
+                            cropLowSize,
+                            cropHighSize,
+                            inputScaleSize,
+                            inputShiftSize,
+                            outputScaleSize,
+                            outputShiftSize))
                 broadcastingPolicy = Mixed;
             else
                 broadcastingPolicy = PerChannel;
@@ -1224,7 +1337,10 @@ FakeQuantize::FakeQuantize(const std::shared_ptr<ov::Node>& op, const GraphConte
 
             bool isFakeQuantization = true;
             bool isFakeQuantizationWithScale = true;
-            for (size_t i = 0; i < std::max(inputLowAxisSize, std::max(outputLowAxisSize, std::max(inputHighAxisSize, outputHighAxisSize))); i++) {
+            for (size_t i = 0;
+                 i < std::max(inputLowAxisSize,
+                              std::max(outputLowAxisSize, std::max(inputHighAxisSize, outputHighAxisSize)));
+                 i++) {
                 float il = inputLowData[isInputLowBroadcasted ? 0 : i];
                 float ol = outputLowData[isOutputLowBroadcasted ? 0 : i];
                 float ih = inputHighData[isInputHighBroadcasted ? 0 : i];
@@ -1236,7 +1352,10 @@ FakeQuantize::FakeQuantize(const std::shared_ptr<ov::Node>& op, const GraphConte
             }
 
             if (isFakeQuantizationWithScale) {
-                for (size_t i = 0; i < std::max(inputLowAxisSize, std::max(outputLowAxisSize, std::max(inputHighAxisSize, outputHighAxisSize))); i++) {
+                for (size_t i = 0;
+                     i < std::max(inputLowAxisSize,
+                                  std::max(outputLowAxisSize, std::max(inputHighAxisSize, outputHighAxisSize)));
+                     i++) {
                     float il = inputLowData[isInputLowBroadcasted ? 0 : i];
                     float ol = outputLowData[isOutputLowBroadcasted ? 0 : i];
                     float ih = inputHighData[isInputHighBroadcasted ? 0 : i];
@@ -1255,22 +1374,22 @@ FakeQuantize::FakeQuantize(const std::shared_ptr<ov::Node>& op, const GraphConte
 
 std::vector<LayoutType> FakeQuantize::getDataFormats() const {
     // Special case for first FQ in the network
-    const auto &dims = getInputShapeAtPort(0).getDims();
+    const auto& dims = getInputShapeAtPort(0).getDims();
     if (dims[getAxis()] == 3) {
-        return { LayoutType::ncsp };
+        return {LayoutType::ncsp};
     } else {
         if (isBinarization()) {
-            return { LayoutType::nspc };
+            return {LayoutType::nspc};
         } else {
             if (one_of(dims.size(), 4u, 5u)) {
                 if (getAxis() == 1) {
                     auto blkFormat = mayiuse(cpu::x64::avx512_core) ? LayoutType::nCsp16c : LayoutType::nCsp8c;
-                    return { blkFormat, LayoutType::nspc, LayoutType::ncsp };
+                    return {blkFormat, LayoutType::nspc, LayoutType::ncsp};
                 } else {
-                    return { LayoutType::ncsp };
+                    return {LayoutType::ncsp};
                 }
             } else {
-                return { LayoutType::ncsp };
+                return {LayoutType::ncsp};
             }
         }
     }
@@ -1284,10 +1403,12 @@ void FakeQuantize::init() {
         inputPrecision = getOriginalInputPrecisionAtPort(0);
         outputPrecision = getOriginalOutputPrecisionAtPort(0);
 
-        if (inputPrecision != ov::element::f32 && inputPrecision != ov::element::u8 && inputPrecision != ov::element::i8)
+        if (inputPrecision != ov::element::f32 && inputPrecision != ov::element::u8 &&
+            inputPrecision != ov::element::i8)
             inputPrecision = ov::element::f32;
 
-        if (outputPrecision != ov::element::f32 && outputPrecision != ov::element::u8 && outputPrecision != ov::element::i8)
+        if (outputPrecision != ov::element::f32 && outputPrecision != ov::element::u8 &&
+            outputPrecision != ov::element::i8)
             outputPrecision = ov::element::f32;
     }
 }
@@ -1381,7 +1502,8 @@ bool FakeQuantize::needPrepareParams() const {
         if (!selectedPrimitiveDescriptor)
             OPENVINO_THROW("CPU quantize node with name '", getName(), "' doesn't have primitive descriptors.");
 
-        if (internalBlobMemory.empty() || (selectedPrimitiveDescriptor->getImplementationType() != impl_desc_type::ref && inputShapesModified())) {
+        if (internalBlobMemory.empty() ||
+            (selectedPrimitiveDescriptor->getImplementationType() != impl_desc_type::ref && inputShapesModified())) {
             return true;
         }
 
@@ -1389,7 +1511,8 @@ bool FakeQuantize::needPrepareParams() const {
         const auto newPaddedSize = rnd_up(axisSize, 16);
         const auto currPaddedSize = rnd_up(currentAxisSize, 16);
 
-        return newPaddedSize != currPaddedSize || ((isInputLowBroadcasted || isOutputHighBroadcasted) && axisSize != currentAxisSize);
+        return newPaddedSize != currPaddedSize ||
+               ((isInputLowBroadcasted || isOutputHighBroadcasted) && axisSize != currentAxisSize);
     }
     return false;
 }
@@ -1401,26 +1524,33 @@ void FakeQuantize::prepareParams() {
         OPENVINO_ASSERT(newPaddedSize != 0);
 
         if (internalBlobMemory.empty() || newPaddedSize != rnd_up(currentAxisSize, 16) ||
-                ((isInputLowBroadcasted || isOutputHighBroadcasted) && axisSize != currentAxisSize)) {
-            DnnlBlockedMemoryDesc weightsDataDesc(Shape(VectorDims{newPaddedSize}), memory::data_type::f32, memory::format_tag::x);
+            ((isInputLowBroadcasted || isOutputHighBroadcasted) && axisSize != currentAxisSize)) {
+            DnnlBlockedMemoryDesc weightsDataDesc(Shape(VectorDims{newPaddedSize}),
+                                                  memory::data_type::f32,
+                                                  memory::format_tag::x);
             constexpr size_t numBinFqIntBlob = 2;
             bool needUpdThr = false, needUpdMask = false;
             if (isInputLowBroadcasted && axisSize != currentAxisSize) {
                 binarizationThresholds.resize(newPaddedSize);
-                std::fill(binarizationThresholds.begin() + 1, binarizationThresholds.begin() + axisSize, binarizationThresholds[0]);
+                std::fill(binarizationThresholds.begin() + 1,
+                          binarizationThresholds.begin() + axisSize,
+                          binarizationThresholds[0]);
                 std::fill(binarizationThresholds.begin() + axisSize, binarizationThresholds.end(), 0.f);
                 needUpdThr = true;
             }
 
             if (isOutputHighBroadcasted && axisSize != currentAxisSize) {
                 binarizationOutputMask.resize(newPaddedSize);
-                std::fill(binarizationOutputMask.begin() + 1, binarizationOutputMask.begin() + axisSize, binarizationOutputMask[0]);
+                std::fill(binarizationOutputMask.begin() + 1,
+                          binarizationOutputMask.begin() + axisSize,
+                          binarizationOutputMask[0]);
                 std::fill(binarizationOutputMask.begin() + axisSize, binarizationOutputMask.end(), 0);
                 needUpdMask = true;
             }
 
             if (internalBlobMemory.empty() || needUpdThr) {
-                auto binarizationThresholdsDataMem = std::make_shared<Memory>(getEngine(), weightsDataDesc, getBinarizationTresholdsPtr());
+                auto binarizationThresholdsDataMem =
+                    std::make_shared<Memory>(getEngine(), weightsDataDesc, getBinarizationTresholdsPtr());
                 if (internalBlobMemory.empty()) {
                     internalBlobMemory.push_back(binarizationThresholdsDataMem);
                 } else {
@@ -1429,7 +1559,8 @@ void FakeQuantize::prepareParams() {
             }
 
             if (internalBlobMemory.size() == (numBinFqIntBlob - 1) || needUpdMask) {
-                auto binarizationMaskDataMem = std::make_shared<Memory>(getEngine(), weightsDataDesc, getBinarizationOutputMaskPtr());
+                auto binarizationMaskDataMem =
+                    std::make_shared<Memory>(getEngine(), weightsDataDesc, getBinarizationOutputMaskPtr());
                 if (internalBlobMemory.size() == (numBinFqIntBlob - 1)) {
                     internalBlobMemory.push_back(binarizationMaskDataMem);
                 } else {
@@ -1449,31 +1580,39 @@ void FakeQuantize::createPrimitive() {
     if (selectedPrimitiveDescriptor->getImplementationType() != impl_desc_type::ref) {
         const auto& config = getSelectedPrimitiveDescriptor()->getConfig();
 
-        //Form FakeQuanKey
+        // Form FakeQuanKey
         FakeQuantKey key = {};
         key.jqp.src_prc = config.inConfs[0].getMemDesc()->getPrecision();
         key.jqp.wei_prc = ov::element::f32;
         key.jqp.dst_prc = config.outConfs[0].getMemDesc()->getPrecision();
 
-        const auto &srcMemory = getParentEdgeAt(0)->getMemory();
-        const auto &srcDesc = srcMemory.getDesc();
+        const auto& srcMemory = getParentEdgeAt(0)->getMemory();
+        const auto& srcDesc = srcMemory.getDesc();
 
         key.jqp.is_planar = srcDesc.hasLayoutType(LayoutType::ncsp) && one_of(srcDesc.getShape().getRank(), 3u, 4u, 5u);
         key.jqp.op_type = getAlgorithm();
 
         if (isBinarization()) {
-            const auto &inDims = srcMemory.getStaticDims();
+            const auto& inDims = srcMemory.getStaticDims();
             key.jqp.c = inDims.size() > 1 ? inDims[1] : 1;
         } else {
-             // in case of blocked layout we need to extend vectors to prevent read from unallocated memory
-            size_t paddedSize = srcDesc.hasLayoutType(LayoutType::nCsp16c) ? 16 : srcDesc.hasLayoutType(LayoutType::nCsp8c) ? 8 : 1;
+            // in case of blocked layout we need to extend vectors to prevent read from unallocated memory
+            size_t paddedSize = srcDesc.hasLayoutType(LayoutType::nCsp16c)  ? 16
+                                : srcDesc.hasLayoutType(LayoutType::nCsp8c) ? 8
+                                                                            : 1;
             if (paddedSize != 1) {
-                if (!broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_LOW)]) cropLow.resize(rnd_up(cropLow.size(), paddedSize));
-                if (!broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)]) cropHigh.resize(rnd_up(cropHigh.size(), paddedSize));
-                if (!broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)]) inputScale.resize(rnd_up(inputScale.size(), paddedSize));
-                if (!broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)]) inputShift.resize(rnd_up(inputShift.size(), paddedSize));
-                if (!broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)]) outputScale.resize(rnd_up(outputScale.size(), paddedSize));
-                if (!broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)]) outputShift.resize(rnd_up(outputShift.size(), paddedSize));
+                if (!broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_LOW)])
+                    cropLow.resize(rnd_up(cropLow.size(), paddedSize));
+                if (!broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)])
+                    cropHigh.resize(rnd_up(cropHigh.size(), paddedSize));
+                if (!broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)])
+                    inputScale.resize(rnd_up(inputScale.size(), paddedSize));
+                if (!broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)])
+                    inputShift.resize(rnd_up(inputShift.size(), paddedSize));
+                if (!broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)])
+                    outputScale.resize(rnd_up(outputScale.size(), paddedSize));
+                if (!broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)])
+                    outputShift.resize(rnd_up(outputShift.size(), paddedSize));
             }
 
             key.jqp.broadcasted = broadcasted;
@@ -1530,11 +1669,10 @@ void FakeQuantize::executeReference() {
         parallel_nd(N, CB, D, H, W, [&](dim_t n, dim_t cb, dim_t d, dim_t h, dim_t w) {
             uint8_t bin_val = 0x00;
             for (int c = cb * nbits, shift = 0; c < std::min(static_cast<dim_t>(C), (cb + 1) * nbits); c++, shift++) {
-                size_t src_off = srcDims.size() == 4 ?
-                                    n * s_str[0] + c * s_str[1] + h * s_str[2] + w * s_str[3] :
-                                 srcDims.size() == 5 ?
-                                    n * s_str[0] + c * s_str[1] + d * s_str[2] + h * s_str[3] + w * s_str[4] :
-                                    n * s_str[0] + c * s_str[1];
+                size_t src_off = srcDims.size() == 4 ? n * s_str[0] + c * s_str[1] + h * s_str[2] + w * s_str[3]
+                                 : srcDims.size() == 5
+                                     ? n * s_str[0] + c * s_str[1] + d * s_str[2] + h * s_str[3] + w * s_str[4]
+                                     : n * s_str[0] + c * s_str[1];
 
                 float val = src[src_off];
                 float thr = thresholds[c];
@@ -1546,11 +1684,10 @@ void FakeQuantize::executeReference() {
                 bin_val |= (bit << shift);
             }
 
-            size_t dst_off = dstDims.size() == 4 ?
-                                n * d_str[0] + (cb * nbits) * d_str[1] + h * d_str[2] + w * d_str[3] :
-                             dstDims.size() == 5 ?
-                                 n * d_str[0] + (cb * nbits) * d_str[1] + d * d_str[2] + h * d_str[3] + w * d_str[4] :
-                                 n * d_str[0] + (cb * nbits) * d_str[1];
+            size_t dst_off = dstDims.size() == 4 ? n * d_str[0] + (cb * nbits) * d_str[1] + h * d_str[2] + w * d_str[3]
+                             : dstDims.size() == 5
+                                 ? n * d_str[0] + (cb * nbits) * d_str[1] + d * d_str[2] + h * d_str[3] + w * d_str[4]
+                                 : n * d_str[0] + (cb * nbits) * d_str[1];
 
             dst[dst_off / nbits] = bin_val;
         });
@@ -1558,46 +1695,44 @@ void FakeQuantize::executeReference() {
         auto dst = dstMemory->getDataAs<float>();
 
         parallel_nd(N, C, D, H, W, [&](dim_t n, dim_t c, dim_t d, dim_t h, dim_t w) {
-            size_t src_off = srcDims.size() == 5 ?
-                                n * s_str[0] + c * s_str[1] + d * s_str[2] + h * s_str[3] + w * s_str[4] :
-                             srcDims.size() == 4 ?
-                                n * s_str[0] + c * s_str[1] + h * s_str[2] + w * s_str[3] :
-                             srcDims.size() == 3 ?
-                                n * s_str[0] + c * s_str[1] + h * s_str[2] :
-                             srcDims.size() == 2 ?
-                                n * s_str[0] + c * s_str[1] :
-                                n * s_str[0];
+            size_t src_off = srcDims.size() == 5
+                                 ? n * s_str[0] + c * s_str[1] + d * s_str[2] + h * s_str[3] + w * s_str[4]
+                             : srcDims.size() == 4 ? n * s_str[0] + c * s_str[1] + h * s_str[2] + w * s_str[3]
+                             : srcDims.size() == 3 ? n * s_str[0] + c * s_str[1] + h * s_str[2]
+                             : srcDims.size() == 2 ? n * s_str[0] + c * s_str[1]
+                                                   : n * s_str[0];
 
             float src_val = src[src_off];
 
             int wei_idx = getAxis() == 0 ? n : c;
             float cl = broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_LOW)] ? cropLow[0] : cropLow[wei_idx];
             float ch = broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)] ? cropHigh[0] : cropHigh[wei_idx];
-            float isc = broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)] ? inputScale[0] : inputScale[wei_idx];
-            float ish = broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)] ? inputShift[0] : inputShift[wei_idx];
-            float osc = broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)] ? outputScale[0] : outputScale[wei_idx];
-            float osh = broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)] ? outputShift[0] : outputShift[wei_idx];
+            float isc =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)] ? inputScale[0] : inputScale[wei_idx];
+            float ish =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)] ? inputShift[0] : inputShift[wei_idx];
+            float osc = broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)] ? outputScale[0]
+                                                                                          : outputScale[wei_idx];
+            float osh = broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)] ? outputShift[0]
+                                                                                          : outputShift[wei_idx];
 
             float dst_val = nstl::min(ch, nstl::max(cl, src_val));
             dst_val = dst_val * isc + ish;
             dst_val = roundf(dst_val);
             dst_val = dst_val * osc + osh;
 
-            size_t dst_off = dstDims.size() == 5 ?
-                             n * d_str[0] + c * d_str[1] + d * d_str[2] + h * d_str[3] + w * d_str[4] :
-                             dstDims.size() == 4 ?
-                             n * d_str[0] + c * d_str[1] + h * d_str[2] + w * d_str[3] :
-                             dstDims.size() == 3 ?
-                             n * d_str[0] + c * d_str[1] + h * d_str[2] :
-                             dstDims.size() == 2 ?
-                             n * d_str[0] + c * d_str[1] :
-                             n * d_str[0];
+            size_t dst_off = dstDims.size() == 5
+                                 ? n * d_str[0] + c * d_str[1] + d * d_str[2] + h * d_str[3] + w * d_str[4]
+                             : dstDims.size() == 4 ? n * d_str[0] + c * d_str[1] + h * d_str[2] + w * d_str[3]
+                             : dstDims.size() == 3 ? n * d_str[0] + c * d_str[1] + h * d_str[2]
+                             : dstDims.size() == 2 ? n * d_str[0] + c * d_str[1]
+                                                   : n * d_str[0];
 
             dst[dst_off] = dst_val;
         });
     }
 }
-void FakeQuantize::executeBinarization(const std::unique_ptr<jit_uni_quantize_kernel> &pKernel) const {
+void FakeQuantize::executeBinarization(const std::unique_ptr<jit_uni_quantize_kernel>& pKernel) const {
 #if defined(OPENVINO_ARCH_X86_64)
     auto srcMemory = getSrcMemoryAtPort(0);
     auto dstMemory = getDstMemoryAtPort(0);
@@ -1628,8 +1763,8 @@ void FakeQuantize::executeBinarization(const std::unique_ptr<jit_uni_quantize_ke
     parallel_nd(N, H, W, [&](dim_t n, dim_t h, dim_t w) {
         auto arg = jit_quantize_call_args();
 
-        arg.from    = &src[(n * s_str[0] + h * s_str[2] + w * s_str[3]) * sizeof(float)];
-        arg.to      = &dst[(n * s_str[0] + h * s_str[2] + w * s_str[3]) / nbits];
+        arg.from = &src[(n * s_str[0] + h * s_str[2] + w * s_str[3]) * sizeof(float)];
+        arg.to = &dst[(n * s_str[0] + h * s_str[2] + w * s_str[3]) / nbits];
         arg.thresholds = &thresholds[0];
         arg.output_mask = &output_mask[0];
         arg.work_amount = (size_t)C;
@@ -1639,7 +1774,7 @@ void FakeQuantize::executeBinarization(const std::unique_ptr<jit_uni_quantize_ke
 #endif
 }
 
-void FakeQuantize::executeQuantization(const std::unique_ptr<jit_uni_quantize_kernel> &pKernel) const {
+void FakeQuantize::executeQuantization(const std::unique_ptr<jit_uni_quantize_kernel>& pKernel) const {
 #if defined(OPENVINO_ARCH_X86_64)
     auto srcMemory = getSrcMemoryAtPort(0);
     auto dstMemory = getDstMemoryAtPort(0);
@@ -1651,10 +1786,11 @@ void FakeQuantize::executeQuantization(const std::unique_ptr<jit_uni_quantize_ke
     auto srcDims = srcDesc.getShape().getStaticDims();
 
     bool is_blk_format = !srcDesc.hasLayoutType(LayoutType::nspc) && one_of(srcDesc.getShape().getRank(), 4u, 5u);
-    int blk_size = (srcDesc.hasLayoutType(LayoutType::ncsp) && one_of(srcDesc.getShape().getRank(), 3u, 4u, 5u))
-                    ? 1 : mayiuse(cpu::x64::avx512_core) ? 16 : 8;
+    int blk_size = (srcDesc.hasLayoutType(LayoutType::ncsp) && one_of(srcDesc.getShape().getRank(), 3u, 4u, 5u)) ? 1
+                   : mayiuse(cpu::x64::avx512_core)                                                              ? 16
+                                                                                                                 : 8;
 
-    const auto &jqp = pKernel->jqp_;
+    const auto& jqp = pKernel->jqp_;
     auto src_type_size = jqp.src_prc.size();
     auto dst_type_size = jqp.dst_prc.size();
 
@@ -1691,15 +1827,20 @@ void FakeQuantize::executeQuantization(const std::unique_ptr<jit_uni_quantize_ke
             arg.from = &src[data_off * src_type_size];
             arg.to = &dst[data_off * dst_type_size];
             arg.crop_low = broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_LOW)] ? &cropLow[0] : &cropLow[c];
-            arg.crop_high = broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)] ? &cropHigh[0] : &cropHigh[c];
-            arg.input_scale = broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)] ? &inputScale[0] : &inputScale[c];
-            arg.input_shift = broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)] ? &inputShift[0] : &inputShift[c];
-            arg.output_scale = broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)] ? &outputScale[0] : &outputScale[c];
-            arg.output_shift = broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)] ? &outputShift[0] : &outputShift[c];
-
-            arg.src_step = (size_t) blk_size * src_type_size;
-            arg.dst_step = (size_t) blk_size * dst_type_size;
-            arg.block_size = (size_t) blk_size;
+            arg.crop_high =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)] ? &cropHigh[0] : &cropHigh[c];
+            arg.input_scale =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)] ? &inputScale[0] : &inputScale[c];
+            arg.input_shift =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)] ? &inputShift[0] : &inputShift[c];
+            arg.output_scale =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)] ? &outputScale[0] : &outputScale[c];
+            arg.output_shift =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)] ? &outputShift[0] : &outputShift[c];
+
+            arg.src_step = (size_t)blk_size * src_type_size;
+            arg.dst_step = (size_t)blk_size * dst_type_size;
+            arg.block_size = (size_t)blk_size;
             arg.work_amount = (size_t)H;
 
             (*pKernel)(&arg);
@@ -1714,22 +1855,27 @@ void FakeQuantize::executeQuantization(const std::unique_ptr<jit_uni_quantize_ke
             const int h = b * batch_size / W;
             const int w = b * batch_size % W;
 
-            const size_t data_off = srcDims.size() == 3 || srcDims.size() == 4 ?
-                                    n * s_str[0] + c * s_str[1] + h * s_str[2] + w :
-                                    n * s_str[0] + c * s_str[1] + d * s_str[2] + h * s_str[3] + w;
+            const size_t data_off = srcDims.size() == 3 || srcDims.size() == 4
+                                        ? n * s_str[0] + c * s_str[1] + h * s_str[2] + w
+                                        : n * s_str[0] + c * s_str[1] + d * s_str[2] + h * s_str[3] + w;
 
             arg.from = &src[data_off * src_type_size];
             arg.to = &dst[data_off * dst_type_size];
             arg.crop_low = broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_LOW)] ? &cropLow[0] : &cropLow[c];
-            arg.crop_high = broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)] ? &cropHigh[0] : &cropHigh[c];
-            arg.input_scale = broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)] ? &inputScale[0] : &inputScale[c];
-            arg.input_shift = broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)] ? &inputShift[0] : &inputShift[c];
-            arg.output_scale = broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)] ? &outputScale[0] : &outputScale[c];
-            arg.output_shift = broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)] ? &outputShift[0] : &outputShift[c];
-
-            arg.src_step = is_blk_format ? (size_t) blk_size * src_type_size : (size_t) C * src_type_size;
-            arg.dst_step = is_blk_format ? (size_t) blk_size * dst_type_size : (size_t) C * dst_type_size;
-            arg.block_size = is_blk_format ? (size_t) blk_size : nstl::min(blk_size, C - c);
+            arg.crop_high =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)] ? &cropHigh[0] : &cropHigh[c];
+            arg.input_scale =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)] ? &inputScale[0] : &inputScale[c];
+            arg.input_shift =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)] ? &inputShift[0] : &inputShift[c];
+            arg.output_scale =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)] ? &outputScale[0] : &outputScale[c];
+            arg.output_shift =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)] ? &outputShift[0] : &outputShift[c];
+
+            arg.src_step = is_blk_format ? (size_t)blk_size * src_type_size : (size_t)C * src_type_size;
+            arg.dst_step = is_blk_format ? (size_t)blk_size * dst_type_size : (size_t)C * dst_type_size;
+            arg.block_size = is_blk_format ? (size_t)blk_size : nstl::min(blk_size, C - c);
             arg.work_amount = (size_t)std::min(static_cast<dim_t>(batch_size), H * W - b * batch_size);
 
             (*pKernel)(&arg);
@@ -1740,25 +1886,29 @@ void FakeQuantize::executeQuantization(const std::unique_ptr<jit_uni_quantize_ke
 
             int c = cb * blk_size;
 
-            size_t data_off = srcDims.size() == 2 ?
-                                    n * s_str[0] + c * s_str[1] :
-                              srcDims.size() == 3 || srcDims.size() == 4 ?
-                                    n * s_str[0] + c * s_str[1] + h * s_str[2] :
-                                    n * s_str[0] + c * s_str[1] + d * s_str[2] + h * s_str[3];
+            size_t data_off = srcDims.size() == 2 ? n * s_str[0] + c * s_str[1]
+                              : srcDims.size() == 3 || srcDims.size() == 4
+                                  ? n * s_str[0] + c * s_str[1] + h * s_str[2]
+                                  : n * s_str[0] + c * s_str[1] + d * s_str[2] + h * s_str[3];
 
             arg.from = &src[data_off * src_type_size];
             arg.to = &dst[data_off * dst_type_size];
             arg.crop_low = broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_LOW)] ? &cropLow[0] : &cropLow[c];
-            arg.crop_high = broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)] ? &cropHigh[0] : &cropHigh[c];
-            arg.input_scale = broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)] ? &inputScale[0] : &inputScale[c];
-            arg.input_shift = broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)] ? &inputShift[0] : &inputShift[c];
-            arg.output_scale = broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)] ? &outputScale[0] : &outputScale[c];
-            arg.output_shift = broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)] ? &outputShift[0] : &outputShift[c];
-
-            arg.src_step = is_blk_format ? (size_t) blk_size * src_type_size : (size_t) C * src_type_size;
-            arg.dst_step = is_blk_format ? (size_t) blk_size * dst_type_size : (size_t) C * dst_type_size;
-            arg.block_size = (is_blk_format && srcDims.size() != 2) ? (size_t) blk_size : nstl::min(blk_size, C - c);
-            arg.work_amount = (size_t) W;
+            arg.crop_high =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::CROP_HIGH)] ? &cropHigh[0] : &cropHigh[c];
+            arg.input_scale =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SCALE)] ? &inputScale[0] : &inputScale[c];
+            arg.input_shift =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::INPUT_SHIFT)] ? &inputShift[0] : &inputShift[c];
+            arg.output_scale =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SCALE)] ? &outputScale[0] : &outputScale[c];
+            arg.output_shift =
+                broadcasted[static_cast<size_t>(FQ_add_input_type::OUTPUT_SHIFT)] ? &outputShift[0] : &outputShift[c];
+
+            arg.src_step = is_blk_format ? (size_t)blk_size * src_type_size : (size_t)C * src_type_size;
+            arg.dst_step = is_blk_format ? (size_t)blk_size * dst_type_size : (size_t)C * dst_type_size;
+            arg.block_size = (is_blk_format && srcDims.size() != 2) ? (size_t)blk_size : nstl::min(blk_size, C - c);
+            arg.work_amount = (size_t)W;
 
             (*pKernel)(&arg);
         });
@@ -1778,7 +1928,7 @@ void FakeQuantize::execute(dnnl::stream strm) {
     }
 }
 
-void FakeQuantize::initializePostOpData(const VectorDims &dims, const size_t bufferAlignment, bool doRounding) {
+void FakeQuantize::initializePostOpData(const VectorDims& dims, const size_t bufferAlignment, bool doRounding) {
     if (postOpDataVersion == parameterVersion)
         return;
 
@@ -1789,11 +1939,15 @@ void FakeQuantize::initializePostOpData(const VectorDims &dims, const size_t buf
         binarizationOutputMask.resize(axisPaddedSize, 0);
 
         if (isInputLowBroadcasted) {
-            std::fill(binarizationThresholds.begin() + 1, binarizationThresholds.begin() + realAxisSize, binarizationThresholds[0]);
+            std::fill(binarizationThresholds.begin() + 1,
+                      binarizationThresholds.begin() + realAxisSize,
+                      binarizationThresholds[0]);
             std::fill(binarizationThresholds.begin() + realAxisSize, binarizationThresholds.end(), 0.f);
         }
         if (isOutputHighBroadcasted) {
-            std::fill(binarizationOutputMask.begin() + 1, binarizationOutputMask.begin() + realAxisSize, binarizationOutputMask[0]);
+            std::fill(binarizationOutputMask.begin() + 1,
+                      binarizationOutputMask.begin() + realAxisSize,
+                      binarizationOutputMask[0]);
             std::fill(binarizationThresholds.begin() + realAxisSize, binarizationThresholds.end(), 0.f);
         }
     } else {
@@ -1803,7 +1957,7 @@ void FakeQuantize::initializePostOpData(const VectorDims &dims, const size_t buf
     postOpDataVersion = parameterVersion;
 }
 
-void FakeQuantize::initializePostOpDataLegacy(const VectorDims &dims, const size_t bufferAlignment) {
+void FakeQuantize::initializePostOpDataLegacy(const VectorDims& dims, const size_t bufferAlignment) {
     if (legacyPostOpDataVersion == parameterVersion)
         return;
 
@@ -1815,11 +1969,15 @@ void FakeQuantize::initializePostOpDataLegacy(const VectorDims &dims, const size
         binarizationOutputMask.resize(axisPaddedSize, 0);
 
         if (isInputLowBroadcasted) {
-            std::fill(binarizationThresholds.begin() + 1, binarizationThresholds.begin() + realAxisSize, binarizationThresholds[0]);
+            std::fill(binarizationThresholds.begin() + 1,
+                      binarizationThresholds.begin() + realAxisSize,
+                      binarizationThresholds[0]);
             std::fill(binarizationThresholds.begin() + realAxisSize, binarizationThresholds.end(), 0.f);
         }
         if (isOutputHighBroadcasted) {
-            std::fill(binarizationOutputMask.begin() + 1, binarizationOutputMask.begin() + realAxisSize, binarizationOutputMask[0]);
+            std::fill(binarizationOutputMask.begin() + 1,
+                      binarizationOutputMask.begin() + realAxisSize,
+                      binarizationOutputMask[0]);
             std::fill(binarizationThresholds.begin() + realAxisSize, binarizationThresholds.end(), 0.f);
         }
 
@@ -1839,7 +1997,10 @@ void FakeQuantize::initializePostOpDataLegacy(const VectorDims &dims, const size
     legacyPostOpDataVersion = parameterVersion;
 }
 
-void FakeQuantize::appendMemory(const size_t dataSize, const void *data, MemoryPtr &memPtr, std::vector<MemoryPtr>& postOpsMem) {
+void FakeQuantize::appendMemory(const size_t dataSize,
+                                const void* data,
+                                MemoryPtr& memPtr,
+                                std::vector<MemoryPtr>& postOpsMem) {
     if (!memPtr) {
         DnnlBlockedMemoryDesc memoryDesc(ov::element::f32, {dataSize});
         memPtr = std::make_shared<Memory>(getEngine(), memoryDesc, data);
@@ -1848,12 +2009,15 @@ void FakeQuantize::appendMemory(const size_t dataSize, const void *data, MemoryP
     }
 }
 
-void FakeQuantize::appendMemory(const size_t dataSize, const void *data, MemoryPtr &memPtr, std::vector<const void*>& postOpsMem) {
+void FakeQuantize::appendMemory(const size_t dataSize,
+                                const void* data,
+                                MemoryPtr& memPtr,
+                                std::vector<const void*>& postOpsMem) {
     postOpsMem.push_back(data);
 }
 
 template <typename T>
-void FakeQuantize::appendPostOpsImpl(dnnl::post_ops& ops, const VectorDims &postOpDims, std::vector<T>& postOpsMem) {
+void FakeQuantize::appendPostOpsImpl(dnnl::post_ops& ops, const VectorDims& postOpDims, std::vector<T>& postOpsMem) {
     // try to map fakeQuantizeNode using output scale & eltwise first
     // if failed, fallback to append_quantization()
 
@@ -1865,21 +2029,40 @@ void FakeQuantize::appendPostOpsImpl(dnnl::post_ops& ops, const VectorDims &post
     initializePostOpDataLegacy(postOpDims, bufferAlignment);
 
     if (getAlgorithm() == Algorithm::FQBinarization) {
-        ops.append_binarization(dnnl::algorithm::binarization_depthwise, (const float*)&binarizationThresholds[0], (const float*)&binarizationOutputMask[0]);
+        ops.append_binarization(dnnl::algorithm::binarization_depthwise,
+                                (const float*)&binarizationThresholds[0],
+                                (const float*)&binarizationOutputMask[0]);
     } else {
-        dnnl::algorithm alg = getAlgorithm() == Algorithm::FQQuantization ? dnnl::algorithm::quantization_quantize :
-                                                                            dnnl::algorithm::quantization_quantize_dequantize;
+        dnnl::algorithm alg = getAlgorithm() == Algorithm::FQQuantization
+                                  ? dnnl::algorithm::quantization_quantize
+                                  : dnnl::algorithm::quantization_quantize_dequantize;
 
-        std::array<bool, 6> per_channel = {cropLowSize > 1, cropHighSize > 1, inputScaleSize > 1,
-                                           inputShiftSize > 1, outputScaleSize > 1, outputShiftSize > 1};
+        std::array<bool, 6> per_channel = {cropLowSize > 1,
+                                           cropHighSize > 1,
+                                           inputScaleSize > 1,
+                                           inputShiftSize > 1,
+                                           outputScaleSize > 1,
+                                           outputShiftSize > 1};
 
         std::array<bool, 6> all_default = {false};
-        all_default[0] = std::all_of(cropLow.cbegin(), cropLow.cend(), [](float val){ return val == 0.f; });
-        all_default[1] = std::all_of(cropHigh.cbegin(), cropHigh.cend(), [](float val){ return val == 0.f; });
-        all_default[2] = std::all_of(inputScale.cbegin(), inputScale.cend(), [](float val){ return val == 1.f; });
-        all_default[3] = std::all_of(inputShift.cbegin(), inputShift.cend(), [](float val){ return val == 0.f; });
-        all_default[4] = std::all_of(outputScale.cbegin(), outputScale.cend(), [](float val){ return val == 1.f; });
-        all_default[5] = std::all_of(outputShift.cbegin(), outputShift.cend(), [](float val){ return val == 0.f; });
+        all_default[0] = std::all_of(cropLow.cbegin(), cropLow.cend(), [](float val) {
+            return val == 0.f;
+        });
+        all_default[1] = std::all_of(cropHigh.cbegin(), cropHigh.cend(), [](float val) {
+            return val == 0.f;
+        });
+        all_default[2] = std::all_of(inputScale.cbegin(), inputScale.cend(), [](float val) {
+            return val == 1.f;
+        });
+        all_default[3] = std::all_of(inputShift.cbegin(), inputShift.cend(), [](float val) {
+            return val == 0.f;
+        });
+        all_default[4] = std::all_of(outputScale.cbegin(), outputScale.cend(), [](float val) {
+            return val == 1.f;
+        });
+        all_default[5] = std::all_of(outputShift.cbegin(), outputShift.cend(), [](float val) {
+            return val == 0.f;
+        });
 
         std::array<size_t, 6> offsets = {0};
         offsets[1] = offsets[0] + cropLowSize;
@@ -1894,7 +2077,9 @@ void FakeQuantize::appendPostOpsImpl(dnnl::post_ops& ops, const VectorDims &post
     }
 }
 
-void FakeQuantize::appendPostOps(dnnl::post_ops& ops, const VectorDims &postOpDims, std::unordered_map<int, MemoryPtr>& postOpsMem,
+void FakeQuantize::appendPostOps(dnnl::post_ops& ops,
+                                 const VectorDims& postOpDims,
+                                 std::unordered_map<int, MemoryPtr>& postOpsMem,
                                  const int channelAxis) {
     std::vector<MemoryPtr> postOpsMemPtrs;
     appendPostOpsImpl(ops, postOpDims, postOpsMemPtrs);
@@ -1906,7 +2091,9 @@ void FakeQuantize::appendPostOps(dnnl::post_ops& ops, const VectorDims &postOpDi
     }
 }
 
-void FakeQuantize::appendPostOps(dnnl::post_ops& ops, const VectorDims &postOpDims, std::vector<const void*>& postOpsMem,
+void FakeQuantize::appendPostOps(dnnl::post_ops& ops,
+                                 const VectorDims& postOpDims,
+                                 std::vector<const void*>& postOpsMem,
                                  const int channelAxis) {
     appendPostOpsImpl(ops, postOpDims, postOpsMem);
 }
@@ -1957,7 +2144,7 @@ void FakeQuantize::updateOptimizedFormula(bool do_rounding) {
     //     per-channel FQ.
     if (isPerTensor(inputShift, inputShift[0], 0.00005f)) {
         f.ish.resize(OC);
-        for (auto & v : f.ish)
+        for (auto& v : f.ish)
             v = inputShift[0];
     } else {
         f.ish = inputShift;
@@ -2115,7 +2302,7 @@ bool FakeQuantize::appendAttrPostOps(DnnlPostOpsComposerLegacy& dnnlpoc,
     return true;
 }
 
-FakeQuantize::FakeQuantizeJitExecutor::FakeQuantizeJitExecutor(const jit_quantize_params &_jqp) {
+FakeQuantize::FakeQuantizeJitExecutor::FakeQuantizeJitExecutor(const jit_quantize_params& _jqp) {
 #if defined(OPENVINO_ARCH_X86_64)
     bool isBinarization = _jqp.op_type == Algorithm::FQBinarization;
     if (mayiuse(cpu::x64::avx512_core)) {
@@ -2157,6 +2344,6 @@ bool FakeQuantize::created() const {
     return getType() == Type::FakeQuantize;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/fake_quantize.h b/src/plugins/intel_cpu/src/nodes/fake_quantize.h
index 62aea6092451a6..af34c0b91a1a7a 100644
--- a/src/plugins/intel_cpu/src/nodes/fake_quantize.h
+++ b/src/plugins/intel_cpu/src/nodes/fake_quantize.h
@@ -4,25 +4,17 @@
 
 #pragma once
 
-#include "common/primitive_attr.hpp"
-#include "node.h"
-
 #include <utility>
+
+#include "common/primitive_attr.hpp"
 #include "dnnl_postops_composer_legacy.h"
+#include "node.h"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-enum class FQ_add_input_type {
-    CROP_LOW,
-    CROP_HIGH,
-    INPUT_SCALE,
-    INPUT_SHIFT,
-    OUTPUT_SCALE,
-    OUTPUT_SHIFT,
-    INPUTS_SIZE
-};
+enum class FQ_add_input_type { CROP_LOW, CROP_HIGH, INPUT_SCALE, INPUT_SHIFT, OUTPUT_SCALE, OUTPUT_SHIFT, INPUTS_SIZE };
 
 struct jit_quantize_params {
     bool is_planar;
@@ -33,8 +25,8 @@ struct jit_quantize_params {
 
     Algorithm op_type;
 
-    int c; // need only for binarization
-    std::bitset<static_cast<size_t>(FQ_add_input_type::INPUTS_SIZE)> broadcasted; // need only for quantization
+    int c;                                                                         // need only for binarization
+    std::bitset<static_cast<size_t>(FQ_add_input_type::INPUTS_SIZE)> broadcasted;  // need only for quantization
 };
 
 struct jit_quantize_call_args {
@@ -57,9 +49,9 @@ struct jit_quantize_call_args {
 };
 
 struct jit_uni_quantize_kernel {
-    void (*ker_)(const jit_quantize_call_args *);
+    void (*ker_)(const jit_quantize_call_args*);
 
-    void operator()(const jit_quantize_call_args *args) {
+    void operator()(const jit_quantize_call_args* args) {
         assert(ker_);
         ker_(args);
     }
@@ -82,58 +74,116 @@ class FakeQuantize : public Node {
     void execute(dnnl::stream strm) override;
     void executeDynamicImpl(dnnl::stream strm) override;
 
-    size_t getAxis() const { return axis; }
+    size_t getAxis() const {
+        return axis;
+    }
 
-    bool isBinarization() const { return getAlgorithm() == Algorithm::FQBinarization; }
+    bool isBinarization() const {
+        return getAlgorithm() == Algorithm::FQBinarization;
+    }
 
     bool needPrepareParams() const override;
     void prepareParams() override;
     void createPrimitive() override;
 
-    const float* getBinarizationTresholdsPtr() const { return &binarizationThresholds[0]; }
-    const float* getBinarizationOutputMaskPtr() const { return reinterpret_cast<const float*>(&binarizationOutputMask[0]); }
-    size_t getBinarizationTresholdsSize() const { return binarizationThresholds.size(); }
-    size_t getBinarizationOutputMaskSize() const { return binarizationOutputMask.size(); }
+    const float* getBinarizationTresholdsPtr() const {
+        return &binarizationThresholds[0];
+    }
+    const float* getBinarizationOutputMaskPtr() const {
+        return reinterpret_cast<const float*>(&binarizationOutputMask[0]);
+    }
+    size_t getBinarizationTresholdsSize() const {
+        return binarizationThresholds.size();
+    }
+    size_t getBinarizationOutputMaskSize() const {
+        return binarizationOutputMask.size();
+    }
 
-    const std::vector<float>& getCropLow() const { return cropLow; }
-    const std::vector<float>& getCropHigh() const { return cropHigh; }
-    const std::vector<float>& getInputScale() const { return inputScale; }
-    const std::vector<float>& getInputShift() const { return inputShift; }
-    const std::vector<float>& getOutputScale() const { return outputScale; }
-    const std::vector<float>& getOutputShift() const { return outputShift; }
-    const size_t getLevels() const { return levels; }
+    const std::vector<float>& getCropLow() const {
+        return cropLow;
+    }
+    const std::vector<float>& getCropHigh() const {
+        return cropHigh;
+    }
+    const std::vector<float>& getInputScale() const {
+        return inputScale;
+    }
+    const std::vector<float>& getInputShift() const {
+        return inputShift;
+    }
+    const std::vector<float>& getOutputScale() const {
+        return outputScale;
+    }
+    const std::vector<float>& getOutputShift() const {
+        return outputShift;
+    }
+    const size_t getLevels() const {
+        return levels;
+    }
 
     void setCropLow(std::vector<float> newCropLow) {
-        cropLow = std::move(newCropLow); cropLowSize = cropLow.size(); ++parameterVersion;
+        cropLow = std::move(newCropLow);
+        cropLowSize = cropLow.size();
+        ++parameterVersion;
     }
     void setCropHigh(std::vector<float> newCropHigh) {
-        cropHigh = std::move(newCropHigh); cropHighSize = cropHigh.size(); ++parameterVersion;
+        cropHigh = std::move(newCropHigh);
+        cropHighSize = cropHigh.size();
+        ++parameterVersion;
     }
     void setInputScale(std::vector<float> newInputScale) {
-        inputScale = std::move(newInputScale); inputScaleSize = inputScale.size(); ++parameterVersion;
+        inputScale = std::move(newInputScale);
+        inputScaleSize = inputScale.size();
+        ++parameterVersion;
     }
     void setInputShift(std::vector<float> newInputShift) {
-        inputShift = std::move(newInputShift); inputShiftSize = inputShift.size(); ++parameterVersion;
+        inputShift = std::move(newInputShift);
+        inputShiftSize = inputShift.size();
+        ++parameterVersion;
     }
     void setOutputScale(std::vector<float> newOutputScale) {
-        outputScale = std::move(newOutputScale); outputScaleSize = outputScale.size(); ++parameterVersion;
+        outputScale = std::move(newOutputScale);
+        outputScaleSize = outputScale.size();
+        ++parameterVersion;
     }
     void setOutputShift(std::vector<float> newOutputShift) {
-        outputShift = std::move(newOutputShift); outputShiftSize = outputShift.size(); ++parameterVersion;
+        outputShift = std::move(newOutputShift);
+        outputShiftSize = outputShift.size();
+        ++parameterVersion;
     }
 
-    const std::vector<float>& getFQScales() const { return fqScales; }
+    const std::vector<float>& getFQScales() const {
+        return fqScales;
+    }
 
-    bool isInputLowBroadcast() const { return isInputLowBroadcasted; }
-    bool isInputHighBroadcast() const { return isInputHighBroadcasted; }
-    bool isOutputLowBroadcast() const { return isOutputLowBroadcasted; }
-    bool isOutputHighBroadcast() const { return isOutputHighBroadcasted; }
+    bool isInputLowBroadcast() const {
+        return isInputLowBroadcasted;
+    }
+    bool isInputHighBroadcast() const {
+        return isInputHighBroadcasted;
+    }
+    bool isOutputLowBroadcast() const {
+        return isOutputLowBroadcasted;
+    }
+    bool isOutputHighBroadcast() const {
+        return isOutputHighBroadcasted;
+    }
 
-    ov::element::Type getInputPrecision() const { return inputPrecision; }
-    ov::element::Type getOutputPrecision() const { return outputPrecision; }
+    ov::element::Type getInputPrecision() const {
+        return inputPrecision;
+    }
+    ov::element::Type getOutputPrecision() const {
+        return outputPrecision;
+    }
 
-    void appendPostOps(dnnl::post_ops& ops, const VectorDims &postOpDims, std::unordered_map<int, MemoryPtr>& postOpsMem, const int channelAxis = 1) override;
-    void appendPostOps(dnnl::post_ops& ops, const VectorDims &postOpDims, std::vector<const void*>& postOpsMem, const int channelAxis = 1) override;
+    void appendPostOps(dnnl::post_ops& ops,
+                       const VectorDims& postOpDims,
+                       std::unordered_map<int, MemoryPtr>& postOpsMem,
+                       const int channelAxis = 1) override;
+    void appendPostOps(dnnl::post_ops& ops,
+                       const VectorDims& postOpDims,
+                       std::vector<const void*>& postOpsMem,
+                       const int channelAxis = 1) override;
     bool appendAttrPostOps(DnnlPostOpsComposerLegacy& dnnlpoc,
                            bool isLastPostOp,
                            dnnl::memory::data_type outDataType,
@@ -143,12 +193,14 @@ class FakeQuantize : public Node {
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
     enum BroadcastingPolicy {
-        PerChannel, // all FQ operations are per channel
-        PerTensor,  // all FQ operations are per tensor
-        Mixed,      // some per channel, some per tensor
+        PerChannel,  // all FQ operations are per channel
+        PerTensor,   // all FQ operations are per tensor
+        Mixed,       // some per channel, some per tensor
     };
 
-    BroadcastingPolicy getBroadcastingPolicy() const { return broadcastingPolicy; }
+    BroadcastingPolicy getBroadcastingPolicy() const {
+        return broadcastingPolicy;
+    }
 
     MemoryPtr cropLowMemory;
     MemoryPtr cropHighMemory;
@@ -165,22 +217,22 @@ class FakeQuantize : public Node {
     using executorPtr = std::shared_ptr<FakeQuantizeExecutor>;
     executorPtr execPtr = nullptr;
     struct FakeQuantizeJitExecutor : public FakeQuantizeExecutor {
-        FakeQuantizeJitExecutor(const jit_quantize_params &_jqp);
+        FakeQuantizeJitExecutor(const jit_quantize_params& _jqp);
         void exec(const FakeQuantize& node) override;
         std::unique_ptr<jit_uni_quantize_kernel> pKernel;
     };
     void init() override;
     std::vector<LayoutType> getDataFormats() const;
-    void initializePostOpData(const VectorDims &postOpDims, const size_t bufferAlignment, bool doRounding);
-    void initializePostOpDataLegacy(const VectorDims &dims, const size_t bufferAlignment);
+    void initializePostOpData(const VectorDims& postOpDims, const size_t bufferAlignment, bool doRounding);
+    void initializePostOpDataLegacy(const VectorDims& dims, const size_t bufferAlignment);
     void executeReference();
-    void executeBinarization(const std::unique_ptr<jit_uni_quantize_kernel> &pKernel) const;
-    void executeQuantization(const std::unique_ptr<jit_uni_quantize_kernel> &pKernel) const;
+    void executeBinarization(const std::unique_ptr<jit_uni_quantize_kernel>& pKernel) const;
+    void executeQuantization(const std::unique_ptr<jit_uni_quantize_kernel>& pKernel) const;
 
-    void appendMemory(const size_t dataSize, const void *data, MemoryPtr &memPtr, std::vector<MemoryPtr>& postOpsMem);
-    void appendMemory(const size_t dataSize, const void *data, MemoryPtr &memPtr, std::vector<const void*>& postOpsMem);
+    void appendMemory(const size_t dataSize, const void* data, MemoryPtr& memPtr, std::vector<MemoryPtr>& postOpsMem);
+    void appendMemory(const size_t dataSize, const void* data, MemoryPtr& memPtr, std::vector<const void*>& postOpsMem);
     template <typename T>
-    void appendPostOpsImpl(dnnl::post_ops& ops, const VectorDims &postOpDims, std::vector<T>& postOpsMem);
+    void appendPostOpsImpl(dnnl::post_ops& ops, const VectorDims& postOpDims, std::vector<T>& postOpsMem);
 
     size_t levels = 0;
 
@@ -273,6 +325,6 @@ class FakeQuantize : public Node {
     BroadcastingPolicy broadcastingPolicy;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/fullyconnected.cpp b/src/plugins/intel_cpu/src/nodes/fullyconnected.cpp
index 0f5c46e8bcd7cd..2df6c0ae7522cc 100644
--- a/src/plugins/intel_cpu/src/nodes/fullyconnected.cpp
+++ b/src/plugins/intel_cpu/src/nodes/fullyconnected.cpp
@@ -13,6 +13,7 @@
 #include "cpu_types.h"
 #include "dnnl_extension_utils.h"
 #include "executors/memory_arguments.hpp"
+#include "fake_quantize.h"
 #include "graph_context.h"
 #include "input.h"
 #include "memory_desc/blocked_memory_desc.h"
@@ -24,17 +25,15 @@
 #include "openvino/core/type/element_type.hpp"
 #include "openvino/runtime/threading/cpu_message.hpp"
 #include "ov_ops/fully_connected.hpp"
+#include "ov_ops/fully_connected_compressed.hpp"
 #include "ov_ops/fully_connected_quantized.hpp"
 #include "ov_ops/fully_connected_quantized_legacy.hpp"
-#include "ov_ops/fully_connected_compressed.hpp"
 #include "post_ops.hpp"
 #include "shape_inference/custom/fullyconnected.hpp"
 #include "transformations/utils/utils.hpp"
 #include "utils/debug_capabilities.h"
 #include "utils/general_utils.h"
 
-#include "fake_quantize.h"
-
 using namespace dnnl;
 using namespace ov::element;
 
@@ -61,7 +60,8 @@ bool FullyConnected::isSupportedOperation(const std::shared_ptr<const ov::Node>&
         if (ov::is_type<const ov::op::internal::FullyConnectedCompressed>(op)) {
             if (!ov::op::util::is_on_constant_path(op->input_value(WEIGHT_SCALES)) ||
                 !ov::op::util::is_on_constant_path(op->input_value(WEIGHT_ZERO_POINTS))) {
-                errorMessage = "Only Constant operation on 'weight scales', and 'weight zero points' inputs is supported";
+                errorMessage =
+                    "Only Constant operation on 'weight scales', and 'weight zero points' inputs is supported";
                 return false;
             }
         }
@@ -137,19 +137,18 @@ FullyConnected::FullyConnected(const std::shared_ptr<ov::Node>& op, const GraphC
     if (!isSupportedOperation(op, errorMessage))
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
 
-    m_atoi[ARG_SRC]  = DATA;
-    m_atoi[ARG_WEI]  = WEIGHTS;
+    m_atoi[ARG_SRC] = DATA;
+    m_atoi[ARG_WEI] = WEIGHTS;
     m_atoi[ARG_BIAS] = BIAS;
 
     auto mapArgToInput = [&op](std::unordered_map<size_t, size_t>& argToInput, size_t argId, size_t inputId) {
-        if (op->get_input_size() > inputId &&
-            op->input(inputId).get_element_type() != ov::element::undefined) {
+        if (op->get_input_size() > inputId && op->input(inputId).get_element_type() != ov::element::undefined) {
             argToInput[argId] = inputId;
         }
     };
 
     if (ov::is_type<const ov::op::internal::FullyConnectedCompressed>(op)) {
-        mapArgToInput(m_atoi, ARG_WEI | ARG_ATTR_SCALES,      WEIGHT_SCALES);
+        mapArgToInput(m_atoi, ARG_WEI | ARG_ATTR_SCALES, WEIGHT_SCALES);
         mapArgToInput(m_atoi, ARG_WEI | ARG_ATTR_ZERO_POINTS, WEIGHT_ZERO_POINTS);
         algorithm = Algorithm::FullyConnectedCompressed;
     } else if (ov::is_type<const ov::op::internal::FullyConnectedQuantizedLegacy>(op)) {
@@ -190,7 +189,8 @@ void FullyConnected::needPrepareParamsForTensorParallel() {
             dim += dims.size();
         }
         OPENVINO_ASSERT(static_cast<int>(dims[dim]) >= tp_cfg.w_size,
-            getName() + " dim[" + std::to_string(dim) + "] is " + std::to_string(dims[dim]) + ", which is larger than w_size " + std::to_string(tp_cfg.w_size));
+                        getName() + " dim[" + std::to_string(dim) + "] is " + std::to_string(dims[dim]) +
+                            ", which is larger than w_size " + std::to_string(tp_cfg.w_size));
         auto splited_dim_vec = split_parts(dims[dim], tp_cfg.w_size);
 
         VectorDims new_dims = std::move(dims);
@@ -269,18 +269,34 @@ void FullyConnected::execTensorParallelSync() {
             for (int idx = 0; idx < tp_cfg.w_size; idx++) {
                 if (wait_list[idx] > 0 && tp_cfg.sub_memory->_memorys_table[tp_cfg.id][idx].flag) {
                     auto new_ptr = static_cast<uint8_t*>(tp_cfg.sub_memory->_memorys_table[tp_cfg.id][idx].send_buf);
-                    const auto copySize = splited_dim_vec[idx] * prec.size();    // bytes of half selected dim.
+                    const auto copySize = splited_dim_vec[idx] * prec.size();  // bytes of half selected dim.
                     const size_t unloop = 8;
                     size_t step = count / unloop;
-                    parallel_for(step, [&](size_t i){
-                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop) * channel_size, new_ptr + (i * unloop) * copySize, copySize);
-                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 1) * channel_size, new_ptr + (i * unloop + 1) * copySize, copySize);
-                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 2) * channel_size, new_ptr + (i * unloop + 2) * copySize, copySize);
-                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 3) * channel_size, new_ptr + (i * unloop + 3) * copySize, copySize);
-                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 4) * channel_size, new_ptr + (i * unloop + 4) * copySize, copySize);
-                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 5) * channel_size, new_ptr + (i * unloop + 5) * copySize, copySize);
-                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 6) * channel_size, new_ptr + (i * unloop + 6) * copySize, copySize);
-                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 7) * channel_size, new_ptr + (i * unloop + 7) * copySize, copySize);
+                    parallel_for(step, [&](size_t i) {
+                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop) * channel_size,
+                                   new_ptr + (i * unloop) * copySize,
+                                   copySize);
+                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 1) * channel_size,
+                                   new_ptr + (i * unloop + 1) * copySize,
+                                   copySize);
+                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 2) * channel_size,
+                                   new_ptr + (i * unloop + 2) * copySize,
+                                   copySize);
+                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 3) * channel_size,
+                                   new_ptr + (i * unloop + 3) * copySize,
+                                   copySize);
+                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 4) * channel_size,
+                                   new_ptr + (i * unloop + 4) * copySize,
+                                   copySize);
+                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 5) * channel_size,
+                                   new_ptr + (i * unloop + 5) * copySize,
+                                   copySize);
+                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 6) * channel_size,
+                                   new_ptr + (i * unloop + 6) * copySize,
+                                   copySize);
+                        cpu_memcpy(dst_ptr + idx * strideSize + (i * unloop + 7) * channel_size,
+                                   new_ptr + (i * unloop + 7) * copySize,
+                                   copySize);
                     });
                     size_t tail = count & ~(unloop - 1);
                     for (size_t i = tail; i < count; ++i) {
@@ -525,8 +541,10 @@ void FullyConnected::needSplitMemoryForTensorParallel() {
         memory[ARG_SRC] = getSrcMemoryAtPort(DATA);
         // wgt
         // split N direction
-        tp_cfg.cached_splited_weight = attrs.weightsNonTransposed ? split_vertical(context->getEngine(), std::move(wgt), 0, tp_cfg.w_rank, tp_cfg.w_size)
-                    : split_horizontal(context->getEngine(), std::move(wgt), 0, tp_cfg.w_rank, tp_cfg.w_size);
+        tp_cfg.cached_splited_weight =
+            attrs.weightsNonTransposed
+                ? split_vertical(context->getEngine(), std::move(wgt), 0, tp_cfg.w_rank, tp_cfg.w_size)
+                : split_horizontal(context->getEngine(), std::move(wgt), 0, tp_cfg.w_rank, tp_cfg.w_size);
         memory[ARG_WEI] = tp_cfg.cached_splited_weight;
         // bias
         if (attrs.withBias) {
@@ -539,21 +557,27 @@ void FullyConnected::needSplitMemoryForTensorParallel() {
         memory[ARG_BIAS] = tp_cfg.cached_splited_bias;
         // dst
         memory[ARG_DST] = getDstMemoryAtPort(0);
-        tp_cfg.cached_dst = split_horizontal(context->getEngine(), std::move(dst), -1, tp_cfg.w_rank, tp_cfg.w_size, false);
+        tp_cfg.cached_dst =
+            split_horizontal(context->getEngine(), std::move(dst), -1, tp_cfg.w_rank, tp_cfg.w_size, false);
 
-        memory[ARG_DST | ARG_ATTR_SCALES] = split_horizontal(context->getEngine(), memory[ARG_DST | ARG_ATTR_SCALES], 0, tp_cfg.w_rank, tp_cfg.w_size);
+        memory[ARG_DST | ARG_ATTR_SCALES] =
+            split_horizontal(context->getEngine(), memory[ARG_DST | ARG_ATTR_SCALES], 0, tp_cfg.w_rank, tp_cfg.w_size);
 
         auto scale_mem = std::const_pointer_cast<IMemory>(memory[ARG_WEI | ARG_ATTR_SCALES]);
-        memory[ARG_WEI | ARG_ATTR_SCALES] = attrs.weightsNonTransposed ? split_vertical(context->getEngine(), scale_mem, 0, tp_cfg.w_rank, tp_cfg.w_size)
-            : split_horizontal(context->getEngine(), scale_mem, 0, tp_cfg.w_rank, tp_cfg.w_size);
+        memory[ARG_WEI | ARG_ATTR_SCALES] =
+            attrs.weightsNonTransposed
+                ? split_vertical(context->getEngine(), scale_mem, 0, tp_cfg.w_rank, tp_cfg.w_size)
+                : split_horizontal(context->getEngine(), scale_mem, 0, tp_cfg.w_rank, tp_cfg.w_size);
 
         auto zeropoint_mem = std::const_pointer_cast<IMemory>(memory[ARG_WEI | ARG_ATTR_ZERO_POINTS]);
         auto element_num = zeropoint_mem->getSize() / zeropoint_mem->getPrecision().size();
         if (element_num == 1) {
             tp_cfg.cached_zeropoint = zeropoint_mem;
         } else {
-            tp_cfg.cached_zeropoint = attrs.weightsNonTransposed ? split_vertical(context->getEngine(), zeropoint_mem, 0, tp_cfg.w_rank, tp_cfg.w_size)
-                                : split_horizontal(context->getEngine(), zeropoint_mem, 0, tp_cfg.w_rank, tp_cfg.w_size);
+            tp_cfg.cached_zeropoint =
+                attrs.weightsNonTransposed
+                    ? split_vertical(context->getEngine(), zeropoint_mem, 0, tp_cfg.w_rank, tp_cfg.w_size)
+                    : split_horizontal(context->getEngine(), zeropoint_mem, 0, tp_cfg.w_rank, tp_cfg.w_size);
         }
     }
 }
diff --git a/src/plugins/intel_cpu/src/nodes/fullyconnected.h b/src/plugins/intel_cpu/src/nodes/fullyconnected.h
index 177edd3d426339..0b50d882c9e554 100644
--- a/src/plugins/intel_cpu/src/nodes/fullyconnected.h
+++ b/src/plugins/intel_cpu/src/nodes/fullyconnected.h
@@ -15,8 +15,8 @@
 
 #include "cpu_memory.h"
 #include "nodes/executors/executor_factory.hpp"
-#include "nodes/executors/memory_arguments.hpp"
 #include "nodes/executors/fullyconnected_config.hpp"
+#include "nodes/executors/memory_arguments.hpp"
 #include "post_ops.hpp"
 
 namespace ov {
@@ -105,7 +105,7 @@ class FullyConnected : public Node {
 
     static bool isConstantInput(const std::shared_ptr<const ov::Node>& op, InputId port);
 
-    std::unordered_map<size_t, size_t> m_atoi; // memory argument id to input id
+    std::unordered_map<size_t, size_t> m_atoi;  // memory argument id to input id
 
     void fuseDecompressionConstant(const MemoryCPtr& memory, MemoryCPtr& decompressionValuesPtr);
 
diff --git a/src/plugins/intel_cpu/src/nodes/gather.h b/src/plugins/intel_cpu/src/nodes/gather.h
index 6ee097e9a1fbab..c20a56807b0165 100644
--- a/src/plugins/intel_cpu/src/nodes/gather.h
+++ b/src/plugins/intel_cpu/src/nodes/gather.h
@@ -5,12 +5,13 @@
 #pragma once
 
 #include <node.h>
-#include "kernels/x64/gather_uni_kernel.hpp"
 
 #include <memory>
 #include <string>
 #include <vector>
 
+#include "kernels/x64/gather_uni_kernel.hpp"
+
 namespace ov {
 namespace intel_cpu {
 namespace node {
@@ -19,7 +20,7 @@ class Gather : public Node {
 public:
     Gather(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void createPrimitive() override;
     void execute(dnnl::stream strm) override;
@@ -115,6 +116,6 @@ class Gather : public Node {
     std::shared_ptr<jitGatherKernelBase> jitKernel;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/gather_elements.cpp b/src/plugins/intel_cpu/src/nodes/gather_elements.cpp
index 8653bda8c483d3..d8f221dcebf34d 100644
--- a/src/plugins/intel_cpu/src/nodes/gather_elements.cpp
+++ b/src/plugins/intel_cpu/src/nodes/gather_elements.cpp
@@ -2,23 +2,25 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "gather_elements.h"
+
 #include <cmath>
-#include <vector>
 #include <string>
+#include <vector>
+
+#include "common/cpu_memcpy.h"
 #include "openvino/core/parallel.hpp"
-#include "gather_elements.h"
 #include "openvino/opsets/opset1.hpp"
 #include "utils/general_utils.h"
-#include "common/cpu_memcpy.h"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-bool GatherElements::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool GatherElements::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                          std::string& errorMessage) noexcept {
     try {
-        if (!one_of(op->get_type_info(),
-                ov::op::v6::GatherElements::get_type_info_static())) {
+        if (!one_of(op->get_type_info(), ov::op::v6::GatherElements::get_type_info_static())) {
             errorMessage = "Node is not an instance of the GatherElements operation from operation set v6.";
             return false;
         }
@@ -88,8 +90,7 @@ void GatherElements::initSupportedPrimitiveDescriptors() {
 
     dataTypeSize_ = inDataPrecision.size();
 
-    addSupportedPrimDesc({{LayoutType::ncsp, inDataPrecision},
-                          {LayoutType::ncsp, ov::element::i32}},
+    addSupportedPrimDesc({{LayoutType::ncsp, inDataPrecision}, {LayoutType::ncsp, ov::element::i32}},
                          {{LayoutType::ncsp, inDataPrecision}},
                          impl_desc_type::ref_any);
 }
@@ -100,9 +101,9 @@ void GatherElements::executeDynamicImpl(dnnl::stream strm) {
 
 template <typename dataType>
 void GatherElements::directExecution() {
-    const auto *srcData = getSrcDataAtPortAs<const dataType>(dataIndex_);
-    const auto *indices = getSrcDataAtPortAs<const int>(indicesIndex_);
-    auto *dstData = getDstDataAtPortAs<dataType>(0);
+    const auto* srcData = getSrcDataAtPortAs<const dataType>(dataIndex_);
+    const auto* indices = getSrcDataAtPortAs<const int>(indicesIndex_);
+    auto* dstData = getDstDataAtPortAs<dataType>(0);
 
     const int outSize = getChildEdgeAt(0)->getMemory().getShape().getElementsCount();
     auto threadBody = [&](const int ithr, const int nthr) {
@@ -133,14 +134,14 @@ void GatherElements::directExecution() {
 
 void GatherElements::execute(dnnl::stream strm) {
     switch (dataTypeSize_) {
-        case sizeof(element_type_traits<ov::element::i32>::value_type):
-            return directExecution<element_type_traits<ov::element::i32>::value_type>();
-        case sizeof(element_type_traits<ov::element::i16>::value_type):
-            return directExecution<element_type_traits<ov::element::i16>::value_type>();
-        case sizeof(element_type_traits<ov::element::i8>::value_type):
-            return directExecution<element_type_traits<ov::element::i8>::value_type>();
-        default:
-            OPENVINO_THROW("Unsupported data type size");
+    case sizeof(element_type_traits<ov::element::i32>::value_type):
+        return directExecution<element_type_traits<ov::element::i32>::value_type>();
+    case sizeof(element_type_traits<ov::element::i16>::value_type):
+        return directExecution<element_type_traits<ov::element::i16>::value_type>();
+    case sizeof(element_type_traits<ov::element::i8>::value_type):
+        return directExecution<element_type_traits<ov::element::i8>::value_type>();
+    default:
+        OPENVINO_THROW("Unsupported data type size");
     }
 }
 
@@ -148,6 +149,6 @@ bool GatherElements::created() const {
     return getType() == Type::GatherElements;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/gather_elements.h b/src/plugins/intel_cpu/src/nodes/gather_elements.h
index 3c2282401f7431..b050cd4e523490 100644
--- a/src/plugins/intel_cpu/src/nodes/gather_elements.h
+++ b/src/plugins/intel_cpu/src/nodes/gather_elements.h
@@ -14,7 +14,7 @@ class GatherElements : public Node {
 public:
     GatherElements(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -40,6 +40,6 @@ class GatherElements : public Node {
     void directExecution();
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/gather_nd.cpp b/src/plugins/intel_cpu/src/nodes/gather_nd.cpp
index 8c81f9b770a687..e962839e571663 100644
--- a/src/plugins/intel_cpu/src/nodes/gather_nd.cpp
+++ b/src/plugins/intel_cpu/src/nodes/gather_nd.cpp
@@ -2,15 +2,17 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "gather_nd.h"
+
 #include <cmath>
-#include <vector>
+#include <openvino/opsets/opset8.hpp>
 #include <string>
+#include <vector>
+
+#include "common/cpu_memcpy.h"
 #include "dnnl_types.h"
 #include "openvino/core/parallel.hpp"
-#include "gather_nd.h"
-#include <openvino/opsets/opset8.hpp>
 #include "utils/general_utils.h"
-#include "common/cpu_memcpy.h"
 
 #define THROW_ERROR(...) OPENVINO_THROW("GatherND layer with name '", getName(), "' ", __VA_ARGS__)
 
@@ -20,7 +22,9 @@ namespace node {
 
 bool GatherND::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
-        if (!one_of(op->get_type_info(), ov::op::v5::GatherND::get_type_info_static(), ov::op::v8::GatherND::get_type_info_static())) {
+        if (!one_of(op->get_type_info(),
+                    ov::op::v5::GatherND::get_type_info_static(),
+                    ov::op::v8::GatherND::get_type_info_static())) {
             errorMessage = "Node is not an instance of the GatherND operation from operation set v5 and v8.";
             return false;
         }
@@ -70,12 +74,16 @@ void GatherND::initSupportedPrimitiveDescriptors() {
 
     ov::element::Type indicesPrecision = getOriginalInputPrecisionAtPort(GATHERND_INDEXES);
     if (!one_of(indicesPrecision,
-                ov::element::i32, ov::element::i64, ov::element::i16, ov::element::u16, ov::element::i8, ov::element::u8)) {
+                ov::element::i32,
+                ov::element::i64,
+                ov::element::i16,
+                ov::element::u16,
+                ov::element::i8,
+                ov::element::u8)) {
         THROW_ERROR("has unsupported 'indices' input precision: ", indicesPrecision);
     }
 
-    addSupportedPrimDesc({{LayoutType::ncsp, inDataPrecision},
-                          {LayoutType::ncsp, ov::element::i32}},
+    addSupportedPrimDesc({{LayoutType::ncsp, inDataPrecision}, {LayoutType::ncsp, ov::element::i32}},
                          {{LayoutType::ncsp, inDataPrecision}},
                          impl_desc_type::ref_any);
 }
@@ -96,24 +104,33 @@ void GatherND::prepareParams() {
     attrs.srcDims = srcMemPtr->getStaticDims();
     attrs.srcStrides = srcMemPtr->getDescWithType<BlockedMemoryDesc>()->getStrides();
     attrs.dstElementCount = dstMemPtr->getShape().getElementsCount();
-    attrs.sliceRank =  idxMemPtr->getStaticDims().back();
+    attrs.sliceRank = idxMemPtr->getStaticDims().back();
     execPtr = std::make_shared<GatherNDExecutor>(attrs);
 }
 
-GatherND::GatherNDExecutor::GatherNDExecutor(const GatherNDAttributes& attrs) : sliceRank(attrs.sliceRank), dataSize(attrs.dataSize) {
-    batchSize = std::accumulate(attrs.srcDims.begin(), attrs.srcDims.begin() + attrs.batchDims, size_t(1), std::multiplies<size_t>());
-    dataLength = std::accumulate(attrs.srcDims.begin() + sliceRank + attrs.batchDims, attrs.srcDims.end(), size_t(1),
+GatherND::GatherNDExecutor::GatherNDExecutor(const GatherNDAttributes& attrs)
+    : sliceRank(attrs.sliceRank),
+      dataSize(attrs.dataSize) {
+    batchSize = std::accumulate(attrs.srcDims.begin(),
+                                attrs.srcDims.begin() + attrs.batchDims,
+                                size_t(1),
+                                std::multiplies<size_t>());
+    dataLength = std::accumulate(attrs.srcDims.begin() + sliceRank + attrs.batchDims,
+                                 attrs.srcDims.end(),
+                                 size_t(1),
                                  std::multiplies<size_t>());
     cycles = attrs.dstElementCount / (dataLength * batchSize);
     workAmount = batchSize * cycles;
 
-    srcBatchStride = std::accumulate(attrs.srcDims.begin() + attrs.batchDims, attrs.srcDims.end(), size_t(1),
+    srcBatchStride = std::accumulate(attrs.srcDims.begin() + attrs.batchDims,
+                                     attrs.srcDims.end(),
+                                     size_t(1),
                                      std::multiplies<size_t>());
     idxBatchStride = cycles * sliceRank;
     dstBatchStride = cycles * dataLength;
 
     srcShifts.resize(attrs.sliceRank, 0);
-    for (size_t i = 0; i < attrs.sliceRank ; i++)
+    for (size_t i = 0; i < attrs.sliceRank; i++)
         srcShifts[i] = attrs.srcStrides[i + attrs.batchDims] * (dataLength > 1 ? dataSize : 1);
 
     // optimized implementation 'blocks' via memcpy
@@ -128,25 +145,33 @@ void GatherND::execute(dnnl::stream strm) {
     if (!execPtr)
         THROW_ERROR("has not compiled executor.");
 
-    execPtr->exec(getSrcMemoryAtPort(GATHERND_DATA),
-                  getSrcMemoryAtPort(GATHERND_INDEXES),
-                  getDstMemoryAtPort(0));
+    execPtr->exec(getSrcMemoryAtPort(GATHERND_DATA), getSrcMemoryAtPort(GATHERND_INDEXES), getDstMemoryAtPort(0));
 }
 
-void GatherND::GatherNDExecutor::exec(const MemoryPtr& srcMemPtr, const MemoryPtr& idxMemPtr, const MemoryPtr& dstMemPtr) {
+void GatherND::GatherNDExecutor::exec(const MemoryPtr& srcMemPtr,
+                                      const MemoryPtr& idxMemPtr,
+                                      const MemoryPtr& dstMemPtr) {
     if (dataLength > 1) {
         gatherBlocks(srcMemPtr, idxMemPtr, dstMemPtr);
         return;
     }
 
-    GatherNDContext ctx { this, srcMemPtr, idxMemPtr, dstMemPtr };
-    OV_SWITCH(intel_cpu, GatherNDEmitter, ctx, dataSize,
-              OV_CASE(sizeof(element_type_traits<ov::element::i32>::value_type), element_type_traits<ov::element::i32>::value_type),
-              OV_CASE(sizeof(element_type_traits<ov::element::i16>::value_type), element_type_traits<ov::element::i16>::value_type),
-              OV_CASE(sizeof(element_type_traits<ov::element::i8>::value_type), element_type_traits<ov::element::i8>::value_type));
+    GatherNDContext ctx{this, srcMemPtr, idxMemPtr, dstMemPtr};
+    OV_SWITCH(intel_cpu,
+              GatherNDEmitter,
+              ctx,
+              dataSize,
+              OV_CASE(sizeof(element_type_traits<ov::element::i32>::value_type),
+                      element_type_traits<ov::element::i32>::value_type),
+              OV_CASE(sizeof(element_type_traits<ov::element::i16>::value_type),
+                      element_type_traits<ov::element::i16>::value_type),
+              OV_CASE(sizeof(element_type_traits<ov::element::i8>::value_type),
+                      element_type_traits<ov::element::i8>::value_type));
 }
 
-void GatherND::GatherNDExecutor::gatherBlocks(const MemoryPtr& srcMemPtr, const MemoryPtr& idxMemPtr, const MemoryPtr& dstMemPtr) {
+void GatherND::GatherNDExecutor::gatherBlocks(const MemoryPtr& srcMemPtr,
+                                              const MemoryPtr& idxMemPtr,
+                                              const MemoryPtr& dstMemPtr) {
     const uint8_t* srcData = srcMemPtr->getDataAs<const uint8_t>();
     const int32_t* indices = idxMemPtr->getDataAs<const int32_t>();
     uint8_t* dstData = dstMemPtr->getDataAs<uint8_t>();
@@ -183,7 +208,9 @@ void GatherND::GatherNDExecutor::gatherBlocks(const MemoryPtr& srcMemPtr, const
 }
 
 template <typename dataType>
-void GatherND::GatherNDExecutor::gatherElementwise(const MemoryPtr& srcMemPtr, const MemoryPtr& idxMemPtr, const MemoryPtr& dstMemPtr) {
+void GatherND::GatherNDExecutor::gatherElementwise(const MemoryPtr& srcMemPtr,
+                                                   const MemoryPtr& idxMemPtr,
+                                                   const MemoryPtr& dstMemPtr) {
     const dataType* srcData = srcMemPtr->getDataAs<const dataType>();
     const int32_t* indices = idxMemPtr->getDataAs<const int32_t>();
     dataType* dstData = dstMemPtr->getDataAs<dataType>();
@@ -227,6 +254,6 @@ bool GatherND::created() const {
     return getType() == Type::GatherND;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/gather_nd.h b/src/plugins/intel_cpu/src/nodes/gather_nd.h
index ed643a2da08899..312cb465bf9e6c 100644
--- a/src/plugins/intel_cpu/src/nodes/gather_nd.h
+++ b/src/plugins/intel_cpu/src/nodes/gather_nd.h
@@ -14,7 +14,7 @@ class GatherND : public Node {
 public:
     GatherND(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -65,7 +65,7 @@ class GatherND : public Node {
             MemoryPtr dstMemPtr;
         };
 
-        template<typename T>
+        template <typename T>
         struct GatherNDEmitter {
             void operator()(GatherNDContext& ctx) {
                 ctx.executor->gatherElementwise<T>(ctx.srcMemPtr, ctx.idxMemPtr, ctx.dstMemPtr);
@@ -80,6 +80,6 @@ class GatherND : public Node {
     executorPtr execPtr = nullptr;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/gather_tree.cpp b/src/plugins/intel_cpu/src/nodes/gather_tree.cpp
index 5834cd1e1048ba..2ff9a1ccdb8f59 100644
--- a/src/plugins/intel_cpu/src/nodes/gather_tree.cpp
+++ b/src/plugins/intel_cpu/src/nodes/gather_tree.cpp
@@ -2,13 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "openvino/op/gather_tree.hpp"
+
+#include <cmath>
 #include <string>
 #include <vector>
-#include <cmath>
 
-#include "openvino/op/gather_tree.hpp"
-#include "openvino/core/parallel.hpp"
 #include "gather_tree.h"
+#include "openvino/core/parallel.hpp"
 #include "utils/general_utils.h"
 
 namespace ov {
@@ -59,11 +60,11 @@ void GatherTree::initSupportedPrimitiveDescriptors() {
     if (!one_of(precision, ov::element::f32, ov::element::i32))
         precision = ov::element::f32;
 
-    if (getOriginalInputPrecisionAtPort(GATHER_TREE_PARENT_IDX)  != precision ||
+    if (getOriginalInputPrecisionAtPort(GATHER_TREE_PARENT_IDX) != precision ||
         getOriginalInputPrecisionAtPort(GATHER_TREE_MAX_SEQ_LEN) != precision ||
-        getOriginalInputPrecisionAtPort(GATHER_TREE_END_TOKEN)   != precision ||
-        getOriginalOutputPrecisionAtPort(0)                 != precision) {
-            OPENVINO_THROW(errorPrefix, " has incorrect input/output data precision. Must be the same.");
+        getOriginalInputPrecisionAtPort(GATHER_TREE_END_TOKEN) != precision ||
+        getOriginalOutputPrecisionAtPort(0) != precision) {
+        OPENVINO_THROW(errorPrefix, " has incorrect input/output data precision. Must be the same.");
     }
 
     addSupportedPrimDesc({{LayoutType::ncsp, precision},
@@ -121,13 +122,15 @@ void GatherTree::executeDynamicImpl(dnnl::stream strm) {
     execute(strm);
 }
 
-GatherTree::GatherTreeExecutor::GatherTreeExecutor(const VectorDims& stepIdxDims, const VectorDims& parentIdxDims,
-    const VectorDims& maxSeqLenDims, const VectorDims& dstDims)
-        : maxTime{static_cast<int32_t>(stepIdxDims[0])}
-        , batchSize{stepIdxDims[1]}
-        , beamWidth{stepIdxDims[2]}
-        , bbSize{batchSize * beamWidth}
-        , parentIdxSize{std::accumulate(parentIdxDims.cbegin(), parentIdxDims.cend(), 1lu, std::multiplies<size_t>())} {
+GatherTree::GatherTreeExecutor::GatherTreeExecutor(const VectorDims& stepIdxDims,
+                                                   const VectorDims& parentIdxDims,
+                                                   const VectorDims& maxSeqLenDims,
+                                                   const VectorDims& dstDims)
+    : maxTime{static_cast<int32_t>(stepIdxDims[0])},
+      batchSize{stepIdxDims[1]},
+      beamWidth{stepIdxDims[2]},
+      bbSize{batchSize * beamWidth},
+      parentIdxSize{std::accumulate(parentIdxDims.cbegin(), parentIdxDims.cend(), 1lu, std::multiplies<size_t>())} {
     if (maxTime != static_cast<int32_t>(parentIdxDims[0]) || maxTime != static_cast<int32_t>(dstDims[0]) ||
         batchSize != parentIdxDims[1] || batchSize != dstDims[1] || batchSize != maxSeqLenDims[0] ||
         beamWidth != parentIdxDims[2] || beamWidth != dstDims[2]) {
@@ -136,14 +139,17 @@ GatherTree::GatherTreeExecutor::GatherTreeExecutor(const VectorDims& stepIdxDims
     }
 }
 
-template<typename DATA_T>
-void GatherTree::GatherTreeExecutor::exec(const MemoryPtr& stepIdxMemPtr, const MemoryPtr& parentIdxMemPtr,
-    const MemoryPtr& maxSeqLenMemPtr, const MemoryPtr& endTokenMemPtr, const MemoryPtr& dstMemPtr) {
-    const auto *stepIdx = stepIdxMemPtr->getDataAs<DATA_T>();
-    const auto *parentIdx = parentIdxMemPtr->getDataAs<DATA_T>();
-    const auto *maxSeqLen = maxSeqLenMemPtr->getDataAs<DATA_T>();
+template <typename DATA_T>
+void GatherTree::GatherTreeExecutor::exec(const MemoryPtr& stepIdxMemPtr,
+                                          const MemoryPtr& parentIdxMemPtr,
+                                          const MemoryPtr& maxSeqLenMemPtr,
+                                          const MemoryPtr& endTokenMemPtr,
+                                          const MemoryPtr& dstMemPtr) {
+    const auto* stepIdx = stepIdxMemPtr->getDataAs<DATA_T>();
+    const auto* parentIdx = parentIdxMemPtr->getDataAs<DATA_T>();
+    const auto* maxSeqLen = maxSeqLenMemPtr->getDataAs<DATA_T>();
     const auto endToken = (endTokenMemPtr->getDataAs<DATA_T>())[0];
-    auto *finalIdx = dstMemPtr->getDataAs<DATA_T>();
+    auto* finalIdx = dstMemPtr->getDataAs<DATA_T>();
 
     bool incorrectResult = false;
     parallel_for2d(batchSize, beamWidth, [&](size_t batch, size_t beam) {
@@ -164,7 +170,7 @@ void GatherTree::GatherTreeExecutor::exec(const MemoryPtr& stepIdxMemPtr, const
             }
 
             bool finished = false;
-            auto *final = &finalIdx[batch * beamWidth + beam];
+            auto* final = &finalIdx[batch * beamWidth + beam];
             for (time = 0; time < maxSequenceInBeam; time++, final += bbSize) {
                 if (finished)
                     (*final) = endToken;
@@ -184,6 +190,6 @@ bool GatherTree::created() const {
     return getType() == Type::GatherTree;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/gather_tree.h b/src/plugins/intel_cpu/src/nodes/gather_tree.h
index 69d63f834b555d..9874fceb835ba5 100644
--- a/src/plugins/intel_cpu/src/nodes/gather_tree.h
+++ b/src/plugins/intel_cpu/src/nodes/gather_tree.h
@@ -14,7 +14,7 @@ class GatherTree : public Node {
 public:
     GatherTree(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -32,7 +32,7 @@ class GatherTree : public Node {
                            const VectorDims& dstDims);
         ~GatherTreeExecutor() = default;
 
-        template<typename DATA_T>
+        template <typename DATA_T>
         void exec(const MemoryPtr& stepIdxMemPtr,
                   const MemoryPtr& parentIdxMemPtr,
                   const MemoryPtr& maxSeqLenMemPtr,
@@ -60,6 +60,6 @@ class GatherTree : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/generate_proposals.cpp b/src/plugins/intel_cpu/src/nodes/generate_proposals.cpp
index ae32e1e4729096..0ed50c7b0d73a8 100644
--- a/src/plugins/intel_cpu/src/nodes/generate_proposals.cpp
+++ b/src/plugins/intel_cpu/src/nodes/generate_proposals.cpp
@@ -2,22 +2,22 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <cstring>
+#include <algorithm>
 #include <cassert>
 #include <cmath>
+#include <cstring>
 #include <string>
-#include <vector>
 #include <utility>
-#include <algorithm>
+#include <vector>
 
 #if defined(HAVE_AVX2)
-#include <immintrin.h>
+#    include <immintrin.h>
 #endif
 
-#include "openvino/op/generate_proposals.hpp"
-#include "openvino/core/parallel.hpp"
 #include "common/cpu_memcpy.h"
 #include "generate_proposals.h"
+#include "openvino/core/parallel.hpp"
+#include "openvino/op/generate_proposals.hpp"
 #include "shape_inference/shape_inference_internal_dyn.hpp"
 
 namespace ov {
@@ -30,21 +30,29 @@ struct Indexer4d {
     int dim23_;
     int dim123_;
 
-    explicit Indexer4d(int dim0, int dim1, int dim2, int dim3):
-            dim3_(dim3), dim23_(dim2 * dim3), dim123_(dim1 * dim2 * dim3) {
+    explicit Indexer4d(int dim0, int dim1, int dim2, int dim3)
+        : dim3_(dim3),
+          dim23_(dim2 * dim3),
+          dim123_(dim1 * dim2 * dim3) {
         (void)dim0;
     }
 
     int operator()(int i, int j, int k, int n) const {
-        return  i * dim123_ + j * dim23_ + k * dim3_ + n;
+        return i * dim123_ + j * dim23_ + k * dim3_ + n;
     }
 };
 
-
-void refine_anchors(const float* deltas, const float* scores, const float* anchors,
-                    float* proposals, const int anchors_num, const int bottom_H,
-                    const int bottom_W, const float img_H, const float img_W,
-                    const float min_box_H, const float min_box_W,
+void refine_anchors(const float* deltas,
+                    const float* scores,
+                    const float* anchors,
+                    float* proposals,
+                    const int anchors_num,
+                    const int bottom_H,
+                    const int bottom_W,
+                    const float img_H,
+                    const float img_W,
+                    const float min_box_H,
+                    const float min_box_W,
                     const float max_delta_log_wh,
                     float coordinates_offset) {
     Indexer4d delta_idx(anchors_num, 4, bottom_H, bottom_W);
@@ -111,18 +119,23 @@ void refine_anchors(const float* deltas, const float* scores, const float* ancho
 
 void unpack_boxes(const float* p_proposals, float* unpacked_boxes, int* is_dead, int pre_nms_topn) {
     parallel_for(pre_nms_topn, [&](size_t i) {
-        unpacked_boxes[0*pre_nms_topn + i] = p_proposals[6*i + 0];
-        unpacked_boxes[1*pre_nms_topn + i] = p_proposals[6*i + 1];
-        unpacked_boxes[2*pre_nms_topn + i] = p_proposals[6*i + 2];
-        unpacked_boxes[3*pre_nms_topn + i] = p_proposals[6*i + 3];
-        unpacked_boxes[4*pre_nms_topn + i] = p_proposals[6*i + 4];
-        is_dead[i] = (p_proposals[6*i + 5] == 1.0) ? 0 : 1;
+        unpacked_boxes[0 * pre_nms_topn + i] = p_proposals[6 * i + 0];
+        unpacked_boxes[1 * pre_nms_topn + i] = p_proposals[6 * i + 1];
+        unpacked_boxes[2 * pre_nms_topn + i] = p_proposals[6 * i + 2];
+        unpacked_boxes[3 * pre_nms_topn + i] = p_proposals[6 * i + 3];
+        unpacked_boxes[4 * pre_nms_topn + i] = p_proposals[6 * i + 4];
+        is_dead[i] = (p_proposals[6 * i + 5] == 1.0) ? 0 : 1;
     });
 }
 
-void nms_cpu(const int num_boxes, int is_dead[],
-             const float* boxes, int index_out[], size_t* const num_out,
-             const int base_index, const float nms_thresh, const int max_num_out,
+void nms_cpu(const int num_boxes,
+             int is_dead[],
+             const float* boxes,
+             int index_out[],
+             size_t* const num_out,
+             const int base_index,
+             const float nms_thresh,
+             const int max_num_out,
              float coordinates_offset) {
     const int num_proposals = num_boxes;
     size_t count = 0;
@@ -133,9 +146,9 @@ void nms_cpu(const int num_boxes, int is_dead[],
     const float* y1 = boxes + 3 * num_proposals;
 
 #if defined(HAVE_AVX2)
-    __m256  vc_fone = _mm256_set1_ps(coordinates_offset);
+    __m256 vc_fone = _mm256_set1_ps(coordinates_offset);
     __m256i vc_ione = _mm256_set1_epi32(1);
-    __m256  vc_zero = _mm256_set1_ps(0.0f);
+    __m256 vc_zero = _mm256_set1_ps(0.0f);
 
     __m256 vc_nms_thresh = _mm256_set1_ps(nms_thresh);
 #endif
@@ -156,13 +169,13 @@ void nms_cpu(const int num_boxes, int is_dead[],
         __m256 vx1i = _mm256_set1_ps(x1[box]);
         __m256 vy1i = _mm256_set1_ps(y1[box]);
 
-        __m256 vA_width  = _mm256_sub_ps(vx1i, vx0i);
+        __m256 vA_width = _mm256_sub_ps(vx1i, vx0i);
         __m256 vA_height = _mm256_sub_ps(vy1i, vy0i);
-        __m256 vA_area   = _mm256_mul_ps(_mm256_add_ps(vA_width, vc_fone), _mm256_add_ps(vA_height, vc_fone));
+        __m256 vA_area = _mm256_mul_ps(_mm256_add_ps(vA_width, vc_fone), _mm256_add_ps(vA_height, vc_fone));
 
         for (; tail <= num_boxes - 8; tail += 8) {
-            __m256i *pdst = reinterpret_cast<__m256i*>(is_dead + tail);
-            __m256i  vdst = _mm256_loadu_si256(pdst);
+            __m256i* pdst = reinterpret_cast<__m256i*>(is_dead + tail);
+            __m256i vdst = _mm256_loadu_si256(pdst);
 
             __m256 vx0j = _mm256_loadu_ps(x0 + tail);
             __m256 vy0j = _mm256_loadu_ps(y0 + tail);
@@ -174,13 +187,13 @@ void nms_cpu(const int num_boxes, int is_dead[],
             __m256 vx1 = _mm256_min_ps(vx1i, vx1j);
             __m256 vy1 = _mm256_min_ps(vy1i, vy1j);
 
-            __m256 vwidth  = _mm256_add_ps(_mm256_sub_ps(vx1, vx0), vc_fone);
+            __m256 vwidth = _mm256_add_ps(_mm256_sub_ps(vx1, vx0), vc_fone);
             __m256 vheight = _mm256_add_ps(_mm256_sub_ps(vy1, vy0), vc_fone);
             __m256 varea = _mm256_mul_ps(_mm256_max_ps(vc_zero, vwidth), _mm256_max_ps(vc_zero, vheight));
 
-            __m256 vB_width  = _mm256_sub_ps(vx1j, vx0j);
+            __m256 vB_width = _mm256_sub_ps(vx1j, vx0j);
             __m256 vB_height = _mm256_sub_ps(vy1j, vy0j);
-            __m256 vB_area   = _mm256_mul_ps(_mm256_add_ps(vB_width, vc_fone), _mm256_add_ps(vB_height, vc_fone));
+            __m256 vB_area = _mm256_mul_ps(_mm256_add_ps(vB_width, vc_fone), _mm256_add_ps(vB_height, vc_fone));
 
             __m256 vdivisor = _mm256_sub_ps(_mm256_add_ps(vA_area, vB_area), varea);
             __m256 vintersection_area = _mm256_div_ps(varea, vdivisor);
@@ -221,9 +234,9 @@ void nms_cpu(const int num_boxes, int is_dead[],
                 const float y1 = std::min<float>(y1i, y1j);
 
                 // intersection area
-                const float width  = std::max<float>(0.0f,  x1 - x0 + coordinates_offset);
-                const float height = std::max<float>(0.0f,  y1 - y0 + coordinates_offset);
-                const float area   = width * height;
+                const float width = std::max<float>(0.0f, x1 - x0 + coordinates_offset);
+                const float height = std::max<float>(0.0f, y1 - y0 + coordinates_offset);
+                const float area = width * height;
 
                 // area of A, B
                 const float A_area = (x1i - x0i + coordinates_offset) * (y1i - y0i + coordinates_offset);
@@ -241,16 +254,20 @@ void nms_cpu(const int num_boxes, int is_dead[],
     *num_out = count;
 }
 
-
-void fill_output_blobs(const float* proposals, const int* roi_indices,
-                       float* rois, float* scores, uint8_t* roi_num,
-                       const int num_proposals, const size_t num_rois, const int post_nms_topn,
+void fill_output_blobs(const float* proposals,
+                       const int* roi_indices,
+                       float* rois,
+                       float* scores,
+                       uint8_t* roi_num,
+                       const int num_proposals,
+                       const size_t num_rois,
+                       const int post_nms_topn,
                        ov::element::Type roi_num_type) {
-    const float *src_x0 = proposals + 0 * num_proposals;
-    const float *src_y0 = proposals + 1 * num_proposals;
-    const float *src_x1 = proposals + 2 * num_proposals;
-    const float *src_y1 = proposals + 3 * num_proposals;
-    const float *src_score = proposals + 4 * num_proposals;
+    const float* src_x0 = proposals + 0 * num_proposals;
+    const float* src_y0 = proposals + 1 * num_proposals;
+    const float* src_x1 = proposals + 2 * num_proposals;
+    const float* src_y1 = proposals + 3 * num_proposals;
+    const float* src_score = proposals + 4 * num_proposals;
 
     parallel_for(num_rois, [&](size_t i) {
         int index = roi_indices[i];
@@ -274,8 +291,8 @@ void fill_output_blobs(const float* proposals, const int* roi_indices,
 
 }  // namespace
 
-bool GenerateProposals::isSupportedOperation
-            (const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool GenerateProposals::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                             std::string& errorMessage) noexcept {
     try {
         if (!ov::as_type_ptr<const ov::op::v9::GenerateProposals>(op)) {
             errorMessage = "Node is not an instance of the Proposal from the operations set v0.";
@@ -332,13 +349,13 @@ void GenerateProposals::execute(dnnl::stream strm) {
         }
 
         size_t anchor_dims_size = 1;
-        const auto &anchorDims = getParentEdgeAt(INPUT_ANCHORS)->getMemory().getStaticDims();
+        const auto& anchorDims = getParentEdgeAt(INPUT_ANCHORS)->getMemory().getStaticDims();
         for (size_t i = 0; i < anchorDims.size(); i++) {
             anchor_dims_size *= anchorDims[i];
         }
 
         size_t deltas_dims_size = 1;
-        const auto &deltaDims = getParentEdgeAt(INPUT_DELTAS)->getMemory().getStaticDims();
+        const auto& deltaDims = getParentEdgeAt(INPUT_DELTAS)->getMemory().getStaticDims();
         for (size_t i = 1; i < deltaDims.size(); i++) {
             deltas_dims_size *= deltaDims[i];
         }
@@ -346,7 +363,7 @@ void GenerateProposals::execute(dnnl::stream strm) {
             OPENVINO_THROW("'Anchors' blob size for GenerateProposals is incompatible with 'deltas' blob size!");
 
         size_t score_dims_size = 1;
-        const auto &scoreDims = getParentEdgeAt(INPUT_SCORES)->getMemory().getStaticDims();
+        const auto& scoreDims = getParentEdgeAt(INPUT_SCORES)->getMemory().getStaticDims();
         for (size_t i = 1; i < scoreDims.size(); i++) {
             score_dims_size *= scoreDims[i];
         }
@@ -354,16 +371,16 @@ void GenerateProposals::execute(dnnl::stream strm) {
             OPENVINO_THROW("'Deltas' blob size for GenerateProposals is incompatible with 'scores' blob size!");
 
         size_t im_info_dims_size = 1;
-        const auto &infoDims = getParentEdgeAt(INPUT_IM_INFO)->getMemory().getStaticDims();
+        const auto& infoDims = getParentEdgeAt(INPUT_IM_INFO)->getMemory().getStaticDims();
         for (size_t i = 1; i < infoDims.size(); i++) {
             im_info_dims_size *= infoDims[i];
         }
 
         // Prepare memory
-        const float *p_deltas_item  = getSrcDataAtPortAs<const float>(INPUT_DELTAS);
-        const float *p_scores_item  = getSrcDataAtPortAs<const float>(INPUT_SCORES);
-        const float *p_anchors_item = getSrcDataAtPortAs<const float>(INPUT_ANCHORS);
-        const float *p_img_info_cpu = getSrcDataAtPortAs<const float>(INPUT_IM_INFO);
+        const float* p_deltas_item = getSrcDataAtPortAs<const float>(INPUT_DELTAS);
+        const float* p_scores_item = getSrcDataAtPortAs<const float>(INPUT_SCORES);
+        const float* p_anchors_item = getSrcDataAtPortAs<const float>(INPUT_ANCHORS);
+        const float* p_img_info_cpu = getSrcDataAtPortAs<const float>(INPUT_IM_INFO);
 
         const int anchors_num = scoreDims[1];
 
@@ -422,27 +439,50 @@ void GenerateProposals::execute(dnnl::stream strm) {
             const float min_box_H = min_size_ * scale_h;
             const float min_box_W = min_size_ * scale_w;
 
-            refine_anchors(p_deltas_item, p_scores_item, p_anchors_item,
-                           reinterpret_cast<float *>(&proposals_[0]), anchors_num, bottom_H,
-                           bottom_W, img_H, img_W,
-                           min_box_H, min_box_W,
+            refine_anchors(p_deltas_item,
+                           p_scores_item,
+                           p_anchors_item,
+                           reinterpret_cast<float*>(&proposals_[0]),
+                           anchors_num,
+                           bottom_H,
+                           bottom_W,
+                           img_H,
+                           img_W,
+                           min_box_H,
+                           min_box_W,
                            static_cast<const float>(std::log(1000. / 16.)),
                            coordinates_offset_);
-            std::partial_sort(proposals_.begin(), proposals_.begin() + pre_nms_topn, proposals_.end(),
-                              [](const ProposalBox &struct1, const ProposalBox &struct2) {
+            std::partial_sort(proposals_.begin(),
+                              proposals_.begin() + pre_nms_topn,
+                              proposals_.end(),
+                              [](const ProposalBox& struct1, const ProposalBox& struct2) {
                                   return (struct1.score > struct2.score);
                               });
 
-            unpack_boxes(reinterpret_cast<float *>(&proposals_[0]), &unpacked_boxes[0], &is_dead[0], pre_nms_topn);
-            nms_cpu(pre_nms_topn, &is_dead[0], &unpacked_boxes[0], &roi_indices_[0], &num_rois, 0,
-                    nms_thresh_, post_nms_topn_, coordinates_offset_);
+            unpack_boxes(reinterpret_cast<float*>(&proposals_[0]), &unpacked_boxes[0], &is_dead[0], pre_nms_topn);
+            nms_cpu(pre_nms_topn,
+                    &is_dead[0],
+                    &unpacked_boxes[0],
+                    &roi_indices_[0],
+                    &num_rois,
+                    0,
+                    nms_thresh_,
+                    post_nms_topn_,
+                    coordinates_offset_);
 
             size_t new_num_rois = total_num_rois + num_rois;
             roi_item.resize(new_num_rois * 4);
             score_item.resize(new_num_rois);
 
-            fill_output_blobs(&unpacked_boxes[0], &roi_indices_[0], &roi_item[total_num_rois * 4], &score_item[total_num_rois],
-                              p_roi_num, pre_nms_topn, num_rois, post_nms_topn_, roi_num_type);
+            fill_output_blobs(&unpacked_boxes[0],
+                              &roi_indices_[0],
+                              &roi_item[total_num_rois * 4],
+                              &score_item[total_num_rois],
+                              p_roi_num,
+                              pre_nms_topn,
+                              num_rois,
+                              post_nms_topn_,
+                              roi_num_type);
             p_deltas_item += deltas_dims_size;
             p_scores_item += score_dims_size;
             p_img_info_cpu += im_info_dims_size;
@@ -451,13 +491,13 @@ void GenerateProposals::execute(dnnl::stream strm) {
         }
         // copy to out memory
         redefineOutputMemory({VectorDims{total_num_rois, 4}, VectorDims{total_num_rois}, VectorDims{batch_size}});
-        float *p_roi_item       = getDstDataAtPortAs<float>(OUTPUT_ROIS);
-        float *p_roi_score_item = getDstDataAtPortAs<float>(OUTPUT_SCORES);
+        float* p_roi_item = getDstDataAtPortAs<float>(OUTPUT_ROIS);
+        float* p_roi_score_item = getDstDataAtPortAs<float>(OUTPUT_SCORES);
         uint8_t* p_roi_num_item = getDstDataAtPortAs<uint8_t>(OUTPUT_ROI_NUM);
         memcpy(p_roi_item, &roi_item[0], roi_item.size() * sizeof(float));
         memcpy(p_roi_score_item, &score_item[0], score_item.size() * sizeof(float));
         memcpy(p_roi_num_item, &roi_num[0], getDstMemoryAtPort(OUTPUT_ROI_NUM)->getSize());
-    } catch (const std::exception &e) {
+    } catch (const std::exception& e) {
         std::string errorMsg = e.what();
         OPENVINO_THROW(errorMsg);
     }
@@ -475,6 +515,6 @@ bool GenerateProposals::needPrepareParams() const {
     return false;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/generate_proposals.h b/src/plugins/intel_cpu/src/nodes/generate_proposals.h
index 5438f30011d986..666338eed3d4aa 100644
--- a/src/plugins/intel_cpu/src/nodes/generate_proposals.h
+++ b/src/plugins/intel_cpu/src/nodes/generate_proposals.h
@@ -14,7 +14,7 @@ class GenerateProposals : public Node {
 public:
     GenerateProposals(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -35,13 +35,13 @@ class GenerateProposals : public Node {
     //      scores,  shape [rois_num]
     //      roi_num, shape [N]
 
-    const int INPUT_IM_INFO {0};
-    const int INPUT_ANCHORS {1};
-    const int INPUT_DELTAS {2};
-    const int INPUT_SCORES {3};
-    const int OUTPUT_ROIS {0};
-    const int OUTPUT_SCORES {1};
-    const int OUTPUT_ROI_NUM {2};
+    const int INPUT_IM_INFO{0};
+    const int INPUT_ANCHORS{1};
+    const int INPUT_DELTAS{2};
+    const int INPUT_SCORES{3};
+    const int OUTPUT_ROIS{0};
+    const int OUTPUT_SCORES{1};
+    const int OUTPUT_ROI_NUM{2};
 
     float min_size_ = 0.f;
     int pre_nms_topn_ = 0;
@@ -52,6 +52,6 @@ class GenerateProposals : public Node {
     std::vector<int> roi_indices_;
 };
 
-}   // namespace node
+}  // namespace node
 }  // namespace intel_cpu
 }  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/grid_sample.cpp b/src/plugins/intel_cpu/src/nodes/grid_sample.cpp
index c8b73360539b68..9f346a2db14dac 100644
--- a/src/plugins/intel_cpu/src/nodes/grid_sample.cpp
+++ b/src/plugins/intel_cpu/src/nodes/grid_sample.cpp
@@ -3,15 +3,16 @@
 //
 
 #include "grid_sample.hpp"
-#include "openvino/op/grid_sample.hpp"
+
 #include "openvino/core/parallel.hpp"
+#include "openvino/op/grid_sample.hpp"
 
 using namespace ov::intel_cpu;
 using namespace ov::intel_cpu::node;
 
 #if defined(OPENVINO_ARCH_X86_64)
 using namespace dnnl::impl::cpu;
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
 #define THROW_ERROR(...) OPENVINO_THROW(getTypeStr(), " node with name '", getName(), "' ", __VA_ARGS__)
 
@@ -28,7 +29,7 @@ bool GridSample::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
         }
 #else
         return false;
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
     } catch (...) {
         return false;
     }
@@ -61,30 +62,30 @@ GridSample::GridSample(const std::shared_ptr<ov::Node>& op, const GraphContext::
     const auto& attributes = ov::as_type_ptr<ov::op::v9::GridSample>(op)->get_attributes();
     alignCorners = attributes.align_corners;
     switch (attributes.mode) {
-        case op::v9::GridSample::InterpolationMode::BILINEAR:
-            interpolationMode = GridSampleInterpolationMode::BILINEAR;
-            break;
-        case op::v9::GridSample::InterpolationMode::BICUBIC:
-            interpolationMode = GridSampleInterpolationMode::BICUBIC;
-            break;
-        case op::v9::GridSample::InterpolationMode::NEAREST:
-            interpolationMode = GridSampleInterpolationMode::NEAREST;
-            break;
-        default:
-            THROW_CPU_NODE_ERR("supports only BILINEAR, BICUBIC, NEAREST interpolation modes.");
+    case op::v9::GridSample::InterpolationMode::BILINEAR:
+        interpolationMode = GridSampleInterpolationMode::BILINEAR;
+        break;
+    case op::v9::GridSample::InterpolationMode::BICUBIC:
+        interpolationMode = GridSampleInterpolationMode::BICUBIC;
+        break;
+    case op::v9::GridSample::InterpolationMode::NEAREST:
+        interpolationMode = GridSampleInterpolationMode::NEAREST;
+        break;
+    default:
+        THROW_CPU_NODE_ERR("supports only BILINEAR, BICUBIC, NEAREST interpolation modes.");
     }
     switch (attributes.padding_mode) {
-        case op::v9::GridSample::PaddingMode::ZEROS:
-            paddingMode = GridSamplePaddingMode::ZEROS;
-            break;
-        case op::v9::GridSample::PaddingMode::BORDER:
-            paddingMode = GridSamplePaddingMode::BORDER;
-            break;
-        case op::v9::GridSample::PaddingMode::REFLECTION:
-            paddingMode = GridSamplePaddingMode::REFLECTION;
-            break;
-        default:
-            THROW_CPU_NODE_ERR("supports only BORDER, REFLECTION, ZEROS paddings modes.");
+    case op::v9::GridSample::PaddingMode::ZEROS:
+        paddingMode = GridSamplePaddingMode::ZEROS;
+        break;
+    case op::v9::GridSample::PaddingMode::BORDER:
+        paddingMode = GridSamplePaddingMode::BORDER;
+        break;
+    case op::v9::GridSample::PaddingMode::REFLECTION:
+        paddingMode = GridSamplePaddingMode::REFLECTION;
+        break;
+    default:
+        THROW_CPU_NODE_ERR("supports only BORDER, REFLECTION, ZEROS paddings modes.");
     }
 }
 
@@ -107,8 +108,7 @@ void GridSample::initSupportedPrimitiveDescriptors() {
     }
 
     // 95905 - to add nspc layout support.
-    addSupportedPrimDesc({{LayoutType::ncsp, dataPrecision},
-                          {LayoutType::ncsp, gridPrecision}},
+    addSupportedPrimDesc({{LayoutType::ncsp, dataPrecision}, {LayoutType::ncsp, gridPrecision}},
                          {{LayoutType::ncsp, dataPrecision}},
                          implType);
 }
@@ -116,25 +116,26 @@ void GridSample::initSupportedPrimitiveDescriptors() {
 void GridSample::createPrimitive() {
     kernel::GridSampleKernelConfParams jcp;
 
-    jcp.inDataPrc     = dataPrecision;
-    jcp.gridPrc       = gridPrecision;
+    jcp.inDataPrc = dataPrecision;
+    jcp.gridPrc = gridPrecision;
     jcp.dynamicShapes = isDynamicNode();
-    jcp.alignCorners  = alignCorners;
+    jcp.alignCorners = alignCorners;
     jcp.interpolationMode = interpolationMode;
-    jcp.paddingMode   = paddingMode;
+    jcp.paddingMode = paddingMode;
 
     const auto& srcDataDims = getInputShapeAtPort(IN_DATA).getDims();
     if (!jcp.dynamicShapes) {
-        jcp.batchNum       = srcDataDims[0];
-        jcp.cannelNum      = srcDataDims[1];
-        jcp.dynamicBatch   = false;
+        jcp.batchNum = srcDataDims[0];
+        jcp.cannelNum = srcDataDims[1];
+        jcp.dynamicBatch = false;
         jcp.dynamicChannel = false;
-        jcp.srcBatchStepB  = std::accumulate(srcDataDims.begin() + 1, srcDataDims.end(), dataTypeSize, std::multiplies<Dim>());
+        jcp.srcBatchStepB =
+            std::accumulate(srcDataDims.begin() + 1, srcDataDims.end(), dataTypeSize, std::multiplies<Dim>());
     } else {
-        jcp.dynamicBatch   = srcDataDims[0] == Shape::UNDEFINED_DIM;
-        jcp.batchNum       = jcp.dynamicBatch ? 1lu : srcDataDims[0];
+        jcp.dynamicBatch = srcDataDims[0] == Shape::UNDEFINED_DIM;
+        jcp.batchNum = jcp.dynamicBatch ? 1lu : srcDataDims[0];
         jcp.dynamicChannel = srcDataDims[1] == Shape::UNDEFINED_DIM;
-        jcp.cannelNum      = jcp.dynamicChannel ? 1lu : srcDataDims[1];
+        jcp.cannelNum = jcp.dynamicChannel ? 1lu : srcDataDims[1];
     }
 
     if (x64::mayiuse(x64::avx512_core)) {
@@ -195,7 +196,7 @@ void GridSample::prepareParams() {
 
     const uint64_t dataElPerVec = jitKernel->getDataElPerVec();
     const auto& srcDataShape = dataMemPtr->getStaticDims();
-    const auto& dstShape     = dstMemPtr->getStaticDims();
+    const auto& dstShape = dstMemPtr->getStaticDims();
     const uint64_t totalWork = dstShape[2] * dstShape[3];
     const uint64_t wpt = ((totalWork / dataElPerVec) / m_threads_num + 1) * dataElPerVec;
 
@@ -210,26 +211,27 @@ void GridSample::prepareParams() {
             return;
         }
 
-        p.batchNum      = srcDataShape[0];
-        p.channelsNum   = srcDataShape[1];
+        p.batchNum = srcDataShape[0];
+        p.channelsNum = srcDataShape[1];
         p.srcHeightF[0] = srcDataShape[2];
-        p.srcWidthF[0]  = srcDataShape[3];
+        p.srcWidthF[0] = srcDataShape[3];
 
         p.gridStartB = dstStart * 2 * gridTypeSize;
-        p.dstStartB  = dstStart * dataTypeSize;
+        p.dstStartB = dstStart * dataTypeSize;
 
-        p.srcBatchStepB  = std::accumulate(srcDataShape.begin() + 1, srcDataShape.end(), dataTypeSize, std::multiplies<Dim>());
+        p.srcBatchStepB =
+            std::accumulate(srcDataShape.begin() + 1, srcDataShape.end(), dataTypeSize, std::multiplies<Dim>());
         p.gridBatchStepB = (dstShape[2] * dstShape[3] - p.workAmount) * 2 * gridTypeSize;
-        p.dstBatchStepB  = (dstShape[1] * dstShape[2] * dstShape[3] - p.workAmount) * dataTypeSize;
+        p.dstBatchStepB = (dstShape[1] * dstShape[2] * dstShape[3] - p.workAmount) * dataTypeSize;
 
         p.srcChannelStepB = srcDataShape[2] * srcDataShape[3] * dataTypeSize;
         p.dstChannelStepB = dstShape[2] * dstShape[3] * dataTypeSize;
         p.dataTypeSize[0] = dataTypeSize;
 
         p.srcHeightSub1F[0] = p.srcHeightF[0] - 1.f;
-        p.srcWidthSub1F[0]  = p.srcWidthF[0]  - 1.f;
+        p.srcWidthSub1F[0] = p.srcWidthF[0] - 1.f;
         p.srcHeightMul2F[0] = p.srcHeightF[0] * 2.f;
-        p.srcWidthMul2F[0]  = p.srcWidthF[0]  * 2.f;
+        p.srcWidthMul2F[0] = p.srcWidthF[0] * 2.f;
         if (interpolationMode == GridSampleInterpolationMode::BICUBIC && srcDataShape[3] >= 4) {
             p.srcWidthB[0] = (srcDataShape[3] - 3) * dataTypeSize;
         } else {
@@ -237,24 +239,24 @@ void GridSample::prepareParams() {
         }
         if (alignCorners) {
             p.srcHeightMul2Sub1F[0] = p.srcHeightF[0] == 1.f ? 1.f : p.srcHeightSub1F[0] * 2.f;
-            p.srcWidthMul2Sub1F[0]  = p.srcWidthF[0]  == 1.f ? 1.f : p.srcWidthSub1F[0]  * 2.f;
-            p.wDenormCoefF[0] = (p.srcWidthF[0]  - 1.f) / 2.f;
+            p.srcWidthMul2Sub1F[0] = p.srcWidthF[0] == 1.f ? 1.f : p.srcWidthSub1F[0] * 2.f;
+            p.wDenormCoefF[0] = (p.srcWidthF[0] - 1.f) / 2.f;
             p.hDenormCoefF[0] = (p.srcHeightF[0] - 1.f) / 2.f;
         } else {
             p.srcHeightMul2Sub1F[0] = p.srcHeightMul2F[0] - 1.f;
-            p.srcWidthMul2Sub1F[0]  = p.srcWidthMul2F[0]  - 1.f;
+            p.srcWidthMul2Sub1F[0] = p.srcWidthMul2F[0] - 1.f;
         }
         if (!x64::mayiuse(x64::avx512_core)) {
-            std::fill(p.srcHeightF.begin(),         p.srcHeightF.end(),         p.srcHeightF[0]);
-            std::fill(p.srcWidthF.begin(),          p.srcWidthF.end(),          p.srcWidthF[0]);
-            std::fill(p.dataTypeSize.begin(),       p.dataTypeSize.end(),       p.dataTypeSize[0]);
-            std::fill(p.srcHeightSub1F.begin(),     p.srcHeightSub1F.end(),     p.srcHeightSub1F[0]);
-            std::fill(p.srcWidthSub1F.begin(),      p.srcWidthSub1F.end(),      p.srcWidthSub1F[0]);
-            std::fill(p.srcHeightMul2F.begin(),     p.srcHeightMul2F.end(),     p.srcHeightMul2F[0]);
-            std::fill(p.srcWidthMul2F.begin(),      p.srcWidthMul2F.end(),      p.srcWidthMul2F[0]);
-            std::fill(p.srcWidthB.begin(),          p.srcWidthB.end(),          p.srcWidthB[0]);
+            std::fill(p.srcHeightF.begin(), p.srcHeightF.end(), p.srcHeightF[0]);
+            std::fill(p.srcWidthF.begin(), p.srcWidthF.end(), p.srcWidthF[0]);
+            std::fill(p.dataTypeSize.begin(), p.dataTypeSize.end(), p.dataTypeSize[0]);
+            std::fill(p.srcHeightSub1F.begin(), p.srcHeightSub1F.end(), p.srcHeightSub1F[0]);
+            std::fill(p.srcWidthSub1F.begin(), p.srcWidthSub1F.end(), p.srcWidthSub1F[0]);
+            std::fill(p.srcHeightMul2F.begin(), p.srcHeightMul2F.end(), p.srcHeightMul2F[0]);
+            std::fill(p.srcWidthMul2F.begin(), p.srcWidthMul2F.end(), p.srcWidthMul2F[0]);
+            std::fill(p.srcWidthB.begin(), p.srcWidthB.end(), p.srcWidthB[0]);
             std::fill(p.srcHeightMul2Sub1F.begin(), p.srcHeightMul2Sub1F.end(), p.srcHeightMul2Sub1F[0]);
-            std::fill(p.srcWidthMul2Sub1F.begin(),  p.srcWidthMul2Sub1F.end(),  p.srcWidthMul2Sub1F[0]);
+            std::fill(p.srcWidthMul2Sub1F.begin(), p.srcWidthMul2Sub1F.end(), p.srcWidthMul2Sub1F[0]);
             if (alignCorners) {
                 std::fill(p.wDenormCoefF.begin(), p.wDenormCoefF.end(), p.wDenormCoefF[0]);
                 std::fill(p.hDenormCoefF.begin(), p.hDenormCoefF.end(), p.hDenormCoefF[0]);
@@ -264,9 +266,9 @@ void GridSample::prepareParams() {
 }
 
 void GridSample::execute(dnnl::stream strm) {
-    const void*    srcData = getSrcDataAtPort(IN_DATA);
+    const void* srcData = getSrcDataAtPort(IN_DATA);
     const uint8_t* gridData = getSrcDataAtPortAs<uint8_t>(IN_GRID);
-    uint8_t*       dstData = getDstDataAtPortAs<uint8_t>(0);
+    uint8_t* dstData = getDstDataAtPortAs<uint8_t>(0);
 
     auto threadBody = [&](const int ithr, const int nthr) {
         const auto& p = execParamsPerThread[ithr];
@@ -275,30 +277,30 @@ void GridSample::execute(dnnl::stream strm) {
             return;
         }
 
-        arg.src                = srcData;
-        arg.grid               = gridData + p.gridStartB;
-        arg.dst                = dstData  + p.dstStartB;
-        arg.batchNum           = p.batchNum;
-        arg.channelsNum        = p.channelsNum;
-        arg.srcHeightF         = p.srcHeightF.data();
-        arg.srcWidthF          = p.srcWidthF.data();
-        arg.srcWidthB          = p.srcWidthB.data();
-        arg.srcChannelStepB    = p.srcChannelStepB;
-        arg.dstChannelStepB    = p.dstChannelStepB;
-        arg.srcBatchStepB      = p.srcBatchStepB;
-        arg.gridBatchStepB     = p.gridBatchStepB;
-        arg.dstBatchStepB      = p.dstBatchStepB;
-        arg.srcHeightSub1F     = p.srcHeightSub1F.data();
-        arg.srcWidthSub1F      = p.srcWidthSub1F.data();
-        arg.srcWidthMul2F      = p.srcWidthMul2F.data();
-        arg.srcHeightMul2F     = p.srcHeightMul2F.data();
+        arg.src = srcData;
+        arg.grid = gridData + p.gridStartB;
+        arg.dst = dstData + p.dstStartB;
+        arg.batchNum = p.batchNum;
+        arg.channelsNum = p.channelsNum;
+        arg.srcHeightF = p.srcHeightF.data();
+        arg.srcWidthF = p.srcWidthF.data();
+        arg.srcWidthB = p.srcWidthB.data();
+        arg.srcChannelStepB = p.srcChannelStepB;
+        arg.dstChannelStepB = p.dstChannelStepB;
+        arg.srcBatchStepB = p.srcBatchStepB;
+        arg.gridBatchStepB = p.gridBatchStepB;
+        arg.dstBatchStepB = p.dstBatchStepB;
+        arg.srcHeightSub1F = p.srcHeightSub1F.data();
+        arg.srcWidthSub1F = p.srcWidthSub1F.data();
+        arg.srcWidthMul2F = p.srcWidthMul2F.data();
+        arg.srcHeightMul2F = p.srcHeightMul2F.data();
         arg.srcHeightMul2Sub1F = p.srcHeightMul2Sub1F.data();
-        arg.srcWidthMul2Sub1F  = p.srcWidthMul2Sub1F.data();
-        arg.wDenormCoefF       = p.wDenormCoefF.data();
-        arg.hDenormCoefF       = p.hDenormCoefF.data();
-        arg.dataTypeSize       = p.dataTypeSize.data();
-        arg.buffer             = p.buffer.data();
-        arg.workAmount         = p.workAmount;
+        arg.srcWidthMul2Sub1F = p.srcWidthMul2Sub1F.data();
+        arg.wDenormCoefF = p.wDenormCoefF.data();
+        arg.hDenormCoefF = p.hDenormCoefF.data();
+        arg.dataTypeSize = p.dataTypeSize.data();
+        arg.buffer = p.buffer.data();
+        arg.workAmount = p.workAmount;
 
         (*jitKernel)(&arg);
     };
@@ -314,4 +316,4 @@ bool GridSample::created() const {
     return getType() == Type::GridSample;
 }
 
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
diff --git a/src/plugins/intel_cpu/src/nodes/grid_sample.hpp b/src/plugins/intel_cpu/src/nodes/grid_sample.hpp
index b4468d58be9b52..eb4fd38b64c878 100644
--- a/src/plugins/intel_cpu/src/nodes/grid_sample.hpp
+++ b/src/plugins/intel_cpu/src/nodes/grid_sample.hpp
@@ -5,6 +5,7 @@
 #pragma once
 
 #include <node.h>
+
 #include "kernels/x64/grid_sample.hpp"
 
 namespace ov {
@@ -16,35 +17,35 @@ class GridSample : public Node {
     GridSample(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void createPrimitive() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
 
     struct threadExecParams {
-        uint64_t batchNum    = 1lu;
+        uint64_t batchNum = 1lu;
         uint64_t channelsNum = 1lu;
-        std::vector<float> srcHeightF{ 1.f };
-        std::vector<float> srcWidthF{ 1.f };
-        std::vector<int>   srcWidthB{ 1lu };
-        std::vector<int>   dataTypeSize{ 1lu };
-        std::vector<float> srcHeightMul2F{ 1.f };
-        std::vector<float> srcWidthMul2F{ 1.f };
-        std::vector<float> srcHeightMul2Sub1F{ 1.f };
-        std::vector<float> srcWidthMul2Sub1F{ 1.f };
-        std::vector<float> srcHeightSub1F{ 1.f };
-        std::vector<float> srcWidthSub1F{ 1.f };
-        std::vector<float> wDenormCoefF{ 1.f };
-        std::vector<float> hDenormCoefF{ 1.f };
-        uint64_t gridStartB      = 0lu;
-        uint64_t dstStartB       = 0lu;
+        std::vector<float> srcHeightF{1.f};
+        std::vector<float> srcWidthF{1.f};
+        std::vector<int> srcWidthB{1lu};
+        std::vector<int> dataTypeSize{1lu};
+        std::vector<float> srcHeightMul2F{1.f};
+        std::vector<float> srcWidthMul2F{1.f};
+        std::vector<float> srcHeightMul2Sub1F{1.f};
+        std::vector<float> srcWidthMul2Sub1F{1.f};
+        std::vector<float> srcHeightSub1F{1.f};
+        std::vector<float> srcWidthSub1F{1.f};
+        std::vector<float> wDenormCoefF{1.f};
+        std::vector<float> hDenormCoefF{1.f};
+        uint64_t gridStartB = 0lu;
+        uint64_t dstStartB = 0lu;
         uint64_t srcChannelStepB = 0lu;
         uint64_t dstChannelStepB = 0lu;
-        uint64_t srcBatchStepB   = 0lu;
-        uint64_t gridBatchStepB  = 0lu;
-        uint64_t dstBatchStepB   = 0lu;
-        uint64_t workAmount      = 0lu;
+        uint64_t srcBatchStepB = 0lu;
+        uint64_t gridBatchStepB = 0lu;
+        uint64_t dstBatchStepB = 0lu;
+        uint64_t workAmount = 0lu;
         std::vector<int> buffer;
     };
 
@@ -71,6 +72,6 @@ class GridSample : public Node {
     std::shared_ptr<kernel::GridSampleKernelBase> jitKernel;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/grn.cpp b/src/plugins/intel_cpu/src/nodes/grn.cpp
index 10de2ef2286f0f..374452812eaf3a 100644
--- a/src/plugins/intel_cpu/src/nodes/grn.cpp
+++ b/src/plugins/intel_cpu/src/nodes/grn.cpp
@@ -2,11 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "grn.h"
+
 #include <string>
 
-#include "openvino/opsets/opset1.hpp"
 #include "openvino/core/parallel.hpp"
-#include "grn.h"
+#include "openvino/opsets/opset1.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -97,11 +98,12 @@ void GRN::execute(dnnl::stream strm) {
     parallel_for3d(N, H, W, [&](int b, int h, int w) {
         double variance = 0;
         for (int c = 0; c < C; c++) {
-            variance += std::pow(src_data[b*C*H*W + c*H*W + h*W + w], 2);
+            variance += std::pow(src_data[b * C * H * W + c * H * W + h * W + w], 2);
         }
         variance = std::pow(variance + bias, 0.5f);
         for (int c = 0; c < C; c++) {
-            dst_data[b*C*H*W + c*H*W + h*W + w] = src_data[b*C*H*W + c*H*W + h*W + w] / static_cast<float>(variance);
+            dst_data[b * C * H * W + c * H * W + h * W + w] =
+                src_data[b * C * H * W + c * H * W + h * W + w] / static_cast<float>(variance);
         }
     });
 }
@@ -110,6 +112,6 @@ bool GRN::created() const {
     return getType() == Type::GRN;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/grn.h b/src/plugins/intel_cpu/src/nodes/grn.h
index 52e77318e2132f..17eac4e81b9d6c 100644
--- a/src/plugins/intel_cpu/src/nodes/grn.h
+++ b/src/plugins/intel_cpu/src/nodes/grn.h
@@ -14,7 +14,7 @@ class GRN : public Node {
 public:
     GRN(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -34,6 +34,6 @@ class GRN : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/if.cpp b/src/plugins/intel_cpu/src/nodes/if.cpp
index 1b6102ff954689..8de1cf14920d74 100644
--- a/src/plugins/intel_cpu/src/nodes/if.cpp
+++ b/src/plugins/intel_cpu/src/nodes/if.cpp
@@ -4,22 +4,22 @@
 
 #include "if.h"
 
-#include "openvino/op/if.hpp"
+#include <string>
+#include <vector>
 
 #include "common/cpu_memcpy.h"
-#include "shape_inference/shape_inference_internal_dyn.hpp"
 #include "nodes/common/cpu_convert.h"
+#include "openvino/op/if.hpp"
+#include "shape_inference/shape_inference_internal_dyn.hpp"
 #include "transformations/utils/utils.hpp"
 
-#include <string>
-#include <vector>
-
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-If::PortMapHelper::PortMapHelper(const MemoryPtr &from, const std::deque<MemoryPtr>& to,
-                                           const dnnl::engine& eng) : srcMemPtr(from), dstMemPtrs(to) {
+If::PortMapHelper::PortMapHelper(const MemoryPtr& from, const std::deque<MemoryPtr>& to, const dnnl::engine& eng)
+    : srcMemPtr(from),
+      dstMemPtrs(to) {
     size = 0;
     if (srcMemPtr->getDesc().isDefined())
         size = srcMemPtr->getShape().getElementsCount();
@@ -43,7 +43,7 @@ void If::PortMapHelper::execute(dnnl::stream& strm) {
 }
 
 void If::PortMapHelper::redefineTo() {
-    const auto &currDesc = dstMemPtrs.front()->getDesc();
+    const auto& currDesc = dstMemPtrs.front()->getDesc();
     if (currDesc.getShape().isDynamic() || currDesc.getShape().getStaticDims() != srcMemPtr->getStaticDims()) {
         // TODO : check the entire dstMemPtrs usage considering the proper memory sharing
         auto newShape = srcMemPtr->getStaticDims();
@@ -60,7 +60,7 @@ bool If::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::st
     try {
         if (!one_of(op->get_type_info(), ov::op::v8::If::get_type_info_static())) {
             errorMessage = "Not supported If operation version " + std::string(op->get_type_info().version_id) +
-                    " with name '" + op->get_friendly_name() + "'. Node If supports only opset8 version.";
+                           " with name '" + op->get_friendly_name() + "'. Node If supports only opset8 version.";
             return false;
         }
     } catch (...) {
@@ -69,8 +69,9 @@ bool If::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::st
     return true;
 }
 
-If::If(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) :
-        Node(op, context, InternalDynShapeInferFactory()), ovOp(op) {
+If::If(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, InternalDynShapeInferFactory()),
+      ovOp(op) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
@@ -111,49 +112,55 @@ void If::getSupportedDescriptors() {
         }
     }
 
-    const auto &outMapThen = subGraphThen.GetOutputNodesMap();
+    const auto& outMapThen = subGraphThen.GetOutputNodesMap();
     for (const auto& out : ifOp->get_then_body()->get_results()) {
         auto outNode = outMapThen.find(ifOp->get_then_body()->get_result_index(out));
         if (outNode != outMapThen.end()) {
             auto outMem = outNode->second->getSrcMemoryAtPort(0);
             outputMemThen.push_back(outMem);
         } else {
-            OPENVINO_THROW("Then body of node If with name ", getName(), " does not have output with name: ", out->get_friendly_name());
+            OPENVINO_THROW("Then body of node If with name ",
+                           getName(),
+                           " does not have output with name: ",
+                           out->get_friendly_name());
         }
     }
 
-    const auto &outMapElse = subGraphElse.GetOutputNodesMap();
+    const auto& outMapElse = subGraphElse.GetOutputNodesMap();
     for (const auto& out : ifOp->get_else_body()->get_results()) {
         auto outNode = outMapElse.find(ifOp->get_else_body()->get_result_index(out));
         if (outNode != outMapElse.end()) {
             auto outMem = outNode->second->getSrcMemoryAtPort(0);
             outputMemElse.push_back(outMem);
         } else {
-            OPENVINO_THROW("Else body of node If with name ", getName(), " does not have output with name: ", out->get_friendly_name());
+            OPENVINO_THROW("Else body of node If with name ",
+                           getName(),
+                           " does not have output with name: ",
+                           out->get_friendly_name());
         }
     }
 
     // Port map: outputs
     for (const auto& desc : ifOp->get_output_descriptions(0)) {
         auto body_output_idx = desc->m_body_value_index;
-        thenOutputPortMap.emplace_back(PortMap {
-            static_cast<int>(desc->m_output_index), static_cast<int>(body_output_idx)});
+        thenOutputPortMap.emplace_back(
+            PortMap{static_cast<int>(desc->m_output_index), static_cast<int>(body_output_idx)});
     }
     for (const auto& desc : ifOp->get_output_descriptions(1)) {
         auto body_output_idx = desc->m_body_value_index;
-        elseOutputPortMap.emplace_back(PortMap {
-            static_cast<int>(desc->m_output_index), static_cast<int>(body_output_idx)});
+        elseOutputPortMap.emplace_back(
+            PortMap{static_cast<int>(desc->m_output_index), static_cast<int>(body_output_idx)});
     }
 
     for (const auto& desc : ifOp->get_input_descriptions(0)) {
         auto body_input_index = desc->m_body_parameter_index;
-        thenInputPortMap.emplace_back(PortMap {
-            static_cast<int>(desc->m_input_index), static_cast<int>(body_input_index)});
+        thenInputPortMap.emplace_back(
+            PortMap{static_cast<int>(desc->m_input_index), static_cast<int>(body_input_index)});
     }
     for (const auto& desc : ifOp->get_input_descriptions(1)) {
         auto body_input_index = desc->m_body_parameter_index;
-        elseInputPortMap.emplace_back(PortMap {
-            static_cast<int>(desc->m_input_index), static_cast<int>(body_input_index)});
+        elseInputPortMap.emplace_back(
+            PortMap{static_cast<int>(desc->m_input_index), static_cast<int>(body_input_index)});
     }
 }
 
@@ -166,16 +173,17 @@ void If::initSupportedPrimitiveDescriptors() {
     config.outConfs.reserve(getChildEdges().size());
 
     for (size_t i = 0; i < inputShapes.size(); i++) {
-        PortConfig dataConf {};
+        PortConfig dataConf{};
         auto descCreator = BlockedDescCreator::getCommonCreators().at(LayoutType::ncsp);
         dataConf.setMemDesc(descCreator->createSharedDesc(getOriginalInputPrecisionAtPort(i), getInputShapeAtPort(i)));
         config.inConfs.emplace_back(dataConf);
     }
 
     for (size_t i = 0; i < outputShapes.size(); i++) {
-        PortConfig dataConf {};
+        PortConfig dataConf{};
         auto descCreator = BlockedDescCreator::getCommonCreators().at(LayoutType::ncsp);
-        dataConf.setMemDesc(descCreator->createSharedDesc(getOriginalOutputPrecisionAtPort(i), getOutputShapeAtPort(i)));
+        dataConf.setMemDesc(
+            descCreator->createSharedDesc(getOriginalOutputPrecisionAtPort(i), getOutputShapeAtPort(i)));
         config.outConfs.push_back(dataConf);
     }
 
@@ -195,9 +203,9 @@ void If::createPrimitive() {
 }
 
 void If::prepareBeforeMappers(const bool isThen, const dnnl::engine& eng) {
-    auto &inputPortMap = isThen ? thenInputPortMap : elseInputPortMap;
-    auto &inputMems = isThen ? inputMemThen : inputMemElse;
-    auto &beforeMappers = isThen ? beforeThenMappers : beforeElseMappers;
+    auto& inputPortMap = isThen ? thenInputPortMap : elseInputPortMap;
+    auto& inputMems = isThen ? inputMemThen : inputMemElse;
+    auto& beforeMappers = isThen ? beforeThenMappers : beforeElseMappers;
     for (auto& map_rule : inputPortMap) {
         auto fromMem = getSrcMemoryAtPort(map_rule.from);
         auto& toMems = inputMems[map_rule.to];
@@ -216,12 +224,12 @@ void If::prepareBeforeMappers(const bool isThen, const dnnl::engine& eng) {
 }
 
 void If::prepareAfterMappers(const bool isThen, const dnnl::engine& eng) {
-    auto &outputPortMap = isThen ? thenOutputPortMap : elseOutputPortMap;
-    auto &outputMems = isThen ? outputMemThen : outputMemElse;
-    auto &afterMappers = isThen ? afterThenMappers : afterElseMappers;
+    auto& outputPortMap = isThen ? thenOutputPortMap : elseOutputPortMap;
+    auto& outputMems = isThen ? outputMemThen : outputMemElse;
+    auto& afterMappers = isThen ? afterThenMappers : afterElseMappers;
     for (auto& map_rule : outputPortMap) {
         auto toMems = getToMemories(this, map_rule.from);
-        auto &fromMem = outputMems[map_rule.to];
+        auto& fromMem = outputMems[map_rule.to];
         // Check precision between If node input/output and it's subgrapsh input/output.
         for (const auto& toMem : toMems) {
             if (fromMem->getDesc().getPrecision() != toMem->getDesc().getPrecision()) {
@@ -250,11 +258,11 @@ void If::execute(dnnl::stream strm) {
     auto& afterMappers = condition ? afterThenMappers : afterElseMappers;
     auto& subGraph = condition ? subGraphThen : subGraphElse;
 
-    for (auto &mapper : beforeMappers)
+    for (auto& mapper : beforeMappers)
         mapper->execute(strm);
     subGraph.ResetInferCount();
     subGraph.Infer();
-    for (auto &mapper : afterMappers)
+    for (auto& mapper : afterMappers)
         mapper->execute(strm);
 }
 
@@ -266,6 +274,6 @@ bool If::created() const {
     return getType() == Type::If;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/if.h b/src/plugins/intel_cpu/src/nodes/if.h
index f858c92b0b2651..a2babb45b6c803 100644
--- a/src/plugins/intel_cpu/src/nodes/if.h
+++ b/src/plugins/intel_cpu/src/nodes/if.h
@@ -4,8 +4,8 @@
 
 #pragma once
 
-#include <node.h>
 #include <graph.h>
+#include <node.h>
 
 #include <memory>
 #include <string>
@@ -25,12 +25,18 @@ class If : public Node {
     void createPrimitive() override;
     bool created() const override;
     void execute(dnnl::stream strm) override;
-    bool isExecutable() const override { return true; }
+    bool isExecutable() const override {
+        return true;
+    }
 
 protected:
     void executeDynamicImpl(dnnl::stream strm) override;
-    bool needPrepareParams() const override { return false; };
-    bool needShapeInfer() const override { return false; }
+    bool needPrepareParams() const override {
+        return false;
+    };
+    bool needShapeInfer() const override {
+        return false;
+    }
 
 private:
     void prepareBeforeMappers(const bool isThen, const dnnl::engine& eng);
@@ -64,21 +70,14 @@ class If : public Node {
     std::vector<std::deque<MemoryPtr>> inputMemThen, inputMemElse;
     std::deque<MemoryPtr> outputMemThen, outputMemElse;
 
-    std::vector<std::shared_ptr<PortMapHelper>>
-        beforeThenMappers,
-        beforeElseMappers,
-        afterThenMappers,
+    std::vector<std::shared_ptr<PortMapHelper>> beforeThenMappers, beforeElseMappers, afterThenMappers,
         afterElseMappers;
 
-    std::vector<PortMap>
-        thenInputPortMap,
-        thenOutputPortMap,
-        elseInputPortMap,
-        elseOutputPortMap;
+    std::vector<PortMap> thenInputPortMap, thenOutputPortMap, elseInputPortMap, elseOutputPortMap;
 
     const std::shared_ptr<ov::Node> ovOp;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/input.cpp b/src/plugins/intel_cpu/src/nodes/input.cpp
index 4ccdc87ada25f1..4bb2f714b284fd 100644
--- a/src/plugins/intel_cpu/src/nodes/input.cpp
+++ b/src/plugins/intel_cpu/src/nodes/input.cpp
@@ -5,12 +5,12 @@
 #include "input.h"
 
 #include "cpu/x64/jit_generator.hpp"
+#include "memory_desc/cpu_memory_desc_utils.h"
 #include "nodes/node_config.h"
 #include "openvino/core/parallel.hpp"
 #include "openvino/core/shape.hpp"
 #include "openvino/core/type/element_type.hpp"
 #include "shape_inference/shape_inference_pass_through.hpp"
-#include "memory_desc/cpu_memory_desc_utils.h"
 
 using namespace dnnl;
 using namespace dnnl::impl::cpu::x64;
@@ -38,16 +38,14 @@ struct jit_has_subnormals_base : public jit_generator {
     }
 
     fn_t get() {
-        return jit_ker() || create_kernel() == dnnl::impl::status::success
-                ? (fn_t)jit_ker()
-                : nullptr;
+        return jit_ker() || create_kernel() == dnnl::impl::status::success ? (fn_t)jit_ker() : nullptr;
     }
 
 protected:
-    void foreach(const Xbyak::Reg64& idx,
-                 size_t step,
-                 const Xbyak::Reg64& end,
-                 std::function<void(const Xbyak::Reg64&)> && fn) {
+    void foreach (const Xbyak::Reg64& idx,
+                  size_t step,
+                  const Xbyak::Reg64& end,
+                  std::function<void(const Xbyak::Reg64&)> && fn) {
         Label loop, exit;
 
         L(loop);
@@ -61,75 +59,76 @@ struct jit_has_subnormals_base : public jit_generator {
         L(exit);
     }
 
-    void copy_floats(const Xbyak::Reg64& dst,
-                     const Xbyak::Reg64& src,
-                     const Xbyak::Reg64& size) {
+    void copy_floats(const Xbyak::Reg64& dst, const Xbyak::Reg64& src, const Xbyak::Reg64& size) {
         push(rsi);
         push(r15);
 
         xor_(rsi, rsi);
 
-        foreach(rsi, 1, size, [&, this](const Xbyak::Reg64& idx) {
+        foreach (rsi, 1, size, [&, this](const Xbyak::Reg64& idx) {
             mov(r15d, dword[src + idx * sizeof(float)]);
             mov(dword[dst + idx * sizeof(float)], r15d);
-        });
+        })
+            ;
 
         pop(r15);
         pop(rsi);
     }
 
-    void check_subnormals(const Xbyak::Reg64& src, const Xbyak::Ymm &exponent_mask, const Xbyak::Ymm &mantissa_mask, const Xbyak::Ymm &zero) {
+    void check_subnormals(const Xbyak::Reg64& src,
+                          const Xbyak::Ymm& exponent_mask,
+                          const Xbyak::Ymm& mantissa_mask,
+                          const Xbyak::Ymm& zero) {
         auto a = ymm1;
         auto b = ymm2;
         auto c = ymm3;
 
-        vmovdqu(a, yword[src]);         // load 8 floats
-        vpand(b, a, mantissa_mask);     // b = a & 00000000011111111111111111111111
-        vpcmpeqd(b, b, zero);           // if (b == 0) b = 1 else b = 0
-        vpand(c, a, exponent_mask);     // c = a & 01111111100000000000000000000000
-        vpcmpeqd(c, c, zero);           // if (c == 0) c = 1 else c = 0
-        vptest(b, c);                   // if ((!b & c) == 0) CF = 1 else CF = 0
+        vmovdqu(a, yword[src]);      // load 8 floats
+        vpand(b, a, mantissa_mask);  // b = a & 00000000011111111111111111111111
+        vpcmpeqd(b, b, zero);        // if (b == 0) b = 1 else b = 0
+        vpand(c, a, exponent_mask);  // c = a & 01111111100000000000000000000000
+        vpcmpeqd(c, c, zero);        // if (c == 0) c = 1 else c = 0
+        vptest(b, c);                // if ((!b & c) == 0) CF = 1 else CF = 0
     }
 
-    void check_subnormals(const Xbyak::Reg64& src, const Xbyak::Xmm &exponent_mask, const Xbyak::Xmm &mantissa_mask, const Xbyak::Xmm &zero) {
+    void check_subnormals(const Xbyak::Reg64& src,
+                          const Xbyak::Xmm& exponent_mask,
+                          const Xbyak::Xmm& mantissa_mask,
+                          const Xbyak::Xmm& zero) {
         auto a = xmm1;
         auto b = xmm2;
         auto c = xmm3;
 
-        uni_vmovdqu(a, xword[src]);          // load 4 floats
-        uni_vmovdqu(b, a);                   // b = a
-        uni_vmovdqu(c, a);                   // c = a
-        uni_vpand(b, b, mantissa_mask);      // b = a & 00000000011111111111111111111111
-        uni_vpcmpeqd(b, b, zero);            // if (b == 0) b = 1 else b = 0
-        uni_vpand(c, c, exponent_mask);      // c = a & 01111111100000000000000000000000
-        uni_vpcmpeqd(c, c, zero);            // if (c == 0) c = 1 else c = 0
-        uni_vtestps(b, c);                   // if ((!b & c) == 0) CF = 1 else CF = 0
+        uni_vmovdqu(a, xword[src]);      // load 4 floats
+        uni_vmovdqu(b, a);               // b = a
+        uni_vmovdqu(c, a);               // c = a
+        uni_vpand(b, b, mantissa_mask);  // b = a & 00000000011111111111111111111111
+        uni_vpcmpeqd(b, b, zero);        // if (b == 0) b = 1 else b = 0
+        uni_vpand(c, c, exponent_mask);  // c = a & 01111111100000000000000000000000
+        uni_vpcmpeqd(c, c, zero);        // if (c == 0) c = 1 else c = 0
+        uni_vtestps(b, c);               // if ((!b & c) == 0) CF = 1 else CF = 0
     }
 
 protected:
     Label exit, has_subnormals, no_subnormals;
 
-    const Reg64 &reg_src = rax;
-    const Reg64 &reg_dst = rbx;
-    const Reg64 &reg_sz = rdx;
-    const Reg64 &reg_idx = rsi;
-    const Reg64 &reg_mask_addr = r15;
+    const Reg64& reg_src = rax;
+    const Reg64& reg_dst = rbx;
+    const Reg64& reg_sz = rdx;
+    const Reg64& reg_idx = rsi;
+    const Reg64& reg_mask_addr = r15;
 
     static const uint32_t exponent_mask_data[8];
     static const uint32_t mantissa_mask_data[8];
 };
 
-const uint32_t jit_has_subnormals_base::exponent_mask_data[8] = {
-    0x7f800000, 0x7f800000, 0x7f800000, 0x7f800000,
-    0x7f800000, 0x7f800000, 0x7f800000, 0x7f800000
-};
+const uint32_t jit_has_subnormals_base::exponent_mask_data[8] =
+    {0x7f800000, 0x7f800000, 0x7f800000, 0x7f800000, 0x7f800000, 0x7f800000, 0x7f800000, 0x7f800000};
 
-const uint32_t jit_has_subnormals_base::mantissa_mask_data[8] = {
-    0x007fffff, 0x007fffff, 0x007fffff, 0x007fffff,
-    0x007fffff, 0x007fffff, 0x007fffff, 0x007fffff
-};
+const uint32_t jit_has_subnormals_base::mantissa_mask_data[8] =
+    {0x007fffff, 0x007fffff, 0x007fffff, 0x007fffff, 0x007fffff, 0x007fffff, 0x007fffff, 0x007fffff};
 
-template<cpu_isa_t isa>
+template <cpu_isa_t isa>
 struct jit_has_subnormals : public jit_has_subnormals_base {
     using Vmm = typename dnnl::impl::utils::conditional<isa == sse41, Xbyak::Xmm, Xbyak::Ymm>::type;
 
@@ -138,7 +137,7 @@ struct jit_has_subnormals : public jit_has_subnormals_base {
     const Vmm rmm6 = Vmm(6);
     const int length = isa == sse41 ? 4 : 8;
 
-    void generate() override final { // NOLINT
+    void generate() override final {  // NOLINT
         size_t const vlen = length;
         const int sh_bits = std::ilogb(vlen);
 
@@ -165,11 +164,12 @@ struct jit_has_subnormals : public jit_has_subnormals_base {
         mov(r8, reg_sz);
         shr(r8, sh_bits);
 
-        foreach(reg_idx, 1, r8, [&, this](const Xbyak::Reg64& idx) {
+        foreach (reg_idx, 1, r8, [&, this](const Xbyak::Reg64& idx) {
             check_subnormals(reg_src, exponent_mask, mantissa_mask, zero);
             jnc(has_subnormals);
             add(reg_src, sizeof(float) * vlen);
-        });
+        })
+            ;
 
         // Tail
         shl(reg_idx, sh_bits);
@@ -216,11 +216,11 @@ jit_has_subnormals_base::fn_t jit_has_subnormals_function() {
     return nullptr;
 }
 
-}   // namespace
+}  // namespace
 #endif
 
 Input::Input(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
-        : Node(op, context, PassThroughShapeInferFactory()) {
+    : Node(op, context, PassThroughShapeInferFactory()) {
     if (!one_of(op->get_type_info(),
                 op::v0::Parameter::get_type_info_static(),
                 op::v0::Constant::get_type_info_static(),
@@ -260,7 +260,7 @@ void Input::cloneBlobIfRequired() {
         needFlushDenormalsToZero = false;
     }
 
-    auto cloneBlob = [&, this] () {
+    auto cloneBlob = [&, this]() {
         MemoryPtr memory;
 
         // CVS-74980
@@ -269,7 +269,8 @@ void Input::cloneBlobIfRequired() {
         // in that case we make a copy to avoid overflow
         if (m_constOp->get_byte_size() >= memDesc.getCurrentMemSize()) {
             if (m_constOp->get_element_type() == element::string) {
-                memory = std::make_shared<StringMemory>(getEngine(), memDesc, m_constOp->get_data_ptr<element::string>());
+                memory =
+                    std::make_shared<StringMemory>(getEngine(), memDesc, m_constOp->get_data_ptr<element::string>());
             } else {
                 memory = std::make_shared<Memory>(getEngine(), memDesc, m_constOp->get_data_ptr());
             }
@@ -296,12 +297,12 @@ void Input::cloneBlobIfRequired() {
         return ptr;
     };
 
-    auto isBlobAligned = [] (const std::shared_ptr<ov::op::v0::Constant>& constant) {
+    auto isBlobAligned = [](const std::shared_ptr<ov::op::v0::Constant>& constant) {
 #if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64)
         // Majority of arithmetic and data processing instructions in legacy SSE isa requires
         // the memory address in the operands must be aligned on 16-byte boundary. To ensure
         // safely reusing ngraph const blob memory, need to check address alignment.
-        const void *ptr = constant->get_data_ptr();
+        const void* ptr = constant->get_data_ptr();
         return mayiuse(cpu_isa_t::avx2) || ((reinterpret_cast<uintptr_t>(ptr) & 15) == 0);
 #else
         return true;
@@ -309,9 +310,9 @@ void Input::cloneBlobIfRequired() {
     };
 
     // The presence of subnormals is better to determined at IR read time.
-    auto hasSubnormals = [&] () {
+    auto hasSubnormals = [&]() {
         if (prec == ov::element::f32) {
-            uint32_t const *u32data = m_constOp->get_data_ptr<uint32_t>();
+            uint32_t const* u32data = m_constOp->get_data_ptr<uint32_t>();
 
             if (!size)
                 return false;
@@ -325,11 +326,9 @@ void Input::cloneBlobIfRequired() {
 
                 parallel_for(iterations_num, [&](int n) {
                     auto ptr = u32data + n * batch_size;
-                    const jit_has_subnormals_base::args_t args = {
-                        reinterpret_cast<float const *>(ptr),
-                        std::min(batch_size, (size_t)(u32data + size - ptr)),
-                        false
-                    };
+                    const jit_has_subnormals_base::args_t args = {reinterpret_cast<float const*>(ptr),
+                                                                  std::min(batch_size, (size_t)(u32data + size - ptr)),
+                                                                  false};
 
                     fn(&args);
 
@@ -352,12 +351,10 @@ void Input::cloneBlobIfRequired() {
         return false;
     };
 
-    auto blobKey = [&] () {
+    auto blobKey = [&]() {
         char ptr[32];
         snprintf(ptr, sizeof ptr, "%p", m_constOp->get_data_ptr());
-        return getName()
-                + "_" + std::to_string(size * prec.size())
-                + "_" + ptr;
+        return getName() + "_" + std::to_string(size * prec.size()) + "_" + ptr;
     };
 
     const auto weightCache = context->getWeightsCache();
@@ -368,7 +365,8 @@ void Input::cloneBlobIfRequired() {
         isBlobAligned(m_constOp) && (!needFlushDenormalsToZero || !hasSubnormals()) &&
         // Blob should be cloned in cache only if original weights are stored on other numa node.
         // This is possible only in multistream case on multisocket machine.
-        // TODO: don't clone blob for multisocket + multistream case if current stream is run on the numa node where original weights are stored.
+        // TODO: don't clone blob for multisocket + multistream case if current stream is run on the numa node where
+        // original weights are stored.
         (!weightCache || context->getNumNumaNodes() == 1 || context->getCPUStreamExecutor()->get_streams_num() == 1);
 
     memoryPtr = clone_is_not_needed ? std::make_shared<Memory>(getEngine(), memDesc, m_constOp->get_data_ptr())
@@ -376,29 +374,25 @@ void Input::cloneBlobIfRequired() {
                                           weightCache ? *weightCache->findOrCreate(blobKey(), cloneBlob) : cloneBlob());
 }
 
-static std::vector<Shape> createInputShapes(const Shape& shape,
-                                            const Type type) {
+static std::vector<Shape> createInputShapes(const Shape& shape, const Type type) {
     if (type == Type::Output)
         return {shape};
     return {};
 }
 
-static std::vector<Shape> createOutputShapes(const Shape& shape,
-                                             const Type type) {
+static std::vector<Shape> createOutputShapes(const Shape& shape, const Type type) {
     if (type == Type::Input)
         return {shape};
     return {};
 }
 
-static std::vector<ov::element::Type> createInputPrecisions(const ov::element::Type& prc,
-                                                         const Type type) {
+static std::vector<ov::element::Type> createInputPrecisions(const ov::element::Type& prc, const Type type) {
     if (type == Type::Output)
         return {prc};
     return {};
 }
 
-static std::vector<ov::element::Type> createOutputPrecisions(const ov::element::Type& prc,
-                                                          const Type type) {
+static std::vector<ov::element::Type> createOutputPrecisions(const ov::element::Type& prc, const Type type) {
     if (type == Type::Input)
         return {prc};
     return {};
@@ -428,17 +422,13 @@ Input::Input(MemoryDescPtr memDesc, const std::string& name, const std::string&
     extMemDesc = memDesc;
 }
 
-Input::Input(const std::shared_ptr<ov::Node>& op,
-             const GraphContext::CPtr context,
-             InputConfig config)
+Input::Input(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context, InputConfig config)
     : Input(op, context) {
     extMemDesc = config.desc;
     m_isInPlace = config.inPlace;
 }
 
-Input::Input(const std::shared_ptr<ov::Node>& op,
-             const GraphContext::CPtr context,
-             OutputConfig config)
+Input::Input(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context, OutputConfig config)
     : Input(op, context) {
     extMemDesc = config.desc;
     m_useParentMemoryDescForOutput = config.useParentMemoryDescForOutput;
@@ -499,17 +489,23 @@ void Input::createPrimitive() {
     for (size_t i = 0; i < getChildEdges().size(); i++) {
         auto dstMemPtr = getDstMemoryAtPort(i);
         if (!dstMemPtr)
-            THROW_CPU_NODE_ERR("has null memory object at port ", i,
-                              " to node ", getChildEdgeAt(i)->getChild()->getName(), ".");
+            THROW_CPU_NODE_ERR("has null memory object at port ",
+                               i,
+                               " to node ",
+                               getChildEdgeAt(i)->getChild()->getName(),
+                               ".");
     }
     for (size_t i = 0; i < getParentEdges().size(); i++) {
         auto srcMemPtr = getSrcMemoryAtPort(i);
         if (!srcMemPtr)
-            THROW_CPU_NODE_ERR("has null memory object at port ", i,
-                              " from node ", getParentEdgeAt(i)->getParent()->getName(), ".");
+            THROW_CPU_NODE_ERR("has null memory object at port ",
+                               i,
+                               " from node ",
+                               getParentEdgeAt(i)->getParent()->getName(),
+                               ".");
     }
 
-    const NodeDesc *selected_pd = getSelectedPrimitiveDescriptor();
+    const NodeDesc* selected_pd = getSelectedPrimitiveDescriptor();
     if (selected_pd == nullptr)
         THROW_CPU_NODE_ERR("doesn't have selected primitive descriptor.");
 }
@@ -535,9 +531,7 @@ void Input::initSupportedPdDefault() {
         inPortConfs.push_back({LayoutType::ncsp, precision});
     }
 
-    addSupportedPrimDesc(inPortConfs,
-                         outPortConfs,
-                         impl_desc_type::unknown);
+    addSupportedPrimDesc(inPortConfs, outPortConfs, impl_desc_type::unknown);
 }
 
 void Input::initSupportedPdFromMemDesc() {
@@ -553,6 +547,6 @@ void Input::initSupportedPdFromMemDesc() {
     supportedPrimitiveDescriptors.emplace_back(std::move(config), impl_desc_type::unknown);
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/input.h b/src/plugins/intel_cpu/src/nodes/input.h
index e659ea2359aabd..6d1f4c27238540 100644
--- a/src/plugins/intel_cpu/src/nodes/input.h
+++ b/src/plugins/intel_cpu/src/nodes/input.h
@@ -5,6 +5,7 @@
 #pragma once
 
 #include <node.h>
+
 #include <openvino/op/constant.hpp>
 
 namespace ov {
@@ -42,13 +43,9 @@ class Input : public Node {
 
     Input(MemoryDescPtr memDesc, const std::string& name, const std::string& type, const GraphContext::CPtr context);
 
-    Input(const std::shared_ptr<ov::Node>& op,
-          const GraphContext::CPtr context,
-          InputConfig config);
+    Input(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context, InputConfig config);
 
-    Input(const std::shared_ptr<ov::Node>& op,
-          const GraphContext::CPtr context,
-          OutputConfig config);
+    Input(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context, OutputConfig config);
 
     void getSupportedDescriptors() override;
     void initSupportedPrimitiveDescriptors() override;
@@ -66,8 +63,12 @@ class Input : public Node {
         return false;
     }
 
-    bool needShapeInfer() const override { return false; }
-    bool needPrepareParams() const override { return false; }
+    bool needShapeInfer() const override {
+        return false;
+    }
+    bool needPrepareParams() const override {
+        return false;
+    }
 
 private:
     void cloneBlobIfRequired();
@@ -83,6 +84,6 @@ class Input : public Node {
     bool m_isInPlace = false;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/interaction.cpp b/src/plugins/intel_cpu/src/nodes/interaction.cpp
index 5ec48e7a263272..905724c3bc829a 100644
--- a/src/plugins/intel_cpu/src/nodes/interaction.cpp
+++ b/src/plugins/intel_cpu/src/nodes/interaction.cpp
@@ -4,7 +4,10 @@
 
 #include "interaction.h"
 
-#include "transformations/cpu_opset/x64/op/interaction.hpp"
+#include <chrono>
+#include <string>
+#include <vector>
+
 #include "common/bfloat16.hpp"
 #include "common/cpu_memcpy.h"
 #include "cpu/x64/cpu_isa_traits.hpp"
@@ -16,10 +19,7 @@
 #include "memory_desc/dnnl_blocked_memory_desc.h"
 #include "nodes/common/cpu_convert.h"
 #include "onednn/dnnl.h"
-
-#include <chrono>
-#include <string>
-#include <vector>
+#include "transformations/cpu_opset/x64/op/interaction.hpp"
 
 using namespace dnnl::impl::cpu::x64;
 using namespace Xbyak;
@@ -36,7 +36,9 @@ template <cpu_isa_t isa>
 struct jit_move_scale_kernel : public jit_uni_move_scale_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_move_scale_kernel)
 
-    explicit jit_move_scale_kernel(const jit_move_scale_compile_params& jcp) : jit_uni_move_scale_kernel(jcp), jit_generator(jit_name()) {
+    explicit jit_move_scale_kernel(const jit_move_scale_compile_params& jcp)
+        : jit_uni_move_scale_kernel(jcp),
+          jit_generator(jit_name()) {
         runtime_prc = jcp_.src_prc == ov::element::bf16 ? ov::element::bf16 : ov::element::f32;
         if (jcp_.dst_prc == ov::element::i8 || jcp_.dst_prc == ov::element::u8)
             runtime_prc = ov::element::f32;
@@ -50,12 +52,13 @@ struct jit_move_scale_kernel : public jit_uni_move_scale_kernel, public jit_gene
     }
 
 private:
-    using Vmm = typename dnnl::impl::utils::conditional3<isa == cpu_isa_t::sse41, Xmm, isa == cpu_isa_t::avx2, Ymm, Zmm>::type;
+    using Vmm =
+        typename dnnl::impl::utils::conditional3<isa == cpu_isa_t::sse41, Xmm, isa == cpu_isa_t::avx2, Ymm, Zmm>::type;
 
     void generate() override {
         this->preamble();
 
-#define GET_OFF(field) offsetof(jit_move_scale_call_args, field)
+#    define GET_OFF(field) offsetof(jit_move_scale_call_args, field)
         mov(reg_in, ptr[reg_params + GET_OFF(p_in)]);
         mov(reg_out, ptr[reg_params + GET_OFF(p_out)]);
         mov(reg_work_amount, jcp_.input_size);
@@ -107,7 +110,7 @@ struct jit_move_scale_kernel : public jit_uni_move_scale_kernel, public jit_gene
         if (jcp_.with_scales) {
             if (!jcp_.broadcast_scales) {
                 load(vmm_scales, reg_scales, ov::element::f32, ov::element::f32, step, false);
-                add(reg_scales,  sizeof(float) * step);
+                add(reg_scales, sizeof(float) * step);
             }
             uni_vmulps(vmm_in, vmm_in, vmm_scales);
         }
@@ -119,25 +122,39 @@ struct jit_move_scale_kernel : public jit_uni_move_scale_kernel, public jit_gene
             add(reg_out_aux, jcp_.dst_prc.size() * step);
         }
     }
-#undef GET_OFF
-
-    inline void load(const Vmm& vmm_dst, const Xbyak::Reg64& reg_src, ov::element::Type src_prc, ov::element::Type dst_prc, const int& elt_num, bool fill) {
+#    undef GET_OFF
+
+    inline void load(const Vmm& vmm_dst,
+                     const Xbyak::Reg64& reg_src,
+                     ov::element::Type src_prc,
+                     ov::element::Type dst_prc,
+                     const int& elt_num,
+                     bool fill) {
         const auto seed = load_emitter_params(src_prc, dst_prc, elt_num, fill, "float_min").hash();
         if (!emitters[seed]) {
-            emitters[seed].reset(new jit_load_emitter(this, isa, src_prc, dst_prc, elt_num, src_prc, fill, "float_min"));
+            emitters[seed].reset(
+                new jit_load_emitter(this, isa, src_prc, dst_prc, elt_num, src_prc, fill, "float_min"));
         }
 
-        emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), 0}, {static_cast<size_t>(vmm_dst.getIdx())},
-                                  pool_aux_vmm_idxs, pool_aux_gpr_idxs);
+        emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), 0},
+                                  {static_cast<size_t>(vmm_dst.getIdx())},
+                                  pool_aux_vmm_idxs,
+                                  pool_aux_gpr_idxs);
     }
-    inline void store(const Xbyak::Reg64& reg_dst, const Vmm& vmm_src, ov::element::Type src_prc, ov::element::Type dst_prc, const int& elt_num) {
+    inline void store(const Xbyak::Reg64& reg_dst,
+                      const Vmm& vmm_src,
+                      ov::element::Type src_prc,
+                      ov::element::Type dst_prc,
+                      const int& elt_num) {
         const auto seed = store_emitter_params(src_prc, dst_prc, elt_num).hash();
         if (!emitters[seed]) {
             emitters[seed].reset(new jit_store_emitter(this, isa, src_prc, dst_prc, elt_num));
         }
 
-        emitters[seed]->emit_code({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(reg_dst.getIdx())},
-                                  pool_aux_vmm_idxs, pool_aux_gpr_idxs);
+        emitters[seed]->emit_code({static_cast<size_t>(vmm_src.getIdx())},
+                                  {static_cast<size_t>(reg_dst.getIdx())},
+                                  pool_aux_vmm_idxs,
+                                  pool_aux_gpr_idxs);
     }
 
     size_t vec_size;
@@ -155,13 +172,14 @@ struct jit_move_scale_kernel : public jit_uni_move_scale_kernel, public jit_gene
     Reg64 reg_work_amount = r14;
     Reg64 reg_params = abi_param1;
 
-    const std::vector<size_t> pool_aux_gpr_idxs = { static_cast<size_t>(rsi.getIdx()), static_cast<size_t>(rbp.getIdx()) };
-    const std::vector<size_t> pool_aux_vmm_idxs = { static_cast<size_t>(xmm_tmp.getIdx()) };
+    const std::vector<size_t> pool_aux_gpr_idxs = {static_cast<size_t>(rsi.getIdx()),
+                                                   static_cast<size_t>(rbp.getIdx())};
+    const std::vector<size_t> pool_aux_vmm_idxs = {static_cast<size_t>(xmm_tmp.getIdx())};
 
     std::unordered_map<size_t, std::unique_ptr<jit_emitter>> emitters;
 };
 
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
 Interaction::Interaction(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
     : Node(op, context, NgraphShapeInferFactory(op)) {
@@ -174,7 +192,7 @@ Interaction::Interaction(const std::shared_ptr<ov::Node>& op, const GraphContext
     const std::vector<float>& scales = interaction->get_output_scales();
     if (!scales.empty()) {
         fqScales = scales;
-        outputDataType  = interaction->get_output_element_type(0);
+        outputDataType = interaction->get_output_element_type(0);
     }
 }
 
@@ -194,23 +212,12 @@ void Interaction::initSupportedPrimitiveDescriptors() {
     // initialize input ports
     std::vector<PortConfigurator> inPortConfigs;
     for (size_t i = 0; i < getParentEdges().size(); ++i) {
-        inPortConfigs.emplace_back(
-            LayoutType::ncsp,
-            dataPrecision,
-            getInputShapeAtPort(i),
-            false, -1);
+        inPortConfigs.emplace_back(LayoutType::ncsp, dataPrecision, getInputShapeAtPort(i), false, -1);
     }
     // initialize output port
     std::vector<PortConfigurator> outPortConfigs = {
-        PortConfigurator {
-            LayoutType::ncsp,
-            outputDataType,
-            getOutputShapeAtPort(0),
-            false,
-            -1
-        }
-    };
-    //add descriptor
+        PortConfigurator{LayoutType::ncsp, outputDataType, getOutputShapeAtPort(0), false, -1}};
+    // add descriptor
     addSupportedPrimDesc(inPortConfigs, outPortConfigs, impl_desc_type::ref_any);
 }
 
@@ -221,8 +228,7 @@ static inline void cat(uint8_t* out,
                        size_t elemSize) {
     size_t offset = 0;
     for (size_t j = 0; j < feature_sizes.size(); j++) {
-        cpu_memcpy(out + offset * elemSize, in[j] + bs * feature_sizes[j] * elemSize,
-            feature_sizes[j] * elemSize);
+        cpu_memcpy(out + offset * elemSize, in[j] + bs * feature_sizes[j] * elemSize, feature_sizes[j] * elemSize);
         offset += feature_sizes[j];
     }
 }
@@ -303,8 +309,7 @@ void Interaction::prepareParams() {
     auto matmul_pd = matmul::primitive_desc(getEngine(), src_md, weights_md, dst_md, matmul_attr);
     prim = matmul(matmul_pd);
     featureSizes.assign(inputSizes, featureSize);
-    auto initMemoryPtr = [&](const ov::element::Type& prc, const intel_cpu::Shape& shape,
-        MemoryPtr& ptr) {
+    auto initMemoryPtr = [&](const ov::element::Type& prc, const intel_cpu::Shape& shape, MemoryPtr& ptr) {
         ptr = std::make_shared<Memory>(getEngine(), intel_cpu::DnnlBlockedMemoryDesc(prc, shape));
     };
     initMemoryPtr(dataPrecision, intel_cpu::Shape{inputSizes, featureSize}, inputMemPtr);
@@ -336,7 +341,7 @@ void Interaction::prepareParams() {
         moveFeatureKernel.reset(new jit_move_scale_kernel<cpu_isa_t::sse41>(jcp));
         moveInteractKernel.reset(new jit_move_scale_kernel<cpu_isa_t::sse41>(interJcp));
     }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
     if (moveFeatureKernel && moveInteractKernel) {
         moveFeatureKernel->create_ker();
@@ -360,8 +365,7 @@ bool Interaction::isExecutable() const {
     return true;
 }
 
-bool Interaction::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
-        std::string& errorMessage) noexcept {
+bool Interaction::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
         const auto interaction = std::dynamic_pointer_cast<const InteractionNode>(op);
         if (!interaction) {
@@ -374,7 +378,6 @@ bool Interaction::isSupportedOperation(const std::shared_ptr<const ov::Node>& op
     return true;
 }
 
-
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/interaction.h b/src/plugins/intel_cpu/src/nodes/interaction.h
index 448484a2512dd1..794ea0af24a87c 100644
--- a/src/plugins/intel_cpu/src/nodes/interaction.h
+++ b/src/plugins/intel_cpu/src/nodes/interaction.h
@@ -19,31 +19,31 @@ struct jit_move_scale_compile_params {
 };
 
 struct jit_move_scale_call_args {
-    const void *p_in;
-    void *p_out;
-    const void *p_scales;
+    const void* p_in;
+    void* p_out;
+    const void* p_scales;
 };
 
 struct jit_uni_move_scale_kernel {
-        void (*ker_)(const jit_move_scale_call_args*);
+    void (*ker_)(const jit_move_scale_call_args*);
 
-        void operator()(const jit_move_scale_call_args* call_args) {
-            assert(ker_);
-            ker_(call_args);
-        }
+    void operator()(const jit_move_scale_call_args* call_args) {
+        assert(ker_);
+        ker_(call_args);
+    }
 
-        explicit jit_uni_move_scale_kernel(const jit_move_scale_compile_params& jcp) : ker_(nullptr), jcp_(jcp) {}
-        virtual ~jit_uni_move_scale_kernel() {}
+    explicit jit_uni_move_scale_kernel(const jit_move_scale_compile_params& jcp) : ker_(nullptr), jcp_(jcp) {}
+    virtual ~jit_uni_move_scale_kernel() {}
 
-        virtual void create_ker() = 0;
+    virtual void create_ker() = 0;
 
-        jit_move_scale_compile_params jcp_;
+    jit_move_scale_compile_params jcp_;
 };
 
 class Interaction : public Node {
 public:
     Interaction(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -74,6 +74,6 @@ class Interaction : public Node {
     std::unique_ptr<jit_uni_move_scale_kernel> moveInteractKernel;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/interpolate.cpp b/src/plugins/intel_cpu/src/nodes/interpolate.cpp
index 37008ee17a9603..beb53cb89a831e 100644
--- a/src/plugins/intel_cpu/src/nodes/interpolate.cpp
+++ b/src/plugins/intel_cpu/src/nodes/interpolate.cpp
@@ -4,6 +4,10 @@
 
 #include "interpolate.h"
 
+#include <algorithm>
+#include <string>
+#include <vector>
+
 #include "common/cpu_memcpy.h"
 #include "cpu/x64/injectors/jit_uni_depthwise_injector.hpp"
 #include "cpu/x64/injectors/jit_uni_eltwise_injector.hpp"
@@ -26,10 +30,6 @@
 #include "utils/cpu_utils.hpp"
 #include "utils/ngraph_utils.hpp"
 
-#include <algorithm>
-#include <string>
-#include <vector>
-
 using namespace dnnl;
 
 using namespace dnnl::impl;
@@ -38,7 +38,6 @@ using namespace dnnl::impl::cpu::x64;
 using namespace dnnl::impl::utils;
 using namespace Xbyak;
 
-
 #define GET_OFF(field) offsetof(jit_interpolate_call_args, field)
 
 namespace ov {
@@ -55,8 +54,9 @@ template <cpu_isa_t isa>
 struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_interpolate_kernel_f32)
 
-    explicit jit_uni_interpolate_kernel_f32(jit_interpolate_config_params jcp, const dnnl_primitive_attr &attr)
-    : jit_uni_interpolate_kernel(jcp, attr), jit_generator(jit_name()) {}
+    explicit jit_uni_interpolate_kernel_f32(jit_interpolate_config_params jcp, const dnnl_primitive_attr& attr)
+        : jit_uni_interpolate_kernel(jcp, attr),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -69,23 +69,24 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
         store_pool_gpr_idxs = {static_cast<size_t>(reg_tmp_64.getIdx())};
         store_pool_vec_idxs = {static_cast<size_t>(vmm_zero.getIdx())};
 
-        const auto &p = attr_.post_ops_;
+        const auto& p = attr_.post_ops_;
         for (int i = 0; i < p.len(); i++) {
-            auto &post_op = p.entry_[i];
+            auto& post_op = p.entry_[i];
             if (post_op.is_eltwise()) {
-                eltwise_injectors.push_back(std::make_shared<jit_uni_eltwise_injector_f32<isa>>(
-                        this,
-                        post_op.eltwise.alg,
-                        post_op.eltwise.alpha,
-                        post_op.eltwise.beta,
-                        1.f));
+                eltwise_injectors.push_back(std::make_shared<jit_uni_eltwise_injector_f32<isa>>(this,
+                                                                                                post_op.eltwise.alg,
+                                                                                                post_op.eltwise.alpha,
+                                                                                                post_op.eltwise.beta,
+                                                                                                1.f));
             } else if (post_op.is_depthwise()) {
-                depthwise_injectors.push_back(std::make_shared<jit_uni_depthwise_injector_f32<isa>>(
-                        this,
-                        post_op));
+                depthwise_injectors.push_back(std::make_shared<jit_uni_depthwise_injector_f32<isa>>(this, post_op));
             } else if (post_op.is_quantization()) {
-                quantization_injectors.push_back(std::make_shared<jit_uni_quantization_injector_f32<isa>>(
-                        this, post_op, vmm_d_weights, vmm_d_bias, reg_d_weights, reg_d_bias));
+                quantization_injectors.push_back(std::make_shared<jit_uni_quantization_injector_f32<isa>>(this,
+                                                                                                          post_op,
+                                                                                                          vmm_d_weights,
+                                                                                                          vmm_d_bias,
+                                                                                                          reg_d_weights,
+                                                                                                          reg_d_bias));
             }
         }
 
@@ -98,81 +99,82 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
         uni_vpxor(vmm_zero, vmm_zero, vmm_zero);
 
         switch (jcp_.mode) {
-            case InterpolateMode::nearest: {
-                mov(reg_dst, ptr[reg_params + GET_OFF(dst)]);
-                mov(reg_src, ptr[reg_params + GET_OFF(src_ptr[0])]);
-                mov(reg_index, ptr[reg_params + GET_OFF(index)]);
-                mov(reg_work_amount, ptr[reg_params + GET_OFF(work_amount)]);
-
-                switch (jcp_.layout) {
-                    case InterpolateLayoutType::planar: {
-                        nn_planar();
-                        break;
-                    }
-                    case InterpolateLayoutType::block: {
-                        nn_blk();
-                        break;
-                    }
-                    case InterpolateLayoutType::by_channel: {
-                        nn_by_channel();
-                        break;
-                    }
-                    default:
-                        assert(!"unsupported memory layout for interpolate layer with nearest neighbor mode.");
-                }
+        case InterpolateMode::nearest: {
+            mov(reg_dst, ptr[reg_params + GET_OFF(dst)]);
+            mov(reg_src, ptr[reg_params + GET_OFF(src_ptr[0])]);
+            mov(reg_index, ptr[reg_params + GET_OFF(index)]);
+            mov(reg_work_amount, ptr[reg_params + GET_OFF(work_amount)]);
+
+            switch (jcp_.layout) {
+            case InterpolateLayoutType::planar: {
+                nn_planar();
                 break;
             }
-            case InterpolateMode::linear_onnx: {
-                switch (jcp_.layout) {
-                    case InterpolateLayoutType::planar: {
-                        linear_onnx_planar();
-                        break;
-                    }
-                    case InterpolateLayoutType::block:
-                    case InterpolateLayoutType::by_channel: {
-                        linear_onnx_c_gathered();
-                        break;
-                    }
-                    default:
-                        assert(!"unsupported memory layout for interpolate layer with linear_onnx mode.");
-                }
+            case InterpolateLayoutType::block: {
+                nn_blk();
                 break;
             }
-            case InterpolateMode::cubic: {
-                switch (jcp_.layout) {
-                    case InterpolateLayoutType::planar: {
-                        cubic_planar();
-                        break;
-                    }
-                    case InterpolateLayoutType::block:
-                    case InterpolateLayoutType::by_channel: {
-                        cubic_c_gathered();
-                        break;
-                    }
-                    default:
-                        assert(!"unsupported memory layout for interpolate layer with cubic mode.");
-                }
+            case InterpolateLayoutType::by_channel: {
+                nn_by_channel();
                 break;
             }
-            case InterpolateMode::bilinear_pillow:
-            case InterpolateMode::bicubic_pillow: {
-                switch (jcp_.layout) {
-                    case InterpolateLayoutType::by_channel: {
-                        pillow_by_channel();
-                        break;
-                    }
-                    default:
-                        assert(!"unsupported memory layout for interpolate layer with bilinear_pillow and bicubic_pillow modes.");
-                }
+            default:
+                assert(!"unsupported memory layout for interpolate layer with nearest neighbor mode.");
+            }
+            break;
+        }
+        case InterpolateMode::linear_onnx: {
+            switch (jcp_.layout) {
+            case InterpolateLayoutType::planar: {
+                linear_onnx_planar();
+                break;
+            }
+            case InterpolateLayoutType::block:
+            case InterpolateLayoutType::by_channel: {
+                linear_onnx_c_gathered();
                 break;
             }
-            case InterpolateMode::linear: {
-                assert(!"unsupported mode for interpolate layer with JITTED implimentation.");
+            default:
+                assert(!"unsupported memory layout for interpolate layer with linear_onnx mode.");
+            }
+            break;
+        }
+        case InterpolateMode::cubic: {
+            switch (jcp_.layout) {
+            case InterpolateLayoutType::planar: {
+                cubic_planar();
+                break;
+            }
+            case InterpolateLayoutType::block:
+            case InterpolateLayoutType::by_channel: {
+                cubic_c_gathered();
+                break;
+            }
+            default:
+                assert(!"unsupported memory layout for interpolate layer with cubic mode.");
+            }
+            break;
+        }
+        case InterpolateMode::bilinear_pillow:
+        case InterpolateMode::bicubic_pillow: {
+            switch (jcp_.layout) {
+            case InterpolateLayoutType::by_channel: {
+                pillow_by_channel();
                 break;
             }
-            default: {
-                assert(!"unsupported mode for interpolate layer.");
+            default:
+                assert(
+                    !"unsupported memory layout for interpolate layer with bilinear_pillow and bicubic_pillow modes.");
             }
+            break;
+        }
+        case InterpolateMode::linear: {
+            assert(!"unsupported mode for interpolate layer with JITTED implimentation.");
+            break;
+        }
+        default: {
+            assert(!"unsupported mode for interpolate layer.");
+        }
         }
 
         this->postamble();
@@ -186,8 +188,8 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
 
     const int vlen = cpu_isa_traits<isa>::vlen;
     const int vector_step = vlen / sizeof(float);
@@ -216,7 +218,7 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
     // for cubic planar
     Xbyak::Reg64 reg_tbl_y = rsi;
     Xbyak::Reg64 reg_tbl_x = rbp;
-    Xbyak::Reg64 reg_table = rdx;   // do not need reg_index_offset in this mode, so use rdx
+    Xbyak::Reg64 reg_table = rdx;  // do not need reg_index_offset in this mode, so use rdx
 
     Vmm vmm_val = Vmm(1);
     Vmm vmm_index = Vmm(0);
@@ -292,14 +294,21 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
         emit_load(reg_src, vmm_src, ov::element::f32, ov::element::f32, elt_num, offset);
     }
 
-    inline void emit_load(Xbyak::Reg64 reg_src, Vmm vmm_src, ov::element::Type src_prc, ov::element::Type dst_prc, const int elt_num, const int offset = 0) {
+    inline void emit_load(Xbyak::Reg64 reg_src,
+                          Vmm vmm_src,
+                          ov::element::Type src_prc,
+                          ov::element::Type dst_prc,
+                          const int elt_num,
+                          const int offset = 0) {
         const auto seed = load_emitter_params(src_prc, dst_prc, elt_num).hash();
         if (!emitters[seed]) {
             emitters[seed].reset(new jit_load_emitter(this, isa, src_prc, dst_prc, elt_num));
         }
 
         emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), static_cast<size_t>(offset)},
-                                  {static_cast<size_t>(vmm_src.getIdx())}, {}, {load_pool_gpr_idxs});
+                                  {static_cast<size_t>(vmm_src.getIdx())},
+                                  {},
+                                  {load_pool_gpr_idxs});
     }
 
     inline void store(Vmm vmm_dst, Xbyak::Reg64 reg_dst, const int elt_num, const int offset = 0) {
@@ -309,12 +318,15 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
         }
 
         // for cases when Store emitter need 2 aux vmm we can use vmm_dst as second aux vmm
-        std::vector<size_t> local_store_pool_vec_idxs = { static_cast<size_t>(vmm_dst.getIdx()) };
-        local_store_pool_vec_idxs.insert(local_store_pool_vec_idxs.begin(), store_pool_vec_idxs.begin(), store_pool_vec_idxs.end());
+        std::vector<size_t> local_store_pool_vec_idxs = {static_cast<size_t>(vmm_dst.getIdx())};
+        local_store_pool_vec_idxs.insert(local_store_pool_vec_idxs.begin(),
+                                         store_pool_vec_idxs.begin(),
+                                         store_pool_vec_idxs.end());
 
         emitters[seed]->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
                                   {static_cast<size_t>(reg_dst.getIdx()), static_cast<size_t>(offset)},
-                                  {local_store_pool_vec_idxs}, {store_pool_gpr_idxs});
+                                  {local_store_pool_vec_idxs},
+                                  {store_pool_gpr_idxs});
     }
 
     // kernel for OH * OW * C
@@ -397,9 +409,10 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
                         }
                         // if int, round
                         if (!isFloatCompatible(jcp_.src_prc)) {
-                            uni_vroundps(vmm_dst, vmm_dst, 0x0); // Round near
+                            uni_vroundps(vmm_dst, vmm_dst, 0x0);  // Round near
                         }
-                        // src_prc, dst_prc and buf ov::element::Type is the same, otherwise need another store with buf(src) precision
+                        // src_prc, dst_prc and buf ov::element::Type is the same, otherwise need another store with
+                        // buf(src) precision
                         store(vmm_dst, reg_dst_aux, vector_step);
                         add(reg_dst_aux, vector_step * jcp_.src_data_size);
                         // advance 8/16 faciliate next block
@@ -415,7 +428,7 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
                             uni_vfmadd231ps(vmm_dst, vmm_val, vmm_weight);
                         }
                         if (!isFloatCompatible(jcp_.src_prc)) {
-                            uni_vroundps(vmm_dst, vmm_dst, 0x0); // Round near
+                            uni_vroundps(vmm_dst, vmm_dst, 0x0);  // Round near
                         }
                         store(vmm_dst, reg_dst_aux, tail_num);
                         add(reg_dst_aux, tail_num * jcp_.src_data_size);
@@ -447,7 +460,7 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
                             uni_vfmadd231ps(vmm_dst, vmm_val, vmm_weight);
                         }
                         if (!isFloatCompatible(jcp_.src_prc)) {
-                            uni_vroundps(vmm_dst, vmm_dst, 0x0); // Round near
+                            uni_vroundps(vmm_dst, vmm_dst, 0x0);  // Round near
                         }
                         store(vmm_dst, reg_dst, vector_step);
                         add(reg_dst, vector_step * jcp_.dst_data_size);
@@ -463,7 +476,7 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
                             uni_vfmadd231ps(vmm_dst, vmm_val, vmm_weight);
                         }
                         if (!isFloatCompatible(jcp_.src_prc)) {
-                            uni_vroundps(vmm_dst, vmm_dst, 0x0); // Round near
+                            uni_vroundps(vmm_dst, vmm_dst, 0x0);  // Round near
                         }
                         store(vmm_dst, reg_dst, tail_num);
                         add(reg_dst, tail_num * jcp_.dst_data_size);
@@ -495,7 +508,7 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
             cmp(reg_work_amount_oh, 1);
             jl(out_loop_end, T_NEAR);
 
-            //reset work_amount to OW
+            // reset work_amount to OW
             mov(reg_work_amount, jcp_.OW);
 
             Xbyak::Reg64 reg_src_h = rsi;
@@ -512,7 +525,7 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
             Xbyak::Label nn_tail_loop_label;
             Xbyak::Label nn_tail_loop_end_label;
 
-            L(nn_loop_label);   // inner loop
+            L(nn_loop_label);  // inner loop
             {
                 cmp(reg_work_amount, vector_step);
                 jl(nn_loop_end_label, T_NEAR);
@@ -552,9 +565,9 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
 
                 jmp(nn_tail_loop_label, T_NEAR);
             }
-            L(nn_tail_loop_end_label);    // inner loop end
+            L(nn_tail_loop_end_label);  // inner loop end
 
-            //increment index_h to next row
+            // increment index_h to next row
             add(reg_index_h, jcp_.indices_size);
 
             sub(reg_work_amount_oh, 1);
@@ -620,7 +633,7 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
             cmp(reg_work_amount_out, 1);
             jl(out_loop_end, T_NEAR);
 
-            //inner loop for C
+            // inner loop for C
             Xbyak::Label nn_loop_label;
             Xbyak::Label nn_loop_end_label;
             Xbyak::Label nn_tail_loop_label;
@@ -716,10 +729,12 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
         mov(reg_work_amount, ptr[reg_params + GET_OFF(work_amount)]);
 
         int blk = (isa == cpu::x64::sse41) ? (2 * vector_step) : vector_step;
-        int dst_stride = (jcp_.layout == InterpolateLayoutType::by_channel) ? (vector_step * jcp_.dst_data_size) :
-                                            (blk * jcp_.OW * jcp_.OH * jcp_.OD * jcp_.dst_data_size);
-        int src_stride = (jcp_.layout == InterpolateLayoutType::by_channel) ? (vector_step * jcp_.src_data_size) :
-                                            (blk * jcp_.IW * jcp_.IH * jcp_.ID * jcp_.src_data_size);
+        int dst_stride = (jcp_.layout == InterpolateLayoutType::by_channel)
+                             ? (vector_step * jcp_.dst_data_size)
+                             : (blk * jcp_.OW * jcp_.OH * jcp_.OD * jcp_.dst_data_size);
+        int src_stride = (jcp_.layout == InterpolateLayoutType::by_channel)
+                             ? (vector_step * jcp_.src_data_size)
+                             : (blk * jcp_.IW * jcp_.IH * jcp_.ID * jcp_.src_data_size);
 
         Xbyak::Label main_loop_label;
         Xbyak::Label main_loop_end_label;
@@ -757,8 +772,10 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
                 // 2d for end depth
                 linear_onnx_worker_2d();
                 // 3th dimension
-                uni_vmulps(vmm_valTR, vmm_valTR, vmm_weightE); // end_value * end_weight
-                uni_vfmadd231ps(vmm_valTR, vmm_d_bias, vmm_weightF); // start_value * start_weight + end_value * end_weight
+                uni_vmulps(vmm_valTR, vmm_valTR, vmm_weightE);  // end_value * end_weight
+                uni_vfmadd231ps(vmm_valTR,
+                                vmm_d_bias,
+                                vmm_weightF);  // start_value * start_weight + end_value * end_weight
             }
 
             if (attr_.post_ops_.len() != 0) {
@@ -788,8 +805,10 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
                     // 2d for end depth
                     linear_onnx_worker_2d();
                     // 3th dimension
-                    uni_vmulps(vmm_valTR, vmm_valTR, vmm_weightE); // end_value * end_weight
-                    uni_vfmadd231ps(vmm_valTR, vmm_d_bias, vmm_weightF); // start_value * start_weight + end_value * end_weight
+                    uni_vmulps(vmm_valTR, vmm_valTR, vmm_weightE);  // end_value * end_weight
+                    uni_vfmadd231ps(vmm_valTR,
+                                    vmm_d_bias,
+                                    vmm_weightF);  // start_value * start_weight + end_value * end_weight
                 }
 
                 if (attr_.post_ops_.len() != 0) {
@@ -813,9 +832,9 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
                 add(reg_src_aux7, src_stride);
             }
             if (jcp_.layout == InterpolateLayoutType::by_channel) {
-                sub(reg_work_amount, vector_step);    // work_amount is c
+                sub(reg_work_amount, vector_step);  // work_amount is c
             } else {
-                sub(reg_work_amount, 1);       // work_amount = div_up(c, blk), no tails
+                sub(reg_work_amount, 1);  // work_amount = div_up(c, blk), no tails
             }
 
             jmp(main_loop_label, T_NEAR);
@@ -843,8 +862,10 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
                 // 2d for end depth
                 linear_onnx_worker_2d();
                 // 3th dimension
-                uni_vmulps(vmm_valTR, vmm_valTR, vmm_weightE); // end_value * end_weight
-                uni_vfmadd231ps(vmm_valTR, vmm_d_bias, vmm_weightF); // start_value * start_weight + end_value * end_weight
+                uni_vmulps(vmm_valTR, vmm_valTR, vmm_weightE);  // end_value * end_weight
+                uni_vfmadd231ps(vmm_valTR,
+                                vmm_d_bias,
+                                vmm_weightF);  // start_value * start_weight + end_value * end_weight
             }
 
             if (attr_.post_ops_.len() != 0) {
@@ -929,8 +950,10 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
                 load_weights(reg_src_aux, vmm_weightE, vector_step, 5 * weight_stride);
                 load_weights(reg_src_aux, vmm_weightF, vector_step, 4 * weight_stride);
 
-                uni_vmulps(vmm_valTR, vmm_valTR, vmm_weightE); // end_value * end_weight
-                uni_vfmadd231ps(vmm_valTR, vmm_d_bias, vmm_weightF); // start_value * start_weight + end_value * end_weight
+                uni_vmulps(vmm_valTR, vmm_valTR, vmm_weightE);  // end_value * end_weight
+                uni_vfmadd231ps(vmm_valTR,
+                                vmm_d_bias,
+                                vmm_weightF);  // start_value * start_weight + end_value * end_weight
             }
 
             if (attr_.post_ops_.len() != 0) {
@@ -1013,8 +1036,10 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
                 load_weights(reg_src_aux, vmm_weightE, scalar_step, 5 * weight_stride);
                 load_weights(reg_src_aux, vmm_weightF, scalar_step, 4 * weight_stride);
 
-                uni_vmulps(vmm_valTR, vmm_valTR, vmm_weightE); // end_value * end_weight
-                uni_vfmadd231ps(vmm_valTR, vmm_d_bias, vmm_weightF); // start_value * start_weight + end_value * end_weight
+                uni_vmulps(vmm_valTR, vmm_valTR, vmm_weightE);  // end_value * end_weight
+                uni_vfmadd231ps(vmm_valTR,
+                                vmm_d_bias,
+                                vmm_weightF);  // start_value * start_weight + end_value * end_weight
             }
 
             if (attr_.post_ops_.len() != 0) {
@@ -1089,7 +1114,7 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
             cubic_c_gathered_matrix(false);
 
             if (attr_.post_ops_.len() != 0) {
-                apply_post_ops(jcp_.dst_prc, false);     // vmm_val is default dst value to post_ops and store
+                apply_post_ops(jcp_.dst_prc, false);  // vmm_val is default dst value to post_ops and store
                 add(reg_oc_off, vector_step * sizeof(float));
             }
             store(vmm_val, reg_dst, vector_step);
@@ -1117,7 +1142,7 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
                 int src_stride = vector_step * jcp_.src_data_size;
                 add(reg_dst, dst_stride);
                 add(reg_src, src_stride);
-                sub(reg_work_amount, vector_step);    // work_amount is c
+                sub(reg_work_amount, vector_step);  // work_amount is c
             } else {
                 int dst_stride = blk * jcp_.OW * jcp_.OH * jcp_.dst_data_size;
                 int src_stride = blk * jcp_.IW * jcp_.IH * jcp_.src_data_size;
@@ -1142,7 +1167,7 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
             cubic_c_gathered_matrix(true);
 
             if (attr_.post_ops_.len() != 0) {
-                apply_post_ops(jcp_.dst_prc, false);     // vmm_val is default dst value
+                apply_post_ops(jcp_.dst_prc, false);  // vmm_val is default dst value
                 add(reg_oc_off, scalar_step * sizeof(float));
             }
             store(vmm_val, reg_dst, scalar_step);
@@ -1151,7 +1176,7 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
             int src_stride = scalar_step * jcp_.src_data_size;
             add(reg_dst, dst_stride);
             add(reg_src, src_stride);
-            sub(reg_work_amount, scalar_step);    // work_amount is c
+            sub(reg_work_amount, scalar_step);  // work_amount is c
 
             jmp(tail_loop_label, T_NEAR);
         }
@@ -1242,7 +1267,9 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
             // build weightX used in y0-y3
             // weight format: w0_0 w1_0 w2_0 w3_0 w0_1 w1_1 w2_1 w3_1 ...
             uni_vpcmpeqd(vmm_mask, vmm_mask, vmm_mask);
-            vgatherdps(vmm_weightX0, ptr[reg_weight_x + vmm_val * grid_len], vmm_mask);  // 4 in vmm_val for weight_size, another 4 for grid_len
+            vgatherdps(vmm_weightX0,
+                       ptr[reg_weight_x + vmm_val * grid_len],
+                       vmm_mask);  // 4 in vmm_val for weight_size, another 4 for grid_len
 
             uni_vpcmpeqd(vmm_mask, vmm_mask, vmm_mask);
             // shift weight_size then gather second weight
@@ -1326,8 +1353,20 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
             // gather weightX by input idx, used in y0-y3
             gather_i32_indices(vmm_weightX0, reg_weight_x, 0, vmm_val, grid_len, ov::element::f32, true);
             gather_i32_indices(vmm_weightX1, reg_weight_x, sizeof(float), vmm_val, grid_len, ov::element::f32, true);
-            gather_i32_indices(vmm_weightX2, reg_weight_x, 2 * sizeof(float), vmm_val, grid_len, ov::element::f32, true);
-            gather_i32_indices(vmm_weightX3, reg_weight_x, 3 * sizeof(float), vmm_val, grid_len, ov::element::f32, true);
+            gather_i32_indices(vmm_weightX2,
+                               reg_weight_x,
+                               2 * sizeof(float),
+                               vmm_val,
+                               grid_len,
+                               ov::element::f32,
+                               true);
+            gather_i32_indices(vmm_weightX3,
+                               reg_weight_x,
+                               3 * sizeof(float),
+                               vmm_val,
+                               grid_len,
+                               ov::element::f32,
+                               true);
             // vmm_val is now relieved and used for dst_value
 
             uni_vpxor(vmm_val, vmm_val, vmm_val);
@@ -1354,7 +1393,13 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
             vpminsd(vmm_index_y_itr, vmm_index_y_itr, cubic_planar_table_val(1));
             vpmaxsd(vmm_index_y_itr, vmm_index_y_itr, vmm_zero);
             // weight y2
-            gather_i32_indices(vmm_weightY, reg_weight_y, 2 * sizeof(float), vmm_tbl_y, grid_len, ov::element::f32, true);
+            gather_i32_indices(vmm_weightY,
+                               reg_weight_y,
+                               2 * sizeof(float),
+                               vmm_tbl_y,
+                               grid_len,
+                               ov::element::f32,
+                               true);
             cubic_planar_line(true);
 
             // y3
@@ -1364,7 +1409,13 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
             vpminsd(vmm_index_y_itr, vmm_index_y_itr, cubic_planar_table_val(1));
             vpmaxsd(vmm_index_y_itr, vmm_index_y_itr, vmm_zero);
             // weight y3
-            gather_i32_indices(vmm_weightY, reg_weight_y, 3 * sizeof(float), vmm_tbl_y, grid_len, ov::element::f32, true);
+            gather_i32_indices(vmm_weightY,
+                               reg_weight_y,
+                               3 * sizeof(float),
+                               vmm_tbl_y,
+                               grid_len,
+                               ov::element::f32,
+                               true);
             cubic_planar_line(true);
 
             if (attr_.post_ops_.len() != 0) {
@@ -1453,8 +1504,13 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
     }
 
     // always gather to Vmm, compute with Vmm, store with Xmm if scalar_step
-    inline void gather_i32_indices(Vmm vmm_src, const Xbyak::Reg64 &base, int offset, Vmm vmm_indices, int scale,
-                                ov::element::Type src_prc, bool is_scalar) {
+    inline void gather_i32_indices(Vmm vmm_src,
+                                   const Xbyak::Reg64& base,
+                                   int offset,
+                                   Vmm vmm_indices,
+                                   int scale,
+                                   ov::element::Type src_prc,
+                                   bool is_scalar) {
         Xbyak::Address table_idx = ptr[base + offset + vmm_indices * scale];
         if ((isa == cpu::x64::avx512_core) && !is_scalar) {
             // [0-15] bit of int to mask
@@ -1483,8 +1539,8 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
 
             int repeats = is_scalar ? 1 : vlen / sizeof(float);
             for (int i = 0; i < repeats; ++i) {
-                mov(reg_tmp_64.cvt32(), ptr[rsp + i * sizeof(int)]);       // sizeof(int)  index_size
-                table_idx = ptr[base + offset + reg_tmp_64 * scale];       // scale: sizeof(float)   value_size
+                mov(reg_tmp_64.cvt32(), ptr[rsp + i * sizeof(int)]);  // sizeof(int)  index_size
+                table_idx = ptr[base + offset + reg_tmp_64 * scale];  // scale: sizeof(float)   value_size
                 mov(reg_tmp_64.cvt32(), table_idx);
                 mov(ptr[rsp + i * sizeof(int)], reg_tmp_64.cvt32());
             }
@@ -1497,9 +1553,10 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
         }
     }
 
-    // is_broadcast for broadcasting param for depth_wise and quantize(channel-sensitive post-ops), for fusion with plain layout.
+    // is_broadcast for broadcasting param for depth_wise and quantize(channel-sensitive post-ops), for fusion with
+    // plain layout.
     void apply_post_ops(ov::element::Type dst_prc, bool is_broadcast) {
-        const auto &p = attr_.post_ops_;
+        const auto& p = attr_.post_ops_;
         int eltwise_inj_idx = 0;
         int depthwise_inj_idx = 0;
         int quantization_inj_idx = 0;
@@ -1514,8 +1571,11 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
                 add(reg_d_weights, reg_oc_off);
 
                 // weight and bias is padded. scalar as vector.
-                depthwise_injectors[depthwise_inj_idx]->compute_vector_range(
-                        vmm_val.getIdx(), vmm_val.getIdx() + 1, reg_d_weights, reg_d_weights, is_broadcast);
+                depthwise_injectors[depthwise_inj_idx]->compute_vector_range(vmm_val.getIdx(),
+                                                                             vmm_val.getIdx() + 1,
+                                                                             reg_d_weights,
+                                                                             reg_d_weights,
+                                                                             is_broadcast);
 
                 post_ops_data_offset += depthwise_injectors[depthwise_inj_idx]->memoryStep();
                 depthwise_inj_idx++;
@@ -1525,15 +1585,25 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
 
                 int s_idx = vmm_val.getIdx();
 
-                quantization_injectors[quantization_inj_idx]->init_crop_ptrs(reg_post_ops_data + post_ops_data_offset, reg_oc_off);
+                quantization_injectors[quantization_inj_idx]->init_crop_ptrs(reg_post_ops_data + post_ops_data_offset,
+                                                                             reg_oc_off);
                 quantization_injectors[quantization_inj_idx]->compute_crop(s_idx, s_idx + 1, 0, 0, is_broadcast);
 
-                quantization_injectors[quantization_inj_idx]->init_input_scale_shift_ptrs(reg_post_ops_data + post_ops_data_offset, reg_oc_off);
-                quantization_injectors[quantization_inj_idx]->compute_input_scale_shift(s_idx, s_idx + 1, 0, do_rounding, 0, is_broadcast);
+                quantization_injectors[quantization_inj_idx]->init_input_scale_shift_ptrs(
+                    reg_post_ops_data + post_ops_data_offset,
+                    reg_oc_off);
+                quantization_injectors[quantization_inj_idx]
+                    ->compute_input_scale_shift(s_idx, s_idx + 1, 0, do_rounding, 0, is_broadcast);
 
                 if (do_dequantization) {
-                    quantization_injectors[quantization_inj_idx]->init_output_scale_shift_ptrs(reg_post_ops_data + post_ops_data_offset, reg_oc_off);
-                    quantization_injectors[quantization_inj_idx]->compute_output_scale_shift(s_idx, s_idx + 1, 0, 0, is_broadcast);
+                    quantization_injectors[quantization_inj_idx]->init_output_scale_shift_ptrs(
+                        reg_post_ops_data + post_ops_data_offset,
+                        reg_oc_off);
+                    quantization_injectors[quantization_inj_idx]->compute_output_scale_shift(s_idx,
+                                                                                             s_idx + 1,
+                                                                                             0,
+                                                                                             0,
+                                                                                             is_broadcast);
                 }
 
                 post_ops_data_offset += quantization_injectors[quantization_inj_idx]->memoryStep();
@@ -1543,7 +1613,7 @@ struct jit_uni_interpolate_kernel_f32 : public jit_uni_interpolate_kernel, publi
     }
 };
 
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
 namespace {
 struct InterpolateKey {
@@ -1585,7 +1655,7 @@ size_t InterpolateKey::hash() const {
     return seed;
 }
 
-bool InterpolateKey::operator==(const InterpolateKey &rhs) const {
+bool InterpolateKey::operator==(const InterpolateKey& rhs) const {
     if (nodeAttrs.mode != rhs.nodeAttrs.mode)
         return false;
     if (nodeAttrs.coordTransMode != rhs.nodeAttrs.coordTransMode)
@@ -1619,7 +1689,7 @@ bool InterpolateKey::operator==(const InterpolateKey &rhs) const {
     return true;
 }
 
-} // namespace
+}  // namespace
 
 // shapeND: n     c     d     h    w
 // blockND: ncdhw cdhw  dhw   hw   w    1
@@ -1628,7 +1698,7 @@ inline VectorDims getBlockND(const VectorDims& shape) {
     int shapeRank = shape.size();
     VectorDims blockND(shapeRank + 1, 1);
     for (int i = shapeRank - 1; i >= 0; i--) {
-        blockND[i] = shape[i] * blockND[i+1];
+        blockND[i] = shape[i] * blockND[i + 1];
     }
     return blockND;
 }
@@ -1664,32 +1734,47 @@ using ngInterpShapeCalcMode = ov::op::v4::Interpolate::ShapeCalcMode;
 bool Interpolate::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
         if (const auto interp = std::dynamic_pointer_cast<const ov::op::v4::Interpolate>(op)) {
-            const auto &interpAttr = interp->get_attrs();
-            const auto &interpMode = interpAttr.mode;
-            if (!one_of(interpMode, ngInterpMode::NEAREST, ngInterpMode::LINEAR, ngInterpMode::LINEAR_ONNX, ngInterpMode::CUBIC)) {
+            const auto& interpAttr = interp->get_attrs();
+            const auto& interpMode = interpAttr.mode;
+            if (!one_of(interpMode,
+                        ngInterpMode::NEAREST,
+                        ngInterpMode::LINEAR,
+                        ngInterpMode::LINEAR_ONNX,
+                        ngInterpMode::CUBIC)) {
                 errorMessage = "Interpolate-4 does not support interpolate mode: " + ov::as_string(interpMode);
                 return false;
             }
 
-            const auto &interpCoordTransMode = interpAttr.coordinate_transformation_mode;
-            if (!one_of(interpCoordTransMode, ngInterpCoordTransf::HALF_PIXEL, ngInterpCoordTransf::PYTORCH_HALF_PIXEL, ngInterpCoordTransf::ASYMMETRIC,
-                                              ngInterpCoordTransf::TF_HALF_PIXEL_FOR_NN, ngInterpCoordTransf::ALIGN_CORNERS)) {
-                errorMessage = "Interpolate-4 does not support coordinate transformation mode: " + ov::as_string(interpCoordTransMode);
+            const auto& interpCoordTransMode = interpAttr.coordinate_transformation_mode;
+            if (!one_of(interpCoordTransMode,
+                        ngInterpCoordTransf::HALF_PIXEL,
+                        ngInterpCoordTransf::PYTORCH_HALF_PIXEL,
+                        ngInterpCoordTransf::ASYMMETRIC,
+                        ngInterpCoordTransf::TF_HALF_PIXEL_FOR_NN,
+                        ngInterpCoordTransf::ALIGN_CORNERS)) {
+                errorMessage = "Interpolate-4 does not support coordinate transformation mode: " +
+                               ov::as_string(interpCoordTransMode);
                 return false;
             }
 
             if (interpMode == ngInterpMode::NEAREST) {
-                const auto &interpNearestMode = interpAttr.nearest_mode;
-                if (!one_of(interpNearestMode, ngInterpNearMode::ROUND_PREFER_FLOOR, ngInterpNearMode::ROUND_PREFER_CEIL, ngInterpNearMode::FLOOR,
-                                               ngInterpNearMode::CEIL, ngInterpNearMode::SIMPLE)) {
-                    errorMessage = "Interpolate-4 does not support nearest round mode: " + ov::as_string(interpNearestMode);
+                const auto& interpNearestMode = interpAttr.nearest_mode;
+                if (!one_of(interpNearestMode,
+                            ngInterpNearMode::ROUND_PREFER_FLOOR,
+                            ngInterpNearMode::ROUND_PREFER_CEIL,
+                            ngInterpNearMode::FLOOR,
+                            ngInterpNearMode::CEIL,
+                            ngInterpNearMode::SIMPLE)) {
+                    errorMessage =
+                        "Interpolate-4 does not support nearest round mode: " + ov::as_string(interpNearestMode);
                     return false;
                 }
             }
 
-            const auto &interpShapeCalcMode = interpAttr.shape_calculation_mode;
+            const auto& interpShapeCalcMode = interpAttr.shape_calculation_mode;
             if (!one_of(interpShapeCalcMode, ngInterpShapeCalcMode::SCALES, ngInterpShapeCalcMode::SIZES)) {
-                errorMessage = "Interpolate-4 does not support shape_calculation_mode: " + ov::as_string(interpShapeCalcMode);
+                errorMessage =
+                    "Interpolate-4 does not support shape_calculation_mode: " + ov::as_string(interpShapeCalcMode);
                 return false;
             }
 
@@ -1700,7 +1785,8 @@ bool Interpolate::isSupportedOperation(const std::shared_ptr<const ov::Node>& op
             }
 
             if (dataRank == 5 && interpMode == ngInterpMode::CUBIC) {
-                errorMessage = "Interpolate-4 doesn't support input tensor with rank: " + std::to_string(dataRank) + " for 'cubic' mode ";
+                errorMessage = "Interpolate-4 doesn't support input tensor with rank: " + std::to_string(dataRank) +
+                               " for 'cubic' mode ";
                 return false;
             }
 
@@ -1710,21 +1796,22 @@ bool Interpolate::isSupportedOperation(const std::shared_ptr<const ov::Node>& op
                 return false;
             }
 
-            if (interp->get_input_size() > 3 &&
-                std::dynamic_pointer_cast<const ov::op::v0::Constant>(interp->get_input_node_shared_ptr(AXES_ID)) == nullptr) {
+            if (interp->get_input_size() > 3 && std::dynamic_pointer_cast<const ov::op::v0::Constant>(
+                                                    interp->get_input_node_shared_ptr(AXES_ID)) == nullptr) {
                 errorMessage = "Only const 'axes' input is supported in Interpolate-4";
                 return false;
             }
         } else if (const auto interp = std::dynamic_pointer_cast<const ov::op::v11::Interpolate>(op)) {
-            const auto &interpAttr = interp->get_attrs();
-            const auto &interpMode = interpAttr.mode;
+            const auto& interpAttr = interp->get_attrs();
+            const auto& interpMode = interpAttr.mode;
             if (!one_of(interpMode, ngInterpMode::BILINEAR_PILLOW, ngInterpMode::BICUBIC_PILLOW)) {
                 errorMessage = "Interpolate-11 does not support interpolate mode: " + ov::as_string(interpMode);
                 return false;
             }
-            const auto &interpShapeCalcMode = interpAttr.shape_calculation_mode;
+            const auto& interpShapeCalcMode = interpAttr.shape_calculation_mode;
             if (!one_of(interpShapeCalcMode, ngInterpShapeCalcMode::SCALES, ngInterpShapeCalcMode::SIZES)) {
-                errorMessage = "Interpolate-11 does not support shape_calculation_mode: " + ov::as_string(interpShapeCalcMode);
+                errorMessage =
+                    "Interpolate-11 does not support shape_calculation_mode: " + ov::as_string(interpShapeCalcMode);
                 return false;
             }
             const size_t dataRank = interp->get_input_partial_shape(DATA_ID).rank().get_length();
@@ -1734,12 +1821,12 @@ bool Interpolate::isSupportedOperation(const std::shared_ptr<const ov::Node>& op
                 return false;
             }
             if (!isDynamicNgraphNode(op) &&
-                    !ov::is_type<ov::op::v0::Constant>(op->get_input_node_ptr(SIZE_OR_SCALE_ID_V11))) {
+                !ov::is_type<ov::op::v0::Constant>(op->get_input_node_ptr(SIZE_OR_SCALE_ID_V11))) {
                 errorMessage = "Only const 'scales_or_sizes' input is supported for static shapes in Interpolate-11";
                 return false;
             }
-            if (interp->get_input_size() > 2 &&
-                std::dynamic_pointer_cast<const ov::op::v0::Constant>(interp->get_input_node_shared_ptr(AXES_ID_V11)) == nullptr) {
+            if (interp->get_input_size() > 2 && std::dynamic_pointer_cast<const ov::op::v0::Constant>(
+                                                    interp->get_input_node_shared_ptr(AXES_ID_V11)) == nullptr) {
                 errorMessage = "Only const 'axes' input is supported in Interpolate-11";
                 return false;
             }
@@ -1763,7 +1850,7 @@ class InterpolateShapeInferFactory : public ShapeInferFactory {
     InterpolateShapeInferFactory(std::shared_ptr<ov::Node> op) : m_op(op) {}
     ShapeInferPtr makeShapeInfer() const override {
         if (auto interp4 = ov::as_type_ptr<ov::opset4::Interpolate>(m_op)) {
-            const auto &attr = interp4->get_attrs();
+            const auto& attr = interp4->get_attrs();
             const auto is_supported_mode = (attr.shape_calculation_mode == ngInterpShapeCalcMode::SCALES) ||
                                            (attr.shape_calculation_mode == ngInterpShapeCalcMode::SIZES);
             OPENVINO_ASSERT(is_supported_mode, "Unsupported interpolate shape calculation mode");
@@ -1782,10 +1869,10 @@ class InterpolateShapeInferFactory : public ShapeInferFactory {
 private:
     std::shared_ptr<ov::Node> m_op;
 };
-} // namespace
+}  // namespace
 
 Interpolate::Interpolate(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
-        : Node(op, context, InterpolateShapeInferFactory(op)) {
+    : Node(op, context, InterpolateShapeInferFactory(op)) {
     std::string errorMessage;
     if (isSupportedOperation(op, errorMessage)) {
         errorPrefix = "Interpolate node with name '" + getName() + "'";
@@ -1799,9 +1886,9 @@ Interpolate::Interpolate(const std::shared_ptr<ov::Node>& op, const GraphContext
                 OPENVINO_THROW(errorPrefix, " has incorrect number of output edges");
             isAxesSpecified = numInputs != 3;
 
-            const auto &interpAttr = interp->get_attrs();
+            const auto& interpAttr = interp->get_attrs();
 
-            const auto &interpMode = interpAttr.mode;
+            const auto& interpMode = interpAttr.mode;
             if (interpMode == ngInterpMode::NEAREST) {
                 interpAttrs.mode = InterpolateMode::nearest;
             } else if (interpMode == ngInterpMode::LINEAR) {
@@ -1818,7 +1905,7 @@ Interpolate::Interpolate(const std::shared_ptr<ov::Node>& op, const GraphContext
                 OPENVINO_THROW(errorPrefix, " has unsupported interpolate mode");
             }
 
-            const auto &interpCoordTransMode = interpAttr.coordinate_transformation_mode;
+            const auto& interpCoordTransMode = interpAttr.coordinate_transformation_mode;
             if (interpCoordTransMode == ngInterpCoordTransf::HALF_PIXEL) {
                 interpAttrs.coordTransMode = InterpolateCoordTransMode::half_pixel;
             } else if (interpCoordTransMode == ngInterpCoordTransf::PYTORCH_HALF_PIXEL) {
@@ -1834,7 +1921,7 @@ Interpolate::Interpolate(const std::shared_ptr<ov::Node>& op, const GraphContext
             }
 
             if (interpAttrs.mode == InterpolateMode::nearest) {
-                const auto &interpNearestMode = interpAttr.nearest_mode;
+                const auto& interpNearestMode = interpAttr.nearest_mode;
                 if (interpNearestMode == ngInterpNearMode::ROUND_PREFER_FLOOR) {
                     interpAttrs.nearestMode = InterpolateNearestMode::round_prefer_floor;
                 } else if (interpNearestMode == ngInterpNearMode::ROUND_PREFER_CEIL) {
@@ -1853,7 +1940,7 @@ Interpolate::Interpolate(const std::shared_ptr<ov::Node>& op, const GraphContext
             }
             interpAttrs.antialias = interpAttr.antialias;
 
-            const auto &interpShapeCalcMode = interpAttr.shape_calculation_mode;
+            const auto& interpShapeCalcMode = interpAttr.shape_calculation_mode;
             if (interpShapeCalcMode == ngInterpShapeCalcMode::SCALES) {
                 interpAttrs.shapeCalcMode = InterpolateShapeCalcMode::scales;
             } else if (interpShapeCalcMode == ngInterpShapeCalcMode::SIZES) {
@@ -1878,14 +1965,16 @@ Interpolate::Interpolate(const std::shared_ptr<ov::Node>& op, const GraphContext
                     interpAttrs.padEnd[i] = static_cast<int>(interpAttr.pads_end[i]);
             }
 
-            const auto scalesNode = std::dynamic_pointer_cast<const ov::op::v0::Constant>(interp->get_input_node_shared_ptr(SCALES_ID));
+            const auto scalesNode =
+                std::dynamic_pointer_cast<const ov::op::v0::Constant>(interp->get_input_node_shared_ptr(SCALES_ID));
             if (scalesNode) {
                 scales = scalesNode->cast_vector<float>();
                 isScaleConstant = true;
             }
 
             if (isAxesSpecified) {
-                axes = std::dynamic_pointer_cast<const ov::op::v0::Constant>(interp->get_input_node_shared_ptr(AXES_ID))->cast_vector<int>();
+                axes = std::dynamic_pointer_cast<const ov::op::v0::Constant>(interp->get_input_node_shared_ptr(AXES_ID))
+                           ->cast_vector<int>();
             } else {
                 axes.resize(dataRank);
                 for (int i = 0; i < static_cast<int>(dataRank); i++) {
@@ -1901,13 +1990,13 @@ Interpolate::Interpolate(const std::shared_ptr<ov::Node>& op, const GraphContext
                 OPENVINO_THROW(errorPrefix, " has incorrect number of output edges");
             isAxesSpecified = numInputs != 2;
 
-            const auto &interpAttr = interp->get_attrs();
-            const auto &interpMode = interpAttr.mode;
+            const auto& interpAttr = interp->get_attrs();
+            const auto& interpMode = interpAttr.mode;
             if (interpMode == ngInterpMode::BILINEAR_PILLOW) {
                 interpAttrs.mode = InterpolateMode::bilinear_pillow;
             } else if (interpMode == ngInterpMode::BICUBIC_PILLOW) {
                 interpAttrs.mode = InterpolateMode::bicubic_pillow;
-                interpAttrs.cubeCoeff = static_cast<float>(interpAttr.cube_coeff); // fixed to be -0.5
+                interpAttrs.cubeCoeff = static_cast<float>(interpAttr.cube_coeff);  // fixed to be -0.5
             } else {
                 OPENVINO_THROW(errorPrefix, " has unsupported interpolate mode");
             }
@@ -1916,10 +2005,11 @@ Interpolate::Interpolate(const std::shared_ptr<ov::Node>& op, const GraphContext
             interpAttrs.coordTransMode = InterpolateCoordTransMode::tf_half_pixel_for_nn;
             interpAttrs.antialias = interpAttr.antialias;
 
-            const auto &interpShapeCalcMode = interpAttr.shape_calculation_mode;
+            const auto& interpShapeCalcMode = interpAttr.shape_calculation_mode;
             if (interpShapeCalcMode == ngInterpShapeCalcMode::SCALES) {
                 interpAttrs.shapeCalcMode = InterpolateShapeCalcMode::scales;
-                const auto scalesNode = std::dynamic_pointer_cast<const ov::op::v0::Constant>(interp->get_input_node_shared_ptr(SIZE_OR_SCALE_ID_V11));
+                const auto scalesNode = std::dynamic_pointer_cast<const ov::op::v0::Constant>(
+                    interp->get_input_node_shared_ptr(SIZE_OR_SCALE_ID_V11));
                 if (scalesNode) {
                     scales = scalesNode->cast_vector<float>();
                     isScaleConstant = true;
@@ -1947,7 +2037,9 @@ Interpolate::Interpolate(const std::shared_ptr<ov::Node>& op, const GraphContext
             }
 
             if (isAxesSpecified) {
-                axes = std::dynamic_pointer_cast<const ov::op::v0::Constant>(interp->get_input_node_shared_ptr(AXES_ID_V11))->cast_vector<int>();
+                axes = std::dynamic_pointer_cast<const ov::op::v0::Constant>(
+                           interp->get_input_node_shared_ptr(AXES_ID_V11))
+                           ->cast_vector<int>();
                 if (dataRank == 4 && axes.size() == 2 && axes[0] == 1 && axes[1] == 2 && mayiuse(cpu::x64::sse41)) {
                     NCHWAsNHWC = true;
                     axes[0] = 2;
@@ -1986,7 +2078,7 @@ void Interpolate::getSupportedDescriptors() {
             break;
         }
     }
-    //correct pad
+    // correct pad
     if (hasPad) {
         NCHWAsNHWC = false;
         auto correctPad = [&](std::vector<int> pad, int rank) {
@@ -2064,15 +2156,21 @@ void Interpolate::initSupportedPrimitiveDescriptors() {
         }
     }
     auto& creatorsMap = BlockedDescCreator::getCommonCreators();
-    auto pushDesc = [&](LayoutType dataFormat, impl_desc_type implDetail, bool is_version11, bool useAclExecutor = false) {
-        config.inConfs[DATA_ID].setMemDesc(creatorsMap.at(dataFormat)->createSharedDesc(inputPrecision, getInputShapeAtPort(DATA_ID)));
+    auto pushDesc = [&](LayoutType dataFormat,
+                        impl_desc_type implDetail,
+                        bool is_version11,
+                        bool useAclExecutor = false) {
+        config.inConfs[DATA_ID].setMemDesc(
+            creatorsMap.at(dataFormat)->createSharedDesc(inputPrecision, getInputShapeAtPort(DATA_ID)));
         if (is_version11) {
             if (interpAttrs.shapeCalcMode == InterpolateShapeCalcMode::sizes) {
                 config.inConfs[SIZE_OR_SCALE_ID_V11].setMemDesc(
-                    creatorsMap.at(LayoutType::ncsp)->createSharedDesc(targetShapeType, getInputShapeAtPort(SIZE_OR_SCALE_ID_V11)));
+                    creatorsMap.at(LayoutType::ncsp)
+                        ->createSharedDesc(targetShapeType, getInputShapeAtPort(SIZE_OR_SCALE_ID_V11)));
             } else {
                 config.inConfs[SIZE_OR_SCALE_ID_V11].setMemDesc(
-                    creatorsMap.at(LayoutType::ncsp)->createSharedDesc(scalesType, getInputShapeAtPort(SIZE_OR_SCALE_ID_V11)));
+                    creatorsMap.at(LayoutType::ncsp)
+                        ->createSharedDesc(scalesType, getInputShapeAtPort(SIZE_OR_SCALE_ID_V11)));
             }
 
             if (isAxesSpecified)
@@ -2080,14 +2178,18 @@ void Interpolate::initSupportedPrimitiveDescriptors() {
                     creatorsMap.at(LayoutType::ncsp)->createSharedDesc(axesType, getInputShapeAtPort(AXES_ID_V11)));
         } else {
             config.inConfs[TARGET_SHAPE_ID].setMemDesc(
-                creatorsMap.at(LayoutType::ncsp)->createSharedDesc(targetShapeType, getInputShapeAtPort(TARGET_SHAPE_ID)));
-            config.inConfs[get_scale_id()].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(scalesType, getInputShapeAtPort(get_scale_id())));
+                creatorsMap.at(LayoutType::ncsp)
+                    ->createSharedDesc(targetShapeType, getInputShapeAtPort(TARGET_SHAPE_ID)));
+            config.inConfs[get_scale_id()].setMemDesc(
+                creatorsMap.at(LayoutType::ncsp)->createSharedDesc(scalesType, getInputShapeAtPort(get_scale_id())));
 
             if (isAxesSpecified)
-                config.inConfs[get_axis_id()].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(axesType, getInputShapeAtPort(get_axis_id())));
+                config.inConfs[get_axis_id()].setMemDesc(
+                    creatorsMap.at(LayoutType::ncsp)->createSharedDesc(axesType, getInputShapeAtPort(get_axis_id())));
         }
 
-        config.outConfs[0].setMemDesc(creatorsMap.at(dataFormat)->createSharedDesc(outputPrecision, getOutputShapeAtPort(0)));
+        config.outConfs[0].setMemDesc(
+            creatorsMap.at(dataFormat)->createSharedDesc(outputPrecision, getOutputShapeAtPort(0)));
 
         if (useAclExecutor) {
             std::vector<MemoryDescPtr> srcMemoryDescs;
@@ -2099,8 +2201,11 @@ void Interpolate::initSupportedPrimitiveDescriptors() {
                 dstMemoryDescs.push_back(config.outConfs[i].getMemDesc());
             }
 
-            auto factory = std::make_shared<InterpolateExecutorFactory>(interpAttrs, srcMemoryDescs, dstMemoryDescs,
-                                                                    std::make_shared<ExecutorContext>(context, getImplPriority()));
+            auto factory = std::make_shared<InterpolateExecutorFactory>(
+                interpAttrs,
+                srcMemoryDescs,
+                dstMemoryDescs,
+                std::make_shared<ExecutorContext>(context, getImplPriority()));
             if (!factory->isEmpty()) {
                 supportedPrimitiveDescriptors.push_back({config, implDetail, factory});
             }
@@ -2109,14 +2214,14 @@ void Interpolate::initSupportedPrimitiveDescriptors() {
         }
     };
     if (is_version11) {
-#if defined (OV_CPU_WITH_ACL)
+#if defined(OV_CPU_WITH_ACL)
         interpAttrs.hasPad = hasPad;
         pushDesc(LayoutType::nspc, undef, true, true);
         pushDesc(LayoutType::ncsp, undef, true, true);
         canUseAclExecutor = !supportedPrimitiveDescriptors.empty();
         if (canUseAclExecutor)
             return;
-        //fallback to f32 if ref is used
+        // fallback to f32 if ref is used
         inputPrecision = outputPrecision = ov::element::f32;
 #endif
 
@@ -2140,17 +2245,17 @@ void Interpolate::initSupportedPrimitiveDescriptors() {
         }
         pushDesc(LayoutType::ncsp, ref, true);
     } else {
-        const auto &dataMinDims = getInputShapeAtPort(DATA_ID).getMinDims();
+        const auto& dataMinDims = getInputShapeAtPort(DATA_ID).getMinDims();
         bool isBlkApplied = dataRank > 1 && dataMinDims[1] != Shape::UNDEFINED_DIM && dataMinDims[1] > 1;
 
-#if defined (OV_CPU_WITH_ACL)
+#if defined(OV_CPU_WITH_ACL)
         interpAttrs.hasPad = hasPad;
         pushDesc(LayoutType::nspc, undef, false, true);
         pushDesc(LayoutType::ncsp, undef, false, true);
         canUseAclExecutor = !supportedPrimitiveDescriptors.empty();
         if (canUseAclExecutor)
             return;
-        //fallback to f32 if ref is used
+        // fallback to f32 if ref is used
         inputPrecision = outputPrecision = ov::element::f32;
 #endif
 
@@ -2195,7 +2300,7 @@ bool Interpolate::needShapeInfer() const {
         if (lastScales.empty()) {
             return true;
         }
-        const float *scales = getSrcDataAtPortAs<const float>(get_scale_id());
+        const float* scales = getSrcDataAtPortAs<const float>(get_scale_id());
         for (size_t i = 0; i < lastScales.size(); i++) {
             if (lastScales[i] != scales[i]) {
                 return true;
@@ -2205,7 +2310,7 @@ bool Interpolate::needShapeInfer() const {
         if (lastSizes.empty()) {
             return true;
         }
-        const int32_t *sizes = getSrcDataAtPortAs<const int32_t>(TARGET_SHAPE_ID);
+        const int32_t* sizes = getSrcDataAtPortAs<const int32_t>(TARGET_SHAPE_ID);
         for (size_t i = 0; i < lastSizes.size(); i++) {
             if (sizes[i] != lastSizes[i]) {
                 return true;
@@ -2219,12 +2324,12 @@ void Interpolate::executeDynamicImpl(dnnl::stream strm) {
     execute(strm);
 
     const size_t port = interpAttrs.shapeCalcMode == InterpolateShapeCalcMode::sizes ? TARGET_SHAPE_ID : get_scale_id();
-    const auto &memory = getParentEdgeAt(port)->getMemory();
+    const auto& memory = getParentEdgeAt(port)->getMemory();
     if (interpAttrs.shapeCalcMode == InterpolateShapeCalcMode::scales) {
-        const float *scales = memory.getDataAs<const float>();
+        const float* scales = memory.getDataAs<const float>();
         lastScales.assign(scales, scales + memory.getDesc().getShape().getElementsCount());
     } else {
-        const int32_t *sizes = memory.getDataAs<const int32_t>();
+        const int32_t* sizes = memory.getDataAs<const int32_t>();
         lastSizes.assign(sizes, sizes + memory.getDesc().getShape().getElementsCount());
     }
 }
@@ -2277,19 +2382,19 @@ void Interpolate::prepareParams() {
             OPENVINO_THROW(errorPrefix, " has undefined axes memory");
     }
 
-    const NodeDesc *selected_pd = getSelectedPrimitiveDescriptor();
+    const NodeDesc* selected_pd = getSelectedPrimitiveDescriptor();
     if (selected_pd == nullptr)
         OPENVINO_THROW(errorPrefix, " did not set preferable primitive descriptor");
 
-    const auto &srcDimsOrign = srcMemPtr->getStaticDims();
-    const auto &dstDimsOrign = dstMemPtr->getStaticDims();
+    const auto& srcDimsOrign = srcMemPtr->getStaticDims();
+    const auto& dstDimsOrign = dstMemPtr->getStaticDims();
 
     VectorDims srcDims = srcDimsOrign;
     VectorDims dstDims = dstDimsOrign;
 
     // layoutAlignment
     if (NCHWAsNHWC && srcMemPtr->getDesc().hasLayoutType(LayoutType::ncsp)) {
-        auto logicalShapeAlign = [] (VectorDims& Dims) {
+        auto logicalShapeAlign = [](VectorDims& Dims) {
             size_t C = Dims[3];
             Dims[3] = Dims[2];
             Dims[2] = Dims[1];
@@ -2308,7 +2413,8 @@ void Interpolate::prepareParams() {
         }
     }
 
-    std::vector<float> dataScales = getScales(getPaddedInputShape(srcDims, interpAttrs.padBegin, interpAttrs.padEnd), dstDims);
+    std::vector<float> dataScales =
+        getScales(getPaddedInputShape(srcDims, interpAttrs.padBegin, interpAttrs.padEnd), dstDims);
     if (!NCHWAsNHWC && (getOutputShapeAtPort(0).getRank() > 2 && (dataScales[0] != 1.f || dataScales[1] != 1.f))) {
         OPENVINO_THROW("Interpolate layer only supports resize on spatial dimensions(depth, height and width)");
     }
@@ -2324,7 +2430,10 @@ void Interpolate::prepareParams() {
         dstMemoryDescs.push_back(getDstMemoryAtPort(0)->getDescPtr());
 
         auto selectedPD = getSelectedPrimitiveDescriptor();
-        aclExecPtr = selectedPD->getExecutorFactoryAs<InterpolateExecutorFactory>()->makeExecutor(interpAttrs, srcMemoryDescs, dstMemoryDescs, {});
+        aclExecPtr = selectedPD->getExecutorFactoryAs<InterpolateExecutorFactory>()->makeExecutor(interpAttrs,
+                                                                                                  srcMemoryDescs,
+                                                                                                  dstMemoryDescs,
+                                                                                                  {});
         selectedPD->setImplementationType(aclExecPtr->getImplType());
 
         return;
@@ -2336,26 +2445,25 @@ void Interpolate::prepareParams() {
     auto buildExecutor = [&](const InterpolateKey& key) -> std::shared_ptr<InterpolateExecutorBase> {
         std::shared_ptr<InterpolateExecutorBase> executor;
         if ((key.nodeAttrs.mode == InterpolateMode::nearest || key.nodeAttrs.mode == InterpolateMode::linear_onnx ||
-            key.nodeAttrs.mode == InterpolateMode::cubic) &&
+             key.nodeAttrs.mode == InterpolateMode::cubic) &&
             ((key.nodeAttrs.layout != InterpolateLayoutType::planar && mayiuse(cpu::x64::sse41)) ||
-                (mayiuse(cpu::x64::avx2) && key.nodeAttrs.inPrc == ov::element::f32))) {
+             (mayiuse(cpu::x64::avx2) && key.nodeAttrs.inPrc == ov::element::f32))) {
             executor = std::make_shared<InterpolateJitExecutor>(key.nodeAttrs,
-                                                               key.srcDims,
-                                                               key.dstDims,
-                                                               key.dataScales,
-                                                               key.attr);
-        } else if ((key.nodeAttrs.mode == InterpolateMode::bilinear_pillow || key.nodeAttrs.mode == InterpolateMode::bicubic_pillow) &&
-            (key.nodeAttrs.layout == InterpolateLayoutType::by_channel)) {
+                                                                key.srcDims,
+                                                                key.dstDims,
+                                                                key.dataScales,
+                                                                key.attr);
+        } else if ((key.nodeAttrs.mode == InterpolateMode::bilinear_pillow ||
+                    key.nodeAttrs.mode == InterpolateMode::bicubic_pillow) &&
+                   (key.nodeAttrs.layout == InterpolateLayoutType::by_channel)) {
             executor = std::make_shared<InterpolateJitExecutor>(key.nodeAttrs,
-                                                               key.srcDims,
-                                                               key.dstDims,
-                                                               key.dataScales,
-                                                               key.attr);
+                                                                key.srcDims,
+                                                                key.dstDims,
+                                                                key.dataScales,
+                                                                key.attr);
         } else {
-            executor = std::make_shared<InterpolateRefExecutor>(key.nodeAttrs,
-                                                               key.srcDims,
-                                                               key.dstDims,
-                                                               key.dataScales);
+            executor =
+                std::make_shared<InterpolateRefExecutor>(key.nodeAttrs, key.srcDims, key.dstDims, key.dataScales);
         }
         return executor;
     };
@@ -2402,18 +2510,18 @@ static inline float triangleCoeff(float x) {
     return (std::max)(0.0f, 1 - std::abs(x));
 }
 
-void Interpolate::setPostOps(dnnl::primitive_attr &attr, const VectorDims &dims) {
+void Interpolate::setPostOps(dnnl::primitive_attr& attr, const VectorDims& dims) {
     dnnl::post_ops ops;
 
     postOpsDataPtrs.clear();
-    for (auto &node : fusedWith) {
-        auto* fakeQuantizeNode = dynamic_cast<FakeQuantize *>(node.get());
+    for (auto& node : fusedWith) {
+        auto* fakeQuantizeNode = dynamic_cast<FakeQuantize*>(node.get());
         if (fakeQuantizeNode) {
             fakeQuantizeNode->appendPostOps(ops, {}, postOpsDataPtrs);
             continue;
         }
 
-        auto* eltwiseNode = dynamic_cast<Eltwise *>(node.get());
+        auto* eltwiseNode = dynamic_cast<Eltwise*>(node.get());
         if (eltwiseNode) {
             eltwiseNode->appendPostOps(ops, dims, postOpsDataPtrs);
             continue;
@@ -2429,9 +2537,9 @@ void Interpolate::setPostOps(dnnl::primitive_attr &attr, const VectorDims &dims)
     attr.set_post_ops(ops);
 }
 
-VectorDims Interpolate::getPaddedInputShape(const VectorDims &srcDims,
-                                                      const std::vector<int> &padBegin,
-                                                      const std::vector<int> &padEnd) {
+VectorDims Interpolate::getPaddedInputShape(const VectorDims& srcDims,
+                                            const std::vector<int>& padBegin,
+                                            const std::vector<int>& padEnd) {
     VectorDims paddedShape;
     int dataRank = srcDims.size();
     for (int i = 0; i < dataRank; i++) {
@@ -2443,18 +2551,21 @@ VectorDims Interpolate::getPaddedInputShape(const VectorDims &srcDims,
 // get scales of data rank size
 // if "scale" version: set scales with input scales, 1.f for other dims not in axis
 // if "size" version: scales = shape[target] / shape[input].pad, 1.f for other dims not in axis
-// scales is a required input, but should not use input scales when "size" case, which may added eps or is a dummy value, recalculate scales instead.
-std::vector<float> Interpolate::getScales(const VectorDims &srcDimPad, const VectorDims &dstDim) {
+// scales is a required input, but should not use input scales when "size" case, which may added eps or is a dummy
+// value, recalculate scales instead.
+std::vector<float> Interpolate::getScales(const VectorDims& srcDimPad, const VectorDims& dstDim) {
     std::vector<float> fullScales(dataRank, 1.f);
     const size_t axesRank = axes.size();
     for (size_t i = 0; i < axesRank; i++) {
         int axis = axes[i];
         // pillow always re-generate scales with input and output shape
-        if (interpAttrs.mode == InterpolateMode::bilinear_pillow || interpAttrs.mode == InterpolateMode::bicubic_pillow) {
+        if (interpAttrs.mode == InterpolateMode::bilinear_pillow ||
+            interpAttrs.mode == InterpolateMode::bicubic_pillow) {
             fullScales[axis] = static_cast<float>(dstDim[axis]) / static_cast<float>(srcDimPad[axis]);
         } else {
-            fullScales[axis] = (interpAttrs.shapeCalcMode == InterpolateShapeCalcMode::scales) ? scales[i] :
-                                                                                     static_cast<float>(dstDim[axis]) / static_cast<float>(srcDimPad[axis]);
+            fullScales[axis] = (interpAttrs.shapeCalcMode == InterpolateShapeCalcMode::scales)
+                                   ? scales[i]
+                                   : static_cast<float>(dstDim[axis]) / static_cast<float>(srcDimPad[axis]);
         }
     }
     return fullScales;
@@ -2465,12 +2576,12 @@ void Interpolate::execute(dnnl::stream strm) {
     auto srcMemPtr = getSrcMemoryAtPort(DATA_ID);
 
     if (execPtr) {
-        uint8_t *dst_data = dstMemPtr->getDataAs<uint8_t>();
-        const uint8_t *src_data_origin = srcMemPtr->getDataAs<uint8_t>();
-        const uint8_t *src_data = nullptr;
+        uint8_t* dst_data = dstMemPtr->getDataAs<uint8_t>();
+        const uint8_t* src_data_origin = srcMemPtr->getDataAs<uint8_t>();
+        const uint8_t* src_data = nullptr;
         std::vector<uint8_t> srcPadded;
         if (hasPad) {
-            const auto &srcDim = srcMemPtr->getStaticDims();
+            const auto& srcDim = srcMemPtr->getStaticDims();
             auto srcDimPad = execPtr->getSrcDimPad5d();
             size_t dimSize = srcDim.size();
 
@@ -2489,23 +2600,34 @@ void Interpolate::execute(dnnl::stream strm) {
 
             if (interpAttrs.layout == InterpolateLayoutType::planar) {
                 srcPadded.resize(inShapePadBlock[0] * srcDataSize, 0);
-                uint8_t *src_data_pad = static_cast<uint8_t *>(&srcPadded[0]);
+                uint8_t* src_data_pad = static_cast<uint8_t*>(&srcPadded[0]);
                 parallel_for4d(srcDim5d[0], srcDim5d[1], srcDim5d[2], srcDim5d[3], [&](int n, int c, int d, int h) {
-                    const uint8_t *src = src_data_origin +
-                        (inShapeBlock[1] * n + inShapeBlock[2] * c + inShapeBlock[3] * d + inShapeBlock[4] * h) * srcDataSize;
-                    uint8_t *srcPad = src_data_pad + (inShapePadBlock[1] * (n + padB0) + inShapePadBlock[2] * (c + padB1) +
-                                inShapePadBlock[3] * (d + padB2) + inShapePadBlock[4] * (h + padB3) + padB4) * srcDataSize;
+                    const uint8_t* src = src_data_origin + (inShapeBlock[1] * n + inShapeBlock[2] * c +
+                                                            inShapeBlock[3] * d + inShapeBlock[4] * h) *
+                                                               srcDataSize;
+                    uint8_t* srcPad =
+                        src_data_pad + (inShapePadBlock[1] * (n + padB0) + inShapePadBlock[2] * (c + padB1) +
+                                        inShapePadBlock[3] * (d + padB2) + inShapePadBlock[4] * (h + padB3) + padB4) *
+                                           srcDataSize;
                     cpu_memcpy(srcPad, src, srcDim5d[4] * srcDataSize);
                 });
                 src_data = src_data_pad;
             } else if (interpAttrs.layout == InterpolateLayoutType::by_channel) {
                 srcPadded.resize(inShapePadBlock[0] * srcDataSize, 0);
-                uint8_t *src_data_pad = static_cast<uint8_t *>(&srcPadded[0]);
+                uint8_t* src_data_pad = static_cast<uint8_t*>(&srcPadded[0]);
                 parallel_for4d(srcDim5d[0], srcDim5d[2], srcDim5d[3], srcDim5d[4], [&](int n, int d, int h, int w) {
-                    const uint8_t *src = src_data_origin + (inShapeBlock[1] * n +
-                                    (inShapeBlock[3] * d + inShapeBlock[4] * h + inShapeBlock[5] * w) * srcDim5d[1]) * srcDataSize;
-                    uint8_t *srcPad = src_data_pad + (inShapePadBlock[1] * (n + padB0) + (inShapePadBlock[3] * (d + padB2) +
-                                    inShapePadBlock[4] * (h + padB3) + inShapePadBlock[5] * (w + padB4)) * srcDimPad5d[1] + padB1) * srcDataSize;
+                    const uint8_t* src =
+                        src_data_origin +
+                        (inShapeBlock[1] * n +
+                         (inShapeBlock[3] * d + inShapeBlock[4] * h + inShapeBlock[5] * w) * srcDim5d[1]) *
+                            srcDataSize;
+                    uint8_t* srcPad =
+                        src_data_pad + (inShapePadBlock[1] * (n + padB0) +
+                                        (inShapePadBlock[3] * (d + padB2) + inShapePadBlock[4] * (h + padB3) +
+                                         inShapePadBlock[5] * (w + padB4)) *
+                                            srcDimPad5d[1] +
+                                        padB1) *
+                                           srcDataSize;
                     cpu_memcpy(srcPad, src, srcDim5d[1] * srcDataSize);
                 });
                 src_data = src_data_pad;
@@ -2514,25 +2636,34 @@ void Interpolate::execute(dnnl::stream strm) {
                 size_t CB = div_up(srcDimPad5d[1], blkSize);
                 size_t eltsTotal = srcDimPad5d[0] * CB * srcDimPad5d[2] * srcDimPad5d[3] * srcDimPad5d[4] * blkSize;
                 srcPadded.resize(eltsTotal * srcDataSize, 0x0);
-                uint8_t *src_data_pad = static_cast<uint8_t *>(&srcPadded[0]);
+                uint8_t* src_data_pad = static_cast<uint8_t*>(&srcPadded[0]);
                 if ((srcDim5d[0] != srcDimPad5d[0]) || (srcDim5d[1] != srcDimPad5d[1])) {
                     OPENVINO_THROW("Interpolate layer with name '",
                                    getName(),
                                    "' does not support padding on batch and channel dimensions");
                 }
-                parallel_for5d(srcDim5d[0], CB, srcDim5d[2], srcDim5d[3], srcDim5d[4], [&](int n, int cb, int d, int h, int w) {
-                    const uint8_t *src = src_data_origin + (n * CB * srcDim5d[2] * srcDim5d[3] * srcDim5d[4] * blkSize) * srcDataSize
-                                                + (cb * srcDim5d[2] * srcDim5d[3] * srcDim5d[4] * blkSize) * srcDataSize
-                                                + (d * srcDim5d[3] * srcDim5d[4] * blkSize) * srcDataSize
-                                                + (h * srcDim5d[4] * blkSize) * srcDataSize
-                                                + (w * blkSize) * srcDataSize;
-                    uint8_t *srcPad = src_data_pad + (n * CB * srcDimPad5d[2] * srcDimPad5d[3] * srcDimPad5d[4] * blkSize) * srcDataSize
-                                                + (cb * srcDimPad5d[2] * srcDimPad5d[3] * srcDimPad5d[4] * blkSize) * srcDataSize
-                                                + ((d + padB2) * srcDimPad5d[3] * srcDimPad5d[4] * blkSize) * srcDataSize
-                                                + ((h + padB3) * srcDimPad5d[4] * blkSize) * srcDataSize
-                                                + ((w + padB4) * blkSize) * srcDataSize;
-                    cpu_memcpy(srcPad, src, blkSize * srcDataSize);
-                });
+                parallel_for5d(srcDim5d[0],
+                               CB,
+                               srcDim5d[2],
+                               srcDim5d[3],
+                               srcDim5d[4],
+                               [&](int n, int cb, int d, int h, int w) {
+                                   const uint8_t* src =
+                                       src_data_origin +
+                                       (n * CB * srcDim5d[2] * srcDim5d[3] * srcDim5d[4] * blkSize) * srcDataSize +
+                                       (cb * srcDim5d[2] * srcDim5d[3] * srcDim5d[4] * blkSize) * srcDataSize +
+                                       (d * srcDim5d[3] * srcDim5d[4] * blkSize) * srcDataSize +
+                                       (h * srcDim5d[4] * blkSize) * srcDataSize + (w * blkSize) * srcDataSize;
+                                   uint8_t* srcPad =
+                                       src_data_pad +
+                                       (n * CB * srcDimPad5d[2] * srcDimPad5d[3] * srcDimPad5d[4] * blkSize) *
+                                           srcDataSize +
+                                       (cb * srcDimPad5d[2] * srcDimPad5d[3] * srcDimPad5d[4] * blkSize) * srcDataSize +
+                                       ((d + padB2) * srcDimPad5d[3] * srcDimPad5d[4] * blkSize) * srcDataSize +
+                                       ((h + padB3) * srcDimPad5d[4] * blkSize) * srcDataSize +
+                                       ((w + padB4) * blkSize) * srcDataSize;
+                                   cpu_memcpy(srcPad, src, blkSize * srcDataSize);
+                               });
                 src_data = src_data_pad;
             }
         } else {
@@ -2549,26 +2680,35 @@ void Interpolate::execute(dnnl::stream strm) {
 
 // for ndhwc and nCdhw8c[16c]
 // input may be f32/bf16/int8, fused->output varies
-void Interpolate::InterpolateJitExecutor::NNCGathered(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_,
-                                                                int B, int C, int ID, int IH, int IW, int OD, int OH, int OW) {
-    int *index_d = static_cast<int*>(&auxTable[0]);
-    int *index_h = static_cast<int*>(&auxTable[OD]);
-    int *index_w = static_cast<int*>(&auxTable[OD + OH]);
+void Interpolate::InterpolateJitExecutor::NNCGathered(const uint8_t* in_ptr_,
+                                                      uint8_t* out_ptr_,
+                                                      const void* post_ops_data_,
+                                                      int B,
+                                                      int C,
+                                                      int ID,
+                                                      int IH,
+                                                      int IW,
+                                                      int OD,
+                                                      int OH,
+                                                      int OW) {
+    int* index_d = static_cast<int*>(&auxTable[0]);
+    int* index_h = static_cast<int*>(&auxTable[OD]);
+    int* index_w = static_cast<int*>(&auxTable[OD + OH]);
 
     bool is_nhwc = (configured_for_layout == by_channel);
 
     for (int b = 0; b < B; b++) {
         if (is_nhwc) {
-            const uint8_t *in_ptr = in_ptr_ + (IW * IH * ID * C * b) * srcDataSize;
-            uint8_t *out_ptr = out_ptr_ + (OW * OH * OD * C * b) * dstDataSize;
+            const uint8_t* in_ptr = in_ptr_ + (IW * IH * ID * C * b) * srcDataSize;
+            uint8_t* out_ptr = out_ptr_ + (OW * OH * OD * C * b) * dstDataSize;
             std::vector<int> index_w_kernel(OW);
             for (int ox = 0; ox < OW; ox++) {
                 index_w_kernel[ox] = index_w[ox] * C * srcDataSize;
             }
             parallel_for2d(OD, OH, [&](size_t d, size_t h) {
                 // kernel for C * OW
-                uint8_t *out_ptr_dh = out_ptr + (C * OW * OH * d + C * OW * h) * dstDataSize;
-                const uint8_t *in_ptr_dh = in_ptr + (C * IW * IH * index_d[d] + C * IW * index_h[h]) * srcDataSize;
+                uint8_t* out_ptr_dh = out_ptr + (C * OW * OH * d + C * OW * h) * dstDataSize;
+                const uint8_t* in_ptr_dh = in_ptr + (C * IW * IH * index_d[d] + C * IW * index_h[h]) * srcDataSize;
                 auto arg = jit_interpolate_call_args();
                 arg.dst = out_ptr_dh;
                 arg.src_ptr[0] = in_ptr_dh;
@@ -2581,15 +2721,16 @@ void Interpolate::InterpolateJitExecutor::NNCGathered(const uint8_t *in_ptr_, ui
         } else {  // for blk
             int blk_size = mayiuse(cpu::x64::avx512_core) ? 16 : 8;
             int CB = div_up(C, blk_size);
-            const uint8_t *in_ptr = in_ptr_ + (IW * IH * ID * CB * blk_size * b) * srcDataSize;
-            uint8_t *out_ptr = out_ptr_ + (OW * OH * OD * CB * blk_size * b) * dstDataSize;
+            const uint8_t* in_ptr = in_ptr_ + (IW * IH * ID * CB * blk_size * b) * srcDataSize;
+            uint8_t* out_ptr = out_ptr_ + (OW * OH * OD * CB * blk_size * b) * dstDataSize;
             std::vector<int> index_w_kernel(OW);
             for (int ox = 0; ox < OW; ox++) {
                 index_w_kernel[ox] = index_w[ox] * blk_size * srcDataSize;
             }
             parallel_for2d(CB, OD, [&](size_t cb, size_t d) {
-                uint8_t *out_ptr_cbd = out_ptr + (blk_size * OW * OH * OD * cb + blk_size * OW * OH * d) * dstDataSize;
-                const uint8_t *in_ptr_cbd = in_ptr + (blk_size * IW * IH * ID * cb + blk_size * IW * IH * index_d[d]) * srcDataSize;
+                uint8_t* out_ptr_cbd = out_ptr + (blk_size * OW * OH * OD * cb + blk_size * OW * OH * d) * dstDataSize;
+                const uint8_t* in_ptr_cbd =
+                    in_ptr + (blk_size * IW * IH * ID * cb + blk_size * IW * IH * index_d[d]) * srcDataSize;
                 auto arg = jit_interpolate_call_args();
                 for (int h = 0; h < OH; h++) {  // kernel for blk_size * OW
                     arg.dst = out_ptr_cbd + blk_size * OW * h * dstDataSize;
@@ -2605,11 +2746,20 @@ void Interpolate::InterpolateJitExecutor::NNCGathered(const uint8_t *in_ptr_, ui
     }  // batch end
 }
 
-void Interpolate::InterpolateJitExecutor::NNPlanar(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_,
-                                                             int B, int C, int ID, int IH, int IW, int OD, int OH, int OW) {
-    int *index_d = static_cast<int*>(&auxTable[0]);
-    int *index_h = static_cast<int*>(&auxTable[OD]);
-    int *index_w = static_cast<int*>(&auxTable[OD + OH]);
+void Interpolate::InterpolateJitExecutor::NNPlanar(const uint8_t* in_ptr_,
+                                                   uint8_t* out_ptr_,
+                                                   const void* post_ops_data_,
+                                                   int B,
+                                                   int C,
+                                                   int ID,
+                                                   int IH,
+                                                   int IW,
+                                                   int OD,
+                                                   int OH,
+                                                   int OW) {
+    int* index_d = static_cast<int*>(&auxTable[0]);
+    int* index_h = static_cast<int*>(&auxTable[OD]);
+    int* index_w = static_cast<int*>(&auxTable[OD + OH]);
 
     std::vector<int> index_kernel(OH + OW);
     // index_h * IW * srcDataSize to reduce and simplify redundant compute
@@ -2622,13 +2772,15 @@ void Interpolate::InterpolateJitExecutor::NNPlanar(const uint8_t *in_ptr_, uint8
     }
 
     parallel_for3d(B, C, OD, [&](size_t b, size_t c, size_t od) {
-        const uint8_t *in_ptr = in_ptr_ + (IW * IH * ID * C * b + IW * IH * ID * c + IW * IH * index_d[od]) * srcDataSize;
-        uint8_t *out_ptr = out_ptr_ + (OW * OH * OD * C * b + OW * OH * OD * c + OW * OH * od) * dstDataSize;
+        const uint8_t* in_ptr =
+            in_ptr_ + (IW * IH * ID * C * b + IW * IH * ID * c + IW * IH * index_d[od]) * srcDataSize;
+        uint8_t* out_ptr = out_ptr_ + (OW * OH * OD * C * b + OW * OH * OD * c + OW * OH * od) * dstDataSize;
 
         auto arg = jit_interpolate_call_args();
         arg.src_ptr[0] = in_ptr;
         arg.dst = out_ptr;
-        arg.index = static_cast<int*>(&index_kernel[0]);  // need index_h and index_w in kernel, it's in continous memory so one param
+        arg.index = static_cast<int*>(
+            &index_kernel[0]);  // need index_h and index_w in kernel, it's in continous memory so one param
         arg.oc_off = static_cast<size_t>(c * sizeof(float));
         // work_amount is OH(out loop) and OW(inner loop), can get in kernel from jcp.
         arg.post_op_data = post_ops_data_;
@@ -2636,18 +2788,27 @@ void Interpolate::InterpolateJitExecutor::NNPlanar(const uint8_t *in_ptr_, uint8
     });
 }
 
-void Interpolate::InterpolateJitExecutor::linearOnnxPlanar(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_, int B, int C,
-                                                                     int ID, int IH, int IW, int OD, int OH, int OW) {
-    // FrontTopLeft:0, FrontTopRight:1, FrontBottomLeft:2, FrontBottomRight:3, EndTopLeft:4,   EndTopRight:5,   EndBottomLeft:6,   EndBottomRight:7
-    // weight: Left:0, ritht:1, top:2, bottom:3, front:4, end:5
-    int *index = static_cast<int*>(&auxTable[0]);
+void Interpolate::InterpolateJitExecutor::linearOnnxPlanar(const uint8_t* in_ptr_,
+                                                           uint8_t* out_ptr_,
+                                                           const void* post_ops_data_,
+                                                           int B,
+                                                           int C,
+                                                           int ID,
+                                                           int IH,
+                                                           int IW,
+                                                           int OD,
+                                                           int OH,
+                                                           int OW) {
+    // FrontTopLeft:0, FrontTopRight:1, FrontBottomLeft:2, FrontBottomRight:3, EndTopLeft:4,   EndTopRight:5,
+    // EndBottomLeft:6,   EndBottomRight:7 weight: Left:0, ritht:1, top:2, bottom:3, front:4, end:5
+    int* index = static_cast<int*>(&auxTable[0]);
     int eltInGrid = (spatialDimSize > 2) ? MAX_INPUT_INTERPOLATE : ((spatialDimSize > 1) ? 4 : 2);
     int scratchLen = rnd_up(eltInGrid * OW * OH * OD, 16);
-    float *weight = reinterpret_cast<float*>(&auxTable[scratchLen]);
+    float* weight = reinterpret_cast<float*>(&auxTable[scratchLen]);
 
     parallel_for2d(B, C, [&](size_t b, size_t c) {
-        uint8_t *out_ptr_nc = out_ptr_ + (OH * OW * OD * C * b + OH * OW * OD * c) * dstDataSize;
-        const uint8_t *in_ptr_nc = in_ptr_ + (IH * IW * ID * C * b + IH * IW * ID * c) * srcDataSize;
+        uint8_t* out_ptr_nc = out_ptr_ + (OH * OW * OD * C * b + OH * OW * OD * c) * dstDataSize;
+        const uint8_t* in_ptr_nc = in_ptr_ + (IH * IW * ID * C * b + IH * IW * ID * c) * srcDataSize;
         auto arg = jit_interpolate_call_args();
         arg.src_ptr[0] = in_ptr_nc;
         arg.index = static_cast<int*>(&index[0]);
@@ -2660,8 +2821,17 @@ void Interpolate::InterpolateJitExecutor::linearOnnxPlanar(const uint8_t *in_ptr
     });
 }
 
-void Interpolate::InterpolateJitExecutor::linearOnnxCGathered(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_,
-                                                                        int B, int C, int ID, int IH, int IW, int OD, int OH, int OW) {
+void Interpolate::InterpolateJitExecutor::linearOnnxCGathered(const uint8_t* in_ptr_,
+                                                              uint8_t* out_ptr_,
+                                                              const void* post_ops_data_,
+                                                              int B,
+                                                              int C,
+                                                              int ID,
+                                                              int IH,
+                                                              int IW,
+                                                              int OD,
+                                                              int OH,
+                                                              int OW) {
     // left:OW right:OW Top:OH Bottom:OH Front:OD End:OD
     std::vector<int*> indexPtr(MAX_INPUT_INTERPOLATE, 0);
     std::vector<float*> weightPtr(MAX_INPUT_INTERPOLATE, 0);
@@ -2696,18 +2866,18 @@ void Interpolate::InterpolateJitExecutor::linearOnnxCGathered(const uint8_t *in_
     int I2 = ID * I1;
     int I3 = CB * I2;
     parallel_for3d(B, OD, OH, [&](size_t b, size_t d, size_t h) {
-        uint8_t *out_ptr_ndh = out_ptr_ + (C3 * b + C1 * d + C0 * h) * dstDataSize;
-
-        const uint8_t *in_ptr_n = in_ptr_ + (I3 * b) * srcDataSize;
-        const uint8_t *in_ptr_nf = in_ptr_n + (indexPtr[4][d] * I1) * srcDataSize;
-        const uint8_t *in_ptr_nft = in_ptr_nf + (indexPtr[2][h] * I0) * srcDataSize;
-        const uint8_t *in_ptr_nfb = in_ptr_nf + (indexPtr[3][h] * I0) * srcDataSize;
-        const uint8_t *in_ptr_ne = in_ptr_n + (indexPtr[5][d] * I1) * srcDataSize;
-        const uint8_t *in_ptr_net = in_ptr_ne + (indexPtr[2][h] * I0) * srcDataSize;
-        const uint8_t *in_ptr_neb = in_ptr_ne + (indexPtr[3][h] * I0) * srcDataSize;
+        uint8_t* out_ptr_ndh = out_ptr_ + (C3 * b + C1 * d + C0 * h) * dstDataSize;
+
+        const uint8_t* in_ptr_n = in_ptr_ + (I3 * b) * srcDataSize;
+        const uint8_t* in_ptr_nf = in_ptr_n + (indexPtr[4][d] * I1) * srcDataSize;
+        const uint8_t* in_ptr_nft = in_ptr_nf + (indexPtr[2][h] * I0) * srcDataSize;
+        const uint8_t* in_ptr_nfb = in_ptr_nf + (indexPtr[3][h] * I0) * srcDataSize;
+        const uint8_t* in_ptr_ne = in_ptr_n + (indexPtr[5][d] * I1) * srcDataSize;
+        const uint8_t* in_ptr_net = in_ptr_ne + (indexPtr[2][h] * I0) * srcDataSize;
+        const uint8_t* in_ptr_neb = in_ptr_ne + (indexPtr[3][h] * I0) * srcDataSize;
         auto arg = jit_interpolate_call_args();
         for (int w = 0; w < OW; ++w) {
-            uint8_t *out_ptr_ndhw = out_ptr_ndh + CGatherLen * w * dstDataSize;
+            uint8_t* out_ptr_ndhw = out_ptr_ndh + CGatherLen * w * dstDataSize;
 
             arg.src_ptr[0] = in_ptr_nft + (indexPtr[0][w] * CGatherLen) * srcDataSize;
             arg.src_ptr[1] = in_ptr_nft + (indexPtr[1][w] * CGatherLen) * srcDataSize;
@@ -2732,13 +2902,20 @@ void Interpolate::InterpolateJitExecutor::linearOnnxCGathered(const uint8_t *in_
     });
 }
 
-void Interpolate::InterpolateJitExecutor::cubicCGathered(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_,
-                                                                   int B, int C, int IH, int IW, int OH, int OW) {
+void Interpolate::InterpolateJitExecutor::cubicCGathered(const uint8_t* in_ptr_,
+                                                         uint8_t* out_ptr_,
+                                                         const void* post_ops_data_,
+                                                         int B,
+                                                         int C,
+                                                         int IH,
+                                                         int IW,
+                                                         int OH,
+                                                         int OW) {
     const int idxNum = 1;
-    int *xOrigin = static_cast<int*>(&auxTable[0]);
-    float *xFactor = reinterpret_cast<float*>(&auxTable[OW]);
-    int *yOrigin = static_cast<int*>(&auxTable[(CUBIC_GRID_LEN + idxNum) * OW]);
-    float *yFactor = reinterpret_cast<float*>(&auxTable[(CUBIC_GRID_LEN + idxNum) * OW + OH]);
+    int* xOrigin = static_cast<int*>(&auxTable[0]);
+    float* xFactor = reinterpret_cast<float*>(&auxTable[OW]);
+    int* yOrigin = static_cast<int*>(&auxTable[(CUBIC_GRID_LEN + idxNum) * OW]);
+    float* yFactor = reinterpret_cast<float*>(&auxTable[(CUBIC_GRID_LEN + idxNum) * OW + OH]);
 
     int blkSize = mayiuse(cpu::x64::avx512_core) ? 16 : 8;
     int CB = div_up(C, blkSize);
@@ -2747,8 +2924,8 @@ void Interpolate::InterpolateJitExecutor::cubicCGathered(const uint8_t *in_ptr_,
     int workAmount = configured_for_layout == InterpolateLayoutType::by_channel ? C : CB;
 
     parallel_for3d(B, OH, OW, [&](size_t b, size_t h, size_t w) {
-        uint8_t *out_ptr_nhw = out_ptr_ + (OH * OW * CSize * b + OW * CGatherLen * h + CGatherLen * w) * dstDataSize;
-        const uint8_t *in_ptr_n = in_ptr_ + (IH * IW * CSize * b) * srcDataSize;
+        uint8_t* out_ptr_nhw = out_ptr_ + (OH * OW * CSize * b + OW * CGatherLen * h + CGatherLen * w) * dstDataSize;
+        const uint8_t* in_ptr_n = in_ptr_ + (IH * IW * CSize * b) * srcDataSize;
 
         std::vector<int> kernelIndex(CUBIC_GRID_LEN * CUBIC_GRID_LEN);  // 16 address offset to src(batch) or src(CB)
         int iy = yOrigin[h];
@@ -2763,41 +2940,48 @@ void Interpolate::InterpolateJitExecutor::cubicCGathered(const uint8_t *in_ptr_,
             }
         }
         auto arg = jit_interpolate_call_args();
-            arg.dst = out_ptr_nhw;
-            arg.src_ptr[0] = in_ptr_n;
-            arg.index = static_cast<int*>(&kernelIndex[0]);
-            // 0 for weight_W, 1 for weight_H
-            arg.weight_ptr[0] = static_cast<float*>(&xFactor[w * CUBIC_GRID_LEN]);
-            arg.weight_ptr[1] = static_cast<float*>(&yFactor[h * CUBIC_GRID_LEN]);
-
-            // for by channel, src + step, dst + step, process next step on continuous memory
-            // for blk, src + IW*IH*blkSize, dst + OW*OH*blkSize, process the blkSize on next CB
-            arg.work_amount = workAmount;
-            arg.oc_off = 0;
-            arg.post_op_data = post_ops_data_;
-            (*interpolateKernel)(&arg);
+        arg.dst = out_ptr_nhw;
+        arg.src_ptr[0] = in_ptr_n;
+        arg.index = static_cast<int*>(&kernelIndex[0]);
+        // 0 for weight_W, 1 for weight_H
+        arg.weight_ptr[0] = static_cast<float*>(&xFactor[w * CUBIC_GRID_LEN]);
+        arg.weight_ptr[1] = static_cast<float*>(&yFactor[h * CUBIC_GRID_LEN]);
+
+        // for by channel, src + step, dst + step, process next step on continuous memory
+        // for blk, src + IW*IH*blkSize, dst + OW*OH*blkSize, process the blkSize on next CB
+        arg.work_amount = workAmount;
+        arg.oc_off = 0;
+        arg.post_op_data = post_ops_data_;
+        (*interpolateKernel)(&arg);
     });
 }
 
-void Interpolate::InterpolateJitExecutor::cubicPlanar(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_,
-                                                                int B, int C, int IH, int IW, int OH, int OW) {
+void Interpolate::InterpolateJitExecutor::cubicPlanar(const uint8_t* in_ptr_,
+                                                      uint8_t* out_ptr_,
+                                                      const void* post_ops_data_,
+                                                      int B,
+                                                      int C,
+                                                      int IH,
+                                                      int IW,
+                                                      int OH,
+                                                      int OW) {
     int tblAdvance = 0;
-    int *xOrigin = static_cast<int*>(&auxTable[tblAdvance]);
+    int* xOrigin = static_cast<int*>(&auxTable[tblAdvance]);
     tblAdvance += OW;
-    float *xFactor = reinterpret_cast<float*>(&auxTable[tblAdvance]);
+    float* xFactor = reinterpret_cast<float*>(&auxTable[tblAdvance]);
     tblAdvance += CUBIC_GRID_LEN * OW;
-    int *yOrigin = static_cast<int*>(&auxTable[tblAdvance]);
+    int* yOrigin = static_cast<int*>(&auxTable[tblAdvance]);
     tblAdvance += OH;
-    float *yFactor = reinterpret_cast<float*>(&auxTable[tblAdvance]);
+    float* yFactor = reinterpret_cast<float*>(&auxTable[tblAdvance]);
 
     tblAdvance += CUBIC_GRID_LEN * OH;
-    int *sequenceOH = static_cast<int*>(&auxTable[tblAdvance]);
+    int* sequenceOH = static_cast<int*>(&auxTable[tblAdvance]);
     tblAdvance += OW * OH;
-    int *sequenceOW = static_cast<int*>(&auxTable[tblAdvance]);
+    int* sequenceOW = static_cast<int*>(&auxTable[tblAdvance]);
 
     parallel_for2d(B, C, [&](size_t n, size_t c) {
-        const uint8_t *in_ptr_nc = in_ptr_ + (IW * IH * C * n + IW * IH * c) * srcDataSize;
-        uint8_t *out_ptr_nc = out_ptr_ + (OW * OH * C * n + OW * OH * c) * dstDataSize;
+        const uint8_t* in_ptr_nc = in_ptr_ + (IW * IH * C * n + IW * IH * c) * srcDataSize;
+        uint8_t* out_ptr_nc = out_ptr_ + (OW * OH * C * n + OW * OH * c) * dstDataSize;
 
         auto arg = jit_interpolate_call_args();
         arg.dst = out_ptr_nc;
@@ -2815,8 +2999,15 @@ void Interpolate::InterpolateJitExecutor::cubicPlanar(const uint8_t *in_ptr_, ui
     });
 }
 
-void Interpolate::InterpolateJitExecutor::pillowCGathered(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_,
-                                                                        int B, int C, int IH, int IW, int OH, int OW) {
+void Interpolate::InterpolateJitExecutor::pillowCGathered(const uint8_t* in_ptr_,
+                                                          uint8_t* out_ptr_,
+                                                          const void* post_ops_data_,
+                                                          int B,
+                                                          int C,
+                                                          int IH,
+                                                          int IW,
+                                                          int OH,
+                                                          int OW) {
     // workBuffer needed when both pass are true
     bool xPass = IW != OW;
     bool yPass = IH != OH;
@@ -2848,8 +3039,11 @@ void Interpolate::InterpolateJitExecutor::pillowCGathered(const uint8_t *in_ptr_
 // =====================================================================================================================
 // index layout:
 // d_0............d_OD-1, h_0..............h_OH-1, w_0................w_OW-1
-void Interpolate::InterpolateExecutorBase::buildTblNN(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d,
-                                        const std::vector<float>& dataScales, InterpolateLayoutType layout, InterpolateNearestMode nearestMode) {
+void Interpolate::InterpolateExecutorBase::buildTblNN(const VectorDims& srcDimPad5d,
+                                                      const VectorDims& dstDim5d,
+                                                      const std::vector<float>& dataScales,
+                                                      InterpolateLayoutType layout,
+                                                      InterpolateNearestMode nearestMode) {
     const int dimSize = dataRank;
     float fz = (dimSize == 5) ? dataScales[dimSize - 3] : 1.f;
     float fy = dataScales[dimSize - 2];
@@ -2881,80 +3075,91 @@ void Interpolate::InterpolateExecutorBase::buildTblNN(const VectorDims& srcDimPa
 // scale is float(outShape) / float(inShape)
 // strictly consistent with onnx calc manner(div scale, not multiply inverse), given this is done offline
 // the slight precison diff can produce obvious wrong value due to "nearest round" behavior for NN mode
-float Interpolate::InterpolateExecutorBase::coordTransToInput(int outCoord, float scale, int inShape, int outShape) const {
+float Interpolate::InterpolateExecutorBase::coordTransToInput(int outCoord,
+                                                              float scale,
+                                                              int inShape,
+                                                              int outShape) const {
     if (scale == 1.0f || (inShape == outShape)) {
         return outCoord;
     }
     switch (coordTransMode) {
-        case InterpolateCoordTransMode::half_pixel: {
+    case InterpolateCoordTransMode::half_pixel: {
+        return (outCoord + 0.5f) / scale - 0.5f;
+        break;
+    }
+    case InterpolateCoordTransMode::pytorch_half_pixel: {
+        if (outShape > 1)
             return (outCoord + 0.5f) / scale - 0.5f;
-            break;
-        }
-        case InterpolateCoordTransMode::pytorch_half_pixel: {
-            if (outShape > 1)
-                return (outCoord + 0.5f) / scale - 0.5f;
-            else
-                return 0;
-            break;
-        }
-        case InterpolateCoordTransMode::asymmetric: {
-            return static_cast<float>(outCoord) / scale;
-            break;
-        }
-        case InterpolateCoordTransMode::tf_half_pixel_for_nn: {
-            return (outCoord + 0.5f) / scale;
-            break;
-        }
-        case InterpolateCoordTransMode::align_corners: {
-            if (outShape > 1)
-                return outCoord * (static_cast<float>(inShape - 1) / static_cast<float>(outShape - 1));
-            else
-                return 0;
-            break;
-        }
-        default: {
-            OPENVINO_THROW("errorPrefix", " does not support specified coordinate transformation mode");
-            break;
-        }
+        else
+            return 0;
+        break;
+    }
+    case InterpolateCoordTransMode::asymmetric: {
+        return static_cast<float>(outCoord) / scale;
+        break;
+    }
+    case InterpolateCoordTransMode::tf_half_pixel_for_nn: {
+        return (outCoord + 0.5f) / scale;
+        break;
+    }
+    case InterpolateCoordTransMode::align_corners: {
+        if (outShape > 1)
+            return outCoord * (static_cast<float>(inShape - 1) / static_cast<float>(outShape - 1));
+        else
+            return 0;
+        break;
+    }
+    default: {
+        OPENVINO_THROW("errorPrefix", " does not support specified coordinate transformation mode");
+        break;
+    }
     }
 }
 
-int Interpolate::InterpolateExecutorBase::nearestRound(float originCoord, bool isDownsample, InterpolateNearestMode nearestMode) const {
+int Interpolate::InterpolateExecutorBase::nearestRound(float originCoord,
+                                                       bool isDownsample,
+                                                       InterpolateNearestMode nearestMode) const {
     switch (nearestMode) {
-        case InterpolateNearestMode::round_prefer_floor: {
-            if (originCoord == (static_cast<int>(originCoord) + 0.5f))
-                return static_cast<int>(std::floor(originCoord));
-            else
-                return static_cast<int>(std::round(originCoord));
-            break;
-        }
-        case InterpolateNearestMode::round_prefer_ceil: {
-            return static_cast<int>(std::round(originCoord));
-            break;
-        }
-        case InterpolateNearestMode::floor: {
+    case InterpolateNearestMode::round_prefer_floor: {
+        if (originCoord == (static_cast<int>(originCoord) + 0.5f))
             return static_cast<int>(std::floor(originCoord));
-            break;
-        }
-        case InterpolateNearestMode::ceil: {
+        else
+            return static_cast<int>(std::round(originCoord));
+        break;
+    }
+    case InterpolateNearestMode::round_prefer_ceil: {
+        return static_cast<int>(std::round(originCoord));
+        break;
+    }
+    case InterpolateNearestMode::floor: {
+        return static_cast<int>(std::floor(originCoord));
+        break;
+    }
+    case InterpolateNearestMode::ceil: {
+        return static_cast<int>(std::ceil(originCoord));
+        break;
+    }
+    case InterpolateNearestMode::simple: {
+        if (isDownsample)
             return static_cast<int>(std::ceil(originCoord));
-            break;
-        }
-        case InterpolateNearestMode::simple: {
-            if (isDownsample)
-                return static_cast<int>(std::ceil(originCoord));
-            else
-                return static_cast<int>(originCoord);
-        }
-        default: {
-            OPENVINO_THROW("errorPrefix", " does not support specified nearest round mode");
-            break;
-        }
+        else
+            return static_cast<int>(originCoord);
+    }
+    default: {
+        OPENVINO_THROW("errorPrefix", " does not support specified nearest round mode");
+        break;
+    }
     }
 }
 
-void Interpolate::InterpolateExecutorBase::linearOnnxCF(int outCoord, float scale, int inShape, int outShape,
-                int& index0, int& index1, float& weight0, float& weight1) {
+void Interpolate::InterpolateExecutorBase::linearOnnxCF(int outCoord,
+                                                        float scale,
+                                                        int inShape,
+                                                        int outShape,
+                                                        int& index0,
+                                                        int& index1,
+                                                        float& weight0,
+                                                        float& weight1) {
     float inCoord = coordTransToInput(outCoord, scale, inShape, outShape);
     inCoord = std::max(0.0f, std::min(inCoord, static_cast<float>(inShape - 1)));
     index0 = std::min(static_cast<int>(inCoord), inShape - 1);
@@ -2968,8 +3173,10 @@ void Interpolate::InterpolateExecutorBase::linearOnnxCF(int outCoord, float scal
     }
 }
 
-void Interpolate::InterpolateExecutorBase::buildTblLinearOnnx(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d,
-                                                const std::vector<float>& dataScales, InterpolateLayoutType layout) {
+void Interpolate::InterpolateExecutorBase::buildTblLinearOnnx(const VectorDims& srcDimPad5d,
+                                                              const VectorDims& dstDim5d,
+                                                              const std::vector<float>& dataScales,
+                                                              InterpolateLayoutType layout) {
     int dimSize = dataRank;
     float fz = (spatialDimSize > 2) ? dataScales[dimSize - 3] : 1.f;
     float fy = (spatialDimSize > 1) ? dataScales[dimSize - 2] : 1.f;
@@ -3028,7 +3235,7 @@ void Interpolate::InterpolateExecutorBase::buildTblLinearOnnx(const VectorDims&
                     indexPtr[1][idxOzOyOx] = (izF * IH * IW + iyT * IW + ixR) * scale;
                     weightPtr[0][idxOzOyOx] = weightL;
                     weightPtr[1][idxOzOyOx] = weightR;
-                    if (spatialDimSize  > 1) {
+                    if (spatialDimSize > 1) {
                         indexPtr[2][idxOzOyOx] = (izF * IH * IW + iyB * IW + ixL) * scale;
                         indexPtr[3][idxOzOyOx] = (izF * IH * IW + iyB * IW + ixR) * scale;
                         weightPtr[2][idxOzOyOx] = weightT;
@@ -3081,8 +3288,11 @@ void Interpolate::InterpolateExecutorBase::buildTblLinearOnnx(const VectorDims&
 // wd .........wd, wh............wh, ww.............ww, id...........id, ih............ih, iw..............iw
 //                        |                                                      |
 //                   wh0.....wh_diameter                                    ih0.....ih_diameter
-void Interpolate::InterpolateExecutorBase::buildTblLinear(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d,
-                                            const std::vector<float>& dataScales, int kernel_width, bool antialias) {
+void Interpolate::InterpolateExecutorBase::buildTblLinear(const VectorDims& srcDimPad5d,
+                                                          const VectorDims& dstDim5d,
+                                                          const std::vector<float>& dataScales,
+                                                          int kernel_width,
+                                                          bool antialias) {
     int dimSize = dataRank;
     float fz = (dimSize == 5) ? dataScales[dimSize - 3] : 1.f;
     float fy = dataScales[dimSize - 2];
@@ -3106,15 +3316,15 @@ void Interpolate::InterpolateExecutorBase::buildTblLinear(const VectorDims& srcD
         int sizeOH = OH * diaOH;
         int sizeOW = OW * diaOW;
         auxTable.resize((sizeOD + sizeOH + sizeOW) * 2);
-        float *weightTable = reinterpret_cast<float*>(&auxTable[0]);
-        float *weightOD = static_cast<float*>(&weightTable[0]);
-        float *weightOH = static_cast<float*>(&weightTable[sizeOD]);
-        float *weightOW = static_cast<float*>(&weightTable[sizeOD + sizeOH]);
+        float* weightTable = reinterpret_cast<float*>(&auxTable[0]);
+        float* weightOD = static_cast<float*>(&weightTable[0]);
+        float* weightOH = static_cast<float*>(&weightTable[sizeOD]);
+        float* weightOW = static_cast<float*>(&weightTable[sizeOD + sizeOH]);
 
-        int *idxTable = static_cast<int*>(&auxTable[sizeOD + sizeOH + sizeOW]);
-        int *idxOD = static_cast<int*>(&idxTable[0]);
-        int *idxOH = static_cast<int*>(&idxTable[sizeOD]);
-        int *idxOW = static_cast<int*>(&idxTable[sizeOD + sizeOH]);
+        int* idxTable = static_cast<int*>(&auxTable[sizeOD + sizeOH + sizeOW]);
+        int* idxOD = static_cast<int*>(&idxTable[0]);
+        int* idxOH = static_cast<int*>(&idxTable[sizeOD]);
+        int* idxOW = static_cast<int*>(&idxTable[sizeOD + sizeOH]);
 
         for (size_t oz = 0; oz < OD; oz++) {
             float iz = coordTransToInput(oz, fz, ID, OD);
@@ -3172,8 +3382,11 @@ std::vector<float> Interpolate::InterpolateExecutorBase::getCubicCoeffs(float ma
 // table layout:
 // OW      OW         OW         OW         OW          OH       OH           OH           OH           OH
 // x_idx   x_weight0  x_weight1  x_weight2  x_weight3   y_idx    y_weight0    y_weight1    y_weight2    y_weight3
-void Interpolate::InterpolateExecutorBase::buildTblCubic(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d, const std::vector<float>& dataScales,
-                                        float cubicCoeff, InterpolateLayoutType layout) {
+void Interpolate::InterpolateExecutorBase::buildTblCubic(const VectorDims& srcDimPad5d,
+                                                         const VectorDims& dstDim5d,
+                                                         const std::vector<float>& dataScales,
+                                                         float cubicCoeff,
+                                                         InterpolateLayoutType layout) {
     int dimSize = dataRank;
     float fy = dataScales[dimSize - 2];
     float fx = dataScales[dimSize - 1];
@@ -3191,9 +3404,9 @@ void Interpolate::InterpolateExecutorBase::buildTblCubic(const VectorDims& srcDi
     }
 
     int tblAdvance = 0;
-    int *xOrigin = static_cast<int*>(&auxTable[tblAdvance]);
+    int* xOrigin = static_cast<int*>(&auxTable[tblAdvance]);
     tblAdvance += OW;
-    float *xFactor = reinterpret_cast<float*>(&auxTable[tblAdvance]);
+    float* xFactor = reinterpret_cast<float*>(&auxTable[tblAdvance]);
     for (int ox = 0; ox < OW; ox++) {
         float ix = coordTransToInput(ox, fx, IW, OW);
         int ix_r = static_cast<int>(std::floor(ix));
@@ -3207,9 +3420,9 @@ void Interpolate::InterpolateExecutorBase::buildTblCubic(const VectorDims& srcDi
     }
 
     tblAdvance += CUBIC_GRID_LEN * OW;
-    int *yOrigin = static_cast<int*>(&auxTable[tblAdvance]);
+    int* yOrigin = static_cast<int*>(&auxTable[tblAdvance]);
     tblAdvance += OH;
-    float *yFactor = reinterpret_cast<float*>(&auxTable[tblAdvance]);
+    float* yFactor = reinterpret_cast<float*>(&auxTable[tblAdvance]);
     for (int oy = 0; oy < OH; oy++) {
         float iy = coordTransToInput(oy, fy, IH, OH);
         int iy_r = static_cast<int>(std::floor(iy));
@@ -3224,9 +3437,9 @@ void Interpolate::InterpolateExecutorBase::buildTblCubic(const VectorDims& srcDi
 
     if (layout == InterpolateLayoutType::planar) {
         tblAdvance += CUBIC_GRID_LEN * OH;
-        int *sequenceOH = static_cast<int*>(&auxTable[tblAdvance]);
+        int* sequenceOH = static_cast<int*>(&auxTable[tblAdvance]);
         tblAdvance += OH * OW;
-        int *sequenceOW = static_cast<int*>(&auxTable[tblAdvance]);
+        int* sequenceOW = static_cast<int*>(&auxTable[tblAdvance]);
         for (int h = 0; h < OH; ++h) {
             int offset = h * OW;
             for (int w = 0; w < OW; ++w) {
@@ -3256,8 +3469,11 @@ float Interpolate::InterpolateExecutorBase::getPillowBicubicCoeffs(float m) {
     return 0.0f;
 }
 
-void Interpolate::InterpolateExecutorBase::buildTblPillow(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d, const std::vector<float>& dataScales,
-                                        float cubicCoeff, InterpolateLayoutType layout) {
+void Interpolate::InterpolateExecutorBase::buildTblPillow(const VectorDims& srcDimPad5d,
+                                                          const VectorDims& dstDim5d,
+                                                          const std::vector<float>& dataScales,
+                                                          float cubicCoeff,
+                                                          InterpolateLayoutType layout) {
     int dimSize = dataRank;
     float fy = dataScales[dimSize - 2];
     float fx = dataScales[dimSize - 1];
@@ -3272,15 +3488,15 @@ void Interpolate::InterpolateExecutorBase::buildTblPillow(const VectorDims& srcD
     };
 
     // pillowScale: e.g. 2.0 means down sample 2 times
-    auto generateArgs = [&] (float pillowScale) -> filterArgs {
+    auto generateArgs = [&](float pillowScale) -> filterArgs {
         filterArgs args;
         float scaleClip = pillowScale < 1.0f ? 1.0f : pillowScale;
         args.ScaleClipReciprocal = 1.0f / scaleClip;
-        args.filterRadius = (mode == InterpolateMode::bilinear_pillow) ? PILLOW_BILINEAR_WINDOW_SCALE * scaleClip :
-                                                                       PILLOW_BICUBIC_WINDOW_SCALE * scaleClip;
+        args.filterRadius = (mode == InterpolateMode::bilinear_pillow) ? PILLOW_BILINEAR_WINDOW_SCALE * scaleClip
+                                                                       : PILLOW_BICUBIC_WINDOW_SCALE * scaleClip;
         args.filterLen = static_cast<int>(std::ceil(args.filterRadius) * 2 + 1);
-        args.weightGen = (mode == InterpolateMode::bilinear_pillow) ? this->getPillowBilinearCoeffs:
-                                                                       this->getPillowBicubicCoeffs;
+        args.weightGen =
+            (mode == InterpolateMode::bilinear_pillow) ? this->getPillowBilinearCoeffs : this->getPillowBicubicCoeffs;
         return args;
     };
 
@@ -3295,15 +3511,15 @@ void Interpolate::InterpolateExecutorBase::buildTblPillow(const VectorDims& srcD
     auxTable[offset] = filterArgsX.filterLen;
     auxTable[offset + 1] = filterArgsY.filterLen;
     offset += 2;
-    float *weightX = reinterpret_cast<float*>(&auxTable[offset]);
+    float* weightX = reinterpret_cast<float*>(&auxTable[offset]);
     offset += filterArgsX.filterLen * OW;
-    float *weightY = reinterpret_cast<float*>(&auxTable[offset]);
+    float* weightY = reinterpret_cast<float*>(&auxTable[offset]);
     offset += filterArgsY.filterLen * OH;
-    int *indexX = static_cast<int*>(&auxTable[offset]);
+    int* indexX = static_cast<int*>(&auxTable[offset]);
     offset += 2 * OW;
-    int *indexY = static_cast<int*>(&auxTable[offset]);
+    int* indexY = static_cast<int*>(&auxTable[offset]);
 
-    auto generateTbl = [&] (int inLen, int outLen, float fScale, filterArgs args, float* weightTbl, int* idxTbl) {
+    auto generateTbl = [&](int inLen, int outLen, float fScale, filterArgs args, float* weightTbl, int* idxTbl) {
         int min = 0;
         int max = 0;
         for (int ox = 0; ox < outLen; ox++) {
@@ -3347,21 +3563,29 @@ void Interpolate::InterpolateExecutorBase::buildTblPillow(const VectorDims& srcD
     generateTbl(IH, OH, fy, filterArgsY, weightY, indexY);
 }
 
-void Interpolate::InterpolateRefExecutor::NNRef(const uint8_t *in_ptr_, uint8_t *out_ptr_, int B, int C, int ID, int IH, int IW,
-                                                          int OD, int OH, int OW) {
-    int *index_d = static_cast<int*>(&auxTable[0]);
-    int *index_h = static_cast<int*>(&auxTable[OD]);
-    int *index_w = static_cast<int*>(&auxTable[OD + OH]);
-
-    const float *in_ptr_f32 = reinterpret_cast<const float *>(in_ptr_);
-    float *out_ptr_f32 = reinterpret_cast<float *>(out_ptr_);
+void Interpolate::InterpolateRefExecutor::NNRef(const uint8_t* in_ptr_,
+                                                uint8_t* out_ptr_,
+                                                int B,
+                                                int C,
+                                                int ID,
+                                                int IH,
+                                                int IW,
+                                                int OD,
+                                                int OH,
+                                                int OW) {
+    int* index_d = static_cast<int*>(&auxTable[0]);
+    int* index_h = static_cast<int*>(&auxTable[OD]);
+    int* index_w = static_cast<int*>(&auxTable[OD + OH]);
+
+    const float* in_ptr_f32 = reinterpret_cast<const float*>(in_ptr_);
+    float* out_ptr_f32 = reinterpret_cast<float*>(out_ptr_);
 
     parallel_for3d(B, C, OD, [&](size_t b, size_t c, size_t od) {
-        const float *in_ptr = in_ptr_f32 + (IW * IH * ID * C * b + IW * IH * ID * c + IW * IH * index_d[od]);
-        float *out_ptr = out_ptr_f32 + (OW * OH * OD * C * b + OW * OH * OD * c + OW * OH * od);
+        const float* in_ptr = in_ptr_f32 + (IW * IH * ID * C * b + IW * IH * ID * c + IW * IH * index_d[od]);
+        float* out_ptr = out_ptr_f32 + (OW * OH * OD * C * b + OW * OH * OD * c + OW * OH * od);
         for (int oh = 0; oh < OH; oh++) {
-            const float *in_ptr_h = in_ptr + (IW * index_h[oh]);
-            float *out_ptr_h = out_ptr + (OW * oh);
+            const float* in_ptr_h = in_ptr + (IW * index_h[oh]);
+            float* out_ptr_h = out_ptr + (OW * oh);
             for (int ow = 0; ow < OW; ow++) {
                 out_ptr_h[ow] = in_ptr_h[index_w[ow]];
             }
@@ -3369,8 +3593,16 @@ void Interpolate::InterpolateRefExecutor::NNRef(const uint8_t *in_ptr_, uint8_t
     });
 }
 
-void Interpolate::InterpolateRefExecutor::linearOnnxRef(const uint8_t *in_ptr_, uint8_t *out_ptr_, int B, int C, int ID, int IH, int IW,
-                                                                  int OD, int OH, int OW) {
+void Interpolate::InterpolateRefExecutor::linearOnnxRef(const uint8_t* in_ptr_,
+                                                        uint8_t* out_ptr_,
+                                                        int B,
+                                                        int C,
+                                                        int ID,
+                                                        int IH,
+                                                        int IW,
+                                                        int OD,
+                                                        int OH,
+                                                        int OW) {
     std::vector<int*> indexPtr(MAX_INPUT_INTERPOLATE, 0);
     std::vector<float*> weightPtr(MAX_INPUT_INTERPOLATE, 0);
     // FrontTopLeft:0, FrontTopRight:1, FrontBottomLeft:2, FrontBottomRight:3,
@@ -3399,87 +3631,87 @@ void Interpolate::InterpolateRefExecutor::linearOnnxRef(const uint8_t *in_ptr_,
         weightPtr[5] = reinterpret_cast<float*>(&auxTable[scratchLen + 5 * OW * OH * OD]);
     }
 
-    const float *in_ptr_f32 = reinterpret_cast<const float *>(in_ptr_);
-    float *out_ptr_f32 = reinterpret_cast<float *>(out_ptr_);
+    const float* in_ptr_f32 = reinterpret_cast<const float*>(in_ptr_);
+    float* out_ptr_f32 = reinterpret_cast<float*>(out_ptr_);
 
     parallel_for2d(B, C, [&](size_t b, size_t c) {
-        float *out_ptr_nc = out_ptr_f32 + (OD * OH * OW * C * b + OD * OH * OW * c);
-        const float *in_ptr_nc = in_ptr_f32 + (ID * IH * IW * C * b + ID * IH * IW * c);
+        float* out_ptr_nc = out_ptr_f32 + (OD * OH * OW * C * b + OD * OH * OW * c);
+        const float* in_ptr_nc = in_ptr_f32 + (ID * IH * IW * C * b + ID * IH * IW * c);
         // do not combined 1d/2d to 3d unified process to get rid of invalid computing.
         switch (spatialDimSize) {
-            case 1:
-                for (int i = 0; i < OW; i++) {
-                    float src0 = in_ptr_nc[indexPtr[0][i]];
-                    float src1 = in_ptr_nc[indexPtr[1][i]];
+        case 1:
+            for (int i = 0; i < OW; i++) {
+                float src0 = in_ptr_nc[indexPtr[0][i]];
+                float src1 = in_ptr_nc[indexPtr[1][i]];
 
-                    out_ptr_nc[i] = src0 * weightPtr[0][i] +
-                                    src1 * weightPtr[1][i];
-                }
-                break;
-            case 2:
-                for (int i = 0; i < OH * OW; i++) {
-                    float src00 = in_ptr_nc[indexPtr[0][i]];
-                    float src01 = in_ptr_nc[indexPtr[1][i]];
-                    float src10 = in_ptr_nc[indexPtr[2][i]];
-                    float src11 = in_ptr_nc[indexPtr[3][i]];
-
-                    out_ptr_nc[i] = src00 * weightPtr[2][i] * weightPtr[0][i] +
-                                    src01 * weightPtr[2][i] * weightPtr[1][i] +
-                                    src10 * weightPtr[3][i] * weightPtr[0][i] +
-                                    src11 * weightPtr[3][i] * weightPtr[1][i];
-                }
-                break;
-            case 3:
-                for (int i = 0; i < OD * OH * OW; i++) {
-                    float src000 = in_ptr_nc[indexPtr[0][i]];
-                    float src001 = in_ptr_nc[indexPtr[1][i]];
-                    float src010 = in_ptr_nc[indexPtr[2][i]];
-                    float src011 = in_ptr_nc[indexPtr[3][i]];
-                    float src100 = in_ptr_nc[indexPtr[4][i]];
-                    float src101 = in_ptr_nc[indexPtr[5][i]];
-                    float src110 = in_ptr_nc[indexPtr[6][i]];
-                    float src111 = in_ptr_nc[indexPtr[7][i]];
-
-                    // float dstValue =
-                    // weightPtr[4][i] * weightPtr[2][i] * weightPtr[0][i] * src000 +
-                    // weightPtr[4][i] * weightPtr[2][i] * weightPtr[1][i] * src001 +
-                    // weightPtr[4][i] * weightPtr[3][i] * weightPtr[0][i] * src010 +
-                    // weightPtr[4][i] * weightPtr[3][i] * weightPtr[1][i] * src011 +
-                    // weightPtr[5][i] * weightPtr[2][i] * weightPtr[0][i] * src100 +
-                    // weightPtr[5][i] * weightPtr[2][i] * weightPtr[1][i] * src101 +
-                    // weightPtr[5][i] * weightPtr[3][i] * weightPtr[0][i] * src110 +
-                    // weightPtr[5][i] * weightPtr[3][i] * weightPtr[1][i] * src111;
-
-                    out_ptr_nc[i] =
-                    weightPtr[4][i] * (weightPtr[2][i] * (weightPtr[0][i] * src000 +
-                                                          weightPtr[1][i] * src001) +
-                                       weightPtr[3][i] * (weightPtr[0][i] * src010 +
-                                                          weightPtr[1][i] * src011)) +
-                    weightPtr[5][i] * (weightPtr[2][i] * (weightPtr[0][i] * src100 +
-                                                          weightPtr[1][i] * src101) +
-                                       weightPtr[3][i] * (weightPtr[0][i] * src110 +
-                                                          weightPtr[1][i] * src111));
-                }
-                break;
-            default:
-                break;
+                out_ptr_nc[i] = src0 * weightPtr[0][i] + src1 * weightPtr[1][i];
+            }
+            break;
+        case 2:
+            for (int i = 0; i < OH * OW; i++) {
+                float src00 = in_ptr_nc[indexPtr[0][i]];
+                float src01 = in_ptr_nc[indexPtr[1][i]];
+                float src10 = in_ptr_nc[indexPtr[2][i]];
+                float src11 = in_ptr_nc[indexPtr[3][i]];
+
+                out_ptr_nc[i] = src00 * weightPtr[2][i] * weightPtr[0][i] + src01 * weightPtr[2][i] * weightPtr[1][i] +
+                                src10 * weightPtr[3][i] * weightPtr[0][i] + src11 * weightPtr[3][i] * weightPtr[1][i];
+            }
+            break;
+        case 3:
+            for (int i = 0; i < OD * OH * OW; i++) {
+                float src000 = in_ptr_nc[indexPtr[0][i]];
+                float src001 = in_ptr_nc[indexPtr[1][i]];
+                float src010 = in_ptr_nc[indexPtr[2][i]];
+                float src011 = in_ptr_nc[indexPtr[3][i]];
+                float src100 = in_ptr_nc[indexPtr[4][i]];
+                float src101 = in_ptr_nc[indexPtr[5][i]];
+                float src110 = in_ptr_nc[indexPtr[6][i]];
+                float src111 = in_ptr_nc[indexPtr[7][i]];
+
+                // float dstValue =
+                // weightPtr[4][i] * weightPtr[2][i] * weightPtr[0][i] * src000 +
+                // weightPtr[4][i] * weightPtr[2][i] * weightPtr[1][i] * src001 +
+                // weightPtr[4][i] * weightPtr[3][i] * weightPtr[0][i] * src010 +
+                // weightPtr[4][i] * weightPtr[3][i] * weightPtr[1][i] * src011 +
+                // weightPtr[5][i] * weightPtr[2][i] * weightPtr[0][i] * src100 +
+                // weightPtr[5][i] * weightPtr[2][i] * weightPtr[1][i] * src101 +
+                // weightPtr[5][i] * weightPtr[3][i] * weightPtr[0][i] * src110 +
+                // weightPtr[5][i] * weightPtr[3][i] * weightPtr[1][i] * src111;
+
+                out_ptr_nc[i] =
+                    weightPtr[4][i] * (weightPtr[2][i] * (weightPtr[0][i] * src000 + weightPtr[1][i] * src001) +
+                                       weightPtr[3][i] * (weightPtr[0][i] * src010 + weightPtr[1][i] * src011)) +
+                    weightPtr[5][i] * (weightPtr[2][i] * (weightPtr[0][i] * src100 + weightPtr[1][i] * src101) +
+                                       weightPtr[3][i] * (weightPtr[0][i] * src110 + weightPtr[1][i] * src111));
+            }
+            break;
+        default:
+            break;
         }
     });
 }
 
-void Interpolate::InterpolateRefExecutor::cubicRef(const uint8_t *in_ptr_, uint8_t *out_ptr_, int B, int C, int IH, int IW, int OH, int OW) {
+void Interpolate::InterpolateRefExecutor::cubicRef(const uint8_t* in_ptr_,
+                                                   uint8_t* out_ptr_,
+                                                   int B,
+                                                   int C,
+                                                   int IH,
+                                                   int IW,
+                                                   int OH,
+                                                   int OW) {
     const int idxNum = 1;
-    int *xOrigin = static_cast<int*>(&auxTable[0]);
-    float *xFactor = reinterpret_cast<float*>(&auxTable[OW]);
-    int *yOrigin = static_cast<int*>(&auxTable[(CUBIC_GRID_LEN + idxNum) * OW]);
-    float *yFactor = reinterpret_cast<float*>(&auxTable[(CUBIC_GRID_LEN + idxNum) * OW + OH]);
+    int* xOrigin = static_cast<int*>(&auxTable[0]);
+    float* xFactor = reinterpret_cast<float*>(&auxTable[OW]);
+    int* yOrigin = static_cast<int*>(&auxTable[(CUBIC_GRID_LEN + idxNum) * OW]);
+    float* yFactor = reinterpret_cast<float*>(&auxTable[(CUBIC_GRID_LEN + idxNum) * OW + OH]);
 
-    const float *in_ptr_f32 = reinterpret_cast<const float *>(in_ptr_);
-    float *out_ptr_f32 = reinterpret_cast<float *>(out_ptr_);
+    const float* in_ptr_f32 = reinterpret_cast<const float*>(in_ptr_);
+    float* out_ptr_f32 = reinterpret_cast<float*>(out_ptr_);
 
     parallel_for4d(B, C, OH, OW, [&](size_t n, size_t c, size_t oy, size_t ox) {
-        const float *in_ptr_nc = in_ptr_f32 + (IW * IH * C * n + IW * IH * c);
-        float *out_ptr_nc = out_ptr_f32 + (OW * OH * C * n + OW * OH * c);
+        const float* in_ptr_nc = in_ptr_f32 + (IW * IH * C * n + IW * IH * c);
+        float* out_ptr_nc = out_ptr_f32 + (OW * OH * C * n + OW * OH * c);
 
         int iy = yOrigin[oy];
         int ix = xOrigin[ox];
@@ -3487,7 +3719,7 @@ void Interpolate::InterpolateRefExecutor::cubicRef(const uint8_t *in_ptr_, uint8
         float retY = 0.f;
         for (int y = iy - 1, i = 0; y <= iy + 2; y++, i++) {
             int yInRange = std::max(0, std::min(y, IH - 1));
-            const float *in_ptr_nch = in_ptr_nc + IW * yInRange;
+            const float* in_ptr_nch = in_ptr_nc + IW * yInRange;
             float retX = 0.f;
             for (int x = ix - 1, j = 0; x <= ix + 2; x++, j++) {
                 int xInRange = std::max(0, std::min(x, IW - 1));
@@ -3499,66 +3731,79 @@ void Interpolate::InterpolateRefExecutor::cubicRef(const uint8_t *in_ptr_, uint8
     });
 }
 
-float Interpolate::InterpolateRefExecutor::getValue(const uint8_t *base, size_t offset, ov::element::Type prec) {
-    const uint8_t *baseOffset = base + offset;
+float Interpolate::InterpolateRefExecutor::getValue(const uint8_t* base, size_t offset, ov::element::Type prec) {
+    const uint8_t* baseOffset = base + offset;
     switch (prec) {
-        case ov::element::u8: {
-            return static_cast<float>(*baseOffset);
-            break;
-        }
-        case ov::element::i8: {
-            const int8_t *valuePtr = reinterpret_cast<const int8_t *>(baseOffset);
-            return static_cast<float>(*valuePtr);
-            break;
-        }
-        case ov::element::bf16: {
-            const uint16_t *valuePtr = reinterpret_cast<const uint16_t *>(baseOffset);
-            return bfloat16_t::from_bits(*valuePtr);
-            break;
-        }
-        case ov::element::f32: {
-            const float *valuePtr = reinterpret_cast<const float *>(baseOffset);
-            return *valuePtr;
-            break;
-        }
-        default: {
-            OPENVINO_THROW("Interpolate layer does not support precision: ", prec);
-            break;
-        }
+    case ov::element::u8: {
+        return static_cast<float>(*baseOffset);
+        break;
+    }
+    case ov::element::i8: {
+        const int8_t* valuePtr = reinterpret_cast<const int8_t*>(baseOffset);
+        return static_cast<float>(*valuePtr);
+        break;
+    }
+    case ov::element::bf16: {
+        const uint16_t* valuePtr = reinterpret_cast<const uint16_t*>(baseOffset);
+        return bfloat16_t::from_bits(*valuePtr);
+        break;
+    }
+    case ov::element::f32: {
+        const float* valuePtr = reinterpret_cast<const float*>(baseOffset);
+        return *valuePtr;
+        break;
+    }
+    default: {
+        OPENVINO_THROW("Interpolate layer does not support precision: ", prec);
+        break;
+    }
     }
 }
 
-void Interpolate::InterpolateRefExecutor::setValue(uint8_t *base, size_t offset, float value, ov::element::Type prec) {
-    uint8_t *baseOffset = base + offset;
+void Interpolate::InterpolateRefExecutor::setValue(uint8_t* base, size_t offset, float value, ov::element::Type prec) {
+    uint8_t* baseOffset = base + offset;
     switch (prec) {
-        case ov::element::u8: {
-            uint8_t data = static_cast<uint8_t>(value < 0 ? 0 : value);
-            cpu_memcpy(baseOffset, &data, 1);
-            break;
-        }
-        case ov::element::i8: {
-            int8_t data = static_cast<int8_t>(value);
-            cpu_memcpy(baseOffset, &data, 1);
-            break;
-        }
-        case ov::element::bf16: {
-            uint16_t data = bfloat16_t(value).to_bits();
-            cpu_memcpy(baseOffset, &data, 2);
-            break;
-        }
-        case ov::element::f32: {
-            cpu_memcpy(baseOffset, &value, sizeof(float));
-            break;
-        }
-        default: {
-            OPENVINO_THROW("Interpolate layer does not support precision: ", prec);
-            break;
-        }
+    case ov::element::u8: {
+        uint8_t data = static_cast<uint8_t>(value < 0 ? 0 : value);
+        cpu_memcpy(baseOffset, &data, 1);
+        break;
+    }
+    case ov::element::i8: {
+        int8_t data = static_cast<int8_t>(value);
+        cpu_memcpy(baseOffset, &data, 1);
+        break;
+    }
+    case ov::element::bf16: {
+        uint16_t data = bfloat16_t(value).to_bits();
+        cpu_memcpy(baseOffset, &data, 2);
+        break;
+    }
+    case ov::element::f32: {
+        cpu_memcpy(baseOffset, &value, sizeof(float));
+        break;
+    }
+    default: {
+        OPENVINO_THROW("Interpolate layer does not support precision: ", prec);
+        break;
+    }
     }
 }
 
-void Interpolate::InterpolateRefExecutor::linearInterpolation(const uint8_t *in_ptr_, uint8_t *out_ptr_, int B, int C, int ID, int IH, int IW,
-                                          float fx, float fy, float fz, int OD, int OH, int OW, int kernel_width, bool antialias) {
+void Interpolate::InterpolateRefExecutor::linearInterpolation(const uint8_t* in_ptr_,
+                                                              uint8_t* out_ptr_,
+                                                              int B,
+                                                              int C,
+                                                              int ID,
+                                                              int IH,
+                                                              int IW,
+                                                              float fx,
+                                                              float fy,
+                                                              float fz,
+                                                              int OD,
+                                                              int OH,
+                                                              int OW,
+                                                              int kernel_width,
+                                                              bool antialias) {
     if (IW == OW && IH == OH && ID == OD) {
         size_t spatialDimSize = IW * IH * ID;
         // TODO: enable when fusing into interp with linear mode will support
@@ -3567,8 +3812,8 @@ void Interpolate::InterpolateRefExecutor::linearInterpolation(const uint8_t *in_
             cpu_memcpy(out_ptr_, in_ptr_, size);
         } else {
             parallel_for2d(B, C, [&](size_t b, size_t c) {
-                const uint8_t *in_ptr_nc = in_ptr_ + (spatialDimSize * C * b + spatialDimSize * c) * srcDataSize;
-                uint8_t *out_ptr_nc = out_ptr_ + (spatialDimSize * C * b + spatialDimSize * c) * dstDataSize;
+                const uint8_t* in_ptr_nc = in_ptr_ + (spatialDimSize * C * b + spatialDimSize * c) * srcDataSize;
+                uint8_t* out_ptr_nc = out_ptr_ + (spatialDimSize * C * b + spatialDimSize * c) * dstDataSize;
                 for (size_t i = 0; i < spatialDimSize; i++) {
                     float dstValue = getValue(in_ptr_nc, i * srcDataSize, inputPrec);
                     setValue(out_ptr_nc, i * dstDataSize, dstValue, outputPrec);
@@ -3593,23 +3838,23 @@ void Interpolate::InterpolateRefExecutor::linearInterpolation(const uint8_t *in_
     int sizeOH = OH * diaOH;
     int sizeOW = OW * diaOW;
 
-    float *weightTable = reinterpret_cast<float*>(&auxTable[0]);
-    float *weightOD = static_cast<float*>(&weightTable[0]);
-    float *weightOH = static_cast<float*>(&weightTable[sizeOD]);
-    float *weightOW = static_cast<float*>(&weightTable[sizeOD + sizeOH]);
+    float* weightTable = reinterpret_cast<float*>(&auxTable[0]);
+    float* weightOD = static_cast<float*>(&weightTable[0]);
+    float* weightOH = static_cast<float*>(&weightTable[sizeOD]);
+    float* weightOW = static_cast<float*>(&weightTable[sizeOD + sizeOH]);
 
-    int *idxTable = static_cast<int*>(&auxTable[sizeOD + sizeOH + sizeOW]);
-    int *idxOD = static_cast<int*>(&idxTable[0]);
-    int *idxOH = static_cast<int*>(&idxTable[sizeOD]);
-    int *idxOW = static_cast<int*>(&idxTable[sizeOD + sizeOH]);
+    int* idxTable = static_cast<int*>(&auxTable[sizeOD + sizeOH + sizeOW]);
+    int* idxOD = static_cast<int*>(&idxTable[0]);
+    int* idxOH = static_cast<int*>(&idxTable[sizeOD]);
+    int* idxOW = static_cast<int*>(&idxTable[sizeOD + sizeOH]);
 
     parallel_for2d(B, C, [&](size_t b, size_t c) {
-        const uint8_t *in_ptr_nc = in_ptr_ + (IW * IH * ID * C * b + IW * IH * ID * c) * srcDataSize;
-        uint8_t *out_ptr_nc = out_ptr_ + (OW * OH * OD * C * b + OW * OH * OD * c) * dstDataSize;
+        const uint8_t* in_ptr_nc = in_ptr_ + (IW * IH * ID * C * b + IW * IH * ID * c) * srcDataSize;
+        uint8_t* out_ptr_nc = out_ptr_ + (OW * OH * OD * C * b + OW * OH * OD * c) * dstDataSize;
         for (int oz = 0; oz < OD; oz++) {
-            uint8_t *out_ptr_ncd = out_ptr_nc + (OW * OH * oz) * dstDataSize;
+            uint8_t* out_ptr_ncd = out_ptr_nc + (OW * OH * oz) * dstDataSize;
             for (int oy = 0; oy < OH; oy++) {
-                uint8_t *out_ptr_ncdh = out_ptr_ncd + (OW * oy) * dstDataSize;
+                uint8_t* out_ptr_ncdh = out_ptr_ncd + (OW * oy) * dstDataSize;
                 for (int ox = 0; ox < OW; ox++) {
                     float sum = 0.f;
                     float wsum = 0.f;
@@ -3652,9 +3897,13 @@ void Interpolate::InterpolateRefExecutor::linearInterpolation(const uint8_t *in_
                                 if (weightOW[ox * diaOW + ix] == 0.f) {
                                     continue;
                                 }
-                                float w = weightOD[oz * diaOD + iz] * weightOH[oy * diaOH + iy] * weightOW[ox * diaOW + ix];
+                                float w =
+                                    weightOD[oz * diaOD + iz] * weightOH[oy * diaOH + iy] * weightOW[ox * diaOW + ix];
                                 float value = getValue(in_ptr_nc,
-                                    (idxOD[oz * diaOD + iz] * IH * IW + idxOH[oy * diaOH + iy] * IW + idxOW[ox * diaOW + ix]) * srcDataSize, inputPrec);
+                                                       (idxOD[oz * diaOD + iz] * IH * IW + idxOH[oy * diaOH + iy] * IW +
+                                                        idxOW[ox * diaOW + ix]) *
+                                                           srcDataSize,
+                                                       inputPrec);
 
                                 sum += w * value;
                                 wsum += w;
@@ -3674,18 +3923,25 @@ void Interpolate::InterpolateRefExecutor::linearInterpolation(const uint8_t *in_
     });
 }
 
-void Interpolate::InterpolateRefExecutor::pillowRef(const uint8_t *in_ptr_, uint8_t *out_ptr_, int B, int C, int IH, int IW, int OH, int OW) {
+void Interpolate::InterpolateRefExecutor::pillowRef(const uint8_t* in_ptr_,
+                                                    uint8_t* out_ptr_,
+                                                    int B,
+                                                    int C,
+                                                    int IH,
+                                                    int IW,
+                                                    int OH,
+                                                    int OW) {
     size_t offset = 0;
     int filterLenX = auxTable[offset];
     int filterLenY = auxTable[offset + 1];
     offset += 2;
-    float *weightX = reinterpret_cast<float*>(&auxTable[offset]);
+    float* weightX = reinterpret_cast<float*>(&auxTable[offset]);
     offset += filterLenX * OW;
-    float *weightY = reinterpret_cast<float*>(&auxTable[offset]);
+    float* weightY = reinterpret_cast<float*>(&auxTable[offset]);
     offset += filterLenY * OH;
-    int *indexX = static_cast<int*>(&auxTable[offset]);
+    int* indexX = static_cast<int*>(&auxTable[offset]);
     offset += 2 * OW;
-    int *indexY = static_cast<int*>(&auxTable[offset]);
+    int* indexY = static_cast<int*>(&auxTable[offset]);
 
     // workBuffer needed when both pass is true
     bool xPass = IW != OW;
@@ -3703,21 +3959,24 @@ void Interpolate::InterpolateRefExecutor::pillowRef(const uint8_t *in_ptr_, uint
     //             |  |
     //             ----
     auto bc_loop = [&](size_t b, size_t c) {
-        const uint8_t *in_ptr_nc = in_ptr_ + (IW * IH * C * b + IW * IH * c) * srcDataSize;
-        uint8_t *out_ptr_nc = out_ptr_ + (OW * OH * C * b + OW * OH * c) * dstDataSize;
-        uint8_t *xpass_out_ptr_nc = nullptr;
-        const uint8_t *ypass_in_ptr_nc = nullptr;
+        const uint8_t* in_ptr_nc = in_ptr_ + (IW * IH * C * b + IW * IH * c) * srcDataSize;
+        uint8_t* out_ptr_nc = out_ptr_ + (OW * OH * C * b + OW * OH * c) * dstDataSize;
+        uint8_t* xpass_out_ptr_nc = nullptr;
+        const uint8_t* ypass_in_ptr_nc = nullptr;
         if (xPass && yPass) {
             size_t parallel_num = B * C;
             // IH * OW buf needed
             if (parallel_num < m_threads_num) {
-                xpass_out_ptr_nc = static_cast<uint8_t*>(&pillow_working_buf[(OW * IH * C * b + OW * IH * c) * srcDataSize]);
-                ypass_in_ptr_nc = static_cast<const uint8_t*>(&pillow_working_buf[(OW * IH * C * b + OW * IH * c) * srcDataSize]);
+                xpass_out_ptr_nc =
+                    static_cast<uint8_t*>(&pillow_working_buf[(OW * IH * C * b + OW * IH * c) * srcDataSize]);
+                ypass_in_ptr_nc =
+                    static_cast<const uint8_t*>(&pillow_working_buf[(OW * IH * C * b + OW * IH * c) * srcDataSize]);
             } else {
                 size_t threadsIdx = parallel_get_thread_num();
                 size_t buffer_size = static_cast<size_t>(OW * IH);
                 xpass_out_ptr_nc = static_cast<uint8_t*>(&pillow_working_buf[threadsIdx * buffer_size * srcDataSize]);
-                ypass_in_ptr_nc = static_cast<const uint8_t*>(&pillow_working_buf[threadsIdx * buffer_size * srcDataSize]);
+                ypass_in_ptr_nc =
+                    static_cast<const uint8_t*>(&pillow_working_buf[threadsIdx * buffer_size * srcDataSize]);
             }
         } else if (xPass && !yPass) {
             xpass_out_ptr_nc = out_ptr_nc;
@@ -3775,14 +4034,14 @@ void Interpolate::InterpolateRefExecutor::pillowRef(const uint8_t *in_ptr_, uint
 void Interpolate::InterpolateExecutorBase::create_pillow_working_buf(InterpolateLayoutType layout) {
     if (srcDimPad5d[3] == dstDim5d[3] || srcDimPad5d[4] == dstDim5d[4])
         return;
-    size_t bufSize = srcDimPad5d[3] * dstDim5d[4] * srcDataSize; // IH * OW
+    size_t bufSize = srcDimPad5d[3] * dstDim5d[4] * srcDataSize;  // IH * OW
     m_threads_num = parallel_get_max_threads();
     if (layout == InterpolateLayoutType::planar) {
         // B and C execute in parallel, need separate buf
         size_t parallel_num = srcDimPad5d[0] * srcDimPad5d[1];
         bufSize *= std::min(m_threads_num, parallel_num);
     } else {
-        bufSize *= srcDimPad5d[1]; // *C
+        bufSize *= srcDimPad5d[1];  // *C
         // B execute in parallel, need separate buf
         size_t parallel_num = srcDimPad5d[0];
         bufSize *= std::min(m_threads_num, parallel_num);
@@ -3791,11 +4050,14 @@ void Interpolate::InterpolateExecutorBase::create_pillow_working_buf(Interpolate
 }
 
 Interpolate::InterpolateExecutorBase::InterpolateExecutorBase(const InterpolateAttrs& interpAttrs,
-                                                      const VectorDims &srcDims,
-                                                      const VectorDims &dstDims,
-                                                      const std::vector<float> &dataScales) :
-        mode(interpAttrs.mode), coordTransMode(interpAttrs.coordTransMode), configured_for_layout(interpAttrs.layout),
-        inputPrec(interpAttrs.inPrc), outputPrec(interpAttrs.outPrc) {
+                                                              const VectorDims& srcDims,
+                                                              const VectorDims& dstDims,
+                                                              const std::vector<float>& dataScales)
+    : mode(interpAttrs.mode),
+      coordTransMode(interpAttrs.coordTransMode),
+      configured_for_layout(interpAttrs.layout),
+      inputPrec(interpAttrs.inPrc),
+      outputPrec(interpAttrs.outPrc) {
     srcDimPad5d = to5Dim(getPaddedInputShape(srcDims, interpAttrs.padBegin, interpAttrs.padEnd));
     dstDim5d = to5Dim(dstDims);
     srcDataSize = interpAttrs.inPrc.size();
@@ -3804,44 +4066,44 @@ Interpolate::InterpolateExecutorBase::InterpolateExecutorBase(const InterpolateA
     spatialDimSize = getSpatialDimsNum(dataRank);
 
     switch (mode) {
-        case InterpolateMode::nearest: {
-            buildTblNN(srcDimPad5d, dstDim5d, dataScales, interpAttrs.layout, interpAttrs.nearestMode);
-            break;
-        }
-        case InterpolateMode::linear_onnx: {
-            buildTblLinearOnnx(srcDimPad5d, dstDim5d, dataScales, interpAttrs.layout);
-            break;
-        }
-        case InterpolateMode::linear: {
-            static constexpr int LINEAR_KERNEL = 2;
-            buildTblLinear(srcDimPad5d, dstDim5d, dataScales, LINEAR_KERNEL, interpAttrs.antialias);
-            break;
-        }
-        case InterpolateMode::cubic: {
-            buildTblCubic(srcDimPad5d, dstDim5d, dataScales, interpAttrs.cubeCoeff, interpAttrs.layout);
-            break;
-        }
-        case InterpolateMode::bilinear_pillow:
-        case InterpolateMode::bicubic_pillow: {
-            buildTblPillow(srcDimPad5d, dstDim5d, dataScales, interpAttrs.cubeCoeff, interpAttrs.layout);
-            if ((srcDimPad5d[4] != dstDim5d[4]) && (srcDimPad5d[3] != dstDim5d[3])) {
-                create_pillow_working_buf(interpAttrs.layout);
-            }
-            break;
-        }
-        default: {
-            OPENVINO_THROW("Interpolate executor does not support interpolate mode: ", mode);
-            break;
+    case InterpolateMode::nearest: {
+        buildTblNN(srcDimPad5d, dstDim5d, dataScales, interpAttrs.layout, interpAttrs.nearestMode);
+        break;
+    }
+    case InterpolateMode::linear_onnx: {
+        buildTblLinearOnnx(srcDimPad5d, dstDim5d, dataScales, interpAttrs.layout);
+        break;
+    }
+    case InterpolateMode::linear: {
+        static constexpr int LINEAR_KERNEL = 2;
+        buildTblLinear(srcDimPad5d, dstDim5d, dataScales, LINEAR_KERNEL, interpAttrs.antialias);
+        break;
+    }
+    case InterpolateMode::cubic: {
+        buildTblCubic(srcDimPad5d, dstDim5d, dataScales, interpAttrs.cubeCoeff, interpAttrs.layout);
+        break;
+    }
+    case InterpolateMode::bilinear_pillow:
+    case InterpolateMode::bicubic_pillow: {
+        buildTblPillow(srcDimPad5d, dstDim5d, dataScales, interpAttrs.cubeCoeff, interpAttrs.layout);
+        if ((srcDimPad5d[4] != dstDim5d[4]) && (srcDimPad5d[3] != dstDim5d[3])) {
+            create_pillow_working_buf(interpAttrs.layout);
         }
+        break;
+    }
+    default: {
+        OPENVINO_THROW("Interpolate executor does not support interpolate mode: ", mode);
+        break;
+    }
     }
 }
 
 Interpolate::InterpolateJitExecutor::InterpolateJitExecutor(const InterpolateAttrs& interpAttrs,
-                                                                      const VectorDims &srcDims,
-                                                                      const VectorDims &dstDims,
-                                                                      const std::vector<float> &dataScales,
-                                                                      const dnnl::primitive_attr &attr) :
-        InterpolateExecutorBase(interpAttrs, srcDims, dstDims, dataScales) {
+                                                            const VectorDims& srcDims,
+                                                            const VectorDims& dstDims,
+                                                            const std::vector<float>& dataScales,
+                                                            const dnnl::primitive_attr& attr)
+    : InterpolateExecutorBase(interpAttrs, srcDims, dstDims, dataScales) {
     auto jcp = jit_interpolate_config_params();
     jcp.mode = mode;
     jcp.src_prc = interpAttrs.inPrc;
@@ -3878,7 +4140,7 @@ Interpolate::InterpolateJitExecutor::InterpolateJitExecutor(const InterpolateAtt
     } else {
         OPENVINO_THROW("Can't create InterpolateJitExecutor");
     }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
     if (interpolateKernel) {
         interpolateKernel->create_ker();
     } else {
@@ -3886,7 +4148,7 @@ Interpolate::InterpolateJitExecutor::InterpolateJitExecutor(const InterpolateAtt
     }
 }
 
-void Interpolate::InterpolateJitExecutor::exec(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_) {
+void Interpolate::InterpolateJitExecutor::exec(const uint8_t* in_ptr_, uint8_t* out_ptr_, const void* post_ops_data_) {
     size_t N = srcDimPad5d[0], C = srcDimPad5d[1], ID = srcDimPad5d[2], IH = srcDimPad5d[3], IW = srcDimPad5d[4];
     size_t OD = dstDim5d[2], OH = dstDim5d[3], OW = dstDim5d[4];
 
@@ -3894,103 +4156,115 @@ void Interpolate::InterpolateJitExecutor::exec(const uint8_t *in_ptr_, uint8_t *
         OPENVINO_THROW("Can't execute, kernel for Interpolate node is not compiled");
     }
     switch (mode) {
-        case InterpolateMode::nearest: {
-            if (configured_for_layout == InterpolateLayoutType::planar) {
-                NNPlanar(in_ptr_, out_ptr_, post_ops_data_, N, C, ID, IH, IW, OD, OH, OW);
-            } else {
-                NNCGathered(in_ptr_, out_ptr_, post_ops_data_, N, C, ID, IH, IW, OD, OH, OW);
-            }
-            break;
-        }
-        case InterpolateMode::linear_onnx: {
-            if (configured_for_layout == InterpolateLayoutType::planar) {
-                linearOnnxPlanar(in_ptr_, out_ptr_, post_ops_data_, N, C, ID, IH, IW, OD, OH, OW);
-            } else {
-                linearOnnxCGathered(in_ptr_, out_ptr_, post_ops_data_, N, C, ID, IH, IW, OD, OH, OW);
-            }
-            break;
+    case InterpolateMode::nearest: {
+        if (configured_for_layout == InterpolateLayoutType::planar) {
+            NNPlanar(in_ptr_, out_ptr_, post_ops_data_, N, C, ID, IH, IW, OD, OH, OW);
+        } else {
+            NNCGathered(in_ptr_, out_ptr_, post_ops_data_, N, C, ID, IH, IW, OD, OH, OW);
         }
-        case InterpolateMode::cubic: {
-            if (configured_for_layout == InterpolateLayoutType::planar) {
-                cubicPlanar(in_ptr_, out_ptr_, post_ops_data_, N, C, IH, IW, OH, OW);
-            } else {
-                cubicCGathered(in_ptr_, out_ptr_, post_ops_data_, N, C, IH, IW, OH, OW);
-            }
-            break;
+        break;
+    }
+    case InterpolateMode::linear_onnx: {
+        if (configured_for_layout == InterpolateLayoutType::planar) {
+            linearOnnxPlanar(in_ptr_, out_ptr_, post_ops_data_, N, C, ID, IH, IW, OD, OH, OW);
+        } else {
+            linearOnnxCGathered(in_ptr_, out_ptr_, post_ops_data_, N, C, ID, IH, IW, OD, OH, OW);
         }
-        case InterpolateMode::bilinear_pillow:
-        case InterpolateMode::bicubic_pillow: {
-            if (configured_for_layout == InterpolateLayoutType::by_channel) {
-                pillowCGathered(in_ptr_, out_ptr_, post_ops_data_, N, C, IH, IW, OH, OW);
-            } else {
-                OPENVINO_THROW("Only channel_first jit kernel is supported for pillow mode", mode);
-            }
-            break;
+        break;
+    }
+    case InterpolateMode::cubic: {
+        if (configured_for_layout == InterpolateLayoutType::planar) {
+            cubicPlanar(in_ptr_, out_ptr_, post_ops_data_, N, C, IH, IW, OH, OW);
+        } else {
+            cubicCGathered(in_ptr_, out_ptr_, post_ops_data_, N, C, IH, IW, OH, OW);
         }
-        default: {
-            OPENVINO_THROW("InterpolateJitExecutor has unsupported interpolate mode: ", mode);
+        break;
+    }
+    case InterpolateMode::bilinear_pillow:
+    case InterpolateMode::bicubic_pillow: {
+        if (configured_for_layout == InterpolateLayoutType::by_channel) {
+            pillowCGathered(in_ptr_, out_ptr_, post_ops_data_, N, C, IH, IW, OH, OW);
+        } else {
+            OPENVINO_THROW("Only channel_first jit kernel is supported for pillow mode", mode);
         }
+        break;
+    }
+    default: {
+        OPENVINO_THROW("InterpolateJitExecutor has unsupported interpolate mode: ", mode);
+    }
     }
 }
 
-void Interpolate::InterpolateRefExecutor::exec(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_) {
+void Interpolate::InterpolateRefExecutor::exec(const uint8_t* in_ptr_, uint8_t* out_ptr_, const void* post_ops_data_) {
     size_t N = srcDimPad5d[0], C = srcDimPad5d[1], ID = srcDimPad5d[2], IH = srcDimPad5d[3], IW = srcDimPad5d[4];
     size_t OD = dstDim5d[2], OH = dstDim5d[3], OW = dstDim5d[4];
 
     switch (mode) {
-        case InterpolateMode::nearest: {
-            NNRef(in_ptr_, out_ptr_, N, C, ID, IH, IW, OD, OH, OW);
-            break;
-        }
-        case InterpolateMode::linear_onnx: {
-            linearOnnxRef(in_ptr_, out_ptr_, N, C, ID, IH, IW, OD, OH, OW);
-            break;
-        }
-        case InterpolateMode::cubic: {
-            cubicRef(in_ptr_, out_ptr_, N, C, IH, IW, OH, OW);
-            break;
-        }
-        case InterpolateMode::linear: {
-            float fz = (dataRank == 5) ? dataScales[dataRank - 3] : 1.f;
-            float fy = dataScales[dataRank - 2];
-            float fx = dataScales[dataRank - 1];
-
-            bool isDownsample = (fx < 1.f) || (fy < 1.f) || (fz < 1.f);
-            int kernel_width = 2;
-            linearInterpolation(in_ptr_, out_ptr_, N, C, ID, IH, IW, fx, fy, fz, OD, OH, OW, kernel_width, isDownsample && antialias);
-            break;
-        }
-        case InterpolateMode::bilinear_pillow:
-        case InterpolateMode::bicubic_pillow: {
-            pillowRef(in_ptr_, out_ptr_, N, C, IH, IW, OH, OW);
-            break;
-        }
-        default: {
-            OPENVINO_THROW("Interpolate layer has unsupported interpolate mode: ", mode);
-        }
+    case InterpolateMode::nearest: {
+        NNRef(in_ptr_, out_ptr_, N, C, ID, IH, IW, OD, OH, OW);
+        break;
+    }
+    case InterpolateMode::linear_onnx: {
+        linearOnnxRef(in_ptr_, out_ptr_, N, C, ID, IH, IW, OD, OH, OW);
+        break;
+    }
+    case InterpolateMode::cubic: {
+        cubicRef(in_ptr_, out_ptr_, N, C, IH, IW, OH, OW);
+        break;
+    }
+    case InterpolateMode::linear: {
+        float fz = (dataRank == 5) ? dataScales[dataRank - 3] : 1.f;
+        float fy = dataScales[dataRank - 2];
+        float fx = dataScales[dataRank - 1];
+
+        bool isDownsample = (fx < 1.f) || (fy < 1.f) || (fz < 1.f);
+        int kernel_width = 2;
+        linearInterpolation(in_ptr_,
+                            out_ptr_,
+                            N,
+                            C,
+                            ID,
+                            IH,
+                            IW,
+                            fx,
+                            fy,
+                            fz,
+                            OD,
+                            OH,
+                            OW,
+                            kernel_width,
+                            isDownsample && antialias);
+        break;
+    }
+    case InterpolateMode::bilinear_pillow:
+    case InterpolateMode::bicubic_pillow: {
+        pillowRef(in_ptr_, out_ptr_, N, C, IH, IW, OH, OW);
+        break;
+    }
+    default: {
+        OPENVINO_THROW("Interpolate layer has unsupported interpolate mode: ", mode);
+    }
     }
 }
 
 size_t Interpolate::getSpatialDimsNum(const Dim rank) {
     switch (rank) {
-        case 1:
-        case 3:
-            return 1;
-        case 2:
-        case 4:
-            return 2;
-        case 5:
-            return 3;
-        default:
-            OPENVINO_THROW("Can't define number spatial");
+    case 1:
+    case 3:
+        return 1;
+    case 2:
+    case 4:
+        return 2;
+    case 5:
+        return 3;
+    default:
+        OPENVINO_THROW("Can't define number spatial");
     }
 }
 
 bool Interpolate::canFuse(const NodePtr& node) const {
-    if (!mayiuse(cpu::x64::sse41) ||
-        interpAttrs.mode == InterpolateMode::linear ||
-        interpAttrs.mode == InterpolateMode::bilinear_pillow ||
-        interpAttrs.mode == InterpolateMode::bicubic_pillow ||
+    if (!mayiuse(cpu::x64::sse41) || interpAttrs.mode == InterpolateMode::linear ||
+        interpAttrs.mode == InterpolateMode::bilinear_pillow || interpAttrs.mode == InterpolateMode::bicubic_pillow ||
         (!one_of(dataRank, 4u, 5u) && !mayiuse(cpu::x64::avx2))) {
         return false;
     }
@@ -4002,6 +4276,6 @@ bool Interpolate::created() const {
     return getType() == Type::Interpolate;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/interpolate.h b/src/plugins/intel_cpu/src/nodes/interpolate.h
index a43b354aa0306a..c6fedf384f449d 100644
--- a/src/plugins/intel_cpu/src/nodes/interpolate.h
+++ b/src/plugins/intel_cpu/src/nodes/interpolate.h
@@ -31,34 +31,36 @@ struct jit_interpolate_config_params {
 };
 
 struct jit_interpolate_call_args {
-    const void *src_ptr[MAX_INPUT_INTERPOLATE];
-    const void *weight_ptr[MAX_INPUT_INTERPOLATE];
-    const int *index;
-    void *dst;
+    const void* src_ptr[MAX_INPUT_INTERPOLATE];
+    const void* weight_ptr[MAX_INPUT_INTERPOLATE];
+    const int* index;
+    void* dst;
     size_t work_amount;
     size_t oc_off;
-    //ptr to array of post op inputs pointers (flat list)
+    // ptr to array of post op inputs pointers (flat list)
     const void* post_op_data;
 };
 
 struct jit_uni_interpolate_kernel {
-    void (*ker_)(const jit_interpolate_call_args *);
+    void (*ker_)(const jit_interpolate_call_args*);
 
-    void operator()(const jit_interpolate_call_args *args) {
+    void operator()(const jit_interpolate_call_args* args) {
         assert(ker_);
         ker_(args);
     }
 
-    explicit jit_uni_interpolate_kernel(jit_interpolate_config_params jcp, const dnnl_primitive_attr &attr) : ker_(nullptr), jcp_(jcp), attr_(attr) {}
+    explicit jit_uni_interpolate_kernel(jit_interpolate_config_params jcp, const dnnl_primitive_attr& attr)
+        : ker_(nullptr),
+          jcp_(jcp),
+          attr_(attr) {}
     virtual ~jit_uni_interpolate_kernel() {}
 
     virtual void create_ker() = 0;
 
     jit_interpolate_config_params jcp_;
-    const dnnl_primitive_attr &attr_;
+    const dnnl_primitive_attr& attr_;
 };
 
-
 class Interpolate : public Node {
 public:
     static constexpr size_t DATA_ID = 0;
@@ -98,8 +100,9 @@ class Interpolate : public Node {
     bool is_version11 = true;
     InterpolateAttrs interpAttrs;
     // Some FEs or preprocessing step resize spatial dimension for tensor with NHWC layout memory,
-    // but imported as planar layout[abcd] with axis[1,2] for convenience. In this case, for pillow modes without pad for now,
-    // nhwc layout path and the kernel(nhwc layout executor) can be used for this planar layout and axis settings(NCHWAsNHWC is true) to get higher perf with
+    // but imported as planar layout[abcd] with axis[1,2] for convenience. In this case, for pillow modes without pad
+    // for now, nhwc layout path and the kernel(nhwc layout executor) can be used for this planar layout and axis
+    // settings(NCHWAsNHWC is true) to get higher perf with
     // 1. logical shape alignment [abcd-nhwc] to [adbc-nchw].
     // 2. axis alignment [1,2] to [2,3].
     // 3. config planar layout support and treated it as channel_first layout.
@@ -107,120 +110,226 @@ class Interpolate : public Node {
     size_t dataRank = 0;
 
     class InterpolateExecutorBase {
-        public:
-            InterpolateExecutorBase(const InterpolateAttrs& interpAttrs,
-                                const VectorDims &srcDims,
-                                const VectorDims &dstDims,
-                                const std::vector<float> &dataScales);
-
-            virtual void exec(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_) = 0;
-            virtual ~InterpolateExecutorBase() = default;
-            VectorDims getSrcDimPad5d() const { return srcDimPad5d; }
-
-        private:
-            void buildTblNN(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d, const std::vector<float>& dataScales,
-                            InterpolateLayoutType layout, InterpolateNearestMode nearestMode);
-            void buildTblLinearOnnx(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d, const std::vector<float>& dataScales,
-                                    InterpolateLayoutType layout);
-            void buildTblLinear(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d, const std::vector<float>& dataScales, int kernel_width,
-                                bool antialias);
-            void buildTblCubic(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d, const std::vector<float>& dataScales, float cubicCoeff,
-                               InterpolateLayoutType layout);
-            void buildTblPillow(const VectorDims& srcDimPad5d, const VectorDims& dstDim5d, const std::vector<float>& dataScales,
-                                float cubicCoeff, InterpolateLayoutType layout);
-
-            float coordTransToInput(int outCoord, float scale, int inShape, int outShape) const;
-            int nearestRound(float origin, bool isDownsample, InterpolateNearestMode nearestMode) const;
-            void linearOnnxCF(int outCoord, float scale, int inShape, int outShape, int& index0, int& index1, float& weight0, float& weight1);
-            std::vector<float> getCubicCoeffs(float mantissa, float a);
-            static float getPillowBilinearCoeffs(float m);
-            static float getPillowBicubicCoeffs(float m);
-            inline void create_pillow_working_buf(InterpolateLayoutType layout);
-
-        protected:
-            InterpolateMode mode;
-            InterpolateCoordTransMode coordTransMode;
-            InterpolateLayoutType configured_for_layout;
-            VectorDims srcDimPad5d, dstDim5d;
-            ov::element::Type inputPrec, outputPrec;
-            size_t srcDataSize, dstDataSize;
-            int spatialDimSize;
-            size_t dataRank;
-            std::vector<int> auxTable;
-            std::vector<uint8_t> pillow_working_buf;
-            size_t m_threads_num = 0lu;
+    public:
+        InterpolateExecutorBase(const InterpolateAttrs& interpAttrs,
+                                const VectorDims& srcDims,
+                                const VectorDims& dstDims,
+                                const std::vector<float>& dataScales);
+
+        virtual void exec(const uint8_t* in_ptr_, uint8_t* out_ptr_, const void* post_ops_data_) = 0;
+        virtual ~InterpolateExecutorBase() = default;
+        VectorDims getSrcDimPad5d() const {
+            return srcDimPad5d;
+        }
+
+    private:
+        void buildTblNN(const VectorDims& srcDimPad5d,
+                        const VectorDims& dstDim5d,
+                        const std::vector<float>& dataScales,
+                        InterpolateLayoutType layout,
+                        InterpolateNearestMode nearestMode);
+        void buildTblLinearOnnx(const VectorDims& srcDimPad5d,
+                                const VectorDims& dstDim5d,
+                                const std::vector<float>& dataScales,
+                                InterpolateLayoutType layout);
+        void buildTblLinear(const VectorDims& srcDimPad5d,
+                            const VectorDims& dstDim5d,
+                            const std::vector<float>& dataScales,
+                            int kernel_width,
+                            bool antialias);
+        void buildTblCubic(const VectorDims& srcDimPad5d,
+                           const VectorDims& dstDim5d,
+                           const std::vector<float>& dataScales,
+                           float cubicCoeff,
+                           InterpolateLayoutType layout);
+        void buildTblPillow(const VectorDims& srcDimPad5d,
+                            const VectorDims& dstDim5d,
+                            const std::vector<float>& dataScales,
+                            float cubicCoeff,
+                            InterpolateLayoutType layout);
+
+        float coordTransToInput(int outCoord, float scale, int inShape, int outShape) const;
+        int nearestRound(float origin, bool isDownsample, InterpolateNearestMode nearestMode) const;
+        void linearOnnxCF(int outCoord,
+                          float scale,
+                          int inShape,
+                          int outShape,
+                          int& index0,
+                          int& index1,
+                          float& weight0,
+                          float& weight1);
+        std::vector<float> getCubicCoeffs(float mantissa, float a);
+        static float getPillowBilinearCoeffs(float m);
+        static float getPillowBicubicCoeffs(float m);
+        inline void create_pillow_working_buf(InterpolateLayoutType layout);
+
+    protected:
+        InterpolateMode mode;
+        InterpolateCoordTransMode coordTransMode;
+        InterpolateLayoutType configured_for_layout;
+        VectorDims srcDimPad5d, dstDim5d;
+        ov::element::Type inputPrec, outputPrec;
+        size_t srcDataSize, dstDataSize;
+        int spatialDimSize;
+        size_t dataRank;
+        std::vector<int> auxTable;
+        std::vector<uint8_t> pillow_working_buf;
+        size_t m_threads_num = 0lu;
     };
     std::shared_ptr<InterpolateExecutorBase> execPtr = nullptr;
 
     class InterpolateJitExecutor : public InterpolateExecutorBase {
-        public:
-            InterpolateJitExecutor(const InterpolateAttrs& interpAttrs,
-                                   const VectorDims &srcDims,
-                                   const VectorDims &dstDims,
-                                   const std::vector<float> &dataScales,
-                                   const dnnl::primitive_attr &attr);
-
-            void exec(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_) override;
-
-        private:
-            // nearest neighbor
-            void NNPlanar(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_,
-                int B, int C, int ID, int IH, int IW, int OD, int OH, int OW);
-            void NNCGathered(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_,
-                int B, int C, int ID, int IH, int IW, int OD, int OH, int OW);
-
-            // onnx linear
-            void linearOnnxPlanar(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_,
-                int B, int C, int ID, int IH, int IW, int OD, int OH, int OW);
-            void linearOnnxCGathered(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_,
-                int B, int C, int ID, int IH, int IW, int OD, int OH, int OW);
-
-            // cubic
-            void cubicPlanar(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_,
-                int B, int C, int IH, int IW, int OH, int OW);
-            void cubicCGathered(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_,
-                int B, int C, int IH, int IW, int OH, int OW);
-
-            // pillow bilinear and pillow bicubic
-            void pillowCGathered(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_,
-                int B, int C, int IH, int IW, int OH, int OW);
-
-        private:
-            std::shared_ptr<jit_uni_interpolate_kernel> interpolateKernel = nullptr;
+    public:
+        InterpolateJitExecutor(const InterpolateAttrs& interpAttrs,
+                               const VectorDims& srcDims,
+                               const VectorDims& dstDims,
+                               const std::vector<float>& dataScales,
+                               const dnnl::primitive_attr& attr);
+
+        void exec(const uint8_t* in_ptr_, uint8_t* out_ptr_, const void* post_ops_data_) override;
+
+    private:
+        // nearest neighbor
+        void NNPlanar(const uint8_t* in_ptr_,
+                      uint8_t* out_ptr_,
+                      const void* post_ops_data_,
+                      int B,
+                      int C,
+                      int ID,
+                      int IH,
+                      int IW,
+                      int OD,
+                      int OH,
+                      int OW);
+        void NNCGathered(const uint8_t* in_ptr_,
+                         uint8_t* out_ptr_,
+                         const void* post_ops_data_,
+                         int B,
+                         int C,
+                         int ID,
+                         int IH,
+                         int IW,
+                         int OD,
+                         int OH,
+                         int OW);
+
+        // onnx linear
+        void linearOnnxPlanar(const uint8_t* in_ptr_,
+                              uint8_t* out_ptr_,
+                              const void* post_ops_data_,
+                              int B,
+                              int C,
+                              int ID,
+                              int IH,
+                              int IW,
+                              int OD,
+                              int OH,
+                              int OW);
+        void linearOnnxCGathered(const uint8_t* in_ptr_,
+                                 uint8_t* out_ptr_,
+                                 const void* post_ops_data_,
+                                 int B,
+                                 int C,
+                                 int ID,
+                                 int IH,
+                                 int IW,
+                                 int OD,
+                                 int OH,
+                                 int OW);
+
+        // cubic
+        void cubicPlanar(const uint8_t* in_ptr_,
+                         uint8_t* out_ptr_,
+                         const void* post_ops_data_,
+                         int B,
+                         int C,
+                         int IH,
+                         int IW,
+                         int OH,
+                         int OW);
+        void cubicCGathered(const uint8_t* in_ptr_,
+                            uint8_t* out_ptr_,
+                            const void* post_ops_data_,
+                            int B,
+                            int C,
+                            int IH,
+                            int IW,
+                            int OH,
+                            int OW);
+
+        // pillow bilinear and pillow bicubic
+        void pillowCGathered(const uint8_t* in_ptr_,
+                             uint8_t* out_ptr_,
+                             const void* post_ops_data_,
+                             int B,
+                             int C,
+                             int IH,
+                             int IW,
+                             int OH,
+                             int OW);
+
+    private:
+        std::shared_ptr<jit_uni_interpolate_kernel> interpolateKernel = nullptr;
     };
 
     class InterpolateRefExecutor : public InterpolateExecutorBase {
-        public:
-            InterpolateRefExecutor(const InterpolateAttrs& interpAttrs,
-                                   const VectorDims &srcDims,
-                                   const VectorDims &dstDims,
-                                   const std::vector<float> &_dataScales) :
-                InterpolateExecutorBase(interpAttrs, srcDims, dstDims, _dataScales),
-                antialias(interpAttrs.antialias), dataScales(_dataScales) {}
-
-            void exec(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_) override;
-
-        private:
-            void NNRef(const uint8_t *in_ptr_, uint8_t *out_ptr_, int B, int C, int ID, int IH, int IW, int OD, int OH, int OW);
-            void linearOnnxRef(const uint8_t *in_ptr_, uint8_t *out_ptr_, int B, int C, int ID, int IH, int IW, int OD, int OH, int OW);
-
-            void cubicRef(const uint8_t *in_ptr_, uint8_t *out_ptr_, int B, int C, int IH, int IW, int OH, int OW);
-            void linearInterpolation(const uint8_t *in_ptr_, uint8_t *out_ptr_, int B, int C, int ID, int IH, int IW,
-                                      float fx, float fy, float fz, int OD, int OH, int OW, int kernel_width, bool antialias);
-            void pillowRef(const uint8_t *in_ptr_, uint8_t *out_ptr_, int B, int C, int IH, int IW, int OH, int OW);
-
-            static float getValue(const uint8_t *base, size_t offset, ov::element::Type prec);
-            static void setValue(uint8_t *base, size_t offset, float value, ov::element::Type prec);
-
-        private:
-            bool antialias;
-            std::vector<float> dataScales;
+    public:
+        InterpolateRefExecutor(const InterpolateAttrs& interpAttrs,
+                               const VectorDims& srcDims,
+                               const VectorDims& dstDims,
+                               const std::vector<float>& _dataScales)
+            : InterpolateExecutorBase(interpAttrs, srcDims, dstDims, _dataScales),
+              antialias(interpAttrs.antialias),
+              dataScales(_dataScales) {}
+
+        void exec(const uint8_t* in_ptr_, uint8_t* out_ptr_, const void* post_ops_data_) override;
+
+    private:
+        void
+        NNRef(const uint8_t* in_ptr_, uint8_t* out_ptr_, int B, int C, int ID, int IH, int IW, int OD, int OH, int OW);
+        void linearOnnxRef(const uint8_t* in_ptr_,
+                           uint8_t* out_ptr_,
+                           int B,
+                           int C,
+                           int ID,
+                           int IH,
+                           int IW,
+                           int OD,
+                           int OH,
+                           int OW);
+
+        void cubicRef(const uint8_t* in_ptr_, uint8_t* out_ptr_, int B, int C, int IH, int IW, int OH, int OW);
+        void linearInterpolation(const uint8_t* in_ptr_,
+                                 uint8_t* out_ptr_,
+                                 int B,
+                                 int C,
+                                 int ID,
+                                 int IH,
+                                 int IW,
+                                 float fx,
+                                 float fy,
+                                 float fz,
+                                 int OD,
+                                 int OH,
+                                 int OW,
+                                 int kernel_width,
+                                 bool antialias);
+        void pillowRef(const uint8_t* in_ptr_, uint8_t* out_ptr_, int B, int C, int IH, int IW, int OH, int OW);
+
+        static float getValue(const uint8_t* base, size_t offset, ov::element::Type prec);
+        static void setValue(uint8_t* base, size_t offset, float value, ov::element::Type prec);
+
+    private:
+        bool antialias;
+        std::vector<float> dataScales;
     };
 
-    void setPostOps(dnnl::primitive_attr &attr, const VectorDims &dims);
+    void setPostOps(dnnl::primitive_attr& attr, const VectorDims& dims);
 
-    static VectorDims getPaddedInputShape(const VectorDims &srcDims, const std::vector<int> &padBegin, const std::vector<int> &padEnd);
-    std::vector<float> getScales(const VectorDims &srcDimPad, const VectorDims &dstDim);
+    static VectorDims getPaddedInputShape(const VectorDims& srcDims,
+                                          const std::vector<int>& padBegin,
+                                          const std::vector<int>& padEnd);
+    std::vector<float> getScales(const VectorDims& srcDimPad, const VectorDims& dstDim);
     static size_t getSpatialDimsNum(const Dim rank);
 
     bool hasPad = false;
@@ -244,6 +353,6 @@ class Interpolate : public Node {
     std::shared_ptr<InterpolateExecutor> aclExecPtr = nullptr;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/jit_eltwise_call_args_ptrs.hpp b/src/plugins/intel_cpu/src/nodes/kernels/jit_eltwise_call_args_ptrs.hpp
index 7370bb824d8c62..66f119ee839b14 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/jit_eltwise_call_args_ptrs.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/jit_eltwise_call_args_ptrs.hpp
@@ -9,21 +9,21 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 
-#define MAX_ELTWISE_INPUTS 7
+#define MAX_ELTWISE_INPUTS   7
 #define MAX_ELTWISE_DIM_RANK 12
 
 struct jit_eltwise_call_args_ptrs {
-    const void *src_ptr[MAX_ELTWISE_INPUTS];
-    void *dst_ptr;
-    //ptr to array of post op inputs pointers (flat list)
+    const void* src_ptr[MAX_ELTWISE_INPUTS];
+    void* dst_ptr;
+    // ptr to array of post op inputs pointers (flat list)
     const void** post_op_data;
 
     // shape agnostic kernel
     size_t work_amount;
-    const void *src_offsets[MAX_ELTWISE_INPUTS];
-    const void *dst_offsets;
+    const void* src_offsets[MAX_ELTWISE_INPUTS];
+    const void* dst_offsets;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_memcpy.cpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_memcpy.cpp
index 755330bd850c4d..b4d38086cefe8a 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_memcpy.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_memcpy.cpp
@@ -13,10 +13,10 @@
 #    include <immintrin.h>
 #endif
 
-#include "openvino/core/type/bfloat16.hpp"
-#include "openvino/core/parallel.hpp"
-#include "common.hpp"
 #include "attn_memcpy.hpp"
+#include "common.hpp"
+#include "openvino/core/parallel.hpp"
+#include "openvino/core/type/bfloat16.hpp"
 
 namespace ov {
 namespace Extensions {
@@ -26,7 +26,7 @@ namespace XARCH {
 using namespace ov;
 
 // float16 <- float
-template<typename TA, typename TB>
+template <typename TA, typename TB>
 void attn_copy(TA* a, TB* b, size_t n) {
     size_t i = 0;
 #if defined(HAVE_AVX512F)
@@ -51,14 +51,11 @@ void attn_memcpy_kernel(const ov::intel_cpu::PlainTensor& k_input,
                         const ov::intel_cpu::PlainTensor& past_k_output,
                         const ov::intel_cpu::PlainTensor& past_v_output) {
     // For compatibility, all input_kvs are permuted to BHLS
-    size_t B = k_input.m_dims[0], H = k_input.m_dims[1], L1 = k_input.m_dims[2], S = k_input.m_dims[3], SV = v_input.m_dims[3];
+    size_t B = k_input.m_dims[0], H = k_input.m_dims[1], L1 = k_input.m_dims[2], S = k_input.m_dims[3],
+           SV = v_input.m_dims[3];
     parallel_for3d(L1, B, H, [&](size_t m, size_t b, size_t h) {
-        attn_copy(past_k_output.ptr<T2>(b, h, m, 0),
-                  k_input.ptr<T>(b, h, m, 0),
-                  S);
-        attn_copy(past_v_output.ptr<T2>(b, h, m, 0),
-                  v_input.ptr<T>(b, h, m, 0),
-                  SV);
+        attn_copy(past_k_output.ptr<T2>(b, h, m, 0), k_input.ptr<T>(b, h, m, 0), S);
+        attn_copy(past_v_output.ptr<T2>(b, h, m, 0), v_input.ptr<T>(b, h, m, 0), SV);
     });
 }
 
@@ -67,14 +64,11 @@ static void attn_memcpy_kernel(const ov::intel_cpu::PlainTensor& k_input,
                                const ov::intel_cpu::PlainTensor& past_k_output,
                                const ov::intel_cpu::PlainTensor& past_v_output) {
     // For compatibility, all input_kvs are permuted to BHLS
-    size_t B = k_input.m_dims[0], H = k_input.m_dims[1], L1 = k_input.m_dims[2], S = k_input.m_dims[3], SV = v_input.m_dims[3];
+    size_t B = k_input.m_dims[0], H = k_input.m_dims[1], L1 = k_input.m_dims[2], S = k_input.m_dims[3],
+           SV = v_input.m_dims[3];
     parallel_for3d(L1, B, H, [&](size_t m, size_t b, size_t h) {
-        std::memcpy(past_k_output.ptr_v(b, h, m, 0),
-                    k_input.ptr_v(b, h, m, 0),
-                    S * k_input.m_element_size);
-        std::memcpy(past_v_output.ptr_v(b, h, m, 0),
-                    v_input.ptr_v(b, h, m, 0),
-                    SV * v_input.m_element_size);
+        std::memcpy(past_k_output.ptr_v(b, h, m, 0), k_input.ptr_v(b, h, m, 0), S * k_input.m_element_size);
+        std::memcpy(past_v_output.ptr_v(b, h, m, 0), v_input.ptr_v(b, h, m, 0), SV * v_input.m_element_size);
     });
 }
 
@@ -84,19 +78,17 @@ static void paged_attn_memcpy_kernel(const ov::intel_cpu::PlainTensor& k_input,
                                      const ov::intel_cpu::PlainTensor& past_k_output,
                                      const ov::intel_cpu::PlainTensor& past_v_output,
                                      const ov::intel_cpu::PlainTensor& slot_mapping) {
-    size_t B = k_input.m_dims[0], H = k_input.m_dims[1], L1 = k_input.m_dims[2], S = k_input.m_dims[3], SV = v_input.m_dims[3];
+    size_t B = k_input.m_dims[0], H = k_input.m_dims[1], L1 = k_input.m_dims[2], S = k_input.m_dims[3],
+           SV = v_input.m_dims[3];
     size_t block_size = past_k_output.m_dims[2];
     parallel_for3d(B, L1, H, [&](size_t b, size_t m, size_t h) {
         auto slot = slot_mapping.ptr<int32_t>(b)[m];
-        if (slot < 0) return;
+        if (slot < 0)
+            return;
         auto block_number = slot / block_size;
         auto block_offset = slot % block_size;
-        attn_copy(past_k_output.ptr<T2>(block_number, h, block_offset, 0),
-                  k_input.ptr<T>(b, h, m, 0),
-                  S);
-        attn_copy(past_v_output.ptr<T2>(block_number, h, block_offset, 0),
-                  v_input.ptr<T>(b, h, m, 0),
-                  SV);
+        attn_copy(past_k_output.ptr<T2>(block_number, h, block_offset, 0), k_input.ptr<T>(b, h, m, 0), S);
+        attn_copy(past_v_output.ptr<T2>(block_number, h, block_offset, 0), v_input.ptr<T>(b, h, m, 0), SV);
     });
 }
 
@@ -105,11 +97,13 @@ static void paged_attn_memcpy_kernel(const ov::intel_cpu::PlainTensor& k_input,
                                      const ov::intel_cpu::PlainTensor& past_k_output,
                                      const ov::intel_cpu::PlainTensor& past_v_output,
                                      const ov::intel_cpu::PlainTensor& slot_mapping) {
-    size_t B = k_input.m_dims[0], H = k_input.m_dims[1], L1 = k_input.m_dims[2], S = k_input.m_dims[3], SV = v_input.m_dims[3];
+    size_t B = k_input.m_dims[0], H = k_input.m_dims[1], L1 = k_input.m_dims[2], S = k_input.m_dims[3],
+           SV = v_input.m_dims[3];
     size_t block_size = past_k_output.m_dims[2];
     parallel_for3d(B, L1, H, [&](size_t b, size_t m, size_t h) {
         auto slot = slot_mapping.ptr<int32_t>(b)[m];
-        if (slot < 0) return;
+        if (slot < 0)
+            return;
         auto block_number = slot / block_size;
         auto block_offset = slot % block_size;
         std::memcpy(past_k_output.ptr_v(block_number, h, block_offset, 0),
@@ -132,7 +126,11 @@ void attn_memcpy(const ov::intel_cpu::PlainTensor& k_input,
     } else if (k_input.get_precision() == ov::element::f32 && past_k_output.get_precision() == ov::element::bf16) {
         attn_memcpy_kernel<float, ov::bfloat16>(k_input, v_input, past_k_output, past_v_output);
     } else {
-        OPENVINO_THROW("unsupport src type: ", k_input.get_precision(), ", dst type: ", past_k_output.get_precision(), " in attn_memcpy");
+        OPENVINO_THROW("unsupport src type: ",
+                       k_input.get_precision(),
+                       ", dst type: ",
+                       past_k_output.get_precision(),
+                       " in attn_memcpy");
     }
 }
 
@@ -148,7 +146,11 @@ void paged_attn_memcpy(const ov::intel_cpu::PlainTensor& k_input,
     } else if (k_input.get_precision() == ov::element::f32 && past_k_output.get_precision() == ov::element::bf16) {
         paged_attn_memcpy_kernel<float, ov::bfloat16>(k_input, v_input, past_k_output, past_v_output, slot_mapping);
     } else {
-        OPENVINO_THROW("unsupport src type: ", k_input.get_precision(), ", dst type: ", past_k_output.get_precision(), " in paged_attn_memcpy");
+        OPENVINO_THROW("unsupport src type: ",
+                       k_input.get_precision(),
+                       ", dst type: ",
+                       past_k_output.get_precision(),
+                       " in paged_attn_memcpy");
     }
 }
 
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_memcpy.hpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_memcpy.hpp
index c0e5892db9926b..ea704232e333bd 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_memcpy.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_memcpy.hpp
@@ -7,6 +7,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <vector>
+
 #include "openvino/core/type/element_type.hpp"
 #include "utils/plain_tensor.hpp"
 
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_quant.cpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_quant.cpp
index ee13118ec80d11..19721b4961fbb0 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_quant.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_quant.cpp
@@ -13,11 +13,11 @@
 #    include <immintrin.h>
 #endif
 
-#include "openvino/core/type/bfloat16.hpp"
-#include "openvino/core/parallel.hpp"
-#include "common.hpp"
 #include "attn_quant.hpp"
 #include "attn_quant_kernel.hpp"
+#include "common.hpp"
+#include "openvino/core/parallel.hpp"
+#include "openvino/core/type/bfloat16.hpp"
 
 namespace ov {
 namespace Extensions {
@@ -26,7 +26,7 @@ namespace XARCH {
 
 using namespace ov;
 
-template<typename T>
+template <typename T>
 static void find_minmax(const T* src, size_t n, float& min, float& max) {
     max = -FLT_MAX;
     min = FLT_MAX;
@@ -133,7 +133,7 @@ static void find_minmax(const T* src, size_t n, float& min, float& max) {
     }
 }
 
-template<typename T>
+template <typename T>
 static void quant_u8(const T* src, uint8_t* dst, size_t n, float& scale, float& zp) {
     size_t i = 0;
     float max = -FLT_MAX;
@@ -176,7 +176,7 @@ static void quant_u8(const T* src, uint8_t* dst, size_t n, float& scale, float&
     }
 }
 
-template<typename T>
+template <typename T>
 static void quant_u4(const T* src, void* dst, size_t n, float& scale, float& zp) {
     size_t i = 0;
     float max = -FLT_MAX;
@@ -184,7 +184,7 @@ static void quant_u4(const T* src, void* dst, size_t n, float& scale, float& zp)
     find_minmax(src, n, min, max);
     auto insert_half_byte = [](uint8_t dst, uint8_t val, bool high_half) -> uint8_t {
         uint8_t shift = high_half ? 0 : 4;
-        return dst | (uint8_t) (val << shift);
+        return dst | (uint8_t)(val << shift);
     };
     auto dst_ptr = reinterpret_cast<uint8_t*>(dst);
     scale = (max - min) / ((1 << 4) - 1);
@@ -209,17 +209,17 @@ static void quant_u4(const T* src, void* dst, size_t n, float& scale, float& zp)
         v1_i32 = _mm512_min_epi32(v1_i32, v_upper);
         __m512i idx1 = _mm512_set_epi32(30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2, 0);
         __m512i idx2 = _mm512_set_epi32(31, 29, 27, 25, 23, 21, 19, 17, 15, 13, 11, 9, 7, 5, 3, 1);
-        auto first_half =  _mm512_permutex2var_epi32(v0_i32, idx1, v1_i32);
-        auto second_half =  _mm512_permutex2var_epi32(v0_i32, idx2, v1_i32);
+        auto first_half = _mm512_permutex2var_epi32(v0_i32, idx1, v1_i32);
+        auto second_half = _mm512_permutex2var_epi32(v0_i32, idx2, v1_i32);
         first_half = _mm512_slli_epi32(first_half, 4);
         auto mask = _mm512_set1_epi32(0x0F);
         second_half = _mm512_and_epi32(second_half, mask);
-        auto combined =  _mm512_or_epi32(first_half, second_half);
+        auto combined = _mm512_or_epi32(first_half, second_half);
         _mm512_mask_cvtepi32_storeu_epi8(dst_ptr + i / 2, 0xffff, combined);
     }
 #endif
 #if defined(HAVE_AVX2) || defined(HAVE_AVX512F)
-    auto v256_zero =  _mm256_set1_epi32(0);
+    auto v256_zero = _mm256_set1_epi32(0);
     auto v256_upper = _mm256_set1_epi32(15);
     auto v256_scale = _mm256_set1_ps(1 / scale);
     auto v256_zp = _mm256_set1_ps(zp);
@@ -264,7 +264,7 @@ static void quant_u4(const T* src, void* dst, size_t n, float& scale, float& zp)
 #endif
     for (; i < n; i++) {
         float tmp = src[i];
-        #define MIN(a, b) ((a) < (b) ? (a) : (b))
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
         uint8_t src_val = MIN(15, (uint8_t)(std::round(tmp / scale + zp)));
         uint8_t dst_val = i % 2 == 0 ? 0 : dst_ptr[i / 2];
         dst_val = insert_half_byte(dst_val, src_val, (uint8_t)(i % 2));
@@ -272,13 +272,13 @@ static void quant_u4(const T* src, void* dst, size_t n, float& scale, float& zp)
     }
 }
 
-template<typename T>
+template <typename T>
 static void quant_s4(const T* src, void* dst, size_t n, float& scale) {
     auto insert_half_byte = [](uint8_t dst, uint8_t val, bool high_half) -> uint8_t {
         uint8_t shift = high_half ? 0 : 4;
         if (high_half)
             val &= 0x0F;
-        return dst | (uint8_t) (val << shift);
+        return dst | (uint8_t)(val << shift);
     };
     auto dst_ptr = reinterpret_cast<uint8_t*>(dst);
     size_t i = 0;
@@ -308,18 +308,18 @@ static void quant_s4(const T* src, void* dst, size_t n, float& scale) {
 
         __m512i idx1 = _mm512_set_epi32(30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2, 0);
         __m512i idx2 = _mm512_set_epi32(31, 29, 27, 25, 23, 21, 19, 17, 15, 13, 11, 9, 7, 5, 3, 1);
-        auto first_half =  _mm512_permutex2var_epi32(v0_i32, idx1, v1_i32);
-        auto second_half =  _mm512_permutex2var_epi32(v0_i32, idx2, v1_i32);
+        auto first_half = _mm512_permutex2var_epi32(v0_i32, idx1, v1_i32);
+        auto second_half = _mm512_permutex2var_epi32(v0_i32, idx2, v1_i32);
 
         auto mask = _mm512_set1_epi32(0x0F);
         second_half = _mm512_and_epi32(second_half, mask);
         first_half = _mm512_slli_epi32(first_half, 4);
-        auto combined =  _mm512_or_epi32(first_half, second_half);
+        auto combined = _mm512_or_epi32(first_half, second_half);
         _mm512_mask_cvtepi32_storeu_epi8(dst_ptr + i / 2, 0xffff, combined);
     }
 #endif
 #if defined(HAVE_AVX2) || defined(HAVE_AVX512F)
-    auto v256_lower =  _mm256_set1_epi32(-8);
+    auto v256_lower = _mm256_set1_epi32(-8);
     auto v256_upper = _mm256_set1_epi32(7);
     auto v256_scale = _mm256_set1_ps(1 / scale);
     for (; i + vec_len_f32_avx2 * 2 <= n; i += vec_len_f32_avx2 * 2) {
@@ -384,16 +384,8 @@ static void attn_quant_mt(const ov::intel_cpu::PlainTensor& k_src,
     parallel_for3d(L1, B, H, [&](size_t m, size_t b, size_t h) {
         auto p_k = k_scale_zp.ptr<float>(m, b, h);
         auto p_v = v_scale_zp.ptr<float>(m, b, h);
-        quant_u8(k_src.ptr<T>(b, h, m),
-                 k_dst.ptr<T2>(b, h, m),
-                 S,
-                 p_k[0],
-                 p_k[1]);
-        quant_u8(v_src.ptr<T>(b, h, m),
-                 v_dst.ptr<T2>(b, h, m),
-                 SV,
-                 p_v[0],
-                 p_v[1]);
+        quant_u8(k_src.ptr<T>(b, h, m), k_dst.ptr<T2>(b, h, m), S, p_k[0], p_k[1]);
+        quant_u8(v_src.ptr<T>(b, h, m), v_dst.ptr<T2>(b, h, m), SV, p_v[0], p_v[1]);
     });
 }
 
@@ -414,11 +406,13 @@ static void paged_attn_quant_mt(const ov::intel_cpu::PlainTensor& k_src,
     size_t _value_group_size = value_group_size == 0 ? SV : value_group_size;
     parallel_for3d(B, L1, H, [&](size_t b, size_t m, size_t h) {
         auto slot = slot_mapping.ptr<int32_t>(b)[m];
-        if (slot < 0) return;
+        if (slot < 0)
+            return;
         auto block_number = slot / block_size;
         auto block_offset = slot % block_size;
         // The layout for per token per head:
-        // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized feature(u8,idx_S)|
+        // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized
+        // feature(u8,idx_S)|
         for (size_t src_offset = 0, dst_offset = 0; src_offset < S;
              src_offset += _key_group_size, dst_offset += _key_group_size + sizeof(float) + sizeof(float)) {
             auto p_k = reinterpret_cast<float*>(
@@ -475,11 +469,13 @@ static void paged_attn_quant_mt(const ov::intel_cpu::PlainTensor& k_src,
     size_t sub_byte_multiplier = 8 / v_dst.get_precision().bitwidth();
     parallel_for3d(B, L1, H, [&](size_t b, size_t m, size_t h) {
         auto slot = slot_mapping.ptr<int32_t>(b)[m];
-        if (slot < 0) return;
+        if (slot < 0)
+            return;
         auto block_number = slot / block_size;
         auto block_offset = slot % block_size;
         // The layout for per token per head:
-        // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized feature(u8,idx_S)|
+        // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized
+        // feature(u8,idx_S)|
         for (size_t src_offset = 0, dst_offset = 0; src_offset < S;
              src_offset += _key_group_size, dst_offset += _key_group_size + sizeof(float) + sizeof(float)) {
             auto p_k = reinterpret_cast<float*>(
@@ -530,11 +526,13 @@ static void paged_attn_quant_mt(const ov::intel_cpu::PlainTensor& k_src,
     size_t sub_byte_multiplier = 8 / v_dst.get_precision().bitwidth();
     parallel_for3d(B, L1, H, [&](size_t b, size_t m, size_t h) {
         auto slot = slot_mapping.ptr<int32_t>(b)[m];
-        if (slot < 0) return;
+        if (slot < 0)
+            return;
         auto block_number = slot / block_size;
         auto block_offset = slot % block_size;
         // The layout for per token per head:
-        // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized feature(u8,idx_S)|
+        // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized
+        // feature(u8,idx_S)|
         for (size_t src_offset = 0, dst_offset = 0; src_offset < S;
              src_offset += _key_group_size, dst_offset += _key_group_size + sizeof(float) + sizeof(float)) {
             auto p_k = reinterpret_cast<float*>(
@@ -553,8 +551,8 @@ static void paged_attn_quant_mt(const ov::intel_cpu::PlainTensor& k_src,
                      p_k[1]);
         }
 
-        for (size_t src_offset = 0, dst_offset = 0; src_offset < SV; src_offset += _value_group_size,
-                    dst_offset += _value_group_size / sub_byte_multiplier + sizeof(float)) {
+        for (size_t src_offset = 0, dst_offset = 0; src_offset < SV;
+             src_offset += _value_group_size, dst_offset += _value_group_size / sub_byte_multiplier + sizeof(float)) {
             uint8_t* v_base = reinterpret_cast<uint8_t*>(
                 v_dst.m_ptr.get() +
                 (block_number * v_dst.m_strides[0] + h * v_dst.m_strides[1] + block_offset * v_dst.m_strides[2]) /
@@ -580,7 +578,11 @@ void attn_quantkv(const ov::intel_cpu::PlainTensor& k_src,
     } else if (k_src.get_precision() == ov::element::f16 && k_dst.get_precision() == ov::element::u8) {
         attn_quant_mt<ov::float16, uint8_t>(k_src, v_src, k_dst, v_dst, k_scale_zp, v_scale_zp);
     } else {
-        OPENVINO_THROW("unsupport src type: ", k_src.get_precision(), ", dst type: ", k_dst.get_precision(), " in attn_quantkv");
+        OPENVINO_THROW("unsupport src type: ",
+                       k_src.get_precision(),
+                       ", dst type: ",
+                       k_dst.get_precision(),
+                       " in attn_quantkv");
     }
 }
 
@@ -592,29 +594,33 @@ void paged_attn_quantkv(const ov::intel_cpu::PlainTensor& k_src,
                         const size_t key_group_size,
                         const size_t value_group_size) {
     using function_type = void (*)(const ov::intel_cpu::PlainTensor&,
-                                    const ov::intel_cpu::PlainTensor&,
-                                    const ov::intel_cpu::PlainTensor&,
-                                    const ov::intel_cpu::PlainTensor&,
-                                    const ov::intel_cpu::PlainTensor&,
-                                    const size_t,
-                                    const size_t);
+                                   const ov::intel_cpu::PlainTensor&,
+                                   const ov::intel_cpu::PlainTensor&,
+                                   const ov::intel_cpu::PlainTensor&,
+                                   const ov::intel_cpu::PlainTensor&,
+                                   const size_t,
+                                   const size_t);
     static constexpr function_type funcs_fp32[] = {
-            paged_attn_quant_mt<float, ov::element::u8, ov::element::u8>,
-            paged_attn_quant_mt<float, ov::element::u8, ov::element::u4>,
-            paged_attn_quant_mt<float, ov::element::u8, ov::element::i4>,
+        paged_attn_quant_mt<float, ov::element::u8, ov::element::u8>,
+        paged_attn_quant_mt<float, ov::element::u8, ov::element::u4>,
+        paged_attn_quant_mt<float, ov::element::u8, ov::element::i4>,
     };
     static constexpr function_type funcs_bf16[] = {
-            paged_attn_quant_mt<ov::bfloat16, ov::element::u8, ov::element::u8>,
-            paged_attn_quant_mt<ov::bfloat16, ov::element::u8, ov::element::u4>,
-            paged_attn_quant_mt<ov::bfloat16, ov::element::u8, ov::element::i4>,
+        paged_attn_quant_mt<ov::bfloat16, ov::element::u8, ov::element::u8>,
+        paged_attn_quant_mt<ov::bfloat16, ov::element::u8, ov::element::u4>,
+        paged_attn_quant_mt<ov::bfloat16, ov::element::u8, ov::element::i4>,
     };
     static constexpr function_type funcs_f16[] = {
-            paged_attn_quant_mt<ov::float16, ov::element::u8, ov::element::u8>,
-            paged_attn_quant_mt<ov::float16, ov::element::u8, ov::element::u4>,
-            paged_attn_quant_mt<ov::float16, ov::element::u8, ov::element::i4>,
+        paged_attn_quant_mt<ov::float16, ov::element::u8, ov::element::u8>,
+        paged_attn_quant_mt<ov::float16, ov::element::u8, ov::element::u4>,
+        paged_attn_quant_mt<ov::float16, ov::element::u8, ov::element::i4>,
     };
     if (k_dst.get_precision() != ov::element::u8) {
-        OPENVINO_THROW("unsupport src type: ", k_src.get_precision(), ", dst type: ", k_dst.get_precision(), " in paged_attn_quantkv");
+        OPENVINO_THROW("unsupport src type: ",
+                       k_src.get_precision(),
+                       ", dst type: ",
+                       k_dst.get_precision(),
+                       " in paged_attn_quantkv");
     }
     std::map<ov::element::Type, size_t> dispatch_table = {
         {ov::element::u8, 0},
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_quant.hpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_quant.hpp
index 70711ee49cbc3c..364e5775861ed2 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_quant.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_quant.hpp
@@ -7,6 +7,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <vector>
+
 #include "openvino/core/type/element_type.hpp"
 #include "utils/plain_tensor.hpp"
 
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_quant_kernel.hpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_quant_kernel.hpp
index 434286766d5188..6083715c917910 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_quant_kernel.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/attn_quant_kernel.hpp
@@ -3,19 +3,21 @@
 //
 #pragma once
 
-#include <array>
+#include "nodes/kernels/scaled_attn/common.hpp"
+
+#if defined(HAVE_SSE) || defined(HAVE_AVX2) || defined(HAVE_AVX512F)
+#    include <immintrin.h>
+#endif
+
 #include <cstddef>
 #include <cstdint>
-#include <vector>
-#include "openvino/core/type/element_type.hpp"
-#include "utils/plain_tensor.hpp"
 
 namespace ov {
 namespace Extensions {
 namespace Cpu {
 namespace XARCH {
 
-template<typename TDST>
+template <typename TDST>
 void attn_dequant_u8_kernel(const uint8_t* src, TDST* dst, size_t n, float scale, float zp) {
     size_t i = 0;
     // loadu_si128/epi64 does not support const qualifier
@@ -218,4 +220,4 @@ void attn_dequant_s4_kernel(const uint8_t* src, TDST* dst, size_t n, float scale
 }  // namespace XARCH
 }  // namespace Cpu
 }  // namespace Extensions
-}  // namespace ov
\ No newline at end of file
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/common.hpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/common.hpp
index 2956c8a6a6b5b8..4e14cf5894b04d 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/common.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/common.hpp
@@ -4,16 +4,20 @@
 #pragma once
 
 #include <array>
+#include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <vector>
-#include <cassert>
 
 #include "openvino/core/type/bfloat16.hpp"
 #include "openvino/core/type/float16.hpp"
 
+#if defined(HAVE_SSE) || defined(HAVE_AVX2) || defined(HAVE_AVX512F)
+#    include <immintrin.h>
+#endif
+
 #if defined(OPENVINO_ARCH_ARM64)
-#include "arm_neon.h"
+#    include "arm_neon.h"
 #endif
 
 namespace ov {
@@ -32,307 +36,307 @@ static constexpr size_t vec_len_f32_neon = vec_len_neon / sizeof(float);
 static constexpr size_t vec_len_f16_neon = vec_len_neon / sizeof(ov::float16);
 
 #ifdef HAVE_AVX512F
-    inline __m512 cvt_bf16_to_fp32(const __m256i src) {
-        __m512i y = _mm512_cvtepu16_epi32(src);
-        return _mm512_castsi512_ps(_mm512_slli_epi32(y, 16));
-    }
-
-    // load addr to __m512 reg
-    inline __m512 mm512_uni_loadu_ps(const float* a) {
-        return _mm512_loadu_ps(a);
-    }
-
-    inline __m512 mm512_uni_loadu_ps(const ov::bfloat16* a) {
-        auto vec_bf16 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(a));
-        return cvt_bf16_to_fp32(vec_bf16);
-    }
-
-    inline __m512 mm512_uni_loadu_ps(const ov::float16* a) {
-        auto vec_f16 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(a));
-        return _mm512_cvtph_ps(vec_f16);
-    }
-
-    // load addr to __m512 reg
-    inline __m512 mm512_uni_loadu_tail_ps(const float* a, size_t count) {
-        __mmask16 mask = (1 << count) - 1;
-        return _mm512_maskz_loadu_ps(mask, a);
-    }
-
-    inline __m512 mm512_uni_loadu_tail_ps(const ov::bfloat16* a, size_t count) {
-        auto mask = (1 << count) - 1;
-        auto bf16_vec = _mm256_maskz_loadu_epi16(mask, a);
-        return cvt_bf16_to_fp32(bf16_vec);
-    }
-
-    inline __m512 mm512_uni_loadu_tail_ps(const ov::float16* a, size_t count) {
-        auto mask = (1 << count) - 1;
-        auto f16_vec = _mm256_maskz_loadu_epi16(mask, a);
-        return _mm512_cvtph_ps(f16_vec);
-    }
-
-    // store __m512 reg to addr
-    inline void mm512_uni_storeu_ps(float* a,  __m512 v) {
-        _mm512_storeu_ps(a, v);
-    }
-    inline void mm512_uni_storeu_ps(ov::bfloat16 *addr, __m512 xps) {
-        __m512i xpi32 = _mm512_castps_si512(xps);
-        __m512i nan = _mm512_set1_epi32(0xffff);
-        auto mask = _mm512_cmp_ps_mask(xps, xps, _CMP_ORD_Q);
-        __m512i ones = _mm512_set1_epi32(0x1);
-        __m512i vec_bias = _mm512_set1_epi32(0x7fff);
-        auto x = _mm512_and_si512(_mm512_srli_epi32(xpi32, 16), ones); // LSB = x[16]
-        x = _mm512_add_epi32(x, vec_bias);                             // rounding_bias = 0x7fff + LSB
-        x = _mm512_srli_epi32(_mm512_add_epi32(x, xpi32), 16);         // x = (x + rounding_bias) >> 16;
-        x = _mm512_mask_blend_epi32(mask, nan, x);                     // Check NaN before converting back to bf16
-        _mm256_storeu_si256(reinterpret_cast<__m256i *>(addr), _mm512_cvtepi32_epi16(x));
-    }
-
-    inline void mm512_uni_storeu_ps(ov::float16* addr,  __m512 v) {
-        __m256i vec_f16 = _mm512_cvtps_ph(v, 0);
-        _mm256_storeu_si256(reinterpret_cast<__m256i *>(addr), vec_f16);
-    }
-
-    // store __m512 reg to addr
-    inline void mm512_uni_mask_storeu_ps(ov::bfloat16 *addr, __mmask16 mask_addr, __m512 xps) {
-        __m512i xpi32 = _mm512_castps_si512(xps);
-        __m512i nan = _mm512_set1_epi32(0xffff);
-        auto mask = _mm512_cmp_ps_mask(xps, xps, _CMP_ORD_Q);
-        __m512i ones = _mm512_set1_epi32(0x1);
-        __m512i vec_bias = _mm512_set1_epi32(0x7fff);
-        auto x = _mm512_and_si512(_mm512_srli_epi32(xpi32, 16), ones); // LSB = x[16]
-        x = _mm512_add_epi32(x, vec_bias);                             // rounding_bias = 0x7fff + LSB
-        x = _mm512_srli_epi32(_mm512_add_epi32(x, xpi32), 16);         // x = (x + rounding_bias) >> 16;
-        x = _mm512_mask_blend_epi32(mask, nan, x);                     // Check NaN before converting back to bf16
-        _mm512_mask_cvtepi32_storeu_epi16(addr, mask_addr, x);
-    }
-
-    inline void mm512_uni_storeu_tail_ps(float *addr, __m512 v, size_t count) {
-        __mmask16 mask_addr = (1 << count) - 1;
-        _mm512_mask_storeu_ps(addr, mask_addr, v);
-    }
-
-    inline void mm512_uni_storeu_tail_ps(ov::bfloat16 *addr, __m512 v, size_t count) {
-        __mmask16 mask_addr = (1 << count) - 1;
-        __m512i xpi32 = _mm512_castps_si512(v);
-        __m512i nan = _mm512_set1_epi32(0xffff);
-        auto mask = _mm512_cmp_ps_mask(v, v, _CMP_ORD_Q);
-        __m512i ones = _mm512_set1_epi32(0x1);
-        __m512i vec_bias = _mm512_set1_epi32(0x7fff);
-        auto x = _mm512_and_si512(_mm512_srli_epi32(xpi32, 16), ones); // LSB = x[16]
-        x = _mm512_add_epi32(x, vec_bias);                             // rounding_bias = 0x7fff + LSB
-        x = _mm512_srli_epi32(_mm512_add_epi32(x, xpi32), 16);         // x = (x + rounding_bias) >> 16;
-        x = _mm512_mask_blend_epi32(mask, nan, x);                     // Check NaN before converting back to bf16
-        _mm512_mask_cvtepi32_storeu_epi16(addr, mask_addr, x);
-    }
-
-    inline void mm512_uni_storeu_tail_ps(ov::float16 *addr, __m512 v, size_t count) {
-        __mmask16 mask_addr = (1 << count) - 1;
-        __m256i vec_f16 = _mm512_cvtps_ph(v, 0);
-        _mm256_mask_storeu_epi16(reinterpret_cast<__m256i *>(addr), mask_addr, vec_f16);
-    }
+inline __m512 cvt_bf16_to_fp32(const __m256i src) {
+    __m512i y = _mm512_cvtepu16_epi32(src);
+    return _mm512_castsi512_ps(_mm512_slli_epi32(y, 16));
+}
+
+// load addr to __m512 reg
+inline __m512 mm512_uni_loadu_ps(const float* a) {
+    return _mm512_loadu_ps(a);
+}
+
+inline __m512 mm512_uni_loadu_ps(const ov::bfloat16* a) {
+    auto vec_bf16 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(a));
+    return cvt_bf16_to_fp32(vec_bf16);
+}
+
+inline __m512 mm512_uni_loadu_ps(const ov::float16* a) {
+    auto vec_f16 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(a));
+    return _mm512_cvtph_ps(vec_f16);
+}
+
+// load addr to __m512 reg
+inline __m512 mm512_uni_loadu_tail_ps(const float* a, size_t count) {
+    __mmask16 mask = (1 << count) - 1;
+    return _mm512_maskz_loadu_ps(mask, a);
+}
+
+inline __m512 mm512_uni_loadu_tail_ps(const ov::bfloat16* a, size_t count) {
+    auto mask = (1 << count) - 1;
+    auto bf16_vec = _mm256_maskz_loadu_epi16(mask, a);
+    return cvt_bf16_to_fp32(bf16_vec);
+}
+
+inline __m512 mm512_uni_loadu_tail_ps(const ov::float16* a, size_t count) {
+    auto mask = (1 << count) - 1;
+    auto f16_vec = _mm256_maskz_loadu_epi16(mask, a);
+    return _mm512_cvtph_ps(f16_vec);
+}
+
+// store __m512 reg to addr
+inline void mm512_uni_storeu_ps(float* a, __m512 v) {
+    _mm512_storeu_ps(a, v);
+}
+inline void mm512_uni_storeu_ps(ov::bfloat16* addr, __m512 xps) {
+    __m512i xpi32 = _mm512_castps_si512(xps);
+    __m512i nan = _mm512_set1_epi32(0xffff);
+    auto mask = _mm512_cmp_ps_mask(xps, xps, _CMP_ORD_Q);
+    __m512i ones = _mm512_set1_epi32(0x1);
+    __m512i vec_bias = _mm512_set1_epi32(0x7fff);
+    auto x = _mm512_and_si512(_mm512_srli_epi32(xpi32, 16), ones);  // LSB = x[16]
+    x = _mm512_add_epi32(x, vec_bias);                              // rounding_bias = 0x7fff + LSB
+    x = _mm512_srli_epi32(_mm512_add_epi32(x, xpi32), 16);          // x = (x + rounding_bias) >> 16;
+    x = _mm512_mask_blend_epi32(mask, nan, x);                      // Check NaN before converting back to bf16
+    _mm256_storeu_si256(reinterpret_cast<__m256i*>(addr), _mm512_cvtepi32_epi16(x));
+}
+
+inline void mm512_uni_storeu_ps(ov::float16* addr, __m512 v) {
+    __m256i vec_f16 = _mm512_cvtps_ph(v, 0);
+    _mm256_storeu_si256(reinterpret_cast<__m256i*>(addr), vec_f16);
+}
+
+// store __m512 reg to addr
+inline void mm512_uni_mask_storeu_ps(ov::bfloat16* addr, __mmask16 mask_addr, __m512 xps) {
+    __m512i xpi32 = _mm512_castps_si512(xps);
+    __m512i nan = _mm512_set1_epi32(0xffff);
+    auto mask = _mm512_cmp_ps_mask(xps, xps, _CMP_ORD_Q);
+    __m512i ones = _mm512_set1_epi32(0x1);
+    __m512i vec_bias = _mm512_set1_epi32(0x7fff);
+    auto x = _mm512_and_si512(_mm512_srli_epi32(xpi32, 16), ones);  // LSB = x[16]
+    x = _mm512_add_epi32(x, vec_bias);                              // rounding_bias = 0x7fff + LSB
+    x = _mm512_srli_epi32(_mm512_add_epi32(x, xpi32), 16);          // x = (x + rounding_bias) >> 16;
+    x = _mm512_mask_blend_epi32(mask, nan, x);                      // Check NaN before converting back to bf16
+    _mm512_mask_cvtepi32_storeu_epi16(addr, mask_addr, x);
+}
+
+inline void mm512_uni_storeu_tail_ps(float* addr, __m512 v, size_t count) {
+    __mmask16 mask_addr = (1 << count) - 1;
+    _mm512_mask_storeu_ps(addr, mask_addr, v);
+}
+
+inline void mm512_uni_storeu_tail_ps(ov::bfloat16* addr, __m512 v, size_t count) {
+    __mmask16 mask_addr = (1 << count) - 1;
+    __m512i xpi32 = _mm512_castps_si512(v);
+    __m512i nan = _mm512_set1_epi32(0xffff);
+    auto mask = _mm512_cmp_ps_mask(v, v, _CMP_ORD_Q);
+    __m512i ones = _mm512_set1_epi32(0x1);
+    __m512i vec_bias = _mm512_set1_epi32(0x7fff);
+    auto x = _mm512_and_si512(_mm512_srli_epi32(xpi32, 16), ones);  // LSB = x[16]
+    x = _mm512_add_epi32(x, vec_bias);                              // rounding_bias = 0x7fff + LSB
+    x = _mm512_srli_epi32(_mm512_add_epi32(x, xpi32), 16);          // x = (x + rounding_bias) >> 16;
+    x = _mm512_mask_blend_epi32(mask, nan, x);                      // Check NaN before converting back to bf16
+    _mm512_mask_cvtepi32_storeu_epi16(addr, mask_addr, x);
+}
+
+inline void mm512_uni_storeu_tail_ps(ov::float16* addr, __m512 v, size_t count) {
+    __mmask16 mask_addr = (1 << count) - 1;
+    __m256i vec_f16 = _mm512_cvtps_ph(v, 0);
+    _mm256_mask_storeu_epi16(reinterpret_cast<__m256i*>(addr), mask_addr, vec_f16);
+}
 #endif
 
 #ifdef HAVE_AVX2
-    inline __m256i get_mask(int N7) {
-        static __m256i mask[] = {
-            _mm256_set_epi32(0, 0, 0, 0, 0, 0, 0, 0),
-            _mm256_set_epi32(0, 0, 0, 0, 0, 0, 0, -1),
-            _mm256_set_epi32(0, 0, 0, 0, 0, 0, -1, -1),
-            _mm256_set_epi32(0, 0, 0, 0, 0, -1, -1, -1),
-            _mm256_set_epi32(0, 0, 0, 0, -1, -1, -1, -1),
-            _mm256_set_epi32(0, 0, 0, -1, -1, -1, -1, -1),
-            _mm256_set_epi32(0, 0, -1, -1, -1, -1, -1, -1),
-            _mm256_set_epi32(0, -1, -1, -1, -1, -1, -1, -1),
-            _mm256_set_epi32(-1, -1, -1, -1, -1, -1, -1, -1),
-        };
-        return _mm256_loadu_si256(&mask[N7]);
-    }
-
-    // load addr to __m256 reg
-    inline __m256 mm256_uni_loadu_ps(const float* a) {
-        return _mm256_loadu_ps(a);
-    }
-
-    inline __m256 mm256_uni_loadu_ps(const ov::bfloat16* a) {
-        auto vec_bf16 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(a));
-        auto o = _mm256_castsi256_ps(_mm256_slli_epi32(_mm256_cvtepu16_epi32(vec_bf16), 16));
-        return o;
-    }
-
-    inline __m256 mm256_uni_loadu_ps(const ov::float16* a) {
-        auto vec_f16 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(a));
-        auto o = _mm256_cvtph_ps(vec_f16);
-        return o;
-    }
-
-    // load addr tail to __m256 reg
-    inline __m256 mm256_uni_loadu_tail_ps(const float* a, const size_t count) {
-        auto mask = get_mask(count);
-        return _mm256_maskload_ps(a, mask);
-    }
-
-    inline __m256 mm256_uni_loadu_tail_ps(const ov::bfloat16* a, const size_t count) {
-        assert("AVX2 version of bfloat16 tail load is just for compilation pass");
-        ov::bfloat16 tmp_values[8] = {0};
-        std::memcpy(tmp_values, a, count * sizeof(ov::bfloat16));
-        return mm256_uni_loadu_ps(tmp_values);
-    }
-
-    inline __m256 mm256_uni_loadu_tail_ps(const ov::float16* a, const size_t count) {
-        ov::float16 tmp_values[8] = {0};
-        std::memcpy(tmp_values, a, count * sizeof(ov::float16));
-        return mm256_uni_loadu_ps(tmp_values);
-    }
-
-    // store __m256 reg to addr
-    inline void mm256_uni_storeu_ps(float* a,  __m256 v) {
-        _mm256_storeu_ps(a, v);
-    }
-
-    inline void mm256_uni_storeu_ps(ov::bfloat16 *addr, __m256 xps) {
-        __m256i xpi32 = _mm256_castps_si256(xps);
-        __m256i nan = _mm256_set1_epi32(0xffff);
-        __m256i mask = _mm256_castps_si256(_mm256_cmp_ps(xps, xps, _CMP_ORD_Q));
-        __m256i ones = _mm256_set1_epi32(0x1);
-        __m256i vec_bias = _mm256_set1_epi32(0x7fff);
-        auto x = _mm256_and_si256(_mm256_srli_epi32(xpi32, 16), ones); // LSB = x[16]
-        x = _mm256_add_epi32(x, vec_bias);                             // rounding_bias = 0x7fff + LSB
-        x = _mm256_srli_epi32(_mm256_add_epi32(x, xpi32), 16);         // x = (x + rounding_bias) >> 16;
-        x = _mm256_blendv_epi8(nan, x, mask);                          // Check NaN before converting back to bf16
-        x = _mm256_packus_epi32(x, x);
-        x = _mm256_permute4x64_epi64(x, 0xd8);
-        __m128i bf16_o = _mm256_extractf128_si256(x, 0);
-        _mm_storeu_si128(reinterpret_cast<__m128i *>(addr), bf16_o);
-    }
-
-    inline void mm256_uni_storeu_ps(ov::float16* a,  __m256 v) {
-        __m128i vec_f16 = _mm256_cvtps_ph(v, 0);
-        _mm_storeu_si128(reinterpret_cast<__m128i *>(a), vec_f16);
-    }
-
-    // store __m256 to addr
-    inline void mm256_uni_storeu_tail_ps(float *addr, __m256 v, size_t count) {
-        const auto mask = get_mask(count);
-        return _mm256_maskstore_ps(addr, mask, v);
-    }
-
-    inline void hsum(__m256& x) {
-        __m256 y;                             // x:  0 1 2 3   4 5 6 7
-        y = _mm256_permute_ps(x, 0x39);       // y:  1 2 3 0   5 6 7 4
-        x = _mm256_add_ps(x, y);              // X:  01 12 23 30  45 56 67 74
-        y = _mm256_permute_ps(x, 0x4e);       // y:  23 30 01 12  67 74 45 56
-        x = _mm256_add_ps(x, y);              // x: 0123 x x x   4567 x x x
-        y = _mm256_permute2f128_ps(x, x, 1);  // y: 4567 x x x  0123 x x x
-        x = _mm256_add_ps(x, y);              // x: 01234567 x x x x x x x
-    }
-    inline void hmax(__m256& x) {
-        __m256 y;                             // x:  0 1 2 3   4 5 6 7
-        y = _mm256_permute_ps(x, 0x39);       // y:  1 2 3 0   5 6 7 4
-        x = _mm256_max_ps(x, y);              // X:  01 12 23 30  45 56 67 74
-        y = _mm256_permute_ps(x, 0x4e);       // y:  23 30 01 12  67 74 45 56
-        x = _mm256_max_ps(x, y);              // x: 0123 x x x   4567 x x x
-        y = _mm256_permute2f128_ps(x, x, 1);  // y: 4567 x x x  0123 x x x
-        x = _mm256_max_ps(x, y);              // x: 01234567 x x x x x x x
-    }
-    inline void hmin(__m256& x) {
-        __m256 y;                             // x:  0 1 2 3   4 5 6 7
-        y = _mm256_permute_ps(x, 0x39);       // y:  1 2 3 0   5 6 7 4
-        x = _mm256_min_ps(x, y);              // X:  01 12 23 30  45 56 67 74
-        y = _mm256_permute_ps(x, 0x4e);       // y:  23 30 01 12  67 74 45 56
-        x = _mm256_min_ps(x, y);              // x: 0123 x x x   4567 x x x
-        y = _mm256_permute2f128_ps(x, x, 1);  // y: 4567 x x x  0123 x x x
-        x = _mm256_min_ps(x, y);              // x: 01234567 x x x x x x x
-    }
+inline __m256i get_mask(int N7) {
+    static __m256i mask[] = {
+        _mm256_set_epi32(0, 0, 0, 0, 0, 0, 0, 0),
+        _mm256_set_epi32(0, 0, 0, 0, 0, 0, 0, -1),
+        _mm256_set_epi32(0, 0, 0, 0, 0, 0, -1, -1),
+        _mm256_set_epi32(0, 0, 0, 0, 0, -1, -1, -1),
+        _mm256_set_epi32(0, 0, 0, 0, -1, -1, -1, -1),
+        _mm256_set_epi32(0, 0, 0, -1, -1, -1, -1, -1),
+        _mm256_set_epi32(0, 0, -1, -1, -1, -1, -1, -1),
+        _mm256_set_epi32(0, -1, -1, -1, -1, -1, -1, -1),
+        _mm256_set_epi32(-1, -1, -1, -1, -1, -1, -1, -1),
+    };
+    return _mm256_loadu_si256(&mask[N7]);
+}
+
+// load addr to __m256 reg
+inline __m256 mm256_uni_loadu_ps(const float* a) {
+    return _mm256_loadu_ps(a);
+}
+
+inline __m256 mm256_uni_loadu_ps(const ov::bfloat16* a) {
+    auto vec_bf16 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(a));
+    auto o = _mm256_castsi256_ps(_mm256_slli_epi32(_mm256_cvtepu16_epi32(vec_bf16), 16));
+    return o;
+}
+
+inline __m256 mm256_uni_loadu_ps(const ov::float16* a) {
+    auto vec_f16 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(a));
+    auto o = _mm256_cvtph_ps(vec_f16);
+    return o;
+}
+
+// load addr tail to __m256 reg
+inline __m256 mm256_uni_loadu_tail_ps(const float* a, const size_t count) {
+    auto mask = get_mask(count);
+    return _mm256_maskload_ps(a, mask);
+}
+
+inline __m256 mm256_uni_loadu_tail_ps(const ov::bfloat16* a, const size_t count) {
+    assert("AVX2 version of bfloat16 tail load is just for compilation pass");
+    ov::bfloat16 tmp_values[8] = {0};
+    std::memcpy(tmp_values, a, count * sizeof(ov::bfloat16));
+    return mm256_uni_loadu_ps(tmp_values);
+}
+
+inline __m256 mm256_uni_loadu_tail_ps(const ov::float16* a, const size_t count) {
+    ov::float16 tmp_values[8] = {0};
+    std::memcpy(tmp_values, a, count * sizeof(ov::float16));
+    return mm256_uni_loadu_ps(tmp_values);
+}
+
+// store __m256 reg to addr
+inline void mm256_uni_storeu_ps(float* a, __m256 v) {
+    _mm256_storeu_ps(a, v);
+}
+
+inline void mm256_uni_storeu_ps(ov::bfloat16* addr, __m256 xps) {
+    __m256i xpi32 = _mm256_castps_si256(xps);
+    __m256i nan = _mm256_set1_epi32(0xffff);
+    __m256i mask = _mm256_castps_si256(_mm256_cmp_ps(xps, xps, _CMP_ORD_Q));
+    __m256i ones = _mm256_set1_epi32(0x1);
+    __m256i vec_bias = _mm256_set1_epi32(0x7fff);
+    auto x = _mm256_and_si256(_mm256_srli_epi32(xpi32, 16), ones);  // LSB = x[16]
+    x = _mm256_add_epi32(x, vec_bias);                              // rounding_bias = 0x7fff + LSB
+    x = _mm256_srli_epi32(_mm256_add_epi32(x, xpi32), 16);          // x = (x + rounding_bias) >> 16;
+    x = _mm256_blendv_epi8(nan, x, mask);                           // Check NaN before converting back to bf16
+    x = _mm256_packus_epi32(x, x);
+    x = _mm256_permute4x64_epi64(x, 0xd8);
+    __m128i bf16_o = _mm256_extractf128_si256(x, 0);
+    _mm_storeu_si128(reinterpret_cast<__m128i*>(addr), bf16_o);
+}
+
+inline void mm256_uni_storeu_ps(ov::float16* a, __m256 v) {
+    __m128i vec_f16 = _mm256_cvtps_ph(v, 0);
+    _mm_storeu_si128(reinterpret_cast<__m128i*>(a), vec_f16);
+}
+
+// store __m256 to addr
+inline void mm256_uni_storeu_tail_ps(float* addr, __m256 v, size_t count) {
+    const auto mask = get_mask(count);
+    return _mm256_maskstore_ps(addr, mask, v);
+}
+
+inline void hsum(__m256& x) {
+    __m256 y;                             // x:  0 1 2 3   4 5 6 7
+    y = _mm256_permute_ps(x, 0x39);       // y:  1 2 3 0   5 6 7 4
+    x = _mm256_add_ps(x, y);              // X:  01 12 23 30  45 56 67 74
+    y = _mm256_permute_ps(x, 0x4e);       // y:  23 30 01 12  67 74 45 56
+    x = _mm256_add_ps(x, y);              // x: 0123 x x x   4567 x x x
+    y = _mm256_permute2f128_ps(x, x, 1);  // y: 4567 x x x  0123 x x x
+    x = _mm256_add_ps(x, y);              // x: 01234567 x x x x x x x
+}
+inline void hmax(__m256& x) {
+    __m256 y;                             // x:  0 1 2 3   4 5 6 7
+    y = _mm256_permute_ps(x, 0x39);       // y:  1 2 3 0   5 6 7 4
+    x = _mm256_max_ps(x, y);              // X:  01 12 23 30  45 56 67 74
+    y = _mm256_permute_ps(x, 0x4e);       // y:  23 30 01 12  67 74 45 56
+    x = _mm256_max_ps(x, y);              // x: 0123 x x x   4567 x x x
+    y = _mm256_permute2f128_ps(x, x, 1);  // y: 4567 x x x  0123 x x x
+    x = _mm256_max_ps(x, y);              // x: 01234567 x x x x x x x
+}
+inline void hmin(__m256& x) {
+    __m256 y;                             // x:  0 1 2 3   4 5 6 7
+    y = _mm256_permute_ps(x, 0x39);       // y:  1 2 3 0   5 6 7 4
+    x = _mm256_min_ps(x, y);              // X:  01 12 23 30  45 56 67 74
+    y = _mm256_permute_ps(x, 0x4e);       // y:  23 30 01 12  67 74 45 56
+    x = _mm256_min_ps(x, y);              // x: 0123 x x x   4567 x x x
+    y = _mm256_permute2f128_ps(x, x, 1);  // y: 4567 x x x  0123 x x x
+    x = _mm256_min_ps(x, y);              // x: 01234567 x x x x x x x
+}
 #endif
 
 #ifdef OPENVINO_ARCH_ARM64
-    inline float32x4_t exp_ps_neon_f32(const float32x4_t& src) {
-        const auto c1 = vreinterpretq_f32_u32(vdupq_n_u32(0x3f7ffff6));
-        const auto c2 = vreinterpretq_f32_u32(vdupq_n_u32(0x3efffedb));
-        const auto c3 = vreinterpretq_f32_u32(vdupq_n_u32(0x3e2aaf33));
-        const auto c4 = vreinterpretq_f32_u32(vdupq_n_u32(0x3d2b9f17));
-        const auto c5 = vreinterpretq_f32_u32(vdupq_n_u32(0x3c072010));
-
-        const auto shift   = vreinterpretq_f32_u32(vdupq_n_u32(0x4b00007f)); // 2^23 + 127 = 0x1.0000fep23f
-        const auto one   = vdupq_n_f32(1.0f); // 1
-        const auto two   = vdupq_n_f32(2.0f); // 2
-        const auto inv_ln2 = vreinterpretq_f32_u32(vdupq_n_u32(0x3fb8aa3b));
-        const auto neg_ln2_hi = vreinterpretq_f32_u32(vdupq_n_u32(0xbf317200));
-        const auto neg_ln2_lo = vreinterpretq_f32_u32(vdupq_n_u32(0xb5bfbe8e));
-
-        const auto inf       = vdupq_n_f32(std::numeric_limits<float>::infinity());
-        const auto max_input = vdupq_n_f32(88.37f); // Approximately ln(2^127.5)
-        const auto zero      = vdupq_n_f32(0.f);
-        const auto min_input = vdupq_n_f32(-86.64f); // Approximately ln(2^-125)
-
-        const auto z     = vmlaq_f32(shift, src, inv_ln2);
-        auto n     = z - shift;
-        n = vsubq_f32(n, one);
-        const auto scale = vreinterpretq_f32_u32(vreinterpretq_u32_f32(z) << 23); // 2^n
-
-        const auto r_hi = vfmaq_f32(src, n, neg_ln2_hi);
-        const auto r    = vfmaq_f32(r_hi, n, neg_ln2_lo);
-
-        const auto r2 = r * r;
-
-        const auto p1     = c1 * r;
-        const auto p23    = vfmaq_f32(c2, c3, r);
-        const auto p45    = vfmaq_f32(c4, c5, r);
-        const auto p2345  = vfmaq_f32(p23, p45, r2);
-        const auto p12345 = vfmaq_f32(p1, p2345, r2);
-
-        auto poly = vfmaq_f32(scale, p12345, scale);
-        poly = vmulq_f32(poly, two);
-
-        poly = vbslq_f32(vcltq_f32(src, min_input), zero, poly);
-        poly = vbslq_f32(vcgtq_f32(src, max_input), inf, poly);
-
-        return poly;
-    }
-    inline float32x4_t __vld1q_f32(const ov::bfloat16* a) {
-        uint16x4_t vec_bf16 = vld1_u16(reinterpret_cast<const uint16_t*>(a));
-
-        float32x4_t vec_f32 = vcvtq_f32_u32(vmovl_u16(vec_bf16));
-        return vec_f32;
-    }
-    inline float32x4_t __vld1q_f32(const float* a) {
-        return vld1q_f32(a);
-    }
-    inline float32x4_t __vld1q_f32(const ov::float16* a) {
-        auto _a = reinterpret_cast<const float16_t*>(a);
-        return vcvt_f32_f16(vld1_f16(_a));
-    }
-    inline void __vst1q_f32(float* a, float32x4_t b) {
-        vst1q_f32(a, b);
-    }
-    inline void __vst1q_f32(ov::float16* a, float32x4_t b) {
-        float16x4_t v_f16 = vcvt_f16_f32(b);
-        vst1_f16(reinterpret_cast<float16_t*>(a), v_f16);
-    }
-    inline void __vst1q_f32(ov::bfloat16* a, float32x4_t b) {
-        uint32x4_t v_int32 = vreinterpretq_u32_f32(b);
-        uint16x4_t v_bf16 = vshrn_n_u32(v_int32, 16);
-
-        vst1_u16(reinterpret_cast<uint16_t*>(a), v_bf16);
-    }
+inline float32x4_t exp_ps_neon_f32(const float32x4_t& src) {
+    const auto c1 = vreinterpretq_f32_u32(vdupq_n_u32(0x3f7ffff6));
+    const auto c2 = vreinterpretq_f32_u32(vdupq_n_u32(0x3efffedb));
+    const auto c3 = vreinterpretq_f32_u32(vdupq_n_u32(0x3e2aaf33));
+    const auto c4 = vreinterpretq_f32_u32(vdupq_n_u32(0x3d2b9f17));
+    const auto c5 = vreinterpretq_f32_u32(vdupq_n_u32(0x3c072010));
+
+    const auto shift = vreinterpretq_f32_u32(vdupq_n_u32(0x4b00007f));  // 2^23 + 127 = 0x1.0000fep23f
+    const auto one = vdupq_n_f32(1.0f);                                 // 1
+    const auto two = vdupq_n_f32(2.0f);                                 // 2
+    const auto inv_ln2 = vreinterpretq_f32_u32(vdupq_n_u32(0x3fb8aa3b));
+    const auto neg_ln2_hi = vreinterpretq_f32_u32(vdupq_n_u32(0xbf317200));
+    const auto neg_ln2_lo = vreinterpretq_f32_u32(vdupq_n_u32(0xb5bfbe8e));
+
+    const auto inf = vdupq_n_f32(std::numeric_limits<float>::infinity());
+    const auto max_input = vdupq_n_f32(88.37f);  // Approximately ln(2^127.5)
+    const auto zero = vdupq_n_f32(0.f);
+    const auto min_input = vdupq_n_f32(-86.64f);  // Approximately ln(2^-125)
+
+    const auto z = vmlaq_f32(shift, src, inv_ln2);
+    auto n = z - shift;
+    n = vsubq_f32(n, one);
+    const auto scale = vreinterpretq_f32_u32(vreinterpretq_u32_f32(z) << 23);  // 2^n
+
+    const auto r_hi = vfmaq_f32(src, n, neg_ln2_hi);
+    const auto r = vfmaq_f32(r_hi, n, neg_ln2_lo);
+
+    const auto r2 = r * r;
+
+    const auto p1 = c1 * r;
+    const auto p23 = vfmaq_f32(c2, c3, r);
+    const auto p45 = vfmaq_f32(c4, c5, r);
+    const auto p2345 = vfmaq_f32(p23, p45, r2);
+    const auto p12345 = vfmaq_f32(p1, p2345, r2);
+
+    auto poly = vfmaq_f32(scale, p12345, scale);
+    poly = vmulq_f32(poly, two);
+
+    poly = vbslq_f32(vcltq_f32(src, min_input), zero, poly);
+    poly = vbslq_f32(vcgtq_f32(src, max_input), inf, poly);
+
+    return poly;
+}
+inline float32x4_t __vld1q_f32(const ov::bfloat16* a) {
+    uint16x4_t vec_bf16 = vld1_u16(reinterpret_cast<const uint16_t*>(a));
+
+    float32x4_t vec_f32 = vcvtq_f32_u32(vmovl_u16(vec_bf16));
+    return vec_f32;
+}
+inline float32x4_t __vld1q_f32(const float* a) {
+    return vld1q_f32(a);
+}
+inline float32x4_t __vld1q_f32(const ov::float16* a) {
+    auto _a = reinterpret_cast<const float16_t*>(a);
+    return vcvt_f32_f16(vld1_f16(_a));
+}
+inline void __vst1q_f32(float* a, float32x4_t b) {
+    vst1q_f32(a, b);
+}
+inline void __vst1q_f32(ov::float16* a, float32x4_t b) {
+    float16x4_t v_f16 = vcvt_f16_f32(b);
+    vst1_f16(reinterpret_cast<float16_t*>(a), v_f16);
+}
+inline void __vst1q_f32(ov::bfloat16* a, float32x4_t b) {
+    uint32x4_t v_int32 = vreinterpretq_u32_f32(b);
+    uint16x4_t v_bf16 = vshrn_n_u32(v_int32, 16);
+
+    vst1_u16(reinterpret_cast<uint16_t*>(a), v_bf16);
+}
 
 #endif
 
 #if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
-    inline float16x8_t exp_ps_neon_f16(float16x8_t x) {
-        const float32x4_t x_high = vcvt_f32_f16(vget_high_f16(x));
-        const float32x4_t x_low  = vcvt_f32_f16(vget_low_f16(x));
-
-        // We use f32 to maintain accuracy
-        const float16x8_t res = vcombine_f16(vcvt_f16_f32(exp_ps_neon_f32(x_low)), vcvt_f16_f32(exp_ps_neon_f32(x_high)));
-        return res;
-    }
-    inline float16_t hsum(float16x8_t vec) {
-        float16x4_t sum1 = vpadd_f16(vget_low_f16(vec), vget_high_f16(vec));
-        float16x4_t sum2 = vpadd_f16(sum1, sum1);
-        float16x4_t sum3 = vpadd_f16(sum2, sum2);
-        return vget_lane_f16(sum3, 0);
-    }
+inline float16x8_t exp_ps_neon_f16(float16x8_t x) {
+    const float32x4_t x_high = vcvt_f32_f16(vget_high_f16(x));
+    const float32x4_t x_low = vcvt_f32_f16(vget_low_f16(x));
+
+    // We use f32 to maintain accuracy
+    const float16x8_t res = vcombine_f16(vcvt_f16_f32(exp_ps_neon_f32(x_low)), vcvt_f16_f32(exp_ps_neon_f32(x_high)));
+    return res;
+}
+inline float16_t hsum(float16x8_t vec) {
+    float16x4_t sum1 = vpadd_f16(vget_low_f16(vec), vget_high_f16(vec));
+    float16x4_t sum2 = vpadd_f16(sum1, sum1);
+    float16x4_t sum3 = vpadd_f16(sum2, sum2);
+    return vget_lane_f16(sum3, 0);
+}
 #endif
 }  // namespace XARCH
 }  // namespace Cpu
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa.cpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa.cpp
index c7d12a0818749e..3acb0c7447db5c 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa.cpp
@@ -13,19 +13,19 @@
 #    include <immintrin.h>
 #endif
 
-#include "openvino/core/type/bfloat16.hpp"
-#include "openvino/core/type/float16.hpp"
-#include "openvino/core/parallel.hpp"
+#include "attn_memcpy.hpp"
+#include "attn_quant.hpp"
+#include "attn_quant_kernel.hpp"
+#include "common.hpp"
 #include "executor_pa.hpp"
 #include "executor_pa_common.hpp"
-#include "common.hpp"
-#include "attn_quant_kernel.hpp"
+#include "nodes/kernels/x64/brgemm_kernel.hpp"
+#include "openvino/core/parallel.hpp"
+#include "openvino/core/type/bfloat16.hpp"
+#include "openvino/core/type/float16.hpp"
 #include "softmax_kernel.hpp"
 #include "transpose_kernel.hpp"
 #include "utils/plain_tensor.hpp"
-#include "attn_memcpy.hpp"
-#include "attn_quant.hpp"
-#include "nodes/kernels/x64/brgemm_kernel.hpp"
 
 namespace ov {
 namespace Extensions {
@@ -38,42 +38,45 @@ using namespace ov::intel_cpu;
 // currently depends on brgemm which only support x64
 #ifdef OPENVINO_ARCH_X86_64
 
-#if defined(HAVE_AVX2) || defined(HAVE_AVX512F)
+#    if defined(HAVE_AVX2) || defined(HAVE_AVX512F)
 
-#define prefetch_bytes(bytes, sel, advance, src) {  \
-    auto *p = reinterpret_cast<char *>(src);        \
-    for (size_t i = 0; i < bytes; i += 64)          \
-        _mm_prefetch(p + i + advance, sel);         \
-}
+#        define prefetch_bytes(bytes, sel, advance, src) \
+            {                                            \
+                auto* p = reinterpret_cast<char*>(src);  \
+                for (size_t i = 0; i < bytes; i += 64)   \
+                    _mm_prefetch(p + i + advance, sel);  \
+            }
 
-#else
+#    else
 
-#define prefetch_bytes(bytes, sel, advance, src)
+#        define prefetch_bytes(bytes, sel, advance, src)
 
-#endif
+#    endif
 
-template<typename TA, typename TB>
+template <typename TA, typename TB>
 void cvt_copy(TA* dst, TB* src, size_t n) {
     size_t i = 0;
-#if defined(HAVE_AVX512F)
+#    if defined(HAVE_AVX512F)
     for (; i + vec_len_f32_avx512 <= n; i += vec_len_f32_avx512) {
         auto vb = mm512_uni_loadu_ps(src + i);
         mm512_uni_storeu_ps(dst + i, vb);
     }
-#elif defined(HAVE_AVX2)
+#    elif defined(HAVE_AVX2)
     for (; i + vec_len_f32_avx2 <= n; i += vec_len_f32_avx2) {
         auto vb = mm256_uni_loadu_ps(src + i);
         mm256_uni_storeu_ps(dst + i, vb);
     }
-#endif
+#    endif
     for (; i < n; i++) {
         dst[i] = src[i];
     }
 }
 
-template<typename T, ov::element::Type_t SRC_PREC, typename std::enable_if<SRC_PREC != ov::element::u8 || SRC_PREC != ov::element::u4, bool>::type = true>
+template <typename T,
+          ov::element::Type_t SRC_PREC,
+          typename std::enable_if<SRC_PREC != ov::element::u8 || SRC_PREC != ov::element::u4, bool>::type = true>
 static void attn_acc_value_block(float* out, float* weight, T* v, size_t S, size_t block_size, size_t group_size = 0) {
-#if defined(HAVE_AVX512F)
+#    if defined(HAVE_AVX512F)
     size_t j = 0;
     for (; j + 4 <= block_size; j += 4) {
         auto attn_w_vec0 = _mm512_set1_ps(weight[0]);
@@ -132,7 +135,7 @@ static void attn_acc_value_block(float* out, float* weight, T* v, size_t S, size
         }
     }
     return;
-#elif defined(HAVE_AVX2)
+#    elif defined(HAVE_AVX2)
     size_t j = 0;
     for (; j + 4 <= block_size; j += 4) {
         auto attn_w_vec0 = _mm256_set1_ps(weight[0]);
@@ -191,7 +194,7 @@ static void attn_acc_value_block(float* out, float* weight, T* v, size_t S, size
         }
     }
     return;
-#endif
+#    endif
     for (size_t j = 0; j < block_size; j++) {
         for (size_t i = 0; i < S; i++) {
             out[i] += weight[j] * v[i];
@@ -199,18 +202,25 @@ static void attn_acc_value_block(float* out, float* weight, T* v, size_t S, size
         v += S;
     }
 }
-template<typename T, ov::element::Type_t SRC_PREC, typename std::enable_if<SRC_PREC == ov::element::u8, bool>::type = true>
-static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S, size_t block_size, size_t group_size = 0) {
+template <typename T,
+          ov::element::Type_t SRC_PREC,
+          typename std::enable_if<SRC_PREC == ov::element::u8, bool>::type = true>
+static void attn_acc_value_block(float* out,
+                                 float* weight,
+                                 uint8_t* v,
+                                 size_t S,
+                                 size_t block_size,
+                                 size_t group_size = 0) {
     // The layout for per token per head:
-    // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized feature(u8,idx_S)|
-    // The quantized feature will start from 8bytes=sizeof(float)+sizeof(float)
+    // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized
+    // feature(u8,idx_S)| The quantized feature will start from 8bytes=sizeof(float)+sizeof(float)
     size_t src_offset = 0;
     size_t dst_offset = 0;
     const size_t _group_size = group_size ? group_size : S;
     const size_t params_offset = sizeof(float) * 2;
     const size_t src_stride = S / _group_size * (_group_size + params_offset);
 
-#if defined(HAVE_AVX512F)
+#    if defined(HAVE_AVX512F)
     size_t j = 0;
     for (; j + 4 <= block_size; j += 4) {
         dst_offset = 0;
@@ -276,7 +286,9 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
             size_t i = 0;
             for (; i + vec_len_f32_avx512 <= _group_size; i += vec_len_f32_avx512) {
                 auto v_out = mm512_uni_loadu_ps((out + dst_offset + i));
-                auto v0 = _mm512_sub_ps(_mm512_cvtepi32_ps(_mm512_cvtepu8_epi32(_mm_loadu_si128(reinterpret_cast<__m128i*>(v_data_ptr + i)))), zp0);
+                auto v0 = _mm512_sub_ps(_mm512_cvtepi32_ps(_mm512_cvtepu8_epi32(
+                                            _mm_loadu_si128(reinterpret_cast<__m128i*>(v_data_ptr + i)))),
+                                        zp0);
                 v_out = _mm512_fmadd_ps(attn_w_vec0, v0, v_out);
 
                 _mm512_storeu_ps((out + dst_offset + i), v_out);
@@ -291,7 +303,7 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
         weight++;
     }
     return;
-#elif defined(HAVE_AVX2)
+#    elif defined(HAVE_AVX2)
     size_t j = 0;
     for (; j < block_size; j++) {
         dst_offset = 0;
@@ -306,7 +318,9 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
             v += 8;
             for (; i + vec_len_f32_avx2 <= _group_size; i += vec_len_f32_avx2) {
                 auto v_out = mm256_uni_loadu_ps(out + dst_offset + i);
-                auto v0 = _mm256_sub_ps(_mm256_cvtepi32_ps(_mm256_cvtepu8_epi32(_mm_loadl_epi64(reinterpret_cast<__m128i*>(v_data_ptr + i)))), zp0);
+                auto v0 = _mm256_sub_ps(_mm256_cvtepi32_ps(_mm256_cvtepu8_epi32(
+                                            _mm_loadl_epi64(reinterpret_cast<__m128i*>(v_data_ptr + i)))),
+                                        zp0);
                 v_out = _mm256_fmadd_ps(attn_w_vec0, v0, v_out);
 
                 mm256_uni_storeu_ps(out + dst_offset + i, v_out);
@@ -321,7 +335,7 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
         weight++;
     }
     return;
-#endif
+#    endif
     for (size_t j = 0; j < block_size; j++) {
         dst_offset = 0;
         src_offset = 0;
@@ -337,8 +351,15 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
     }
 }
 
-template<typename T, ov::element::Type_t SRC_PREC, typename std::enable_if<SRC_PREC == ov::element::u4, bool>::type = true>
-static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S, size_t block_size, size_t group_size = 0) {
+template <typename T,
+          ov::element::Type_t SRC_PREC,
+          typename std::enable_if<SRC_PREC == ov::element::u4, bool>::type = true>
+static void attn_acc_value_block(float* out,
+                                 float* weight,
+                                 uint8_t* v,
+                                 size_t S,
+                                 size_t block_size,
+                                 size_t group_size = 0) {
     size_t src_offset = 0;
     size_t dst_offset = 0;
     const size_t _group_size = group_size ? group_size : S;
@@ -348,7 +369,7 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
     auto extract_half_byte = [](uint8_t val, bool high_half) -> uint8_t {
         uint8_t shift = high_half ? 0 : 4;
 
-        return (uint8_t) ((val >> shift) & 0x000F);
+        return (uint8_t)((val >> shift) & 0x000F);
     };
     for (size_t j = 0; j < block_size; j++) {
         dst_offset = 0;
@@ -356,11 +377,11 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
         while (dst_offset < S) {
             auto v0 = reinterpret_cast<float*>(v + src_offset);
             size_t i = 0;
-#if defined(HAVE_AVX512F)
+#    if defined(HAVE_AVX512F)
             auto attn_w_vec0 = _mm512_set1_ps(weight[j] * v0[0]);
             auto v_zp = _mm512_set1_ps(v0[1]);
             for (; i + vec_len_f32_avx512 * 2 <= _group_size; i += vec_len_f32_avx512 * 2) {
-                auto data = _mm_loadu_si128(reinterpret_cast<__m128i*>(v + i/2 + src_offset + params_offset));
+                auto data = _mm_loadu_si128(reinterpret_cast<__m128i*>(v + i / 2 + src_offset + params_offset));
                 auto v_i32 = _mm512_cvtepu8_epi32(data);
 
                 auto v_512_low_half = _mm512_srli_epi32(v_i32, 4);
@@ -385,11 +406,11 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
                 mm512_uni_storeu_ps(out + dst_offset + i, v_out0);
                 mm512_uni_storeu_ps(out + dst_offset + i + vec_len_f32_avx512, v_out1);
             }
-#elif defined(HAVE_AVX2) || defined(HAVE_AVX512F)
+#    elif defined(HAVE_AVX2) || defined(HAVE_AVX512F)
             auto v256_attn_w_vec0 = _mm256_set1_ps(weight[j] * v0[0]);
             auto v256_zp = _mm256_set1_ps(v0[1]);
             for (; i + vec_len_f32_avx2 * 2 <= _group_size; i += vec_len_f32_avx2 * 2) {
-                auto data = _mm_loadl_epi64(reinterpret_cast<__m128i*>(v + i/2 + src_offset + params_offset));
+                auto data = _mm_loadl_epi64(reinterpret_cast<__m128i*>(v + i / 2 + src_offset + params_offset));
 
                 auto v_i32 = _mm256_cvtepu8_epi32(data);
                 auto v_256_low_half = _mm256_srli_epi32(v_i32, 4);
@@ -416,9 +437,9 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
                 mm256_uni_storeu_ps(out + dst_offset + i, v_out0);
                 mm256_uni_storeu_ps(out + dst_offset + i + vec_len_f32_avx2, v_out1);
             }
-#endif
+#    endif
             for (; i < _group_size; i += 2) {
-                uint8_t data = v[i/2 + src_offset + params_offset];
+                uint8_t data = v[i / 2 + src_offset + params_offset];
                 float tmp0 = extract_half_byte(data, static_cast<bool>(i % 2));
                 float tmp1 = extract_half_byte(data, static_cast<bool>((i + 1) % 2));
                 out[dst_offset + i] += weight[j] * (tmp0 - v0[1]) * v0[0];
@@ -431,8 +452,15 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
     }
 }
 
-template<typename T, ov::element::Type_t SRC_PREC, typename std::enable_if<SRC_PREC == ov::element::i4, bool>::type = true>
-static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S, size_t block_size, size_t group_size = 0) {
+template <typename T,
+          ov::element::Type_t SRC_PREC,
+          typename std::enable_if<SRC_PREC == ov::element::i4, bool>::type = true>
+static void attn_acc_value_block(float* out,
+                                 float* weight,
+                                 uint8_t* v,
+                                 size_t S,
+                                 size_t block_size,
+                                 size_t group_size = 0) {
     size_t src_offset = 0;
     size_t dst_offset = 0;
     const size_t _group_size = group_size ? group_size : S;
@@ -442,7 +470,7 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
     auto extract_half_byte = [](uint8_t val, bool high_half) -> uint8_t {
         uint8_t shift = high_half ? 0 : 4;
 
-        return (uint8_t) ((val >> shift) & 0x000F);
+        return (uint8_t)((val >> shift) & 0x000F);
     };
 
     for (size_t j = 0; j < block_size; j++) {
@@ -451,12 +479,12 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
         while (dst_offset < S) {
             auto v0 = reinterpret_cast<float*>(v + src_offset);
             size_t i = 0;
-#if defined(HAVE_AVX512F)
+#    if defined(HAVE_AVX512F)
             auto attn_w_vec0 = _mm512_set1_ps(weight[j] * v0[0]);
             for (; i + vec_len_f32_avx512 * 2 <= _group_size; i += vec_len_f32_avx512 * 2) {
-                auto data = _mm_loadu_si128(reinterpret_cast<__m128i*>(v + i/2 + src_offset + params_offset));
+                auto data = _mm_loadu_si128(reinterpret_cast<__m128i*>(v + i / 2 + src_offset + params_offset));
                 auto v_i32 = _mm512_cvtepi8_epi32(data);
-                //cvt to f32
+                // cvt to f32
                 auto v_256_low_half = _mm512_srai_epi32(v_i32, 4);
                 auto v_256_high_half = _mm512_slli_epi32(v_i32, 28);
                 v_256_high_half = _mm512_srai_epi32(v_256_high_half, 28);
@@ -475,10 +503,10 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
                 mm512_uni_storeu_ps(out + dst_offset + i, v_out0);
                 mm512_uni_storeu_ps(out + dst_offset + i + vec_len_f32_avx512, v_out1);
             }
-#elif defined(HAVE_AVX2) || defined(HAVE_AVX512F)
+#    elif defined(HAVE_AVX2) || defined(HAVE_AVX512F)
             auto v256_attn_w_vec0 = _mm256_set1_ps(weight[j] * v0[0]);
             for (; i + vec_len_f32_avx2 * 2 <= _group_size; i += vec_len_f32_avx2 * 2) {
-                auto data = _mm_loadl_epi64(reinterpret_cast<__m128i*>(v + i/2 + src_offset + params_offset));
+                auto data = _mm_loadl_epi64(reinterpret_cast<__m128i*>(v + i / 2 + src_offset + params_offset));
 
                 auto v_i32 = _mm256_cvtepi8_epi32(data);
                 auto v_256_low_half = _mm256_srai_epi32(v_i32, 4);
@@ -500,15 +528,15 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
                 mm256_uni_storeu_ps(out + dst_offset + i, v_out0);
                 mm256_uni_storeu_ps(out + dst_offset + i + vec_len_f32_avx2, v_out1);
             }
-#endif
+#    endif
             for (; i < _group_size; i += 2) {
-                uint8_t data = v[i/2 + src_offset + params_offset];
+                uint8_t data = v[i / 2 + src_offset + params_offset];
                 float tmp0 = extract_half_byte(data, static_cast<bool>(i % 2));
                 tmp0 = tmp0 > 8 ? (tmp0 - 16) : tmp0;
                 float tmp1 = extract_half_byte(data, static_cast<bool>((i + 1) % 2));
                 tmp1 = tmp1 > 8 ? (tmp1 - 16) : tmp1;
-                out[dst_offset + i] += weight[j] * (tmp0) * v0[0];
-                out[dst_offset + i + 1] += weight[j] * (tmp1) * v0[0];
+                out[dst_offset + i] += weight[j] * (tmp0)*v0[0];
+                out[dst_offset + i + 1] += weight[j] * (tmp1)*v0[0];
             }
             dst_offset += _group_size;
             src_offset += _group_size / sub_byte_multiplyer + params_offset;
@@ -517,9 +545,9 @@ static void attn_acc_value_block(float* out, float* weight, uint8_t* v, size_t S
     }
 }
 
-template<typename TA, typename TB>
+template <typename TA, typename TB>
 static void dot_product_block(TA* a, TB* b, float* c, size_t n, size_t block_size, size_t group_size = 0) {
-#if defined(HAVE_AVX512F)
+#    if defined(HAVE_AVX512F)
     size_t j = 0;
     for (; j + 4 <= block_size; j += 4) {
         auto vsum0 = _mm512_setzero_ps();
@@ -549,7 +577,7 @@ static void dot_product_block(TA* a, TB* b, float* c, size_t n, size_t block_siz
         c[2] = sum2;
         c[3] = sum3;
         c += 4;
-        b +=  4 * n;
+        b += 4 * n;
     }
     for (; j < block_size; j++) {
         auto vsum = _mm512_setzero_ps();
@@ -566,7 +594,7 @@ static void dot_product_block(TA* a, TB* b, float* c, size_t n, size_t block_siz
         *c++ = sum;
     }
     return;
-#elif defined(HAVE_AVX2)
+#    elif defined(HAVE_AVX2)
     size_t j = 0;
     for (; j + 4 <= block_size; j += 4) {
         auto vsum0 = _mm256_set1_ps(0.0f);
@@ -600,7 +628,7 @@ static void dot_product_block(TA* a, TB* b, float* c, size_t n, size_t block_siz
         c[2] = sum2;
         c[3] = sum3;
         c += 4;
-        b +=  4 * n;
+        b += 4 * n;
     }
     for (; j < block_size; j++) {
         auto vsum = _mm256_set1_ps(0.0f);
@@ -618,7 +646,7 @@ static void dot_product_block(TA* a, TB* b, float* c, size_t n, size_t block_siz
         *c++ = sum;
     }
     return;
-#endif
+#    endif
     for (size_t j = 0; j < block_size; j++) {
         float sum = 0;
         for (size_t i = 0; i < n; i++) {
@@ -629,17 +657,17 @@ static void dot_product_block(TA* a, TB* b, float* c, size_t n, size_t block_siz
     }
 }
 
-template<typename TA>
+template <typename TA>
 static void dot_product_block(TA* a, uint8_t* b, float* c, size_t n, size_t block_size, size_t group_size = 0) {
     // The layout for per token per head:
-    // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized feature(u8,idx_S)|
-    // The quantized feature will start from 8bytes=sizeof(float)+sizeof(float)
+    // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized
+    // feature(u8,idx_S)| The quantized feature will start from 8bytes=sizeof(float)+sizeof(float)
     size_t src_offset = 0;
     size_t dst_offset = 0;
     const size_t _group_size = group_size ? group_size : n;
     const size_t params_offset = sizeof(float) * 2;
     const size_t src_stride = n / _group_size * (_group_size + params_offset);
-#if defined(HAVE_AVX512F)
+#    if defined(HAVE_AVX512F)
     size_t j = 0;
     for (; j + 4 <= block_size; j += 4) {
         src_offset = 0;
@@ -719,7 +747,9 @@ static void dot_product_block(TA* a, uint8_t* b, float* c, size_t n, size_t bloc
             uint8_t* b_data_ptr = b + src_offset + params_offset;
             for (; i + vec_len_f32_avx512 <= _group_size; i += vec_len_f32_avx512) {
                 auto va = mm512_uni_loadu_ps(a + dst_offset + i);
-                auto vb = _mm512_sub_ps(_mm512_cvtepi32_ps(_mm512_cvtepu8_epi32(_mm_loadu_si128(reinterpret_cast<__m128i*>(b_data_ptr + i)))), v_zp);
+                auto vb = _mm512_sub_ps(_mm512_cvtepi32_ps(_mm512_cvtepu8_epi32(
+                                            _mm_loadu_si128(reinterpret_cast<__m128i*>(b_data_ptr + i)))),
+                                        v_zp);
                 vsum = _mm512_fmadd_ps(va, vb, vsum);
             }
             float group_sum = _mm512_reduce_add_ps(vsum);
@@ -734,7 +764,7 @@ static void dot_product_block(TA* a, uint8_t* b, float* c, size_t n, size_t bloc
         *c++ = sum;
     }
     return;
-#elif defined(HAVE_AVX2)
+#    elif defined(HAVE_AVX2)
     size_t j = 0;
     for (; j + 4 <= block_size; j += 4) {
         src_offset = 0;
@@ -788,7 +818,7 @@ static void dot_product_block(TA* a, uint8_t* b, float* c, size_t n, size_t bloc
             float group_sum3 = _mm256_cvtss_f32(vsum3);
             for (; i < _group_size; i++) {
                 group_sum0 += a[dst_offset + i] * (b[i] - b0[1]);
-                group_sum1 += a[dst_offset + i] * (b[i +src_stride] - b1[1]);
+                group_sum1 += a[dst_offset + i] * (b[i + src_stride] - b1[1]);
                 group_sum2 += a[dst_offset + i] * (b[i + 2 * src_stride] - b2[1]);
                 group_sum3 += a[dst_offset + i] * (b[i + 3 * src_stride] - b3[1]);
             }
@@ -804,7 +834,7 @@ static void dot_product_block(TA* a, uint8_t* b, float* c, size_t n, size_t bloc
         c[2] = sum2;
         c[3] = sum3;
         c += 4;
-        b +=  4 * src_stride;
+        b += 4 * src_stride;
     }
     for (; j < block_size; j++) {
         src_offset = 0;
@@ -818,7 +848,9 @@ static void dot_product_block(TA* a, uint8_t* b, float* c, size_t n, size_t bloc
             uint8_t* b_data_ptr = b + src_offset + params_offset;
             for (; i + vec_len_f32_avx2 <= _group_size; i += vec_len_f32_avx2) {
                 auto va = mm256_uni_loadu_ps(a + dst_offset + i);
-                auto vb = _mm256_sub_ps(_mm256_cvtepi32_ps(_mm256_cvtepu8_epi32(_mm_loadl_epi64(reinterpret_cast<__m128i*>(b_data_ptr + i)))), v_zp);
+                auto vb = _mm256_sub_ps(_mm256_cvtepi32_ps(_mm256_cvtepu8_epi32(
+                                            _mm_loadl_epi64(reinterpret_cast<__m128i*>(b_data_ptr + i)))),
+                                        v_zp);
                 vsum = _mm256_fmadd_ps(va, vb, vsum);
             }
             hsum(vsum);
@@ -834,7 +866,7 @@ static void dot_product_block(TA* a, uint8_t* b, float* c, size_t n, size_t bloc
         *c++ = sum;
     }
     return;
-#endif
+#    endif
     for (size_t j = 0; j < block_size; j++) {
         float sum = 0;
         dst_offset = 0;
@@ -854,11 +886,11 @@ static void dot_product_block(TA* a, uint8_t* b, float* c, size_t n, size_t bloc
     }
 }
 
-template<typename T>
+template <typename T>
 static void attn_reduce(T* dst, float* temp, size_t M, size_t S, size_t temp_stride) {
     size_t i = 0;
-#if defined(HAVE_AVX512F)
-    for (; i + vec_len_f32_avx512 <= S; i+= vec_len_f32_avx512) {
+#    if defined(HAVE_AVX512F)
+    for (; i + vec_len_f32_avx512 <= S; i += vec_len_f32_avx512) {
         auto* src = temp + i;
         auto result_vec_fp32 = _mm512_setzero_ps();
         for (size_t m = 0; m < M; m++) {
@@ -869,7 +901,7 @@ static void attn_reduce(T* dst, float* temp, size_t M, size_t S, size_t temp_str
         // save to bf16
         mm512_uni_storeu_ps(dst + i, result_vec_fp32);
     }
-#elif defined(HAVE_AVX2)
+#    elif defined(HAVE_AVX2)
     for (; i + vec_len_f32_avx2 <= S; i += vec_len_f32_avx2) {
         auto* src = temp + i;
         auto result_vec_fp32 = _mm256_set1_ps(0.0f);
@@ -880,7 +912,7 @@ static void attn_reduce(T* dst, float* temp, size_t M, size_t S, size_t temp_str
         }
         mm256_uni_storeu_ps(dst + i, result_vec_fp32);
     }
-#endif
+#    endif
     for (; i < S; i++) {
         auto* src = temp + i;
         float sum = 0.0f;
@@ -894,8 +926,17 @@ static void attn_reduce(T* dst, float* temp, size_t M, size_t S, size_t temp_str
 }
 
 // N must be multiple of 16
-template<typename TDST, ov::element::Type_t SRC_PREC, typename std::enable_if<(SRC_PREC != ov::element::u8 && SRC_PREC != ov::element::u4), bool>::type = true>
-void transpose_16NxK(TDST* dst, void* src, TDST* tmp, size_t N, size_t K, size_t dst_stride, size_t src_stride, size_t group_size = 0) {
+template <typename TDST,
+          ov::element::Type_t SRC_PREC,
+          typename std::enable_if<(SRC_PREC != ov::element::u8 && SRC_PREC != ov::element::u4), bool>::type = true>
+void transpose_16NxK(TDST* dst,
+                     void* src,
+                     TDST* tmp,
+                     size_t N,
+                     size_t K,
+                     size_t dst_stride,
+                     size_t src_stride,
+                     size_t group_size = 0) {
     size_t k = 0;
     auto* src_ptr = reinterpret_cast<typename ov::element_type_traits<SRC_PREC>::value_type*>(src);
     for (; k + 16 <= K; k += 16) {
@@ -912,7 +953,7 @@ void transpose_16NxK(TDST* dst, void* src, TDST* tmp, size_t N, size_t K, size_t
         }
     }
 }
-#if defined(HAVE_AVX512F)
+#    if defined(HAVE_AVX512F)
 template <typename T,
           ov::element::Type_t SRC_PREC,
           typename std::enable_if<(SRC_PREC == ov::element::bf16 || SRC_PREC == ov::element::f16) &&
@@ -939,16 +980,25 @@ static void transpose_16NxK(T* dst,
 }
 #    endif
 
-template<typename TDST, ov::element::Type_t SRC_PREC, typename std::enable_if<SRC_PREC == ov::element::u8, bool>::type = true>
-void transpose_16NxK(TDST* dst, void* src, TDST* tmp, size_t N, size_t K, size_t dst_stride, size_t src_stride, size_t group_size = 0) {
+template <typename TDST,
+          ov::element::Type_t SRC_PREC,
+          typename std::enable_if<SRC_PREC == ov::element::u8, bool>::type = true>
+void transpose_16NxK(TDST* dst,
+                     void* src,
+                     TDST* tmp,
+                     size_t N,
+                     size_t K,
+                     size_t dst_stride,
+                     size_t src_stride,
+                     size_t group_size = 0) {
     // The layout for per token per head:
-    // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized feature(u8,idx_S)|
-    // The quantized feature will start from 8bytes=sizeof(float)+sizeof(float)
+    // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized
+    // feature(u8,idx_S)| The quantized feature will start from 8bytes=sizeof(float)+sizeof(float)
     auto s = reinterpret_cast<typename ov::element_type_traits<SRC_PREC>::value_type*>(src);
     auto t = tmp;
     // if group_size not set, the whole row is used as a group
     size_t _group_size = group_size ? group_size : K;
-    for (size_t n = 0; n < N; n ++) {
+    for (size_t n = 0; n < N; n++) {
         size_t src_offset = 0;
         size_t dst_offset = 0;
         while (dst_offset < K) {
@@ -960,31 +1010,43 @@ void transpose_16NxK(TDST* dst, void* src, TDST* tmp, size_t N, size_t K, size_t
         s += src_offset;
         t += src_stride;
     }
-    transpose_16NxK<TDST, precision_of<TDST>::value>(dst, tmp, reinterpret_cast<TDST*>(0), N, K, dst_stride, src_stride);
+    transpose_16NxK<TDST, precision_of<TDST>::value>(dst,
+                                                     tmp,
+                                                     reinterpret_cast<TDST*>(0),
+                                                     N,
+                                                     K,
+                                                     dst_stride,
+                                                     src_stride);
 }
 
 // dequant f16/u8 to float
-template<typename T, ov::element::Type_t SRC_PREC, typename std::enable_if<SRC_PREC != ov::element::u8, bool>::type = true>
+template <typename T,
+          ov::element::Type_t SRC_PREC,
+          typename std::enable_if<SRC_PREC != ov::element::u8, bool>::type = true>
 static inline void dequant(T* dst, void* src, size_t N, size_t K, size_t group_size = 0) {
     // never called
     OPENVINO_THROW("dequant: should not be called.");
 }
-template<typename T, ov::element::Type_t SRC_PREC, typename std::enable_if<SRC_PREC == ov::element::f16, bool>::type = true>
+template <typename T,
+          ov::element::Type_t SRC_PREC,
+          typename std::enable_if<SRC_PREC == ov::element::f16, bool>::type = true>
 static inline void dequant(float* dst, ov::float16* src, size_t N, size_t K, size_t group_size = 0) {
     cvt_copy(dst, src, K * N);
 }
 
-template<typename TDST, ov::element::Type_t SRC_PREC, typename std::enable_if<SRC_PREC == ov::element::u8, bool>::type = true>
+template <typename TDST,
+          ov::element::Type_t SRC_PREC,
+          typename std::enable_if<SRC_PREC == ov::element::u8, bool>::type = true>
 void dequant(TDST* dst, uint8_t* src, size_t N, size_t K, size_t group_size = 0) {
     // The layout for per token per head:
-    // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized feature(u8,idx_S)|
-    // The quantized feature will start from 8bytes=sizeof(float)+sizeof(float)
+    // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized
+    // feature(u8,idx_S)| The quantized feature will start from 8bytes=sizeof(float)+sizeof(float)
     auto s = src;
     const size_t params_offset = sizeof(float) * 2;
     const size_t _group_size = group_size ? group_size : K;
     const size_t src_stride = K / _group_size * (_group_size + params_offset);
 
-    for (size_t n = 0; n < N; n ++) {
+    for (size_t n = 0; n < N; n++) {
         size_t group_offset = 0;
         size_t dst_offset = 0;
         while (dst_offset < K) {
@@ -998,17 +1060,19 @@ void dequant(TDST* dst, uint8_t* src, size_t N, size_t K, size_t group_size = 0)
     }
 }
 
-template<typename TDST, ov::element::Type_t SRC_PREC, typename std::enable_if<SRC_PREC == ov::element::u4, bool>::type = true>
+template <typename TDST,
+          ov::element::Type_t SRC_PREC,
+          typename std::enable_if<SRC_PREC == ov::element::u4, bool>::type = true>
 void dequant(TDST* dst, uint8_t* src, size_t N, size_t K, size_t group_size = 0) {
     // The layout for per token per head:
-    // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized feature(u8,idx_S)|
-    // The quantized feature will start from 8bytes=sizeof(float)+sizeof(float)
+    // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized
+    // feature(u8,idx_S)| The quantized feature will start from 8bytes=sizeof(float)+sizeof(float)
     auto s = src;
     const size_t params_offset = sizeof(float) * 2;
     const size_t _group_size = group_size ? group_size : K;
     const size_t sub_byte_mulitplier = 2;
 
-    for (size_t n = 0; n < N; n ++) {
+    for (size_t n = 0; n < N; n++) {
         size_t src_offset = 0;
         size_t dst_offset = 0;
         while (dst_offset < K) {
@@ -1022,17 +1086,19 @@ void dequant(TDST* dst, uint8_t* src, size_t N, size_t K, size_t group_size = 0)
     }
 }
 
-template<typename TDST, ov::element::Type_t SRC_PREC, typename std::enable_if<SRC_PREC == ov::element::i4, bool>::type = true>
+template <typename TDST,
+          ov::element::Type_t SRC_PREC,
+          typename std::enable_if<SRC_PREC == ov::element::i4, bool>::type = true>
 void dequant(TDST* dst, uint8_t* src, size_t N, size_t K, size_t group_size = 0) {
     // The layout for per token per head:
-    // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized feature(u8,idx_S)|
-    // The quantized feature will start from 8bytes=sizeof(float)+sizeof(float)
+    // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized
+    // feature(u8,idx_S)| The quantized feature will start from 8bytes=sizeof(float)+sizeof(float)
     auto s = src;
     const size_t params_offset = sizeof(float);
     const size_t _group_size = group_size ? group_size : K;
     const size_t sub_byte_mulitplier = 2;
 
-    for (size_t n = 0; n < N; n ++) {
+    for (size_t n = 0; n < N; n++) {
         size_t src_offset = 0;
         size_t dst_offset = 0;
         while (dst_offset < K) {
@@ -1046,18 +1112,24 @@ void dequant(TDST* dst, uint8_t* src, size_t N, size_t K, size_t group_size = 0)
     }
 }
 
-#if defined(HAVE_AVX512F)
-template<typename T, typename = typename std::enable_if<(std::is_same<T, ov::bfloat16>::value || std::is_same<T, ov::float16>::value), bool>::type>
+#    if defined(HAVE_AVX512F)
+template <typename T,
+          typename = typename std::
+              enable_if<(std::is_same<T, ov::bfloat16>::value || std::is_same<T, ov::float16>::value), bool>::type>
 static void pack_32x32_kernel(T* dst, T* src, size_t dst_stride, size_t src_stride) {
     static const uint64_t idx[8] = {0, 4, 1, 5, 2, 6, 3, 7};
     auto midx = _mm512_loadu_si512(idx);
     for (size_t i = 0; i < 16; i++) {
-        auto a = _mm512_loadu_si512(src);               // [a1  a2  a3 a4 | a5  a6  a7 a8]   total 512-bits in 8 64bits unit
+        auto a = _mm512_loadu_si512(src);  // [a1  a2  a3 a4 | a5  a6  a7 a8]   total 512-bits in 8 64bits unit
         auto b = _mm512_loadu_si512(src + src_stride);  // [b1  b2  b3 b4 | b5  b6  b7 b8]   total 512-bits
         a = _mm512_permutexvar_epi64(midx, a);          // [a1 a5 | a2 a6 | a3 a7 | a4 a8]
         b = _mm512_permutexvar_epi64(midx, b);          // [b1 b5 | b2 b6 | b3 b7 | b4 b8]
-        auto B0 = _mm512_unpacklo_epi16(a, b);          // [ a1&b1  a2&b2   a3&b3   a4&b4] for each 128-bits lane, interleave word in low 64 bits
-        auto B1 = _mm512_unpackhi_epi16(a, b);          // [ a5&b5  a6&b6   a7&b7   a8&b8] for each 128-bits lane, interleave word in high 64 bits
+        auto B0 = _mm512_unpacklo_epi16(
+            a,
+            b);  // [ a1&b1  a2&b2   a3&b3   a4&b4] for each 128-bits lane, interleave word in low 64 bits
+        auto B1 = _mm512_unpackhi_epi16(
+            a,
+            b);  // [ a5&b5  a6&b6   a7&b7   a8&b8] for each 128-bits lane, interleave word in high 64 bits
         _mm512_storeu_si512(dst, B0);
         _mm512_storeu_si512(dst + 32, B1);
         src += 2 * src_stride;
@@ -1065,17 +1137,20 @@ static void pack_32x32_kernel(T* dst, T* src, size_t dst_stride, size_t src_stri
     }
 }
 
-template<typename T, typename = typename std::enable_if<(std::is_same<T, ov::bfloat16>::value || std::is_same<T, ov::float16>::value), bool>::type>
+template <typename T,
+          typename = typename std::
+              enable_if<(std::is_same<T, ov::bfloat16>::value || std::is_same<T, ov::float16>::value), bool>::type>
 static void pack_32x16_kernel(T* dst, T* src, size_t dst_stride, size_t src_stride) {
     static const uint64_t idx[8] = {0, 4, 1, 5, 2, 6, 3, 7};
     auto midx = _mm512_loadu_si512(idx);
     for (size_t i = 0; i < 16; i++) {
-        auto x = _mm256_loadu_si256(reinterpret_cast<__m256i*>(src));               // [a1  a2  a3 a4]   total 256-bits in 4 64bits unit
+        auto x =
+            _mm256_loadu_si256(reinterpret_cast<__m256i*>(src));  // [a1  a2  a3 a4]   total 256-bits in 4 64bits unit
         auto y = _mm256_loadu_si256(reinterpret_cast<__m256i*>(src + src_stride));  // [b1  b2  b3 b4]   total 256-bits
         auto a = _mm512_castsi256_si512(x);
         auto b = _mm512_castsi256_si512(y);
-        a = _mm512_permutexvar_epi64(midx, a);                                      // [a1 x | a2 x | a3 x | a4 x]
-        b = _mm512_permutexvar_epi64(midx, b);                                      // [b1 x | b2 x | b3 x | b4 x]
+        a = _mm512_permutexvar_epi64(midx, a);  // [a1 x | a2 x | a3 x | a4 x]
+        b = _mm512_permutexvar_epi64(midx, b);  // [b1 x | b2 x | b3 x | b4 x]
         auto B0 = _mm512_unpacklo_epi16(a, b);
         _mm512_storeu_si512(dst, B0);
         src += 2 * src_stride;
@@ -1083,18 +1158,20 @@ static void pack_32x16_kernel(T* dst, T* src, size_t dst_stride, size_t src_stri
     }
 }
 
-template<typename T, typename = typename std::enable_if<(std::is_same<T, ov::bfloat16>::value || std::is_same<T, ov::float16>::value), bool>::type>
+template <typename T,
+          typename = typename std::
+              enable_if<(std::is_same<T, ov::bfloat16>::value || std::is_same<T, ov::float16>::value), bool>::type>
 static void pack_32xK_kernel(T* dst, T* src, size_t dst_stride, size_t src_stride, size_t K) {
     static const uint64_t idx[8] = {0, 4, 1, 5, 2, 6, 3, 7};
     auto midx = _mm512_loadu_si512(idx);
     __mmask16 mask = (1 << K) - 1;
     for (size_t i = 0; i < K; i++) {
-        auto x = _mm256_maskz_loadu_epi16(mask, src);                              // [a1  a2  a3 a4]   total 256-bits in 4 64bits unit
-        auto y = _mm256_maskz_loadu_epi16(mask, src + src_stride);                 // [b1  b2  b3 b4]   total 256-bits
+        auto x = _mm256_maskz_loadu_epi16(mask, src);               // [a1  a2  a3 a4]   total 256-bits in 4 64bits unit
+        auto y = _mm256_maskz_loadu_epi16(mask, src + src_stride);  // [b1  b2  b3 b4]   total 256-bits
         auto a = _mm512_castsi256_si512(x);
         auto b = _mm512_castsi256_si512(y);
-        a = _mm512_permutexvar_epi64(midx, a);                                      // [a1 x | a2 x | a3 x | a4 x]
-        b = _mm512_permutexvar_epi64(midx, b);                                      // [b1 x | b2 x | b3 x | b4 x]
+        a = _mm512_permutexvar_epi64(midx, a);  // [a1 x | a2 x | a3 x | a4 x]
+        b = _mm512_permutexvar_epi64(midx, b);  // [b1 x | b2 x | b3 x | b4 x]
         auto B0 = _mm512_unpacklo_epi16(a, b);
         _mm512_mask_storeu_epi32(dst, mask, B0);
         src += 2 * src_stride;
@@ -1239,8 +1316,17 @@ static void pack_32NxK(TDST* dst,
 }
 #    endif
 
-template<typename TDST, ov::element::Type_t SRC_PREC, typename std::enable_if<precision_of<TDST>::value == ov::element::f32, bool>::type = true>
-static void pack_32NxK(TDST* dst, void* src, TDST* tmp, size_t N, size_t K, size_t dst_stride, size_t src_stride, size_t group_size = 0) {
+template <typename TDST,
+          ov::element::Type_t SRC_PREC,
+          typename std::enable_if<precision_of<TDST>::value == ov::element::f32, bool>::type = true>
+static void pack_32NxK(TDST* dst,
+                       void* src,
+                       TDST* tmp,
+                       size_t N,
+                       size_t K,
+                       size_t dst_stride,
+                       size_t src_stride,
+                       size_t group_size = 0) {
     // never called
     OPENVINO_THROW("pack_32NxK: should not be called.");
 }
@@ -1260,10 +1346,10 @@ struct MHAHelper {
     size_t _key_group_size = 0;
     size_t _value_group_size = 0;
 
-    PlainTensor _weight;            // [nthr, H, 32, rnd_up(kv_len, block_size)], shared by first and second loop along bh
-    PlainTensor _output;            // [nthr, 32, H, S], shared by first and second loop along bh
-    PlainTensor _qk_scratch_a;      // [nthr, scratch_a_size]
-    PlainTensor _qk_scratch_b;      // [B, rnd_up(kv_len, block_size), Hk, scratch_b_size]
+    PlainTensor _weight;        // [nthr, H, 32, rnd_up(kv_len, block_size)], shared by first and second loop along bh
+    PlainTensor _output;        // [nthr, 32, H, S], shared by first and second loop along bh
+    PlainTensor _qk_scratch_a;  // [nthr, scratch_a_size]
+    PlainTensor _qk_scratch_b;  // [B, rnd_up(kv_len, block_size), Hk, scratch_b_size]
     PlainTensor _wv_scratch_a;
     PlainTensor _wv_scratch_b;
     PlainTensor _alibi_lookup;
@@ -1288,12 +1374,22 @@ struct MHAHelper {
         _weight.resize<float>({size_t{1}, size_t{1}, size_t{1}, size_t{1}});
     }
 
-    explicit MHAHelper(size_t key_group_size, size_t value_group_size) : _key_group_size(key_group_size), _value_group_size(value_group_size) {
+    explicit MHAHelper(size_t key_group_size, size_t value_group_size)
+        : _key_group_size(key_group_size),
+          _value_group_size(value_group_size) {
         _weight.resize<float>({size_t{1}, size_t{1}, size_t{1}, size_t{1}});
     }
 
-    void init(size_t H, size_t S, size_t SV, size_t Hk, size_t h_each_group_len, size_t block_size, size_t sliding_window,
-              float d_scale, size_t kv_len, bool init_alibi_lookup) {
+    void init(size_t H,
+              size_t S,
+              size_t SV,
+              size_t Hk,
+              size_t h_each_group_len,
+              size_t block_size,
+              size_t sliding_window,
+              float d_scale,
+              size_t kv_len,
+              bool init_alibi_lookup) {
         // query shape: [B, H, L, S]
         // present_key shape: [block, H, 32, S]
         // Q*K': [M1, S] * [M2, S]'
@@ -1335,25 +1431,27 @@ struct MHAHelper {
                                                              _weight.stride(2),
                                                              false,
                                                              in_type);
-                _wv_gemm[i] = std::make_shared<BrgemmKernel>(i + 1,
-                                                             _SV,
-                                                             _block_size,
-                                                             // if it's bf16, the stride needs double due to reuse float buffer
-                                                             (in_type == ov::element::Type_t::f32 ? 1 : 2) * _weight.stride(2),
-                                                             _SV,
-                                                             _output.stride(1),
-                                                             false,
-                                                             in_type);
-                _wv_gemm_acc[i] = std::make_shared<BrgemmKernel>(i + 1,
-                                                                 _SV,
-                                                                 _block_size,
-                                                                 // if it's bf16, the stride needs double due to reuse float buffer
-                                                                 (in_type == ov::element::Type_t::f32 ? 1 : 2) * _weight.stride(2),
-                                                                 _SV,
-                                                                 _output.stride(1),
-                                                                 false,
-                                                                 in_type,
-                                                                 true);
+                _wv_gemm[i] =
+                    std::make_shared<BrgemmKernel>(i + 1,
+                                                   _SV,
+                                                   _block_size,
+                                                   // if it's bf16, the stride needs double due to reuse float buffer
+                                                   (in_type == ov::element::Type_t::f32 ? 1 : 2) * _weight.stride(2),
+                                                   _SV,
+                                                   _output.stride(1),
+                                                   false,
+                                                   in_type);
+                _wv_gemm_acc[i] =
+                    std::make_shared<BrgemmKernel>(i + 1,
+                                                   _SV,
+                                                   _block_size,
+                                                   // if it's bf16, the stride needs double due to reuse float buffer
+                                                   (in_type == ov::element::Type_t::f32 ? 1 : 2) * _weight.stride(2),
+                                                   _SV,
+                                                   _output.stride(1),
+                                                   false,
+                                                   in_type,
+                                                   true);
             }
 
             // wsp is used to compute beta when K is blocked
@@ -1361,8 +1459,10 @@ struct MHAHelper {
             _wsp.resize(_nthr * _wsp_size_per_thread);
 
             // allocate scratch a/b, notice get_scratch_a_size/get_scratch_b_size returns in bytes
-            _qk_scratch_a.resize<DATA_TYPE>({_nthr, _qk_gemm[_block_size - 1]->get_scratch_a_size() / sizeof(DATA_TYPE)});
-            _wv_scratch_a.resize<DATA_TYPE>({_nthr, _wv_gemm[_block_size - 1]->get_scratch_a_size() / sizeof(DATA_TYPE)});
+            _qk_scratch_a.resize<DATA_TYPE>(
+                {_nthr, _qk_gemm[_block_size - 1]->get_scratch_a_size() / sizeof(DATA_TYPE)});
+            _wv_scratch_a.resize<DATA_TYPE>(
+                {_nthr, _wv_gemm[_block_size - 1]->get_scratch_a_size() / sizeof(DATA_TYPE)});
 
             if ((S % 32 == 0) && (block_size % 16 == 0) && (S <= 32 * 6)) {
                 if (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::amx_bf16) &&
@@ -1378,14 +1478,16 @@ struct MHAHelper {
                 }
             }
             if (one_of(_fastpath_valid_prec, ov::element::bf16, ov::element::f16) && !_gemv) {
-                _gemv = std::make_shared<JitMatMulVecAMX>(static_cast<int>(S), static_cast<int>(block_size), _fastpath_valid_prec);
+                _gemv = std::make_shared<JitMatMulVecAMX>(static_cast<int>(S),
+                                                          static_cast<int>(block_size),
+                                                          _fastpath_valid_prec);
             }
         }
 
         if (init_alibi_lookup && (!_alibi_lookup || _alibi_lookup.m_dims[0] < kv_len)) {
             _alibi_lookup.resize<float>({kv_len * 2});
             for (size_t i = 0; i < _alibi_lookup.m_dims[0]; i++)
-                _alibi_lookup.ptr<float>()[i] = - static_cast<int>((_alibi_lookup.m_dims[0] - 1 - i));
+                _alibi_lookup.ptr<float>()[i] = -static_cast<int>((_alibi_lookup.m_dims[0] - 1 - i));
         }
     }
 
@@ -1421,9 +1523,21 @@ struct MHAHelper {
     //  output_emb: [L, H * S]
     //  qk_scratch_b: [rnd_up(kv_len, block_size), Hk, scratch_b_size]
     //  wv_scratch_b: [rnd_up(kv_len, block_size), Hk, scratch_b_size]
-    void exec_kernel_multiple(const PlainTensor& query, const PlainTensor& present_value, const PlainTensor& output_emb,
-        const PlainTensor& qk_scratch_b, const PlainTensor& wv_scratch_b, const int32_t* block_table, size_t ithr, size_t q_blk,
-        size_t hq_beg, size_t hq_end, size_t hk, size_t q_len, size_t cur_kv_len, const PlainTensor& alibi_slopes, float* score_output) {
+    void exec_kernel_multiple(const PlainTensor& query,
+                              const PlainTensor& present_value,
+                              const PlainTensor& output_emb,
+                              const PlainTensor& qk_scratch_b,
+                              const PlainTensor& wv_scratch_b,
+                              const int32_t* block_table,
+                              size_t ithr,
+                              size_t q_blk,
+                              size_t hq_beg,
+                              size_t hq_end,
+                              size_t hk,
+                              size_t q_len,
+                              size_t cur_kv_len,
+                              const PlainTensor& alibi_slopes,
+                              float* score_output) {
         auto q_start = q_blk * _block_size;
         auto q_end = std::min(q_start + _block_size, q_len);
         auto q_cnt = q_end - q_start;
@@ -1496,13 +1610,16 @@ struct MHAHelper {
                                                alibi_slope);
                 }
                 if (score_output) {
-                    cvt_copy(score_output + h * rnd_up(cur_kv_len, 16), reinterpret_cast<DATA_TYPE*>(score), cur_kv_len);
+                    cvt_copy(score_output + h * rnd_up(cur_kv_len, 16),
+                             reinterpret_cast<DATA_TYPE*>(score),
+                             cur_kv_len);
                 }
             }
 
             // reuse float buffer, need to use float to compute offset
             auto* w_ptr = reinterpret_cast<DATA_TYPE*>(_weight.ptr<float>(ithr, h, 0, 0));
-            float* fp32_out_ptr = q_is_xf16 ? _output.ptr<float>(ithr, 0, h, 0) : output_emb.ptr<float>(q_start, h * _SV);
+            float* fp32_out_ptr =
+                q_is_xf16 ? _output.ptr<float>(ithr, 0, h, 0) : output_emb.ptr<float>(q_start, h * _SV);
 
             // for each weight block, loop through all value block
             for (size_t v_blk = 0; v_blk < cur_kv_len_blocks; v_blk++) {
@@ -1520,12 +1637,13 @@ struct MHAHelper {
                                                      _wsp.data() + ithr * _wsp_size_per_thread,
                                                      _wv_scratch_a ? _wv_scratch_a.ptr<DATA_TYPE>(ithr, 0) : nullptr);
                 } else {
-                    _wv_gemm_acc[q_cnt - 1]->executeGemm(q_cnt < _block_size,
-                                                         w_ptr + v_blk * _block_size,
-                                                         v_ptr,
-                                                         fp32_out_ptr,
-                                                         _wsp.data() + ithr * _wsp_size_per_thread,
-                                                         _wv_scratch_a ? _wv_scratch_a.ptr<DATA_TYPE>(ithr, 0) : nullptr);
+                    _wv_gemm_acc[q_cnt - 1]->executeGemm(
+                        q_cnt < _block_size,
+                        w_ptr + v_blk * _block_size,
+                        v_ptr,
+                        fp32_out_ptr,
+                        _wsp.data() + ithr * _wsp_size_per_thread,
+                        _wv_scratch_a ? _wv_scratch_a.ptr<DATA_TYPE>(ithr, 0) : nullptr);
                 }
             }
             if (q_is_xf16) {
@@ -1548,17 +1666,28 @@ struct MHAHelper {
     //  output_emb: [L, H * S]
     //  weight: [nthr, H, 32, rnd_up(kv_len, block_size)]
     //  output: [nthr, 32, H, S]
-    void exec_kernel_one_bh(const PlainTensor& query, const PlainTensor& present_key, const PlainTensor& present_value, const PlainTensor& output_emb,
-        const int32_t* block_table, size_t ithr, size_t hq_beg, size_t hq_end, size_t hk,
-        size_t q_len, size_t cur_kv_len, const PlainTensor& alibi_slopes, float* score_output) {
+    void exec_kernel_one_bh(const PlainTensor& query,
+                            const PlainTensor& present_key,
+                            const PlainTensor& present_value,
+                            const PlainTensor& output_emb,
+                            const int32_t* block_table,
+                            size_t ithr,
+                            size_t hq_beg,
+                            size_t hq_end,
+                            size_t hk,
+                            size_t q_len,
+                            size_t cur_kv_len,
+                            const PlainTensor& alibi_slopes,
+                            float* score_output) {
         if (one_of(_fastpath_valid_prec, ov::element::bf16, ov::element::f16)) {
             _gemv->tile_config();
             for (size_t pk = 0, i = 0; pk < cur_kv_len; pk += _block_size, i++) {
                 auto block_number = block_table[i];
                 for (size_t pq = 0; pq < q_len; pq++) {
                     for (size_t h = hq_beg; h < hq_end; h++) {
-                        (*_gemv)(query.ptr<DATA_TYPE>(h, pq), present_key.ptr<KEY_CACHE_TYPE>(block_number, hk),
-                            _weight.ptr<float>(ithr, h, pq) + pk);
+                        (*_gemv)(query.ptr<DATA_TYPE>(h, pq),
+                                 present_key.ptr<KEY_CACHE_TYPE>(block_number, hk),
+                                 _weight.ptr<float>(ithr, h, pq) + pk);
                     }
                 }
             }
@@ -1568,8 +1697,12 @@ struct MHAHelper {
                 auto block_number = block_table[i];
                 for (size_t pq = 0; pq < q_len; pq++) {
                     for (size_t h = hq_beg; h < hq_end; h++) {
-                        dot_product_block(query.ptr<DATA_TYPE>(h, pq), present_key.ptr<KEY_CACHE_TYPE>(block_number, hk),
-                            _weight.ptr<float>(ithr, h, pq) + pk, _S, std::min(_block_size, cur_kv_len - pk), _key_group_size);
+                        dot_product_block(query.ptr<DATA_TYPE>(h, pq),
+                                          present_key.ptr<KEY_CACHE_TYPE>(block_number, hk),
+                                          _weight.ptr<float>(ithr, h, pq) + pk,
+                                          _S,
+                                          std::min(_block_size, cur_kv_len - pk),
+                                          _key_group_size);
                     }
                 }
             }
@@ -1597,7 +1730,9 @@ struct MHAHelper {
                                            ov::element::f32,
                                            alibi_slope);
                 if (score_output) {
-                    memcpy(score_output + h * rnd_up(cur_kv_len, 16), _weight.ptr<float>(ithr, h, pq), cur_kv_len * sizeof(float));
+                    memcpy(score_output + h * rnd_up(cur_kv_len, 16),
+                           _weight.ptr<float>(ithr, h, pq),
+                           cur_kv_len * sizeof(float));
                 }
             }
         }
@@ -1610,26 +1745,28 @@ struct MHAHelper {
                 for (size_t h = hq_beg; h < hq_end; h++) {
                     if (present_value.get_precision() == ov::element::u4) {
                         auto sub_byte_multiplyer = 8 / present_value.get_precision().bitwidth();
-                        size_t v_stride = (block_number * present_value.m_strides[0] + hk * present_value.m_strides[1]) / sub_byte_multiplyer;
+                        size_t v_stride =
+                            (block_number * present_value.m_strides[0] + hk * present_value.m_strides[1]) /
+                            sub_byte_multiplyer;
                         auto* v_ptr = present_value.m_ptr.get() + v_stride;
-                        attn_acc_value_block<VALUE_CACHE_TYPE, ov::element::u4>(
-                            _output.ptr<float>(ithr, pq, h),
-                            _weight.ptr<float>(ithr, h, pq) + pv,
-                            v_ptr,
-                            _SV,
-                            std::min(_block_size, cur_kv_len - pv),
-                            _value_group_size);
+                        attn_acc_value_block<VALUE_CACHE_TYPE, ov::element::u4>(_output.ptr<float>(ithr, pq, h),
+                                                                                _weight.ptr<float>(ithr, h, pq) + pv,
+                                                                                v_ptr,
+                                                                                _SV,
+                                                                                std::min(_block_size, cur_kv_len - pv),
+                                                                                _value_group_size);
                     } else if (present_value.get_precision() == ov::element::i4) {
                         auto sub_byte_multiplyer = 8 / present_value.get_precision().bitwidth();
-                        size_t v_stride = (block_number * present_value.m_strides[0] + hk * present_value.m_strides[1]) / sub_byte_multiplyer;
+                        size_t v_stride =
+                            (block_number * present_value.m_strides[0] + hk * present_value.m_strides[1]) /
+                            sub_byte_multiplyer;
                         auto* v_ptr = present_value.m_ptr.get() + v_stride;
-                        attn_acc_value_block<VALUE_CACHE_TYPE, ov::element::i4>(
-                            _output.ptr<float>(ithr, pq, h),
-                            _weight.ptr<float>(ithr, h, pq) + pv,
-                            v_ptr,
-                            _SV,
-                            std::min(_block_size, cur_kv_len - pv),
-                            _value_group_size);
+                        attn_acc_value_block<VALUE_CACHE_TYPE, ov::element::i4>(_output.ptr<float>(ithr, pq, h),
+                                                                                _weight.ptr<float>(ithr, h, pq) + pv,
+                                                                                v_ptr,
+                                                                                _SV,
+                                                                                std::min(_block_size, cur_kv_len - pv),
+                                                                                _value_group_size);
                     } else {
                         attn_acc_value_block<VALUE_CACHE_TYPE, precision_of<VALUE_CACHE_TYPE>::value>(
                             _output.ptr<float>(ithr, pq, h),
@@ -1648,9 +1785,9 @@ struct MHAHelper {
                 cvt_copy(output_emb.ptr<DATA_TYPE>(pq, h * _SV), _output.ptr<float>(ithr, pq, h), _SV);
     }
 
-    // compute one token, loop along batch, head dimensions and kv_len, it's special for very long kv_len with small batch tokens.
-    // It will assume NO mixture execution of first and second token.
-    // all tensors such as query... have batch dimension which is DIFFERENT from above
+    // compute one token, loop along batch, head dimensions and kv_len, it's special for very long kv_len with small
+    // batch tokens. It will assume NO mixture execution of first and second token. all tensors such as query... have
+    // batch dimension which is DIFFERENT from above
     //  query: [B, H, L, S]
     //  present_*: [block_number, H, 32, S]
     //  output_emb: [B, L, H * S]
@@ -1689,17 +1826,18 @@ struct MHAHelper {
             // for bigger batch skip the test to save the cost
             prefer_static_loop = false;
         }
-        auto get_h_params = [] (bool loop_hk, size_t hx, size_t h_each_group_len, size_t& hq_beg, size_t& hq_end, size_t& hk) {
-            if (loop_hk) {
-                hk = hx;
-                hq_beg = hk * h_each_group_len;
-                hq_end = (hk + 1) * h_each_group_len;
-            } else {
-                hq_beg = hx;
-                hq_end = hx + 1;
-                hk = hx / h_each_group_len;
-            }
-        };
+        auto get_h_params =
+            [](bool loop_hk, size_t hx, size_t h_each_group_len, size_t& hq_beg, size_t& hq_end, size_t& hk) {
+                if (loop_hk) {
+                    hk = hx;
+                    hq_beg = hk * h_each_group_len;
+                    hq_end = (hk + 1) * h_each_group_len;
+                } else {
+                    hq_beg = hx;
+                    hq_end = hx + 1;
+                    hk = hx / h_each_group_len;
+                }
+            };
         auto loop_qk = [&](size_t b, size_t pk_in_blocks, size_t hx) {
             auto context_len = static_cast<size_t>(past_lens.ptr<int32_t>()[b]) + 1;
             size_t hk, hq_beg, hq_end;
@@ -1713,16 +1851,21 @@ struct MHAHelper {
                     _gemv->tile_config();
                     for (size_t pq = 0; pq < q_len; pq++) {
                         for (size_t h = hq_beg; h < hq_end; h++) {
-                            (*_gemv)(query.ptr<DATA_TYPE>(b, h, pq), present_key.ptr<KEY_CACHE_TYPE>(block_number, hk),
-                                _weight_bhl.ptr<float>(b, h, pq) + pk);
+                            (*_gemv)(query.ptr<DATA_TYPE>(b, h, pq),
+                                     present_key.ptr<KEY_CACHE_TYPE>(block_number, hk),
+                                     _weight_bhl.ptr<float>(b, h, pq) + pk);
                         }
                     }
                     _gemv->tile_release();
                 } else {
                     for (size_t pq = 0; pq < q_len; pq++) {
                         for (size_t h = hq_beg; h < hq_end; h++) {
-                            dot_product_block(query.ptr<DATA_TYPE>(b, h, pq), present_key.ptr<KEY_CACHE_TYPE>(block_number, hk),
-                                _weight_bhl.ptr<float>(b, h, pq) + pk, _S, std::min(_block_size, context_len - pk), _key_group_size);
+                            dot_product_block(query.ptr<DATA_TYPE>(b, h, pq),
+                                              present_key.ptr<KEY_CACHE_TYPE>(block_number, hk),
+                                              _weight_bhl.ptr<float>(b, h, pq) + pk,
+                                              _S,
+                                              std::min(_block_size, context_len - pk),
+                                              _key_group_size);
                         }
                     }
                 }
@@ -1794,7 +1937,9 @@ struct MHAHelper {
                     for (size_t h = hq_beg; h < hq_end; h++) {
                         if (present_value.get_precision() == ov::element::u4) {
                             auto sub_byte_multiplyer = 8 / present_value.get_precision().bitwidth();
-                            size_t v_stride = (block_number * present_value.m_strides[0] + hk * present_value.m_strides[1]) / sub_byte_multiplyer;
+                            size_t v_stride =
+                                (block_number * present_value.m_strides[0] + hk * present_value.m_strides[1]) /
+                                sub_byte_multiplyer;
                             auto* v_ptr = present_value.m_ptr.get() + v_stride;
                             attn_acc_value_block<VALUE_CACHE_TYPE, ov::element::u4>(
                                 _output_bhl.ptr<float>(ithr, b, pq, h),
@@ -1805,7 +1950,9 @@ struct MHAHelper {
                                 _value_group_size);
                         } else if (present_value.get_precision() == ov::element::i4) {
                             auto sub_byte_multiplyer = 8 / present_value.get_precision().bitwidth();
-                            size_t v_stride = (block_number * present_value.m_strides[0] + hk * present_value.m_strides[1]) / sub_byte_multiplyer;
+                            size_t v_stride =
+                                (block_number * present_value.m_strides[0] + hk * present_value.m_strides[1]) /
+                                sub_byte_multiplyer;
                             auto* v_ptr = present_value.m_ptr.get() + v_stride;
                             attn_acc_value_block<VALUE_CACHE_TYPE, ov::element::i4>(
                                 _output_bhl.ptr<float>(ithr, b, pq, h),
@@ -1847,26 +1994,29 @@ template <typename DATA_TYPE, typename KEY_CACHE_TYPE, typename VALUE_CACHE_TYPE
 struct MHA {
     MHAHelper<DATA_TYPE, KEY_CACHE_TYPE, VALUE_CACHE_TYPE>& _helper;
     struct AttnWorkItem {
-        int32_t batch_in_reorder;                   // which batch in reorder buffer will be used
-        int32_t batch_in_seq;                       // batch idx in sequence
-        int32_t q_len;                              // current sequence length, 1 for second token, 2+ for first token
-        int32_t q_block_id;                         // block id in this seq, valid at first token
+        int32_t batch_in_reorder;  // which batch in reorder buffer will be used
+        int32_t batch_in_seq;      // batch idx in sequence
+        int32_t q_len;             // current sequence length, 1 for second token, 2+ for first token
+        int32_t q_block_id;        // block id in this seq, valid at first token
     };
     struct ReorderWorkItem {
-        int32_t batch_in_seq;                       // batch idx in sequence
-        int32_t batch_in_reorder;                   // which batch in reorder buffer will be used
-        int32_t kv_block_id;                        // block id in this kv cache seq
+        int32_t batch_in_seq;      // batch idx in sequence
+        int32_t batch_in_reorder;  // which batch in reorder buffer will be used
+        int32_t kv_block_id;       // block id in this kv cache seq
     };
     struct WorkItems {
     private:
         std::vector<AttnWorkItem> attn_items;
         std::vector<ReorderWorkItem> reorder_items;
-        int32_t max_kv_len_in_reorder;              // max kv len between first tokens
+        int32_t max_kv_len_in_reorder;  // max kv len between first tokens
         int32_t max_batch_in_reorder;
         int32_t total_kv_len;
 
     public:
-        void reset(const PlainTensor& query, const PlainTensor& past_lens, const PlainTensor& subsequence_begins, size_t block_size) {
+        void reset(const PlainTensor& query,
+                   const PlainTensor& past_lens,
+                   const PlainTensor& subsequence_begins,
+                   size_t block_size) {
             attn_items.clear();
             reorder_items.clear();
             max_kv_len_in_reorder = 0;
@@ -1879,21 +2029,19 @@ struct MHA {
                 auto kv_len = past_lens.ptr<int32_t>()[i] + q_len;
                 auto kv_len_in_block = static_cast<int32_t>(div_up(kv_len, block_size));
                 if (q_len == 1) {
-                    attn_items.emplace_back(AttnWorkItem{
-                        0,                          // batch_in_reorder
-                        i,                          // batch_in_seq
-                        1ull,                       // q_len
-                        // kv_len in blocks, used in the sort function
-                        kv_len_in_block - 1
-                    });
+                    attn_items.emplace_back(AttnWorkItem{0,     // batch_in_reorder
+                                                         i,     // batch_in_seq
+                                                         1ull,  // q_len
+                                                         // kv_len in blocks, used in the sort function
+                                                         kv_len_in_block - 1});
                 } else {
                     auto reorder_sub_work_count = kv_len_in_block;
                     max_kv_len_in_reorder = std::max(max_kv_len_in_reorder, kv_len);
                     for (int32_t block_id = 0; block_id < reorder_sub_work_count; block_id++) {
                         reorder_items.emplace_back(ReorderWorkItem{
-                            i,                       // batch_in_seq
-                            max_batch_in_reorder,    // batch_in_reorder
-                            block_id                 // kv_block_id
+                            i,                     // batch_in_seq
+                            max_batch_in_reorder,  // batch_in_reorder
+                            block_id               // kv_block_id
                         });
                     }
 
@@ -1901,17 +2049,18 @@ struct MHA {
                     auto attn_sub_work_count = static_cast<int32_t>(div_up(q_len, block_size));
                     for (int32_t block_id = 0; block_id < attn_sub_work_count; block_id++) {
                         attn_items.emplace_back(AttnWorkItem{
-                            max_batch_in_reorder,    // batch_in_reorder
-                            i,                       // batch_in_seq
-                            q_len,                   // q_len
-                            block_id                 // q_block_id
+                            max_batch_in_reorder,  // batch_in_reorder
+                            i,                     // batch_in_seq
+                            q_len,                 // q_len
+                            block_id               // q_block_id
                         });
                     }
                     max_batch_in_reorder++;
                 }
                 total_kv_len += kv_len;
             }
-            // std::sort(attn_items.begin(), attn_items.end(), [] (const AttnWorkItem& left, const AttnWorkItem& right) {
+            // std::sort(attn_items.begin(), attn_items.end(), [] (const AttnWorkItem& left, const AttnWorkItem& right)
+            // {
             //     // kv block number which will be acessed later
             //     auto left_kv_blocks = left.q_block_id;
             //     auto right_kv_blocks = right.q_block_id;
@@ -1965,7 +2114,8 @@ struct MHA {
         auto reorder_work_count = _workitems.reorder_work_size();
 
         // buffer for transpose and repack
-        _helper.init_reorder_buffers(_workitems.get_reorder_max_batch_size(), div_up(_workitems.get_reorder_max_kv_len(), _helper._block_size));
+        _helper.init_reorder_buffers(_workitems.get_reorder_max_batch_size(),
+                                     div_up(_workitems.get_reorder_max_kv_len(), _helper._block_size));
 
         // packed k, v
         parallel_for2d_dynamic(reorder_work_count, Hk, [&](size_t w, size_t hk) {
@@ -1973,7 +2123,8 @@ struct MHA {
             const auto batch_in_seq = item.batch_in_seq;
             const auto batch_in_reorder = item.batch_in_reorder;
             const auto kv_block = item.kv_block_id;
-            auto block_number = block_indices.ptr<int32_t>()[block_indices_begins.ptr<int32_t>()[batch_in_seq] + kv_block];
+            auto block_number =
+                block_indices.ptr<int32_t>()[block_indices_begins.ptr<int32_t>()[batch_in_seq] + kv_block];
             if (block_number < 0)
                 return;
 
@@ -1981,46 +2132,55 @@ struct MHA {
             auto* k_ptr = k_cache.ptr<KEY_CACHE_TYPE>(block_number, hk);
             auto* v_ptr = v_cache.ptr<VALUE_CACHE_TYPE>(block_number, hk);
 
-            transpose_16NxK<DATA_TYPE, precision_of<KEY_CACHE_TYPE>::value>(_helper._qk_scratch_b.template ptr<DATA_TYPE>(batch_in_reorder, kv_block, hk),
-            k_ptr,
-            _helper._output.template ptr<DATA_TYPE>(ithr),
-            _helper._block_size,
-            _helper._S, _helper._block_size, _helper._S, _helper._key_group_size);
+            transpose_16NxK<DATA_TYPE, precision_of<KEY_CACHE_TYPE>::value>(
+                _helper._qk_scratch_b.template ptr<DATA_TYPE>(batch_in_reorder, kv_block, hk),
+                k_ptr,
+                _helper._output.template ptr<DATA_TYPE>(ithr),
+                _helper._block_size,
+                _helper._S,
+                _helper._block_size,
+                _helper._S,
+                _helper._key_group_size);
 
             if (q_is_xf16) {
                 if (v_cache.get_precision() == ov::element::u4) {
                     auto sub_byte_multiplyer = 8 / v_cache.get_precision().bitwidth();
-                    size_t v_stride = (block_number * v_cache.m_strides[0] + hk * v_cache.m_strides[1]) / sub_byte_multiplyer;
+                    size_t v_stride =
+                        (block_number * v_cache.m_strides[0] + hk * v_cache.m_strides[1]) / sub_byte_multiplyer;
                     auto* v_ptr = v_cache.m_ptr.get() + v_stride;
-                    pack_32NxK<DATA_TYPE, ov::element::u4>(_helper._wv_scratch_b.template ptr<DATA_TYPE>(batch_in_reorder, kv_block, hk),
-                                v_ptr,
-                                _helper._output.template ptr<DATA_TYPE>(ithr),
-                                _helper._block_size,
-                                _helper._SV,
-                                rnd_up(_helper._SV, _helper._block_size),
-                                _helper._SV,
-                                _helper._value_group_size);
+                    pack_32NxK<DATA_TYPE, ov::element::u4>(
+                        _helper._wv_scratch_b.template ptr<DATA_TYPE>(batch_in_reorder, kv_block, hk),
+                        v_ptr,
+                        _helper._output.template ptr<DATA_TYPE>(ithr),
+                        _helper._block_size,
+                        _helper._SV,
+                        rnd_up(_helper._SV, _helper._block_size),
+                        _helper._SV,
+                        _helper._value_group_size);
                 } else if (v_cache.get_precision() == ov::element::i4) {
                     auto sub_byte_multiplyer = 8 / v_cache.get_precision().bitwidth();
-                    size_t v_stride = (block_number * v_cache.m_strides[0] + hk * v_cache.m_strides[1]) / sub_byte_multiplyer;
+                    size_t v_stride =
+                        (block_number * v_cache.m_strides[0] + hk * v_cache.m_strides[1]) / sub_byte_multiplyer;
                     auto* v_ptr = v_cache.m_ptr.get() + v_stride;
-                    pack_32NxK<DATA_TYPE, ov::element::i4>(_helper._wv_scratch_b.template ptr<DATA_TYPE>(batch_in_reorder, kv_block, hk),
-                                v_ptr,
-                                _helper._output.template ptr<DATA_TYPE>(ithr),
-                                _helper._block_size,
-                                _helper._SV,
-                                rnd_up(_helper._SV, _helper._block_size),
-                                _helper._SV,
-                                _helper._value_group_size);
+                    pack_32NxK<DATA_TYPE, ov::element::i4>(
+                        _helper._wv_scratch_b.template ptr<DATA_TYPE>(batch_in_reorder, kv_block, hk),
+                        v_ptr,
+                        _helper._output.template ptr<DATA_TYPE>(ithr),
+                        _helper._block_size,
+                        _helper._SV,
+                        rnd_up(_helper._SV, _helper._block_size),
+                        _helper._SV,
+                        _helper._value_group_size);
                 } else {
-                    pack_32NxK<DATA_TYPE, precision_of<VALUE_CACHE_TYPE>::value>(_helper._wv_scratch_b.template ptr<DATA_TYPE>(batch_in_reorder, kv_block, hk),
-                                v_ptr,
-                                _helper._output.template ptr<DATA_TYPE>(ithr),
-                                _helper._block_size,
-                                _helper._SV,
-                                rnd_up(_helper._SV, _helper._block_size),
-                                _helper._SV,
-                                _helper._value_group_size);
+                    pack_32NxK<DATA_TYPE, precision_of<VALUE_CACHE_TYPE>::value>(
+                        _helper._wv_scratch_b.template ptr<DATA_TYPE>(batch_in_reorder, kv_block, hk),
+                        v_ptr,
+                        _helper._output.template ptr<DATA_TYPE>(ithr),
+                        _helper._block_size,
+                        _helper._SV,
+                        rnd_up(_helper._SV, _helper._block_size),
+                        _helper._SV,
+                        _helper._value_group_size);
                 }
             } else {
                 // need to decompress
@@ -2059,10 +2219,13 @@ struct MHA {
             }
         });
 
-        // loop along HK dimension: if mixed first/second token and elements count is enough, loop HK to reuse KV in the CPU cache
+        // loop along HK dimension: if mixed first/second token and elements count is enough, loop HK to reuse KV in the
+        // CPU cache
         //    else if elements count is small, prefer to loop H to get more work to avoid thread imbalance
-        bool loop_hk = _workitems.get_reorder_max_batch_size() == past_lens.m_dims[0] ||        // if only first token, loop H
-            attn_work_count * Hk <= 2 * _helper._nthr ? false : true;                           // or less than 2 work items per thread, loop H
+        bool loop_hk = _workitems.get_reorder_max_batch_size() == past_lens.m_dims[0] ||  // if only first token, loop H
+                               attn_work_count * Hk <= 2 * _helper._nthr
+                           ? false
+                           : true;  // or less than 2 work items per thread, loop H
 
         parallel_for2d_dynamic(attn_work_count, loop_hk ? Hk : _helper._H, [&](size_t w, size_t hx) {
             size_t hk, hq_beg, hq_end;
@@ -2090,16 +2253,26 @@ struct MHA {
                     score_output = _helper._score_output.template ptr<float>() + score_offset * _helper._H;
                 }
 
-                _helper.exec_kernel_one_bh(q.slice(0, batch_in_token, batch_in_token), k_cache, v_cache,
+                _helper.exec_kernel_one_bh(
+                    q.slice(0, batch_in_token, batch_in_token),
+                    k_cache,
+                    v_cache,
                     output_emb.slice(0, batch_in_token, batch_in_token),
                     block_indices.ptr<int32_t>() + block_indices_begins.ptr<int32_t>()[batch_in_seq],
-                    ithr, hq_beg, hq_end, hk, 1ul, cur_kv_len, alibi_slopes,
+                    ithr,
+                    hq_beg,
+                    hq_end,
+                    hk,
+                    1ul,
+                    cur_kv_len,
+                    alibi_slopes,
                     score_output);
             } else {
                 const auto batch_in_reorder = item.batch_in_reorder;
                 const auto q_blk = item.q_block_id;
                 const auto q_cnt = std::min(_helper._block_size, q_len - q_blk * _helper._block_size);
-                const auto cur_kv_len = static_cast<size_t>(past_lens.ptr<int32_t>()[batch_in_seq]) + q_blk * _helper._block_size + q_cnt;
+                const auto cur_kv_len =
+                    static_cast<size_t>(past_lens.ptr<int32_t>()[batch_in_seq]) + q_blk * _helper._block_size + q_cnt;
                 float* score_output = nullptr;
                 if (output_score) {
                     // last block
@@ -2112,9 +2285,11 @@ struct MHA {
                 PlainTensor sub_query;
                 sub_query.resize({q_len, _helper._H, _helper._S}, q.ptr<DATA_TYPE>(batch_in_token));
                 sub_query = sub_query.permute({1, 0, 2});
-                _helper.exec_kernel_multiple(sub_query,
+                _helper.exec_kernel_multiple(
+                    sub_query,
                     v_cache,
-                    output_emb.slice(0, batch_in_token, batch_in_token + q_len).reshape({q_len, _helper._H * _helper._SV}),
+                    output_emb.slice(0, batch_in_token, batch_in_token + q_len)
+                        .reshape({q_len, _helper._H * _helper._SV}),
                     _helper._qk_scratch_b.slice(0, batch_in_reorder, batch_in_reorder),
                     _helper._wv_scratch_b.slice(0, batch_in_reorder, batch_in_reorder),
                     block_indices.ptr<int32_t>() + block_indices_begins.ptr<int32_t>()[batch_in_seq],
@@ -2131,7 +2306,8 @@ struct MHA {
         });
         if (output_score) {
             parallel_for2d_dynamic(past_lens.m_dims[0], 1, [&](size_t b, size_t pq) {
-                auto seq_len = static_cast<size_t>(subsequence_begins.ptr<int32_t>()[b + 1] - subsequence_begins.ptr<int32_t>()[b]);
+                auto seq_len = static_cast<size_t>(subsequence_begins.ptr<int32_t>()[b + 1] -
+                                                   subsequence_begins.ptr<int32_t>()[b]);
                 auto cur_kv_len = static_cast<size_t>(past_lens.ptr<int32_t>()[b]) + seq_len;
                 auto src_offset = _helper._score_offsets_aligned.template ptr<int32_t>()[b];
                 auto* src = _helper._score_output.template ptr<float>() + src_offset * _helper._H;
@@ -2162,11 +2338,29 @@ struct MHA {
         auto nthr = static_cast<size_t>(parallel_get_max_threads());
 
         if (past_lens.m_dims[0] >= nthr || _workitems.get_reorder_max_batch_size() > 0) {
-            exec_loop_mixed(query, present_key, present_value, output_emb, output_score, max_context_len, past_lens, subsequence_begins,
-                block_indices, block_indices_begins, alibi_slopes);
+            exec_loop_mixed(query,
+                            present_key,
+                            present_value,
+                            output_emb,
+                            output_score,
+                            max_context_len,
+                            past_lens,
+                            subsequence_begins,
+                            block_indices,
+                            block_indices_begins,
+                            alibi_slopes);
         } else {
-            _helper.exec_loop_bhl(query, present_key, present_value, output_emb, output_score, max_context_len, past_lens, subsequence_begins,
-                block_indices, block_indices_begins, alibi_slopes);
+            _helper.exec_loop_bhl(query,
+                                  present_key,
+                                  present_value,
+                                  output_emb,
+                                  output_score,
+                                  max_context_len,
+                                  past_lens,
+                                  subsequence_begins,
+                                  block_indices,
+                                  block_indices_begins,
+                                  alibi_slopes);
         }
     }
 };
@@ -2183,18 +2377,32 @@ struct AttentionExecutor : public PagedAttentionExecutor {
         : _helper(MHAHelper<DATA_TYPE, KEY_CACHE_TYPE, VALUE_CACHE_TYPE>(key_group_size, value_group_size)),
           _kernel(_helper) {}
 
-    void init(const std::vector<MemoryPtr>& inputs, const std::vector<MemoryPtr>& outputs, PlainTensor& q, PlainTensor& k, PlainTensor& v, PlainTensor& k_cache,
-        PlainTensor& v_cache, PlainTensor& past_lens, PlainTensor& subsequence_begins, PlainTensor& block_indices, PlainTensor& block_indices_begins,
-        float& scale, size_t& sliding_window, PlainTensor& alibi_slopes, size_t& max_context_len, PlainTensor& output_emb, PlainTensor& output_score) {
-        q.reset(inputs[ID_Q]);                                      // [B_token, H * S]
+    void init(const std::vector<MemoryPtr>& inputs,
+              const std::vector<MemoryPtr>& outputs,
+              PlainTensor& q,
+              PlainTensor& k,
+              PlainTensor& v,
+              PlainTensor& k_cache,
+              PlainTensor& v_cache,
+              PlainTensor& past_lens,
+              PlainTensor& subsequence_begins,
+              PlainTensor& block_indices,
+              PlainTensor& block_indices_begins,
+              float& scale,
+              size_t& sliding_window,
+              PlainTensor& alibi_slopes,
+              size_t& max_context_len,
+              PlainTensor& output_emb,
+              PlainTensor& output_score) {
+        q.reset(inputs[ID_Q]);  // [B_token, H * S]
         k.reset(inputs[ID_K]);
         v.reset(inputs[ID_V]);
-        k_cache.reset(inputs[ID_KCACHE]);                           // [NUM_BLOCKS, H, 32, S]
-        v_cache.reset(inputs[ID_VCACHE]);                           // [NUM_BLOCKS, H, 32, S]
-        past_lens.reset(inputs[ID_PAST_LENS]);                      // [B_seq]
-        subsequence_begins.reset(inputs[ID_SUBSEQUENCE_BEGINS]);    // [B_seq+1]
-        block_indices.reset(inputs[ID_BLOCK_INDICES]);              // [num_blocks]
-        block_indices_begins.reset(inputs[ID_BLOCK_INDICES_BEGINS]);// [B_seq+1]
+        k_cache.reset(inputs[ID_KCACHE]);                             // [NUM_BLOCKS, H, 32, S]
+        v_cache.reset(inputs[ID_VCACHE]);                             // [NUM_BLOCKS, H, 32, S]
+        past_lens.reset(inputs[ID_PAST_LENS]);                        // [B_seq]
+        subsequence_begins.reset(inputs[ID_SUBSEQUENCE_BEGINS]);      // [B_seq+1]
+        block_indices.reset(inputs[ID_BLOCK_INDICES]);                // [num_blocks]
+        block_indices_begins.reset(inputs[ID_BLOCK_INDICES_BEGINS]);  // [B_seq+1]
         scale = *inputs[ID_SCALE]->getDataAs<float>();
         sliding_window = static_cast<size_t>(*inputs[ID_SLIDING_WINDOW]->getDataAs<int32_t>());
         if (!inputs[ID_ALIBI_SLOPES]->getShape().hasZeroDims())
@@ -2209,13 +2417,14 @@ struct AttentionExecutor : public PagedAttentionExecutor {
         auto _key_group_size = _helper._key_group_size;
         auto _value_group_size = _helper._key_group_size;
         // The layout for per token per head for u8 kv cache:
-        // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized feature(u8,idx_S)|
-        // The actual size needs to deduct scale and zeropoint.
+        // |scale(f32)|zeropoint(f32)|quantized feature(u8,idx_1)|quantized feature(u8,idx_2)|...|quantized
+        // feature(u8,idx_S)| The actual size needs to deduct scale and zeropoint.
         const size_t key_sub_byte_multiplyer = 8 / k_cache.get_precision().bitwidth();
         const size_t value_sub_byte_multiplyer = 8 / v_cache.get_precision().bitwidth();
         const size_t key_params_size = sizeof(float) * 2 * key_sub_byte_multiplyer;
         // u4 needs scale + zp. s4 needs scale.
-        const size_t param_size = one_of(v_cache.get_precision(), ov::element::u4, ov::element::u8) ? sizeof(float) * 2 : sizeof(float);
+        const size_t param_size =
+            one_of(v_cache.get_precision(), ov::element::u4, ov::element::u8) ? sizeof(float) * 2 : sizeof(float);
         const size_t value_params_size = param_size * value_sub_byte_multiplyer;
         size_t key_group_num = _key_group_size ? k_cache.size(3) / (_key_group_size + key_params_size) : 1;
         size_t value_group_num = _value_group_size ? v_cache.size(3) / (_value_group_size + value_params_size) : 1;
@@ -2261,8 +2470,14 @@ struct AttentionExecutor : public PagedAttentionExecutor {
         _helper.init(H, S, SV, Hk, h_each_group_len, block_size, sliding_window, scale, max_context_len, alibi_slopes);
     }
 
-    void concat_pastkv(const PlainTensor& k, const PlainTensor& v, const PlainTensor& k_cache, const PlainTensor& v_cache,
-        const PlainTensor& past_lens, const PlainTensor& subsequence_begins, const PlainTensor& block_indices, const PlainTensor& block_indices_begins) {
+    void concat_pastkv(const PlainTensor& k,
+                       const PlainTensor& v,
+                       const PlainTensor& k_cache,
+                       const PlainTensor& v_cache,
+                       const PlainTensor& past_lens,
+                       const PlainTensor& subsequence_begins,
+                       const PlainTensor& block_indices,
+                       const PlainTensor& block_indices_begins) {
         auto B_token = k.size(0);
         _slot_mapping.resize<int32_t>({B_token});
 
@@ -2274,13 +2489,21 @@ struct AttentionExecutor : public PagedAttentionExecutor {
             auto block_offset_start = kv_len - q_len;
             for (int32_t j = 0; j < q_len; j++) {
                 auto block_offset = block_offset_start + j;
-                auto block_number = block_indices.ptr<int32_t>()[block_number_start + block_offset / _helper._block_size];
-                _slot_mapping.ptr<int32_t>()[idx++] = block_number * _helper._block_size + block_offset % _helper._block_size;
+                auto block_number =
+                    block_indices.ptr<int32_t>()[block_number_start + block_offset / _helper._block_size];
+                _slot_mapping.ptr<int32_t>()[idx++] =
+                    block_number * _helper._block_size + block_offset % _helper._block_size;
             }
         }
 
         if (k_cache.m_dt == ov::element::Type_t::u8) {
-            paged_attn_quantkv(k, v, k_cache, v_cache, _slot_mapping, _helper._key_group_size, _helper._value_group_size);
+            paged_attn_quantkv(k,
+                               v,
+                               k_cache,
+                               v_cache,
+                               _slot_mapping,
+                               _helper._key_group_size,
+                               _helper._value_group_size);
         } else {
             paged_attn_memcpy(k, v, k_cache, v_cache, _slot_mapping);
         }
@@ -2296,12 +2519,36 @@ struct AttentionExecutor : public PagedAttentionExecutor {
         PlainTensor output_emb;
         PlainTensor output_score;
 
-        init(inputs, outputs, q, k, v, k_cache, v_cache, past_lens, subsequence_begins, block_indices, block_indices_begins,
-            scale, sliding_window, alibi_slopes, max_context_len, output_emb, output_score);
+        init(inputs,
+             outputs,
+             q,
+             k,
+             v,
+             k_cache,
+             v_cache,
+             past_lens,
+             subsequence_begins,
+             block_indices,
+             block_indices_begins,
+             scale,
+             sliding_window,
+             alibi_slopes,
+             max_context_len,
+             output_emb,
+             output_score);
         concat_pastkv(k, v, k_cache, v_cache, past_lens, subsequence_begins, block_indices, block_indices_begins);
 
-        _kernel(q, k_cache, v_cache, output_emb, output_score, max_context_len, past_lens, subsequence_begins, block_indices,
-            block_indices_begins, alibi_slopes);
+        _kernel(q,
+                k_cache,
+                v_cache,
+                output_emb,
+                output_score,
+                max_context_len,
+                past_lens,
+                subsequence_begins,
+                block_indices,
+                block_indices_begins,
+                alibi_slopes);
     }
 };
 #endif
@@ -2315,32 +2562,35 @@ std::shared_ptr<PagedAttentionExecutor> make_pa_executor(ov::element::Type data_
 
 #ifdef OPENVINO_ARCH_X86_64
     if (data_type == ov::element::bf16) {
-#if defined(HAVE_AVX512F)
+#    if defined(HAVE_AVX512F)
         if (key_cache_type == ov::element::u8) {
-            executor = std::make_shared<AttentionExecutor<ov::bfloat16, uint8_t, uint8_t>>(key_group_size, value_group_size);
+            executor =
+                std::make_shared<AttentionExecutor<ov::bfloat16, uint8_t, uint8_t>>(key_group_size, value_group_size);
         } else {
             OPENVINO_ASSERT(key_cache_type == ov::element::bf16, "expect kvcache type bf16, current: ", key_cache_type);
             executor = std::make_shared<AttentionExecutor<ov::bfloat16, ov::bfloat16, ov::bfloat16>>();
         }
-#else
+#    else
         OPENVINO_THROW("make_pa_executor: bf16 needs avx512+ hardware.");
-#endif
+#    endif
     } else if (data_type == ov::element::f16) {
-#if defined(HAVE_AVX512F)
+#    if defined(HAVE_AVX512F)
         if (key_cache_type == ov::element::u8) {
-            executor = std::make_shared<AttentionExecutor<ov::float16, uint8_t, uint8_t>>(key_group_size, value_group_size);
+            executor =
+                std::make_shared<AttentionExecutor<ov::float16, uint8_t, uint8_t>>(key_group_size, value_group_size);
         } else {
             OPENVINO_ASSERT(key_cache_type == ov::element::f16, "expect kvcache type f16, current: ", key_cache_type);
             executor = std::make_shared<AttentionExecutor<ov::float16, ov::float16, ov::float16>>();
         }
-#else
+#    else
         OPENVINO_THROW("make_pa_executor: f16 needs avx512+ hardware.");
-#endif
+#    endif
     } else if (data_type == ov::element::f32) {
         if (key_cache_type == ov::element::u8) {
             executor = std::make_shared<AttentionExecutor<float, uint8_t, uint8_t>>(key_group_size, value_group_size);
         } else if (key_cache_type == ov::element::f16) {
-            executor = std::make_shared<AttentionExecutor<float, ov::float16, ov::float16>>(key_group_size, value_group_size);
+            executor =
+                std::make_shared<AttentionExecutor<float, ov::float16, ov::float16>>(key_group_size, value_group_size);
         } else {
             OPENVINO_ASSERT(key_cache_type == ov::element::f32, "expect kvcache type f32, current: ", key_cache_type);
             executor = std::make_shared<AttentionExecutor<float, float, float>>(key_group_size, value_group_size);
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa.hpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa.hpp
index d386dc9f44e321..64e4eefc3b760d 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa.hpp
@@ -6,8 +6,9 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <vector>
 #include <openvino/core/type/element_type.hpp>
+#include <vector>
+
 #include "cpu_memory.h"
 #include "executor_pa_common.hpp"
 
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa_common.cpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa_common.cpp
index 70723a577b0c2b..8a7fa211f8f4ce 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa_common.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa_common.cpp
@@ -1,6 +1,8 @@
 // Copyright (C) 2018-2024 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
+#include "executor_pa_common.hpp"
+
 #include <float.h>
 
 #include <cmath>
@@ -9,10 +11,9 @@
 #include <limits>
 #include <type_traits>
 
+#include "openvino/core/parallel.hpp"
 #include "openvino/core/type/bfloat16.hpp"
 #include "openvino/core/type/float16.hpp"
-#include "openvino/core/parallel.hpp"
-#include "executor_pa_common.hpp"
 #include "utils/plain_tensor.hpp"
 
 namespace ov {
@@ -58,20 +59,23 @@ void TileConfiger::generate() {
     ret();
 }
 
-JitMatMulVecAMX::JitMatMulVecAMX(int head_size, int block_size, ov::element::Type amx_prec) :
-    jit_generator(jit_name()), m_head_size(head_size), m_block_size(block_size), m_amx_prec(amx_prec) {
+JitMatMulVecAMX::JitMatMulVecAMX(int head_size, int block_size, ov::element::Type amx_prec)
+    : jit_generator(jit_name()),
+      m_head_size(head_size),
+      m_block_size(block_size),
+      m_amx_prec(amx_prec) {
     create_kernel();
     m_tile_cfg.reset(1,
                      0,
                      {
-                        {16, 4},   // C:0   M x 1     (4b)
-                        {16, 64},  // A:1   M x 32/64 (64b)
-                        {16, 4},   // B:2   32/64 x 1 (4b)
-                        {16, 4},   // B:3
-                        {16, 4},   // B:4
-                        {16, 4},   // B:5
-                        {16, 4},   // B:6
-                        {16, 4},   // B:7
+                         {16, 4},   // C:0   M x 1     (4b)
+                         {16, 64},  // A:1   M x 32/64 (64b)
+                         {16, 4},   // B:2   32/64 x 1 (4b)
+                         {16, 4},   // B:3
+                         {16, 4},   // B:4
+                         {16, 4},   // B:5
+                         {16, 4},   // B:6
+                         {16, 4},   // B:7
                      });
 }
 
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa_common.hpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa_common.hpp
index bc21457a3285b4..81c54c84d9453a 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa_common.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/executor_pa_common.hpp
@@ -6,11 +6,12 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <vector>
 #include <openvino/core/type/element_type.hpp>
-#include "cpu_memory.h"
+#include <vector>
+
 #include "cpu/x64/cpu_isa_traits.hpp"
 #include "cpu/x64/jit_generator.hpp"
+#include "cpu_memory.h"
 
 namespace ov {
 namespace Extensions {
@@ -20,20 +21,21 @@ namespace Cpu {
 
 struct PagedAttentionExecutor {
     // PagedAttention input index
-    static const size_t ID_Q = 0;                           // [B_token, H * S], float
-    static const size_t ID_K = 1;                           // [B_token, Hk * S], float
-    static const size_t ID_V = 2;                           // [B_token, Hk * S], float
-    static const size_t ID_KCACHE = 3;                      // [block_number, H, block_size, S], float
-    static const size_t ID_VCACHE = 4;                      // [block_number, H, block_size, S], float
-    static const size_t ID_PAST_LENS = 5;                   // [B_seq]
-    static const size_t ID_SUBSEQUENCE_BEGINS = 6;          // [B_seq+1]
-    static const size_t ID_BLOCK_INDICES = 7;               // [num_blocks]
-    static const size_t ID_BLOCK_INDICES_BEGINS = 8;        // [B_seq+1]
-    static const size_t ID_SCALE = 9;                       // [], float
-    static const size_t ID_SLIDING_WINDOW = 10;             // []
-    static const size_t ID_ALIBI_SLOPES = 11;               // [H|0], float
-    static const size_t ID_MAX_CONTEXT_LEN = 12;            // []
-    virtual void execute(const std::vector<ov::intel_cpu::MemoryPtr>& inputs, const std::vector<ov::intel_cpu::MemoryPtr> outputs) = 0;
+    static const size_t ID_Q = 0;                     // [B_token, H * S], float
+    static const size_t ID_K = 1;                     // [B_token, Hk * S], float
+    static const size_t ID_V = 2;                     // [B_token, Hk * S], float
+    static const size_t ID_KCACHE = 3;                // [block_number, H, block_size, S], float
+    static const size_t ID_VCACHE = 4;                // [block_number, H, block_size, S], float
+    static const size_t ID_PAST_LENS = 5;             // [B_seq]
+    static const size_t ID_SUBSEQUENCE_BEGINS = 6;    // [B_seq+1]
+    static const size_t ID_BLOCK_INDICES = 7;         // [num_blocks]
+    static const size_t ID_BLOCK_INDICES_BEGINS = 8;  // [B_seq+1]
+    static const size_t ID_SCALE = 9;                 // [], float
+    static const size_t ID_SLIDING_WINDOW = 10;       // []
+    static const size_t ID_ALIBI_SLOPES = 11;         // [H|0], float
+    static const size_t ID_MAX_CONTEXT_LEN = 12;      // []
+    virtual void execute(const std::vector<ov::intel_cpu::MemoryPtr>& inputs,
+                         const std::vector<ov::intel_cpu::MemoryPtr> outputs) = 0;
     virtual ~PagedAttentionExecutor() = default;
 };
 
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/mha_single_token.cpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/mha_single_token.cpp
index 25ddbb1b4246b1..f2180b5314cc07 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/mha_single_token.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/mha_single_token.cpp
@@ -13,11 +13,10 @@
 #    include <immintrin.h>
 #endif
 
-
-#include "openvino/core/type/bfloat16.hpp"
-#include "openvino/core/parallel.hpp"
-#include "mha_single_token.hpp"
 #include "common.hpp"
+#include "mha_single_token.hpp"
+#include "openvino/core/parallel.hpp"
+#include "openvino/core/type/bfloat16.hpp"
 #include "softmax_kernel.hpp"
 
 #if defined(OPENVINO_ARCH_ARM64)
@@ -33,19 +32,20 @@ using namespace ov;
 
 #if defined(HAVE_AVX2)
 
-#define prefetch_bytes(bytes, sel, advance, src) {  \
-    auto *p = reinterpret_cast<char *>(src);        \
-    for (size_t i = 0; i < bytes; i += 64)          \
-        _mm_prefetch(p + i + advance, sel);         \
-}
+#    define prefetch_bytes(bytes, sel, advance, src) \
+        {                                            \
+            auto* p = reinterpret_cast<char*>(src);  \
+            for (size_t i = 0; i < bytes; i += 64)   \
+                _mm_prefetch(p + i + advance, sel);  \
+        }
 
 #else
 
-#define prefetch_bytes(bytes, sel, advance, src)
+#    define prefetch_bytes(bytes, sel, advance, src)
 
 #endif
 
-template<typename TA, typename TB>
+template <typename TA, typename TB>
 void cvt_copy(TA* dst, TB* src, size_t n) {
     size_t i = 0;
 #if defined(HAVE_AVX512F)
@@ -65,21 +65,21 @@ void cvt_copy(TA* dst, TB* src, size_t n) {
             __vst1q_f32(dst + i, vb1);
         }
     }
-#if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
+#    if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
     if (std::is_same<TA, ov::float16>::value && std::is_same<TB, ov::float16>::value) {
         for (; i + vec_len_f16_neon <= n; i += vec_len_f16_neon) {
             auto vb1 = vld1q_f16(reinterpret_cast<const float16_t*>(src + i));
             vst1q_f16(reinterpret_cast<float16_t*>(dst + i), vb1);
         }
     }
-#endif
+#    endif
 #endif
     for (; i < n; i++) {
         dst[i] = src[i];
     }
 }
 
-template<typename T>
+template <typename T>
 static void attn_acc_value(float* out, float weight, T* v, size_t S, float* scale, float* zp) {
     size_t i = 0;
 #if defined(HAVE_AVX512F)
@@ -113,12 +113,12 @@ static void attn_acc_value(float* out, float weight, T* v, size_t S, float* scal
 }
 
 #if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
-template<typename T>
+template <typename T>
 static void attn_acc_value(ov::float16* out, ov::float16 weight, T* v, size_t S, float* scale, float* zp) {
     size_t i = 0;
     auto attn_w_vec_fp16 = vdupq_n_f16(weight);
-    auto _v = reinterpret_cast<float16_t *>(v);
-    auto _out = reinterpret_cast<float16_t *>(out);
+    auto _v = reinterpret_cast<float16_t*>(v);
+    auto _out = reinterpret_cast<float16_t*>(out);
     for (; i + vec_len_f16_neon <= S; i += vec_len_f16_neon) {
         auto v_value = vld1q_f16(_v + i);
         auto v_out = vld1q_f16(_out + i);
@@ -131,7 +131,6 @@ static void attn_acc_value(ov::float16* out, ov::float16 weight, T* v, size_t S,
 }
 #endif
 
-
 static void attn_acc_value(float* out, float weight, uint8_t* v, size_t S, float* scale, float* zp) {
     size_t i = 0;
     weight *= *scale;
@@ -285,7 +284,7 @@ static void attn_acc_value(float* out, float weight, uint8_t* v, size_t S, float
     }
 }
 
-template<typename T>
+template <typename T>
 static float sum_q_head(T* a, size_t n) {
     float sum = 0.0f;
     size_t i = 0;
@@ -406,7 +405,7 @@ static float sum_q_head(T* a, size_t n) {
     return sum;
 }
 
-template<typename TA, typename TB>
+template <typename TA, typename TB>
 static float dot_product(TA* a, TB* b, size_t n, float* scale, float* zp, float* head_sum) {
     size_t i = 0;
     float sum = 0.0f;
@@ -552,7 +551,12 @@ static float dot_product(TA* a, TB* b, size_t n, float* scale, float* zp, float*
 }
 
 #if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
-static ov::float16 dot_product_fp16(ov::float16* a, ov::float16* b, size_t n, float* scale, float* zp, float* head_sum) {
+static ov::float16 dot_product_fp16(ov::float16* a,
+                                    ov::float16* b,
+                                    size_t n,
+                                    float* scale,
+                                    float* zp,
+                                    float* head_sum) {
     size_t i = 0;
     ov::float16 sum = 0.0f;
     auto vsum0 = vdupq_n_f16(0.0f);
@@ -609,7 +613,7 @@ static ov::float16 dot_product_fp16(ov::float16* a, ov::float16* b, size_t n, fl
 }
 #endif
 
-template<typename TA>
+template <typename TA>
 static float dot_product(TA* a, uint8_t* b, size_t n, float* scale, float* zp, float* head_sum) {
     size_t i = 0;
     float sum = 0.0f;
@@ -763,11 +767,11 @@ static float dot_product(TA* a, uint8_t* b, size_t n, float* scale, float* zp, f
 #endif
 }
 
-template<typename T>
+template <typename T>
 static void attn_reduce(T* dst, float* temp, size_t M, size_t S, size_t temp_stride) {
     size_t i = 0;
 #if defined(HAVE_AVX512F)
-    for (; i + vec_len_f32_avx512 <= S; i+= vec_len_f32_avx512) {
+    for (; i + vec_len_f32_avx512 <= S; i += vec_len_f32_avx512) {
         auto* src = temp + i;
         auto result_vec_fp32 = _mm512_setzero_ps();
         for (size_t m = 0; m < M; m++) {
@@ -903,11 +907,16 @@ static void mha_single_token_kernel(const ov::intel_cpu::PlainTensor& query,
                     for (size_t iwork = start; iwork < end; ++iwork) {
                         auto p = past_k_scale_zp.ptr<float>(pk, 0, h_group);
 #if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
-                        if (std::is_same<T3, ov::float16>::value && std::is_same<T, ov::float16>::value && std::is_same<T2, ov::float16>::value) {
+                        if (std::is_same<T3, ov::float16>::value && std::is_same<T, ov::float16>::value &&
+                            std::is_same<T2, ov::float16>::value) {
                             auto p_k = present_key.ptr<ov::float16>(0, h_group, pk);
                             prefetch_bytes(S, _MM_HINT_T0, 4096, p_k);
-                            auto _qk = dot_product_fp16(query.ptr<ov::float16>(0, h_group), p_k,
-                                                        S, p, p + 1, head_sum.ptr<float>(0, h_group));
+                            auto _qk = dot_product_fp16(query.ptr<ov::float16>(0, h_group),
+                                                        p_k,
+                                                        S,
+                                                        p,
+                                                        p + 1,
+                                                        head_sum.ptr<float>(0, h_group));
                             buf_attn_w.ptr<T3>(0, h_group, 0)[pk] = _qk;
                             parallel_it_step(pk, kv_len, b, B, h_group, h_group_num);
                             continue;
@@ -915,8 +924,9 @@ static void mha_single_token_kernel(const ov::intel_cpu::PlainTensor& query,
 #endif
                         auto p_k = present_key.ptr<T2>(0, h_group, pk);
                         prefetch_bytes(S, _MM_HINT_T0, 4096, p_k);
-                        buf_attn_w.ptr<T3>(0, h_group, 0)[pk] = dot_product(query.ptr<T>(0, h_group), p_k,
-                                                                            S, p, p + 1, head_sum.ptr<float>(0, h_group));;
+                        buf_attn_w.ptr<T3>(0, h_group, 0)[pk] =
+                            dot_product(query.ptr<T>(0, h_group), p_k, S, p, p + 1, head_sum.ptr<float>(0, h_group));
+                        ;
                         parallel_it_step(pk, kv_len, b, B, h_group, h_group_num);
                     }
                 } else {
@@ -924,10 +934,15 @@ static void mha_single_token_kernel(const ov::intel_cpu::PlainTensor& query,
                         auto b_kv = beams ? beams.ptr<int32_t>(b)[pk] : b;
                         auto p = past_k_scale_zp.ptr<float>(pk, b_kv, h_group);
 #if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
-                        if (std::is_same<T3, ov::float16>::value && std::is_same<T, ov::float16>::value && std::is_same<T2, ov::float16>::value) {
+                        if (std::is_same<T3, ov::float16>::value && std::is_same<T, ov::float16>::value &&
+                            std::is_same<T2, ov::float16>::value) {
                             auto p_k = present_key.ptr<ov::float16>(b_kv, h_group, pk);
-                            auto _qk = dot_product_fp16(query.ptr<ov::float16>(b, h_group), p_k,
-                                                        S, p, p + 1, head_sum.ptr<float>(b, h_group));
+                            auto _qk = dot_product_fp16(query.ptr<ov::float16>(b, h_group),
+                                                        p_k,
+                                                        S,
+                                                        p,
+                                                        p + 1,
+                                                        head_sum.ptr<float>(b, h_group));
                             buf_attn_w.ptr<T3>(b, h_group, 0)[pk] = _qk;
                             parallel_it_step(pk, kv_len, b, B, h_group, h_group_num);
                             continue;
@@ -935,8 +950,7 @@ static void mha_single_token_kernel(const ov::intel_cpu::PlainTensor& query,
 #endif
                         auto p_k = present_key.ptr<T2>(b_kv, h_group, pk);
                         buf_attn_w.ptr<T3>(b, h_group, 0)[pk] =
-                                dot_product(query.ptr<T>(b, h_group), p_k,
-                                    S, p, p + 1, head_sum.ptr<float>(b, h_group));
+                            dot_product(query.ptr<T>(b, h_group), p_k, S, p, p + 1, head_sum.ptr<float>(b, h_group));
                         parallel_it_step(pk, kv_len, b, B, h_group, h_group_num);
                     }
                 }
@@ -947,17 +961,25 @@ static void mha_single_token_kernel(const ov::intel_cpu::PlainTensor& query,
                         auto p = past_k_scale_zp.ptr<float>(pk, b_kv, h_group);
                         for (size_t h = h_group * h_each_group_len; h < (h_group + 1) * h_each_group_len; h++) {
 #if defined(__ARM_FEATURE_FP16_VECTOR_ARITHMETIC)
-                            if (std::is_same<T3, ov::float16>::value && std::is_same<T, ov::float16>::value && std::is_same<T2, ov::float16>::value) {
+                            if (std::is_same<T3, ov::float16>::value && std::is_same<T, ov::float16>::value &&
+                                std::is_same<T2, ov::float16>::value) {
                                 auto p_k = present_key.ptr<ov::float16>(b_kv, h_group, pk);
-                                auto _qk = dot_product_fp16(query.ptr<ov::float16>(b, h, pq), p_k,
-                                                            S, p, p + 1, head_sum.ptr<float>(b, h, pq));
+                                auto _qk = dot_product_fp16(query.ptr<ov::float16>(b, h, pq),
+                                                            p_k,
+                                                            S,
+                                                            p,
+                                                            p + 1,
+                                                            head_sum.ptr<float>(b, h, pq));
                                 buf_attn_w.ptr<T3>(b, h, pq)[pk] = _qk;
                                 continue;
                             }
 #endif
-                            buf_attn_w.ptr<T3>(b, h, pq)[pk] =
-                                    dot_product(query.ptr<T>(b, h, pq), present_key.ptr<T2>(b_kv, h_group, pk),
-                                        S, p, p + 1, head_sum.ptr<float>(b, h, pq));
+                            buf_attn_w.ptr<T3>(b, h, pq)[pk] = dot_product(query.ptr<T>(b, h, pq),
+                                                                           present_key.ptr<T2>(b_kv, h_group, pk),
+                                                                           S,
+                                                                           p,
+                                                                           p + 1,
+                                                                           head_sum.ptr<float>(b, h, pq));
                         }
                     }
                     parallel_it_step(pk, kv_len, b, B, h_group, h_group_num);
@@ -1001,7 +1023,8 @@ static void mha_single_token_kernel(const ov::intel_cpu::PlainTensor& query,
                 auto* v = present_value.ptr<T2>(b_kv, h_group, pv);
                 auto p = past_v_scale_zp.ptr<float>(pv, b_kv, h_group);
                 for (size_t pq = 0; pq < q_len; pq++) {
-                    for (size_t h = h_group * h_each_group_len, group_idx = 0; h < (h_group + 1) * h_each_group_len; h++, group_idx++) {
+                    for (size_t h = h_group * h_each_group_len, group_idx = 0; h < (h_group + 1) * h_each_group_len;
+                         h++, group_idx++) {
                         attn_acc_value(buf_attn_score.ptr<T3>(ithr, pq, group_idx),
                                        buf_attn_w.ptr<T3>(b, h, pq)[pv],
                                        v,
@@ -1014,7 +1037,7 @@ static void mha_single_token_kernel(const ov::intel_cpu::PlainTensor& query,
             // convert to dst
             for (size_t pq = 0; pq < q_len; pq++) {
                 for (size_t h = h_group * h_each_group_len, group_idx = 0; h < (h_group + 1) * h_each_group_len;
-                        h++, group_idx++) {
+                     h++, group_idx++) {
                     auto* dst = has_out_transpose ? output_emb.ptr<T>(b, pq, h * SV) : output_emb.ptr<T>(b, h, pq);
                     cvt_copy(dst, buf_attn_score.ptr<T3>(ithr, pq, group_idx), SV);
                 }
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/mha_single_token.hpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/mha_single_token.hpp
index e29e2bae0aa07a..2ef0f62d7e0df0 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/mha_single_token.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/mha_single_token.hpp
@@ -6,8 +6,9 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <vector>
 #include <openvino/core/type/element_type.hpp>
+#include <vector>
+
 #include "utils/plain_tensor.hpp"
 
 namespace ov {
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax.cpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax.cpp
index 28755e69eaf589..c02f9770a37be9 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax.cpp
@@ -13,10 +13,10 @@
 #    include <immintrin.h>
 #endif
 
+#include "common.hpp"
 #include "openvino/core/type/bfloat16.hpp"
 #include "softmax.hpp"
 #include "softmax_kernel.hpp"
-#include "common.hpp"
 
 namespace ov {
 namespace Extensions {
@@ -39,13 +39,33 @@ void attn_softmax(void* a,
     if (precision == ov::element::f16) {
         auto _a = reinterpret_cast<ov::float16*>(a);
         auto _alibi = reinterpret_cast<ov::float16*>(alibi);
-        attn_softmax_kernel<ov::float16>(_a, a_dst, scale, _alibi, attn_mask, causal_mask, select_nfltmax_at_0, len, total_size, attn_mask_prec, dst_precision);
+        attn_softmax_kernel<ov::float16>(_a,
+                                         a_dst,
+                                         scale,
+                                         _alibi,
+                                         attn_mask,
+                                         causal_mask,
+                                         select_nfltmax_at_0,
+                                         len,
+                                         total_size,
+                                         attn_mask_prec,
+                                         dst_precision);
         return;
     }
 #endif
     auto _a = reinterpret_cast<float*>(a);
     auto _alibi = reinterpret_cast<float*>(alibi);
-    attn_softmax_kernel<float>(_a, a_dst, scale, _alibi, attn_mask, causal_mask, select_nfltmax_at_0, len, total_size, attn_mask_prec, dst_precision);
+    attn_softmax_kernel<float>(_a,
+                               a_dst,
+                               scale,
+                               _alibi,
+                               attn_mask,
+                               causal_mask,
+                               select_nfltmax_at_0,
+                               len,
+                               total_size,
+                               attn_mask_prec,
+                               dst_precision);
 }
 
 }  // namespace XARCH
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax.hpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax.hpp
index ee264924e8f256..d620a01e221788 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax.hpp
@@ -6,8 +6,8 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <vector>
 #include <openvino/core/type/element_type.hpp>
+#include <vector>
 
 namespace ov {
 namespace Extensions {
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax_kernel.hpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax_kernel.hpp
index 60c6a24ec5f2fa..48b92b53fa2727 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax_kernel.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/softmax_kernel.hpp
@@ -3,16 +3,16 @@
 //
 #pragma once
 
-#include "common.hpp"
-#include "openvino/core/type/element_type.hpp"
-
 #include <array>
 #include <cstddef>
 #include <cstdint>
 #include <vector>
 
+#include "common.hpp"
+#include "openvino/core/type/element_type.hpp"
+
 #if defined(OPENVINO_ARCH_ARM64)
-#include "arm_neon.h"
+#    include "arm_neon.h"
 #endif
 
 namespace ov {
@@ -22,7 +22,7 @@ namespace XARCH {
 
 #if defined(HAVE_AVX2)
 inline void exp_ps_avx2(__m256& src) {
-#define REPEAT8(x) x, x, x, x, x, x, x, x
+#    define REPEAT8(x) x, x, x, x, x, x, x, x
     static const uint32_t c_min[] = {REPEAT8(0xc2aeac50)};
     static const uint32_t c_max[] = {REPEAT8(0x42b17218)};
     static const uint32_t c_e[] = {REPEAT8(0x3fb8aa3b)};
@@ -36,21 +36,21 @@ inline void exp_ps_avx2(__m256& src) {
     static const uint32_t c_p4[] = {REPEAT8(0x3d2b9d0d)};
     static const uint32_t c_p5[] = {REPEAT8(0x3c07cfce)};
     static const uint32_t c_2[] = {REPEAT8(0x40000000)};
-#undef REPEAT8
+#    undef REPEAT8
     static constexpr int n_mantissa_bits = 23;
-    __m256 exp_ln_flt_min_f = _mm256_loadu_ps(reinterpret_cast<const float*>(c_min));    // log(FLT_MIN)
-    __m256 exp_ln_flt_max_f = _mm256_loadu_ps(reinterpret_cast<const float*>(c_max));    // log(FLT_MAX)
-    __m256 exp_log2ef = _mm256_loadu_ps(reinterpret_cast<const float*>(c_e));            // log2(e)
-    __m256 half = _mm256_loadu_ps(reinterpret_cast<const float*>(c_half));               // 0.5f
-    __m256 ln2f = _mm256_loadu_ps(reinterpret_cast<const float*>(c_ln2));                // ln(2)
-    __m256 one = _mm256_loadu_ps(reinterpret_cast<const float*>(c_1));                   // 1.0f
-    __m256i exponent_bias = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(c_bias));// 127
-    __m256 exp_pol1 = _mm256_loadu_ps(reinterpret_cast<const float*>(c_p1));             // p1 = 0.999999701f
-    __m256 exp_pol2 = _mm256_loadu_ps(reinterpret_cast<const float*>(c_p2));             // p2 = 0.499991506f
-    __m256 exp_pol3 = _mm256_loadu_ps(reinterpret_cast<const float*>(c_p3));             // p3 = 0.166676521f
-    __m256 exp_pol4 = _mm256_loadu_ps(reinterpret_cast<const float*>(c_p4));             // p4 = 0.0418978221f
-    __m256 exp_pol5 = _mm256_loadu_ps(reinterpret_cast<const float*>(c_p5));             // p5 = 0.00828929059f
-    __m256 two = _mm256_loadu_ps(reinterpret_cast<const float*>(c_2));                   // 2
+    __m256 exp_ln_flt_min_f = _mm256_loadu_ps(reinterpret_cast<const float*>(c_min));      // log(FLT_MIN)
+    __m256 exp_ln_flt_max_f = _mm256_loadu_ps(reinterpret_cast<const float*>(c_max));      // log(FLT_MAX)
+    __m256 exp_log2ef = _mm256_loadu_ps(reinterpret_cast<const float*>(c_e));              // log2(e)
+    __m256 half = _mm256_loadu_ps(reinterpret_cast<const float*>(c_half));                 // 0.5f
+    __m256 ln2f = _mm256_loadu_ps(reinterpret_cast<const float*>(c_ln2));                  // ln(2)
+    __m256 one = _mm256_loadu_ps(reinterpret_cast<const float*>(c_1));                     // 1.0f
+    __m256i exponent_bias = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(c_bias));  // 127
+    __m256 exp_pol1 = _mm256_loadu_ps(reinterpret_cast<const float*>(c_p1));               // p1 = 0.999999701f
+    __m256 exp_pol2 = _mm256_loadu_ps(reinterpret_cast<const float*>(c_p2));               // p2 = 0.499991506f
+    __m256 exp_pol3 = _mm256_loadu_ps(reinterpret_cast<const float*>(c_p3));               // p3 = 0.166676521f
+    __m256 exp_pol4 = _mm256_loadu_ps(reinterpret_cast<const float*>(c_p4));               // p4 = 0.0418978221f
+    __m256 exp_pol5 = _mm256_loadu_ps(reinterpret_cast<const float*>(c_p5));               // p5 = 0.00828929059f
+    __m256 two = _mm256_loadu_ps(reinterpret_cast<const float*>(c_2));                     // 2
     // exp(x) =
     // = exp(n * ln(2) + r) // divide x by ln(2) and get quot and rem
     // = 2^n * exp(r)       // simplify the exp(n*ln(2)) expression
@@ -195,32 +195,33 @@ inline void scale_add2_reduce_max(float* a,
     // process vector body
     // unroll to avoid dependency caused by _mm256_max_ps
     for (; i + 4 * vec_len_f32_avx512 <= size; i += 4 * vec_len_f32_avx512) {
-    #define ITEM(n) \
-        v_a = _mm512_loadu_ps(a + i + n * vec_len_f32_avx512);  \
-        v_a = _mm512_mul_ps(v_a, v_scale);  \
-        if (has_alibi) {    \
-            auto v_lookup = _mm512_loadu_ps(alibi_lookup + i + n * vec_len_f32_avx512); \
-            v_a = _mm512_fmadd_ps(v_lookup, v_alibi_slope, v_a); \
-        } \
-        if (has_attn_mask) {    \
-            auto v_mask = mm512_uni_loadu_ps(attn_mask + i + n * vec_len_f32_avx512);   \
-            v_a = _mm512_add_ps(v_a, v_mask);   \
-        }   \
-        if (has_causal_mask) {  \
-            auto v_maski8 = _mm_loadu_si128(reinterpret_cast<__m128i const*>(causal_mask + i + n * vec_len_f32_avx512));    \
-            auto v_maski32 = _mm512_cvtepi8_epi32(v_maski8);    \
-            auto kmask = _mm512_cmp_epi32_mask(v_maski32, v_zeroi32, _MM_CMPINT_NE);    \
-            kmask = _kxor_mask16(kmask, kmask_xor);                                     \
-            v_a = _mm512_mask_blend_ps(kmask, v_a, v_nfltmax);                          \
-        }   \
-        v_max##n = _mm512_max_ps(v_max##n, v_a);   \
+#    define ITEM(n)                                                                                          \
+        v_a = _mm512_loadu_ps(a + i + n * vec_len_f32_avx512);                                               \
+        v_a = _mm512_mul_ps(v_a, v_scale);                                                                   \
+        if (has_alibi) {                                                                                     \
+            auto v_lookup = _mm512_loadu_ps(alibi_lookup + i + n * vec_len_f32_avx512);                      \
+            v_a = _mm512_fmadd_ps(v_lookup, v_alibi_slope, v_a);                                             \
+        }                                                                                                    \
+        if (has_attn_mask) {                                                                                 \
+            auto v_mask = mm512_uni_loadu_ps(attn_mask + i + n * vec_len_f32_avx512);                        \
+            v_a = _mm512_add_ps(v_a, v_mask);                                                                \
+        }                                                                                                    \
+        if (has_causal_mask) {                                                                               \
+            auto v_maski8 =                                                                                  \
+                _mm_loadu_si128(reinterpret_cast<__m128i const*>(causal_mask + i + n * vec_len_f32_avx512)); \
+            auto v_maski32 = _mm512_cvtepi8_epi32(v_maski8);                                                 \
+            auto kmask = _mm512_cmp_epi32_mask(v_maski32, v_zeroi32, _MM_CMPINT_NE);                         \
+            kmask = _kxor_mask16(kmask, kmask_xor);                                                          \
+            v_a = _mm512_mask_blend_ps(kmask, v_a, v_nfltmax);                                               \
+        }                                                                                                    \
+        v_max##n = _mm512_max_ps(v_max##n, v_a);                                                             \
         _mm512_storeu_ps(a + i + n * vec_len_f32_avx512, v_a);
 
         ITEM(0);
         ITEM(1);
         ITEM(2);
         ITEM(3);
-    #undef ITEM
+#    undef ITEM
     }
     while (i + vec_len_f32_avx512 <= size) {
         v_a = _mm512_loadu_ps(a + i);
@@ -295,32 +296,32 @@ inline void scale_add2_reduce_max(float* a,
     // process vector body
     // unroll to avoid dependency caused by _mm512_max_ps
     for (; i + 4 * vec_len_f32_avx2 <= size; i += 4 * vec_len_f32_avx2) {
-    #define ITEM(n) \
-        v_a = _mm256_loadu_ps(a + i + n * vec_len_f32_avx2);    \
-        v_a = _mm256_mul_ps(v_a, v_scale);                      \
-        if (has_alibi) {                                        \
-            auto v_lookup = _mm256_loadu_ps(alibi_lookup + i + n * vec_len_f32_avx2);   \
-            v_a = _mm256_fmadd_ps(v_lookup, v_alibi_slope, v_a);                        \
-        }                                                       \
-        if (has_attn_mask) {                                    \
-            auto v_mask = mm256_uni_loadu_ps(attn_mask + i + n * vec_len_f32_avx2);     \
-            v_a = _mm256_add_ps(v_a, v_mask);                                           \
-        }                                                       \
-        if (has_causal_mask) {                                  \
-            auto v_maski8 = _mm_loadu_si128(reinterpret_cast<__m128i const*>(causal_mask + i + n * vec_len_f32_avx2));  \
-            auto v_maski32 = _mm256_cvtepi8_epi32(v_maski8);    \
-            v_maski32 = _mm256_cmpeq_epi32(v_maski32, v_zeroi32);\
-            v_maski32 = _mm256_xor_si256(v_maski32, v_mask_xor);\
-            v_a = _mm256_blendv_ps(v_nfltmax, v_a, _mm256_castsi256_ps(v_maski32));     \
-        }                                                       \
-        v_max##n = _mm256_max_ps(v_max##n, v_a);                      \
+#    define ITEM(n)                                                                                                    \
+        v_a = _mm256_loadu_ps(a + i + n * vec_len_f32_avx2);                                                           \
+        v_a = _mm256_mul_ps(v_a, v_scale);                                                                             \
+        if (has_alibi) {                                                                                               \
+            auto v_lookup = _mm256_loadu_ps(alibi_lookup + i + n * vec_len_f32_avx2);                                  \
+            v_a = _mm256_fmadd_ps(v_lookup, v_alibi_slope, v_a);                                                       \
+        }                                                                                                              \
+        if (has_attn_mask) {                                                                                           \
+            auto v_mask = mm256_uni_loadu_ps(attn_mask + i + n * vec_len_f32_avx2);                                    \
+            v_a = _mm256_add_ps(v_a, v_mask);                                                                          \
+        }                                                                                                              \
+        if (has_causal_mask) {                                                                                         \
+            auto v_maski8 = _mm_loadu_si128(reinterpret_cast<__m128i const*>(causal_mask + i + n * vec_len_f32_avx2)); \
+            auto v_maski32 = _mm256_cvtepi8_epi32(v_maski8);                                                           \
+            v_maski32 = _mm256_cmpeq_epi32(v_maski32, v_zeroi32);                                                      \
+            v_maski32 = _mm256_xor_si256(v_maski32, v_mask_xor);                                                       \
+            v_a = _mm256_blendv_ps(v_nfltmax, v_a, _mm256_castsi256_ps(v_maski32));                                    \
+        }                                                                                                              \
+        v_max##n = _mm256_max_ps(v_max##n, v_a);                                                                       \
         _mm256_storeu_ps(a + i + n * vec_len_f32_avx2, v_a);
 
         ITEM(0);
         ITEM(1);
         ITEM(2);
         ITEM(3);
-    #undef ITEM
+#    undef ITEM
     }
 
     while (i + vec_len_f32_avx2 <= size) {
@@ -415,7 +416,7 @@ inline void scale_add2_reduce_max(float* a,
             uint32x4_t v_maski32[2] = {v_maski32_low, v_maski32_high};
             for (int j = 0; j < 2; ++j) {
                 uint32x4_t kmask = vceqq_u32(v_maski32[j], v_zeroi32);  // ==0
-                v_a = vbslq_f32(kmask, v_nfltmax, v_a);  // mask => -FLT_MAX
+                v_a = vbslq_f32(kmask, v_nfltmax, v_a);                 // mask => -FLT_MAX
             }
         }
 
@@ -521,7 +522,7 @@ inline void scale_add2_reduce_max(ov::float16* a,
 
 #if defined(HAVE_AVX512F)
 static inline void exp_ps_avx512(__m512& src) {
-#define REPEAT16(x) x, x, x, x, x, x, x, x, x, x, x, x, x, x, x, x
+#    define REPEAT16(x) x, x, x, x, x, x, x, x, x, x, x, x, x, x, x, x
     static const uint32_t c_min[] = {REPEAT16(0xc2aeac50)};
     static const uint32_t c_max[] = {REPEAT16(0x42b17218)};
     static const uint32_t c_e[] = {REPEAT16(0x3fb8aa3b)};
@@ -535,21 +536,21 @@ static inline void exp_ps_avx512(__m512& src) {
     static const uint32_t c_p4[] = {REPEAT16(0x3d2b9d0d)};
     static const uint32_t c_p5[] = {REPEAT16(0x3c07cfce)};
     static const uint32_t c_2[] = {REPEAT16(0x40000000)};
-#undef REPEAT16
+#    undef REPEAT16
     static constexpr int n_mantissa_bits = 23;
-    __m512 exp_ln_flt_min_f = _mm512_loadu_ps(reinterpret_cast<const float*>(c_min));    // log(FLT_MIN)
-    __m512 exp_ln_flt_max_f = _mm512_loadu_ps(reinterpret_cast<const float*>(c_max));    // log(FLT_MAX)
-    __m512 exp_log2ef = _mm512_loadu_ps(reinterpret_cast<const float*>(c_e));            // log2(e)
-    __m512 half = _mm512_loadu_ps(reinterpret_cast<const float*>(c_half));               // 0.5f
-    __m512 ln2f = _mm512_loadu_ps(reinterpret_cast<const float*>(c_ln2));                // ln(2)
-    __m512 one = _mm512_loadu_ps(reinterpret_cast<const float*>(c_1));                   // 1.0f
-    __m512i exponent_bias = _mm512_loadu_si512(c_bias);                                  // 127
-    __m512 exp_pol1 = _mm512_loadu_ps(reinterpret_cast<const float*>(c_p1));             // p1 = 0.999999701f
-    __m512 exp_pol2 = _mm512_loadu_ps(reinterpret_cast<const float*>(c_p2));             // p2 = 0.499991506f
-    __m512 exp_pol3 = _mm512_loadu_ps(reinterpret_cast<const float*>(c_p3));             // p3 = 0.166676521f
-    __m512 exp_pol4 = _mm512_loadu_ps(reinterpret_cast<const float*>(c_p4));             // p4 = 0.0418978221f
-    __m512 exp_pol5 = _mm512_loadu_ps(reinterpret_cast<const float*>(c_p5));             // p5 = 0.00828929059f
-    __m512 two = _mm512_loadu_ps(reinterpret_cast<const float*>(c_2));                   // 2
+    __m512 exp_ln_flt_min_f = _mm512_loadu_ps(reinterpret_cast<const float*>(c_min));  // log(FLT_MIN)
+    __m512 exp_ln_flt_max_f = _mm512_loadu_ps(reinterpret_cast<const float*>(c_max));  // log(FLT_MAX)
+    __m512 exp_log2ef = _mm512_loadu_ps(reinterpret_cast<const float*>(c_e));          // log2(e)
+    __m512 half = _mm512_loadu_ps(reinterpret_cast<const float*>(c_half));             // 0.5f
+    __m512 ln2f = _mm512_loadu_ps(reinterpret_cast<const float*>(c_ln2));              // ln(2)
+    __m512 one = _mm512_loadu_ps(reinterpret_cast<const float*>(c_1));                 // 1.0f
+    __m512i exponent_bias = _mm512_loadu_si512(c_bias);                                // 127
+    __m512 exp_pol1 = _mm512_loadu_ps(reinterpret_cast<const float*>(c_p1));           // p1 = 0.999999701f
+    __m512 exp_pol2 = _mm512_loadu_ps(reinterpret_cast<const float*>(c_p2));           // p2 = 0.499991506f
+    __m512 exp_pol3 = _mm512_loadu_ps(reinterpret_cast<const float*>(c_p3));           // p3 = 0.166676521f
+    __m512 exp_pol4 = _mm512_loadu_ps(reinterpret_cast<const float*>(c_p4));           // p4 = 0.0418978221f
+    __m512 exp_pol5 = _mm512_loadu_ps(reinterpret_cast<const float*>(c_p5));           // p5 = 0.00828929059f
+    __m512 two = _mm512_loadu_ps(reinterpret_cast<const float*>(c_2));                 // 2
     // exp(x) =
     // = exp(n * ln(2) + r) // divide x by ln(2) and get quot and rem
     // = 2^n * exp(r)       // simplify the exp(n*ln(2)) expression
@@ -793,7 +794,9 @@ inline void multiply_scalar(float* a, float* a_dst, const float val, const size_
     }
 }
 
-template<typename T, typename = typename std::enable_if<(std::is_same<T, ov::bfloat16>::value || std::is_same<T, ov::float16>::value), bool>::type>
+template <typename T,
+          typename = typename std::
+              enable_if<(std::is_same<T, ov::bfloat16>::value || std::is_same<T, ov::float16>::value), bool>::type>
 inline void multiply_scalar(float* a, T* a_dst, const float val, const size_t size) {
     size_t i = 0;
 #if defined(HAVE_AVX512F)
@@ -899,47 +902,68 @@ inline void attn_softmax_kernel<float>(float* a,
                                        ov::element::Type attn_mask_prec,
                                        ov::element::Type dst_precision,
                                        float alibi_slope) {
-    using func_fp32_type = void (*)(float*, float, const float*, const float*, const uint8_t*, bool, size_t, float, float&);
-    using func_bf16_type = void (*)(float*, float, const float*, const ov::bfloat16*, const uint8_t*, bool, size_t, float, float&);
-    using func_f16_type = void (*)(float*, float, const float*, const ov::float16*, const uint8_t*, bool, size_t, float, float&);
-    static constexpr func_fp32_type funcs_fp32[] = {
-        scale_add2_reduce_max<false, false, false>,
-        scale_add2_reduce_max<false, false, true>,
-        scale_add2_reduce_max<false, true, false>,
-        scale_add2_reduce_max<false, true, true>,
-        scale_add2_reduce_max<true, false, false>,
-        scale_add2_reduce_max<true, false, true>,
-        scale_add2_reduce_max<true, true, false>,
-        scale_add2_reduce_max<true, true, true>
-    };
-    static constexpr func_bf16_type funcs_bf16[] = {
-        scale_add2_reduce_max<false, false, false>,
-        scale_add2_reduce_max<false, false, true>,
-        scale_add2_reduce_max<false, true, false>,
-        scale_add2_reduce_max<false, true, true>,
-        scale_add2_reduce_max<true, false, false>,
-        scale_add2_reduce_max<true, false, true>,
-        scale_add2_reduce_max<true, true, false>,
-        scale_add2_reduce_max<true, true, true>
-    };
-    static constexpr func_f16_type funcs_f16[] = {
-        scale_add2_reduce_max<false, false, false>,
-        scale_add2_reduce_max<false, false, true>,
-        scale_add2_reduce_max<false, true, false>,
-        scale_add2_reduce_max<false, true, true>,
-        scale_add2_reduce_max<true, false, false>,
-        scale_add2_reduce_max<true, false, true>,
-        scale_add2_reduce_max<true, true, false>,
-        scale_add2_reduce_max<true, true, true>
-    };
+    using func_fp32_type =
+        void (*)(float*, float, const float*, const float*, const uint8_t*, bool, size_t, float, float&);
+    using func_bf16_type =
+        void (*)(float*, float, const float*, const ov::bfloat16*, const uint8_t*, bool, size_t, float, float&);
+    using func_f16_type =
+        void (*)(float*, float, const float*, const ov::float16*, const uint8_t*, bool, size_t, float, float&);
+    static constexpr func_fp32_type funcs_fp32[] = {scale_add2_reduce_max<false, false, false>,
+                                                    scale_add2_reduce_max<false, false, true>,
+                                                    scale_add2_reduce_max<false, true, false>,
+                                                    scale_add2_reduce_max<false, true, true>,
+                                                    scale_add2_reduce_max<true, false, false>,
+                                                    scale_add2_reduce_max<true, false, true>,
+                                                    scale_add2_reduce_max<true, true, false>,
+                                                    scale_add2_reduce_max<true, true, true>};
+    static constexpr func_bf16_type funcs_bf16[] = {scale_add2_reduce_max<false, false, false>,
+                                                    scale_add2_reduce_max<false, false, true>,
+                                                    scale_add2_reduce_max<false, true, false>,
+                                                    scale_add2_reduce_max<false, true, true>,
+                                                    scale_add2_reduce_max<true, false, false>,
+                                                    scale_add2_reduce_max<true, false, true>,
+                                                    scale_add2_reduce_max<true, true, false>,
+                                                    scale_add2_reduce_max<true, true, true>};
+    static constexpr func_f16_type funcs_f16[] = {scale_add2_reduce_max<false, false, false>,
+                                                  scale_add2_reduce_max<false, false, true>,
+                                                  scale_add2_reduce_max<false, true, false>,
+                                                  scale_add2_reduce_max<false, true, true>,
+                                                  scale_add2_reduce_max<true, false, false>,
+                                                  scale_add2_reduce_max<true, false, true>,
+                                                  scale_add2_reduce_max<true, true, false>,
+                                                  scale_add2_reduce_max<true, true, true>};
     int dispatch = (alibi ? 0b100 : 0) | (attn_mask ? 0b010 : 0) | (causal_mask ? 0b001 : 0);
     float max = std::numeric_limits<float>::lowest();
     if (attn_mask_prec == ov::element::f32) {
-        funcs_fp32[dispatch](a, scale, alibi, static_cast<const float*>(attn_mask), causal_mask, select_nfltmax_at_0, len, alibi_slope, max);
+        funcs_fp32[dispatch](a,
+                             scale,
+                             alibi,
+                             static_cast<const float*>(attn_mask),
+                             causal_mask,
+                             select_nfltmax_at_0,
+                             len,
+                             alibi_slope,
+                             max);
     } else if (attn_mask_prec == ov::element::bf16) {
-        funcs_bf16[dispatch](a, scale, alibi, static_cast<const ov::bfloat16*>(attn_mask), causal_mask, select_nfltmax_at_0, len, alibi_slope, max);
+        funcs_bf16[dispatch](a,
+                             scale,
+                             alibi,
+                             static_cast<const ov::bfloat16*>(attn_mask),
+                             causal_mask,
+                             select_nfltmax_at_0,
+                             len,
+                             alibi_slope,
+                             max);
     } else {
-        funcs_f16[dispatch](a, scale, alibi, static_cast<const ov::float16*>(attn_mask), causal_mask, select_nfltmax_at_0, len, alibi_slope, max);
+        funcs_f16[dispatch](a,
+                            scale,
+                            alibi,
+                            static_cast<const ov::float16*>(attn_mask),
+                            causal_mask,
+                            select_nfltmax_at_0,
+                            len,
+                            alibi_slope,
+                            max);
     }
 
     float sum = 0.0f;
@@ -978,47 +1002,89 @@ inline void attn_softmax_kernel<ov::float16>(ov::float16* a,
                                              ov::element::Type attn_mask_prec,
                                              ov::element::Type dst_precision,
                                              float alibi_slope) {
-    using func_fp32_type = void (*)(ov::float16*, float, const ov::float16*, const float*, const uint8_t*, bool, size_t, float, ov::float16&);
-    using func_bf16_type = void (*)(ov::float16*, float, const ov::float16*, const ov::bfloat16*, const uint8_t*, bool, size_t, float, ov::float16&);
-    using func_fp16_type = void (*)(ov::float16*, float, const ov::float16*, const ov::float16*, const uint8_t*, bool, size_t, float, ov::float16&);
-    static constexpr func_fp32_type funcs_fp32[] = {
-            scale_add2_reduce_max<false, false, false>,
-            scale_add2_reduce_max<false, false, true>,
-            scale_add2_reduce_max<false, true, false>,
-            scale_add2_reduce_max<false, true, true>,
-            scale_add2_reduce_max<true, false, false>,
-            scale_add2_reduce_max<true, false, true>,
-            scale_add2_reduce_max<true, true, false>,
-            scale_add2_reduce_max<true, true, true>
-    };
-    static constexpr func_bf16_type funcs_bf16[] = {
-            scale_add2_reduce_max<false, false, false>,
-            scale_add2_reduce_max<false, false, true>,
-            scale_add2_reduce_max<false, true, false>,
-            scale_add2_reduce_max<false, true, true>,
-            scale_add2_reduce_max<true, false, false>,
-            scale_add2_reduce_max<true, false, true>,
-            scale_add2_reduce_max<true, true, false>,
-            scale_add2_reduce_max<true, true, true>
-    };
-    static constexpr func_fp16_type funcs_fp16[] = {
-            scale_add2_reduce_max<false, false, false>,
-            scale_add2_reduce_max<false, false, true>,
-            scale_add2_reduce_max<false, true, false>,
-            scale_add2_reduce_max<false, true, true>,
-            scale_add2_reduce_max<true, false, false>,
-            scale_add2_reduce_max<true, false, true>,
-            scale_add2_reduce_max<true, true, false>,
-            scale_add2_reduce_max<true, true, true>
-    };
+    using func_fp32_type = void (*)(ov::float16*,
+                                    float,
+                                    const ov::float16*,
+                                    const float*,
+                                    const uint8_t*,
+                                    bool,
+                                    size_t,
+                                    float,
+                                    ov::float16&);
+    using func_bf16_type = void (*)(ov::float16*,
+                                    float,
+                                    const ov::float16*,
+                                    const ov::bfloat16*,
+                                    const uint8_t*,
+                                    bool,
+                                    size_t,
+                                    float,
+                                    ov::float16&);
+    using func_fp16_type = void (*)(ov::float16*,
+                                    float,
+                                    const ov::float16*,
+                                    const ov::float16*,
+                                    const uint8_t*,
+                                    bool,
+                                    size_t,
+                                    float,
+                                    ov::float16&);
+    static constexpr func_fp32_type funcs_fp32[] = {scale_add2_reduce_max<false, false, false>,
+                                                    scale_add2_reduce_max<false, false, true>,
+                                                    scale_add2_reduce_max<false, true, false>,
+                                                    scale_add2_reduce_max<false, true, true>,
+                                                    scale_add2_reduce_max<true, false, false>,
+                                                    scale_add2_reduce_max<true, false, true>,
+                                                    scale_add2_reduce_max<true, true, false>,
+                                                    scale_add2_reduce_max<true, true, true>};
+    static constexpr func_bf16_type funcs_bf16[] = {scale_add2_reduce_max<false, false, false>,
+                                                    scale_add2_reduce_max<false, false, true>,
+                                                    scale_add2_reduce_max<false, true, false>,
+                                                    scale_add2_reduce_max<false, true, true>,
+                                                    scale_add2_reduce_max<true, false, false>,
+                                                    scale_add2_reduce_max<true, false, true>,
+                                                    scale_add2_reduce_max<true, true, false>,
+                                                    scale_add2_reduce_max<true, true, true>};
+    static constexpr func_fp16_type funcs_fp16[] = {scale_add2_reduce_max<false, false, false>,
+                                                    scale_add2_reduce_max<false, false, true>,
+                                                    scale_add2_reduce_max<false, true, false>,
+                                                    scale_add2_reduce_max<false, true, true>,
+                                                    scale_add2_reduce_max<true, false, false>,
+                                                    scale_add2_reduce_max<true, false, true>,
+                                                    scale_add2_reduce_max<true, true, false>,
+                                                    scale_add2_reduce_max<true, true, true>};
     int dispatch = (alibi ? 0b100 : 0) | (attn_mask ? 0b010 : 0) | (causal_mask ? 0b001 : 0);
     ov::float16 max = std::numeric_limits<ov::float16>::lowest();
     if (attn_mask_prec == ov::element::f32) {
-        funcs_fp32[dispatch](a, scale, alibi, static_cast<const float*>(attn_mask), causal_mask, select_nfltmax_at_0, len, alibi_slope, max);
+        funcs_fp32[dispatch](a,
+                             scale,
+                             alibi,
+                             static_cast<const float*>(attn_mask),
+                             causal_mask,
+                             select_nfltmax_at_0,
+                             len,
+                             alibi_slope,
+                             max);
     } else if (attn_mask_prec == ov::element::f16) {
-        funcs_fp16[dispatch](a, scale, alibi, static_cast<const ov::float16*>(attn_mask), causal_mask, select_nfltmax_at_0, len, alibi_slope, max);
+        funcs_fp16[dispatch](a,
+                             scale,
+                             alibi,
+                             static_cast<const ov::float16*>(attn_mask),
+                             causal_mask,
+                             select_nfltmax_at_0,
+                             len,
+                             alibi_slope,
+                             max);
     } else {
-        funcs_bf16[dispatch](a, scale, alibi, static_cast<const ov::bfloat16*>(attn_mask), causal_mask, select_nfltmax_at_0, len, alibi_slope, max);
+        funcs_bf16[dispatch](a,
+                             scale,
+                             alibi,
+                             static_cast<const ov::bfloat16*>(attn_mask),
+                             causal_mask,
+                             select_nfltmax_at_0,
+                             len,
+                             alibi_slope,
+                             max);
     }
 
     ov::float16 sum = 0.0f;
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/transpose_kernel.hpp b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/transpose_kernel.hpp
index b719246e4976a1..93d7db55107951 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/transpose_kernel.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/scaled_attn/transpose_kernel.hpp
@@ -3,96 +3,108 @@
 //
 #pragma once
 
-#include "common.hpp"
-#include "openvino/core/type/element_type.hpp"
-
 #include <array>
 #include <cstddef>
 #include <cstdint>
 #include <vector>
 
+#include "common.hpp"
+#include "openvino/core/type/element_type.hpp"
+
 namespace ov {
 namespace Extensions {
 namespace Cpu {
 namespace XARCH {
 
 #if defined(HAVE_AVX512F)
-inline void transpose_m512i_16x16(__m512i& r0, __m512i& r1, __m512i& r2, __m512i& r3,
-    __m512i& r4, __m512i& r5, __m512i& r6, __m512i& r7,
-    __m512i& r8, __m512i& r9, __m512i& ra, __m512i& rb,
-    __m512i& rc, __m512i& rd, __m512i& re, __m512i& rf) {
+inline void transpose_m512i_16x16(__m512i& r0,
+                                  __m512i& r1,
+                                  __m512i& r2,
+                                  __m512i& r3,
+                                  __m512i& r4,
+                                  __m512i& r5,
+                                  __m512i& r6,
+                                  __m512i& r7,
+                                  __m512i& r8,
+                                  __m512i& r9,
+                                  __m512i& ra,
+                                  __m512i& rb,
+                                  __m512i& rc,
+                                  __m512i& rd,
+                                  __m512i& re,
+                                  __m512i& rf) {
     __m512i t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, ta, tb, tc, td, te, tf;
 
-    t0 = _mm512_unpacklo_epi32(r0, r1); //   0  16   1  17   4  20   5  21   8  24   9  25  12  28  13  29
-    t1 = _mm512_unpackhi_epi32(r0, r1); //   2  18   3  19   6  22   7  23  10  26  11  27  14  30  15  31
-    t2 = _mm512_unpacklo_epi32(r2, r3); //  32  48  33  49 ...
-    t3 = _mm512_unpackhi_epi32(r2, r3); //  34  50  35  51 ...
-    t4 = _mm512_unpacklo_epi32(r4, r5); //  64  80  65  81 ...
-    t5 = _mm512_unpackhi_epi32(r4, r5); //  66  82  67  83 ...
-    t6 = _mm512_unpacklo_epi32(r6, r7); //  96 112  97 113 ...
-    t7 = _mm512_unpackhi_epi32(r6, r7); //  98 114  99 115 ...
-    t8 = _mm512_unpacklo_epi32(r8, r9); // 128 ...
-    t9 = _mm512_unpackhi_epi32(r8, r9); // 130 ...
-    ta = _mm512_unpacklo_epi32(ra, rb); // 160 ...
-    tb = _mm512_unpackhi_epi32(ra, rb); // 162 ...
-    tc = _mm512_unpacklo_epi32(rc, rd); // 196 ...
-    td = _mm512_unpackhi_epi32(rc, rd); // 198 ...
-    te = _mm512_unpacklo_epi32(re, rf); // 228 ...
-    tf = _mm512_unpackhi_epi32(re, rf); // 230 ...
-
-    r0 = _mm512_unpacklo_epi64(t0, t2); //   0  16  32  48 ...
-    r1 = _mm512_unpackhi_epi64(t0, t2); //   1  17  33  49 ...
-    r2 = _mm512_unpacklo_epi64(t1, t3); //   2  18  34  49 ...
-    r3 = _mm512_unpackhi_epi64(t1, t3); //   3  19  35  51 ...
-    r4 = _mm512_unpacklo_epi64(t4, t6); //  64  80  96 112 ...
-    r5 = _mm512_unpackhi_epi64(t4, t6); //  65  81  97 114 ...
-    r6 = _mm512_unpacklo_epi64(t5, t7); //  66  82  98 113 ...
-    r7 = _mm512_unpackhi_epi64(t5, t7); //  67  83  99 115 ...
-    r8 = _mm512_unpacklo_epi64(t8, ta); // 128 144 160 176 ...
-    r9 = _mm512_unpackhi_epi64(t8, ta); // 129 145 161 178 ...
-    ra = _mm512_unpacklo_epi64(t9, tb); // 130 146 162 177 ...
-    rb = _mm512_unpackhi_epi64(t9, tb); // 131 147 163 179 ...
-    rc = _mm512_unpacklo_epi64(tc, te); // 192 208 228 240 ...
-    rd = _mm512_unpackhi_epi64(tc, te); // 193 209 229 241 ...
-    re = _mm512_unpacklo_epi64(td, tf); // 194 210 230 242 ...
-    rf = _mm512_unpackhi_epi64(td, tf); // 195 211 231 243 ...
-
-    t0 = _mm512_shuffle_i32x4(r0, r4, 0x88); //   0  16  32  48   8  24  40  56  64  80  96  112 ...
-    t1 = _mm512_shuffle_i32x4(r1, r5, 0x88); //   1  17  33  49 ...
-    t2 = _mm512_shuffle_i32x4(r2, r6, 0x88); //   2  18  34  50 ...
-    t3 = _mm512_shuffle_i32x4(r3, r7, 0x88); //   3  19  35  51 ...
-    t4 = _mm512_shuffle_i32x4(r0, r4, 0xdd); //   4  20  36  52 ...
-    t5 = _mm512_shuffle_i32x4(r1, r5, 0xdd); //   5  21  37  53 ...
-    t6 = _mm512_shuffle_i32x4(r2, r6, 0xdd); //   6  22  38  54 ...
-    t7 = _mm512_shuffle_i32x4(r3, r7, 0xdd); //   7  23  39  55 ...
-    t8 = _mm512_shuffle_i32x4(r8, rc, 0x88); // 128 144 160 176 ...
-    t9 = _mm512_shuffle_i32x4(r9, rd, 0x88); // 129 145 161 177 ...
-    ta = _mm512_shuffle_i32x4(ra, re, 0x88); // 130 146 162 178 ...
-    tb = _mm512_shuffle_i32x4(rb, rf, 0x88); // 131 147 163 179 ...
-    tc = _mm512_shuffle_i32x4(r8, rc, 0xdd); // 132 148 164 180 ...
-    td = _mm512_shuffle_i32x4(r9, rd, 0xdd); // 133 149 165 181 ...
-    te = _mm512_shuffle_i32x4(ra, re, 0xdd); // 134 150 166 182 ...
-    tf = _mm512_shuffle_i32x4(rb, rf, 0xdd); // 135 151 167 183 ...
-
-    r0 = _mm512_shuffle_i32x4(t0, t8, 0x88); //   0  16  32  48  64  80  96 112 ... 240
-    r1 = _mm512_shuffle_i32x4(t1, t9, 0x88); //   1  17  33  49  66  81  97 113 ... 241
-    r2 = _mm512_shuffle_i32x4(t2, ta, 0x88); //   2  18  34  50  67  82  98 114 ... 242
-    r3 = _mm512_shuffle_i32x4(t3, tb, 0x88); //   3  19  35  51  68  83  99 115 ... 243
-    r4 = _mm512_shuffle_i32x4(t4, tc, 0x88); //   4 ...
-    r5 = _mm512_shuffle_i32x4(t5, td, 0x88); //   5 ...
-    r6 = _mm512_shuffle_i32x4(t6, te, 0x88); //   6 ...
-    r7 = _mm512_shuffle_i32x4(t7, tf, 0x88); //   7 ...
-    r8 = _mm512_shuffle_i32x4(t0, t8, 0xdd); //   8 ...
-    r9 = _mm512_shuffle_i32x4(t1, t9, 0xdd); //   9 ...
-    ra = _mm512_shuffle_i32x4(t2, ta, 0xdd); //  10 ...
-    rb = _mm512_shuffle_i32x4(t3, tb, 0xdd); //  11 ...
-    rc = _mm512_shuffle_i32x4(t4, tc, 0xdd); //  12 ...
-    rd = _mm512_shuffle_i32x4(t5, td, 0xdd); //  13 ...
-    re = _mm512_shuffle_i32x4(t6, te, 0xdd); //  14 ...
-    rf = _mm512_shuffle_i32x4(t7, tf, 0xdd); //  15  31  47  63  79  96 111 127 ... 255
+    t0 = _mm512_unpacklo_epi32(r0, r1);  //   0  16   1  17   4  20   5  21   8  24   9  25  12  28  13  29
+    t1 = _mm512_unpackhi_epi32(r0, r1);  //   2  18   3  19   6  22   7  23  10  26  11  27  14  30  15  31
+    t2 = _mm512_unpacklo_epi32(r2, r3);  //  32  48  33  49 ...
+    t3 = _mm512_unpackhi_epi32(r2, r3);  //  34  50  35  51 ...
+    t4 = _mm512_unpacklo_epi32(r4, r5);  //  64  80  65  81 ...
+    t5 = _mm512_unpackhi_epi32(r4, r5);  //  66  82  67  83 ...
+    t6 = _mm512_unpacklo_epi32(r6, r7);  //  96 112  97 113 ...
+    t7 = _mm512_unpackhi_epi32(r6, r7);  //  98 114  99 115 ...
+    t8 = _mm512_unpacklo_epi32(r8, r9);  // 128 ...
+    t9 = _mm512_unpackhi_epi32(r8, r9);  // 130 ...
+    ta = _mm512_unpacklo_epi32(ra, rb);  // 160 ...
+    tb = _mm512_unpackhi_epi32(ra, rb);  // 162 ...
+    tc = _mm512_unpacklo_epi32(rc, rd);  // 196 ...
+    td = _mm512_unpackhi_epi32(rc, rd);  // 198 ...
+    te = _mm512_unpacklo_epi32(re, rf);  // 228 ...
+    tf = _mm512_unpackhi_epi32(re, rf);  // 230 ...
+
+    r0 = _mm512_unpacklo_epi64(t0, t2);  //   0  16  32  48 ...
+    r1 = _mm512_unpackhi_epi64(t0, t2);  //   1  17  33  49 ...
+    r2 = _mm512_unpacklo_epi64(t1, t3);  //   2  18  34  49 ...
+    r3 = _mm512_unpackhi_epi64(t1, t3);  //   3  19  35  51 ...
+    r4 = _mm512_unpacklo_epi64(t4, t6);  //  64  80  96 112 ...
+    r5 = _mm512_unpackhi_epi64(t4, t6);  //  65  81  97 114 ...
+    r6 = _mm512_unpacklo_epi64(t5, t7);  //  66  82  98 113 ...
+    r7 = _mm512_unpackhi_epi64(t5, t7);  //  67  83  99 115 ...
+    r8 = _mm512_unpacklo_epi64(t8, ta);  // 128 144 160 176 ...
+    r9 = _mm512_unpackhi_epi64(t8, ta);  // 129 145 161 178 ...
+    ra = _mm512_unpacklo_epi64(t9, tb);  // 130 146 162 177 ...
+    rb = _mm512_unpackhi_epi64(t9, tb);  // 131 147 163 179 ...
+    rc = _mm512_unpacklo_epi64(tc, te);  // 192 208 228 240 ...
+    rd = _mm512_unpackhi_epi64(tc, te);  // 193 209 229 241 ...
+    re = _mm512_unpacklo_epi64(td, tf);  // 194 210 230 242 ...
+    rf = _mm512_unpackhi_epi64(td, tf);  // 195 211 231 243 ...
+
+    t0 = _mm512_shuffle_i32x4(r0, r4, 0x88);  //   0  16  32  48   8  24  40  56  64  80  96  112 ...
+    t1 = _mm512_shuffle_i32x4(r1, r5, 0x88);  //   1  17  33  49 ...
+    t2 = _mm512_shuffle_i32x4(r2, r6, 0x88);  //   2  18  34  50 ...
+    t3 = _mm512_shuffle_i32x4(r3, r7, 0x88);  //   3  19  35  51 ...
+    t4 = _mm512_shuffle_i32x4(r0, r4, 0xdd);  //   4  20  36  52 ...
+    t5 = _mm512_shuffle_i32x4(r1, r5, 0xdd);  //   5  21  37  53 ...
+    t6 = _mm512_shuffle_i32x4(r2, r6, 0xdd);  //   6  22  38  54 ...
+    t7 = _mm512_shuffle_i32x4(r3, r7, 0xdd);  //   7  23  39  55 ...
+    t8 = _mm512_shuffle_i32x4(r8, rc, 0x88);  // 128 144 160 176 ...
+    t9 = _mm512_shuffle_i32x4(r9, rd, 0x88);  // 129 145 161 177 ...
+    ta = _mm512_shuffle_i32x4(ra, re, 0x88);  // 130 146 162 178 ...
+    tb = _mm512_shuffle_i32x4(rb, rf, 0x88);  // 131 147 163 179 ...
+    tc = _mm512_shuffle_i32x4(r8, rc, 0xdd);  // 132 148 164 180 ...
+    td = _mm512_shuffle_i32x4(r9, rd, 0xdd);  // 133 149 165 181 ...
+    te = _mm512_shuffle_i32x4(ra, re, 0xdd);  // 134 150 166 182 ...
+    tf = _mm512_shuffle_i32x4(rb, rf, 0xdd);  // 135 151 167 183 ...
+
+    r0 = _mm512_shuffle_i32x4(t0, t8, 0x88);  //   0  16  32  48  64  80  96 112 ... 240
+    r1 = _mm512_shuffle_i32x4(t1, t9, 0x88);  //   1  17  33  49  66  81  97 113 ... 241
+    r2 = _mm512_shuffle_i32x4(t2, ta, 0x88);  //   2  18  34  50  67  82  98 114 ... 242
+    r3 = _mm512_shuffle_i32x4(t3, tb, 0x88);  //   3  19  35  51  68  83  99 115 ... 243
+    r4 = _mm512_shuffle_i32x4(t4, tc, 0x88);  //   4 ...
+    r5 = _mm512_shuffle_i32x4(t5, td, 0x88);  //   5 ...
+    r6 = _mm512_shuffle_i32x4(t6, te, 0x88);  //   6 ...
+    r7 = _mm512_shuffle_i32x4(t7, tf, 0x88);  //   7 ...
+    r8 = _mm512_shuffle_i32x4(t0, t8, 0xdd);  //   8 ...
+    r9 = _mm512_shuffle_i32x4(t1, t9, 0xdd);  //   9 ...
+    ra = _mm512_shuffle_i32x4(t2, ta, 0xdd);  //  10 ...
+    rb = _mm512_shuffle_i32x4(t3, tb, 0xdd);  //  11 ...
+    rc = _mm512_shuffle_i32x4(t4, tc, 0xdd);  //  12 ...
+    rd = _mm512_shuffle_i32x4(t5, td, 0xdd);  //  13 ...
+    re = _mm512_shuffle_i32x4(t6, te, 0xdd);  //  14 ...
+    rf = _mm512_shuffle_i32x4(t7, tf, 0xdd);  //  15  31  47  63  79  96 111 127 ... 255
 }
 
-template<typename T>
+template <typename T>
 inline void transpose_16x16_kernel(float* _dst, T* src, size_t dst_stride, size_t src_stride) {
     auto* dst = reinterpret_cast<uint32_t*>(_dst);
     __m512i r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, ra, rb, rc, rd, re, rf;
@@ -133,7 +145,7 @@ inline void transpose_16x16_kernel(float* _dst, T* src, size_t dst_stride, size_
     _mm512_storeu_si512(dst + 15 * dst_stride, rf);
 }
 
-template<typename T>
+template <typename T>
 inline void transpose_16xK_kernel(float* _dst, T* src, size_t K, size_t dst_stride, size_t src_stride) {
     auto* dst = reinterpret_cast<uint32_t*>(_dst);
     __m512i r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, ra, rb, rc, rd, re, rf;
@@ -156,24 +168,110 @@ inline void transpose_16xK_kernel(float* _dst, T* src, size_t K, size_t dst_stri
 
     transpose_m512i_16x16(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, ra, rb, rc, rd, re, rf);
 
-#define S(m) _mm512_storeu_si512(dst + 0x##m * dst_stride, r##m)
-#define S8() S(0); S(1); S(2); S(3); S(4); S(5); S(6); S(7);
+#    define S(m) _mm512_storeu_si512(dst + 0x##m * dst_stride, r##m)
+#    define S8() \
+        S(0);    \
+        S(1);    \
+        S(2);    \
+        S(3);    \
+        S(4);    \
+        S(5);    \
+        S(6);    \
+        S(7);
     switch (K) {
-        case 8: S8(); break;
-        case 9: S8() S(8); break;
-        case 10: S8(); S(8); S(9); break;
-        case 11: S8(); S(8); S(9); S(a); break;
-        case 12: S8(); S(8); S(9); S(a); S(b); break;
-        case 13: S8(); S(8); S(9); S(a); S(b); S(c); break;
-        case 14: S8(); S(8); S(9); S(a); S(b); S(c); S(d); break;
-        case 15: S8(); S(8); S(9); S(a); S(b); S(c); S(d); S(e); break;
-        case 1: S(0); break;
-        case 2: S(0); S(1); break;
-        case 3: S(0); S(1); S(2); break;
-        case 4: S(0); S(1); S(2); S(3); break;
-        case 5: S(0); S(1); S(2); S(3); S(4); break;
-        case 6: S(0); S(1); S(2); S(3); S(4); S(5); break;
-        case 7: S(0); S(1); S(2); S(3); S(4); S(5); S(6); break;
+    case 8:
+        S8();
+        break;
+    case 9:
+        S8() S(8);
+        break;
+    case 10:
+        S8();
+        S(8);
+        S(9);
+        break;
+    case 11:
+        S8();
+        S(8);
+        S(9);
+        S(a);
+        break;
+    case 12:
+        S8();
+        S(8);
+        S(9);
+        S(a);
+        S(b);
+        break;
+    case 13:
+        S8();
+        S(8);
+        S(9);
+        S(a);
+        S(b);
+        S(c);
+        break;
+    case 14:
+        S8();
+        S(8);
+        S(9);
+        S(a);
+        S(b);
+        S(c);
+        S(d);
+        break;
+    case 15:
+        S8();
+        S(8);
+        S(9);
+        S(a);
+        S(b);
+        S(c);
+        S(d);
+        S(e);
+        break;
+    case 1:
+        S(0);
+        break;
+    case 2:
+        S(0);
+        S(1);
+        break;
+    case 3:
+        S(0);
+        S(1);
+        S(2);
+        break;
+    case 4:
+        S(0);
+        S(1);
+        S(2);
+        S(3);
+        break;
+    case 5:
+        S(0);
+        S(1);
+        S(2);
+        S(3);
+        S(4);
+        break;
+    case 6:
+        S(0);
+        S(1);
+        S(2);
+        S(3);
+        S(4);
+        S(5);
+        break;
+    case 7:
+        S(0);
+        S(1);
+        S(2);
+        S(3);
+        S(4);
+        S(5);
+        S(6);
+        break;
     }
 }
 
@@ -240,30 +338,109 @@ inline void transpose_16xK_kernel(uint32_t* dst, uint32_t* src, size_t K, size_t
     transpose_m512i_16x16(r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, ra, rb, rc, rd, re, rf);
 
     switch (K) {
-        case 8: S8(); break;
-        case 9: S8() S(8); break;
-        case 10: S8(); S(8); S(9); break;
-        case 11: S8(); S(8); S(9); S(a); break;
-        case 12: S8(); S(8); S(9); S(a); S(b); break;
-        case 13: S8(); S(8); S(9); S(a); S(b); S(c); break;
-        case 14: S8(); S(8); S(9); S(a); S(b); S(c); S(d); break;
-        case 15: S8(); S(8); S(9); S(a); S(b); S(c); S(d); S(e); break;
-        case 1: S(0); break;
-        case 2: S(0); S(1); break;
-        case 3: S(0); S(1); S(2); break;
-        case 4: S(0); S(1); S(2); S(3); break;
-        case 5: S(0); S(1); S(2); S(3); S(4); break;
-        case 6: S(0); S(1); S(2); S(3); S(4); S(5); break;
-        case 7: S(0); S(1); S(2); S(3); S(4); S(5); S(6); break;
+    case 8:
+        S8();
+        break;
+    case 9:
+        S8() S(8);
+        break;
+    case 10:
+        S8();
+        S(8);
+        S(9);
+        break;
+    case 11:
+        S8();
+        S(8);
+        S(9);
+        S(a);
+        break;
+    case 12:
+        S8();
+        S(8);
+        S(9);
+        S(a);
+        S(b);
+        break;
+    case 13:
+        S8();
+        S(8);
+        S(9);
+        S(a);
+        S(b);
+        S(c);
+        break;
+    case 14:
+        S8();
+        S(8);
+        S(9);
+        S(a);
+        S(b);
+        S(c);
+        S(d);
+        break;
+    case 15:
+        S8();
+        S(8);
+        S(9);
+        S(a);
+        S(b);
+        S(c);
+        S(d);
+        S(e);
+        break;
+    case 1:
+        S(0);
+        break;
+    case 2:
+        S(0);
+        S(1);
+        break;
+    case 3:
+        S(0);
+        S(1);
+        S(2);
+        break;
+    case 4:
+        S(0);
+        S(1);
+        S(2);
+        S(3);
+        break;
+    case 5:
+        S(0);
+        S(1);
+        S(2);
+        S(3);
+        S(4);
+        break;
+    case 6:
+        S(0);
+        S(1);
+        S(2);
+        S(3);
+        S(4);
+        S(5);
+        break;
+    case 7:
+        S(0);
+        S(1);
+        S(2);
+        S(3);
+        S(4);
+        S(5);
+        S(6);
+        break;
     }
-#undef S
-#undef S8
+#    undef S
+#    undef S8
 }
 
 #elif defined(HAVE_AVX2)
 
 // https://stackoverflow.com/questions/25622745/transpose-an-8x8-float-using-avx-avx2
-inline void transpose_8x8(__m256& r0, __m256& r1, __m256& r2, __m256& r3, __m256& r4, __m256& r5, __m256& r6, __m256& r7) {
+inline void
+transpose_8x8(__m256& r0, __m256& r1, __m256& r2, __m256& r3, __m256& r4, __m256& r5, __m256& r6, __m256& r7) {
     __m256 t0, t1, t2, t3, t4, t5, t6, t7;
     __m256 tt0, tt1, tt2, tt3, tt4, tt5, tt6, tt7;
     t0 = _mm256_unpacklo_ps(r0, r1);
@@ -292,7 +469,7 @@ inline void transpose_8x8(__m256& r0, __m256& r1, __m256& r2, __m256& r3, __m256
     r7 = _mm256_permute2f128_ps(tt3, tt7, 0x31);
 }
 
-template<typename T>
+template <typename T>
 inline void transpose_16x16_kernel(float* dst, T* src, size_t dst_stride, size_t src_stride) {
     __m256 r0, r1, r2, r3, r4, r5, r6, r7;
 
@@ -323,7 +500,7 @@ inline void transpose_16x16_kernel(float* dst, T* src, size_t dst_stride, size_t
     }
 }
 
-template<typename T>
+template <typename T>
 inline void transpose_16xK_kernel(float* dst, T* src, size_t K, size_t dst_stride, size_t src_stride) {
     __m256 r0, r1, r2, r3, r4, r5, r6, r7;
 
@@ -366,24 +543,59 @@ inline void transpose_16xK_kernel(float* dst, T* src, size_t K, size_t dst_strid
 
             transpose_8x8(r0, r1, r2, r3, r4, r5, r6, r7);
 
-#define S(m) _mm256_storeu_ps(dst + j + m * dst_stride, r##m)
+#    define S(m) _mm256_storeu_ps(dst + j + m * dst_stride, r##m)
             switch (K) {
-                case 1: S(0); break;
-                case 2: S(0); S(1); break;
-                case 3: S(0); S(1); S(2); break;
-                case 4: S(0); S(1); S(2); S(3); break;
-                case 5: S(0); S(1); S(2); S(3); S(4); break;
-                case 6: S(0); S(1); S(2); S(3); S(4); S(5); break;
-                case 7: S(0); S(1); S(2); S(3); S(4); S(5); S(6); break;
+            case 1:
+                S(0);
+                break;
+            case 2:
+                S(0);
+                S(1);
+                break;
+            case 3:
+                S(0);
+                S(1);
+                S(2);
+                break;
+            case 4:
+                S(0);
+                S(1);
+                S(2);
+                S(3);
+                break;
+            case 5:
+                S(0);
+                S(1);
+                S(2);
+                S(3);
+                S(4);
+                break;
+            case 6:
+                S(0);
+                S(1);
+                S(2);
+                S(3);
+                S(4);
+                S(5);
+                break;
+            case 7:
+                S(0);
+                S(1);
+                S(2);
+                S(3);
+                S(4);
+                S(5);
+                S(6);
+                break;
             }
-#undef S
+#    undef S
         }
     }
 }
 
 #else
 
-template<typename TSRC, typename TDST>
+template <typename TSRC, typename TDST>
 inline void transpose_16x16_kernel(TDST* dst, TSRC* src, size_t dst_stride, size_t src_stride) {
     for (size_t i = 0; i < 16; i++) {
         for (size_t j = 0; j < 16; j++) {
@@ -392,7 +604,7 @@ inline void transpose_16x16_kernel(TDST* dst, TSRC* src, size_t dst_stride, size
     }
 }
 
-template<typename TSRC, typename TDST>
+template <typename TSRC, typename TDST>
 inline void transpose_16xK_kernel(TDST* dst, TSRC* src, size_t K, size_t dst_stride, size_t src_stride) {
     for (size_t i = 0; i < K; i++) {
         for (size_t j = 0; j < 16; j++) {
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/brgemm_kernel.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/brgemm_kernel.cpp
index 2895a272b982b5..7df2e2371a843a 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/brgemm_kernel.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/brgemm_kernel.cpp
@@ -4,11 +4,12 @@
 
 #include "brgemm_kernel.hpp"
 
-#include "dnnl_extension_utils.h"
-#include "utils/cpu_utils.hpp"
 #include <cpu/x64/cpu_isa_traits.hpp>
 #include <openvino/core/except.hpp>
 
+#include "dnnl_extension_utils.h"
+#include "utils/cpu_utils.hpp"
+
 using namespace dnnl::impl::cpu::x64;
 using namespace dnnl::impl;
 using namespace dnnl::impl::cpu::x64::matmul;
@@ -100,8 +101,9 @@ BrgemmKernel::BrgemmKernel(size_t M,
                 brgemmCtx.M = M_;
                 brgemmCtx.N = N_;
                 brgemmCtx.K = K_;
-                brgemmCtx.LDA = k ? K_blk : (is_avx_f16_only ? K : lda); // f16 use f32 internally
-                brgemmCtx.LDB = (!is_f32 || b_transposed) ? rnd_up(N, N_blk) : ldb;  // bf16/fp16/b_transposed needs copy
+                brgemmCtx.LDA = k ? K_blk : (is_avx_f16_only ? K : lda);  // f16 use f32 internally
+                brgemmCtx.LDB =
+                    (!is_f32 || b_transposed) ? rnd_up(N, N_blk) : ldb;  // bf16/fp16/b_transposed needs copy
                 brgemmCtx.LDC = ldc;
                 brgemmCtx.dt_in0 = static_cast<dnnl_data_type_t>(DnnlExtensionUtils::ElementTypeToDataType(srcType));
                 brgemmCtx.dt_in1 = static_cast<dnnl_data_type_t>(DnnlExtensionUtils::ElementTypeToDataType(weiType));
@@ -158,8 +160,8 @@ const size_t BrgemmKernel::get_scratch_b_size() const {
 }
 
 void BrgemmKernel::init_brgemm(brgemmCtx& ctx,
-                                 std::unique_ptr<dnnl::impl::cpu::x64::brgemm_kernel_t>& brgKernel,
-                                 bool use_amx) {
+                               std::unique_ptr<dnnl::impl::cpu::x64::brgemm_kernel_t>& brgKernel,
+                               bool use_amx) {
     brgemm_desc_t brgDesc;
 
     const bool is_int8 =
@@ -208,7 +210,8 @@ void BrgemmKernel::init_brgemm(brgemmCtx& ctx,
         brgattr.max_bs = 1;
         brgattr.wary_tail_read = false;
         brgattr.hint_innermost_loop = brgemm_innermost_undef;
-        // if b_accumulate is true, it means we want c+=a*b. jit_brgemm_amx_uker_base_t::load_accumulators can support this using tileload(c) without postops
+        // if b_accumulate is true, it means we want c+=a*b. jit_brgemm_amx_uker_base_t::load_accumulators can support
+        // this using tileload(c) without postops
         brgattr.use_uker = true;
         brgattr.use_interleave_stores = true;
         brgattr.hint_prefetching = brgemm_kernel_prefetching_t::brgemm_prf1;
@@ -248,7 +251,7 @@ void BrgemmKernel::init_brgemm_copy_a(
     brgCopyKernelConf.K_tail = K_tail;
     brgCopyKernelConf.K_blk = K_blk;
     brgCopyKernelConf.use_buffer_a_tail_only = false;
-    //padding K tail to K_blk, LDA is the stride for target tensor
+    // padding K tail to K_blk, LDA is the stride for target tensor
     brgCopyKernelConf.LDA = LDA;
     brgCopyKernelConf.has_zero_point_b = false;
     brgCopyKernelConf.s8s8_compensation_required = false;
@@ -258,9 +261,13 @@ void BrgemmKernel::init_brgemm_copy_a(
     brgCopyKernelConf.copy_A_src_stride = copy_A_src_stride;
     // copy_a_kernel assumes that in/out tensor has same data type except f16
     // copy_a_kernel has special path for f16: assuming input(f16) -> output(f32)
-    brgCopyKernelConf.a_dt_sz = is_avx_f16_only ? sizeof(ov::float16) : DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(dt_in0));
+    brgCopyKernelConf.a_dt_sz = is_avx_f16_only
+                                    ? sizeof(ov::float16)
+                                    : DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(dt_in0));
     // copied A has the same precision of original
-    brgCopyKernelConf.tr_a_dt_sz = is_avx_f16_only ? sizeof(float) : DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(dt_in0));
+    brgCopyKernelConf.tr_a_dt_sz =
+        is_avx_f16_only ? sizeof(float)
+                        : DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(dt_in0));
     brgCopyKernelConf.transposed_A = transpose;
     brgCopyKernelConf.isa = is_avx_f16_only ? avx512_core_fp16 : avx512_core_amx;
 
@@ -284,7 +291,7 @@ void BrgemmKernel::init_brgemm_copy_b(
     brgCopyKernelConf.wei_dt = is_avx_f16_only ? dnnl_data_type_t::dnnl_f32 : dt_in1;
     brgCopyKernelConf.orig_wei_dt = dt_in1;
     brgCopyKernelConf.wei_n_blk = N_blk;
-    brgCopyKernelConf.wei_tag =  transpose ? dnnl_ba : dnnl_ab;
+    brgCopyKernelConf.wei_tag = transpose ? dnnl_ba : dnnl_ab;
     brgCopyKernelConf.copy_B_wei_stride = copy_B_wei_stride;
     brgCopyKernelConf.transposed_B = transpose;
 
@@ -298,10 +305,14 @@ void BrgemmKernel::init_brgemm_copy_b(
     brgCopyKernelConf.K_tail = 0;
     brgCopyKernelConf.N_chunk_elems = brgCopyKernelConf.N_blk;
     // f16 is computed by upconverting. in(f16) -> out(f32)
-    brgCopyKernelConf.b_dt_sz = is_avx_f16_only ? sizeof(ov::float16) :
-        DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(brgCopyKernelConf.src_dt));
-    brgCopyKernelConf.tr_b_dt_sz = is_avx_f16_only ?  sizeof(float) :
-        DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(brgCopyKernelConf.src_dt));
+    brgCopyKernelConf.b_dt_sz =
+        is_avx_f16_only
+            ? sizeof(ov::float16)
+            : DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(brgCopyKernelConf.src_dt));
+    brgCopyKernelConf.tr_b_dt_sz =
+        is_avx_f16_only
+            ? sizeof(float)
+            : DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(brgCopyKernelConf.src_dt));
     brgCopyKernelConf.req_wei_vnni_downconvert = false;
 
     if (is_with_amx) {
@@ -390,12 +401,7 @@ void BrgemmKernel::executeGemm(bool is_M_tail, void* a, void* b, void* c, void*
                 auto weight_ptr = ptr_scartch_b + B_stride;
                 auto C_stride = n * count_N * ov::element::f32.size();
                 auto out_ptr = ptr_C + C_stride;
-                callBrgemm(brgemmCtx,
-                           brgKernels[getBrgIdx(mIdx, k, n)],
-                           local_a_ptr,
-                           weight_ptr,
-                           out_ptr,
-                           wsp);
+                callBrgemm(brgemmCtx, brgKernels[getBrgIdx(mIdx, k, n)], local_a_ptr, weight_ptr, out_ptr, wsp);
                 // stride K, N if body kernel is executed.
                 if (k == 0) {
                     count_K = brgemmCtx.K * brgemmCtx.LDB;
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/dft_uni_kernel.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/dft_uni_kernel.cpp
index f8b0df611258a7..1d5e81410a0bf3 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/dft_uni_kernel.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/dft_uni_kernel.cpp
@@ -4,7 +4,6 @@
 
 #include "dft_uni_kernel.hpp"
 
-
 using namespace dnnl::impl;
 using namespace dnnl::impl::utils;
 using namespace dnnl::impl::cpu::x64;
@@ -16,7 +15,8 @@ namespace ov {
 namespace intel_cpu {
 
 template <cpu::x64::cpu_isa_t isa>
-jit_uni_dft_kernel_f32<isa>::jit_uni_dft_kernel_f32() : jit_uni_dft_kernel(), jit_generator(jit_name()) {}
+jit_uni_dft_kernel_f32<isa>::jit_uni_dft_kernel_f32() : jit_uni_dft_kernel(),
+                                                        jit_generator(jit_name()) {}
 
 template <cpu::x64::cpu_isa_t isa>
 void jit_uni_dft_kernel_f32<isa>::create_ker() {
@@ -115,11 +115,9 @@ template struct jit_uni_dft_kernel_f32<cpu::x64::sse41>;
 template struct jit_uni_dft_kernel_f32<cpu::x64::avx2>;
 template struct jit_uni_dft_kernel_f32<cpu::x64::avx512_core>;
 
-
 template <cpu::x64::cpu_isa_t isa>
-jit_uni_fft_kernel_f32<isa>::jit_uni_fft_kernel_f32()
-    : jit_uni_fft_kernel(),
-      jit_generator(jit_name()) {}
+jit_uni_fft_kernel_f32<isa>::jit_uni_fft_kernel_f32() : jit_uni_fft_kernel(),
+                                                        jit_generator(jit_name()) {}
 
 template <cpu::x64::cpu_isa_t isa>
 void jit_uni_fft_kernel_f32<isa>::create_ker() {
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/dft_uni_kernel.hpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/dft_uni_kernel.hpp
index b70c99e5f8a527..095a3db97d2a64 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/dft_uni_kernel.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/dft_uni_kernel.hpp
@@ -130,7 +130,6 @@ struct jit_uni_fft_kernel_f32 : public jit_uni_fft_kernel, public dnnl::impl::cp
 
     Vmm vmm_data_result = vmm_data_odd_2;
 
-
     template <typename T>
     void loop_process(int step);
 
@@ -138,5 +137,5 @@ struct jit_uni_fft_kernel_f32 : public jit_uni_fft_kernel, public dnnl::impl::cp
     void move_data(const Xbyak::Xmm& x, const Xbyak::Address& addr, int count);
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/gather_uni_kernel.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/gather_uni_kernel.cpp
index 5aaefb086f119c..c0de6520b7099c 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/gather_uni_kernel.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/gather_uni_kernel.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "gather_uni_kernel.hpp"
+
 #include "openvino/core/except.hpp"
 
 using namespace dnnl::impl::cpu;
@@ -10,23 +11,52 @@ using namespace dnnl::impl::cpu;
 namespace ov {
 namespace intel_cpu {
 
-const unsigned jitGatherKernelBase::shufMask8bitUni[16]  = {0x0C080400, 0x80808080, 0x80808080, 0x80808080, 0x0C080400, 0x80808080, 0x80808080, 0x80808080,
-                                                            0x0C080400, 0x80808080, 0x80808080, 0x80808080, 0x0C080400, 0x80808080, 0x80808080, 0x80808080};
-const unsigned jitGatherKernelBase::permMask8bitA2[8]    = {0, 4, 1, 5, 2, 6, 3, 7};
-const unsigned jitGatherKernelBase::permMask8bitA5[16]   = {0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15};
-
-const unsigned jitGatherKernelBase::shufMask16bitUni[16] = {0x05040100, 0x0D0C0908, 0x80808080, 0x80808080, 0x05040100, 0x0D0C0908, 0x80808080, 0x80808080,
-                                                            0x05040100, 0x0D0C0908, 0x80808080, 0x80808080, 0x05040100, 0x0D0C0908, 0x80808080, 0x80808080};
-const unsigned jitGatherKernelBase::permMask16bitA2[8]   = {0, 1, 4, 5, 2, 3, 6, 7};
-const unsigned jitGatherKernelBase::permMask16bitA5[16]  = {0, 1, 4, 5, 8, 9, 12, 13, 2, 3, 6, 7, 10, 11, 14, 15};
+const unsigned jitGatherKernelBase::shufMask8bitUni[16] = {0x0C080400,
+                                                           0x80808080,
+                                                           0x80808080,
+                                                           0x80808080,
+                                                           0x0C080400,
+                                                           0x80808080,
+                                                           0x80808080,
+                                                           0x80808080,
+                                                           0x0C080400,
+                                                           0x80808080,
+                                                           0x80808080,
+                                                           0x80808080,
+                                                           0x0C080400,
+                                                           0x80808080,
+                                                           0x80808080,
+                                                           0x80808080};
+const unsigned jitGatherKernelBase::permMask8bitA2[8] = {0, 4, 1, 5, 2, 6, 3, 7};
+const unsigned jitGatherKernelBase::permMask8bitA5[16] = {0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15};
+
+const unsigned jitGatherKernelBase::shufMask16bitUni[16] = {0x05040100,
+                                                            0x0D0C0908,
+                                                            0x80808080,
+                                                            0x80808080,
+                                                            0x05040100,
+                                                            0x0D0C0908,
+                                                            0x80808080,
+                                                            0x80808080,
+                                                            0x05040100,
+                                                            0x0D0C0908,
+                                                            0x80808080,
+                                                            0x80808080,
+                                                            0x05040100,
+                                                            0x0D0C0908,
+                                                            0x80808080,
+                                                            0x80808080};
+const unsigned jitGatherKernelBase::permMask16bitA2[8] = {0, 1, 4, 5, 2, 3, 6, 7};
+const unsigned jitGatherKernelBase::permMask16bitA5[16] = {0, 1, 4, 5, 8, 9, 12, 13, 2, 3, 6, 7, 10, 11, 14, 15};
 
 const unsigned jitGatherKernelBase::incVec[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
 
 #define GET_OFF(field) offsetof(gatherJitExecArgs, field)
 
 template <x64::cpu_isa_t isa>
-jitUniGatherKernel<isa>::jitUniGatherKernel(const jGatherConfParams& jcp) :
-        jitGatherKernelBase(jcp), x64::jit_generator(jit_name()) {
+jitUniGatherKernel<isa>::jitUniGatherKernel(const jGatherConfParams& jcp)
+    : jitGatherKernelBase(jcp),
+      x64::jit_generator(jit_name()) {
     vlen = x64::cpu_isa_traits<isa>::vlen;
     dataElPerVec = vlen / jcp.dataTypeSize;
     idxElPerVec = vlen / indicesTypeSize;
@@ -74,7 +104,7 @@ void jitUniGatherKernel<isa>::generate() {
     if (!jcp.dynamicShapes) {
         mov(regAux1, ptr[regParams + GET_OFF(specIndicesSize)]);
         uni_vpbroadcastd(vmmSpecIdxSizeB, ptr[regAux1]);
-        uni_vpslld(vmmSpecIdxSizeB, vmmSpecIdxSizeB, idxTypeShift); // multiply by indices type size.
+        uni_vpslld(vmmSpecIdxSizeB, vmmSpecIdxSizeB, idxTypeShift);  // multiply by indices type size.
 
         mov(regAux1, ptr[regParams + GET_OFF(specIdxB)]);
         uni_vmovups(vmmSpecIdxB, ptr[regAux1]);
@@ -84,7 +114,7 @@ void jitUniGatherKernel<isa>::generate() {
             uni_vmovups(vmmSrcBeforeAxisSumB, ptr[regAux1]);
         }
 
-        if (jcp.afterAxisSize == 1lu) { // Elementwise case.
+        if (jcp.afterAxisSize == 1lu) {  // Elementwise case.
             uni_vmovd(reg32SpecIdxSizeB, xmmSpecIdxSizeB);
             if (jcp.beforeAxisSize != 1lu) {
                 mov(regAux1, ptr[regParams + GET_OFF(axisAndAfterAxisSizeB)]);
@@ -98,8 +128,9 @@ void jitUniGatherKernel<isa>::generate() {
             mov(regBetweenBatchAndAxisSize, ptr[regAux1]);
             mov(regBetweenBatchAndAxisIter, ptr[regParams + GET_OFF(betweenBatchAndAxisIter)]);
 
-            if (jcp.specIdxSize < idxElPerVec) { // Short case.
-                if (jcp.specIdxSize != 1 && jcp.specIdxSize != 2 && jcp.specIdxSize != 4 && jcp.specIdxSize != 8 && jcp.specIdxSize != 16) {
+            if (jcp.specIdxSize < idxElPerVec) {  // Short case.
+                if (jcp.specIdxSize != 1 && jcp.specIdxSize != 2 && jcp.specIdxSize != 4 && jcp.specIdxSize != 8 &&
+                    jcp.specIdxSize != 16) {
                     mov(regAux1, ptr[regParams + GET_OFF(permIdxMask)]);
                     uni_vmovups(vmmPermIdxMask, ptr[regAux1]);
                 }
@@ -107,7 +138,7 @@ void jitUniGatherKernel<isa>::generate() {
                     mov(regAux1, ptr[regParams + GET_OFF(beforeAxisDiff)]);
                     uni_vmovups(vmmBeforeAxDiffB, ptr[regAux1]);
                     if (jcp.dataTypeSize != 1)
-                        uni_vpslld(vmmBeforeAxDiffB, vmmBeforeAxDiffB, dataTypeShift); // multiply by data type size
+                        uni_vpslld(vmmBeforeAxDiffB, vmmBeforeAxDiffB, dataTypeShift);  // multiply by data type size
                 }
                 if (jcp.batchDims > 0lu) {
                     mov(regAux1, ptr[regParams + GET_OFF(srcAfterBatchSizeB)]);
@@ -115,14 +146,14 @@ void jitUniGatherKernel<isa>::generate() {
                 }
 
                 process(true, false);
-            } else { // Long case.
+            } else {  // Long case.
                 uni_vmovd(reg32IdxIter, xmmSpecIdxB);
                 fillVlenVector();
 
                 process(false, false);
             }
-        } else { // Blocked case.
-            if (jcp.afterAxisSize <= idxElPerVec) { // Short case.
+        } else {                                     // Blocked case.
+            if (jcp.afterAxisSize <= idxElPerVec) {  // Short case.
                 mov(regAux1, ptr[regParams + GET_OFF(afterAxIdxB)]);
                 uni_vmovups(vmmAfterAxisIdxB, ptr[regAux1]);
                 mov(regAux1, ptr[regParams + GET_OFF(afterAxisPermMask)]);
@@ -146,18 +177,19 @@ void jitUniGatherKernel<isa>::generate() {
                     }
                     const uint64_t specIdxAndAfterAxisSize = jcp.specIdxSize * jcp.afterAxisSize;
                     if (specIdxAndAfterAxisSize != 1 && specIdxAndAfterAxisSize != 2 && specIdxAndAfterAxisSize != 4 &&
-                            specIdxAndAfterAxisSize != 8 && specIdxAndAfterAxisSize != 16) {
+                        specIdxAndAfterAxisSize != 8 && specIdxAndAfterAxisSize != 16) {
                         mov(regAux1, ptr[regParams + GET_OFF(beforeAxisPermMask)]);
                         uni_vmovups(vmmBeforeAxPermMask, ptr[regAux1]);
                     }
                 }
 
                 process(true, true);
-            } else { // Long case.
-                OPENVINO_THROW("Gather kernel does not support static shape with after axis size greater than elements in vector.");
+            } else {  // Long case.
+                OPENVINO_THROW("Gather kernel does not support static shape with after axis size greater than elements "
+                               "in vector.");
             }
         }
-    } else { // Dynamic shapes.
+    } else {  // Dynamic shapes.
         mov(regAux1, ptr[regParams + GET_OFF(start)]);
         uni_vpbroadcastd(vmmSpecIdxB, ptr[regAux1]);
         mov(regAux1, reinterpret_cast<uintptr_t>(incVec));
@@ -172,8 +204,8 @@ void jitUniGatherKernel<isa>::generate() {
         uni_vroundps(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, 0x1);
         uni_vfnmadd231ps(vmmSpecIdxB, vmmSrcBeforeAxisSumB, vAux1);
         uni_vcvtps2dq(vmmSpecIdxB, vmmSpecIdxB);
-        uni_vpslld(vmmSpecIdxB, vmmSpecIdxB, idxTypeShift); // multiply by indices type size.
-        uni_vpslld(vmmSpecIdxSizeB, vmmSpecIdxSizeB, idxTypeShift); // multiply by indices type size.
+        uni_vpslld(vmmSpecIdxB, vmmSpecIdxB, idxTypeShift);          // multiply by indices type size.
+        uni_vpslld(vmmSpecIdxSizeB, vmmSpecIdxSizeB, idxTypeShift);  // multiply by indices type size.
         uni_vmovd(reg32SpecIdxSizeB, xmmSpecIdxSizeB);
 
         mov(regAux1, ptr[regParams + GET_OFF(betweenBatchAndAxisSize)]);
@@ -189,7 +221,8 @@ void jitUniGatherKernel<isa>::generate() {
 
         mov(regAux1, ptr[regParams + GET_OFF(axisAndAfterAxisSizeB)]);
         uni_vpbroadcastd(vmmAxisAndAfterAxisSizeB, ptr[regAux1]);
-        // Formula: srcBeforeAxisSum = ((start / specIndicesSize) % betweenBatchAndAxis) * axisAndAfterAxisSize + srcAfterBatchSize * idxBatchSum
+        // Formula: srcBeforeAxisSum = ((start / specIndicesSize) % betweenBatchAndAxis) * axisAndAfterAxisSize +
+        // srcAfterBatchSize * idxBatchSum
         if (jcp.beforeAxisSize != 1lu) {
             uni_vpmulld(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, vmmAxisAndAfterAxisSizeB);
             mov(regAux1, ptr[regParams + GET_OFF(srcAfterBatchSizeB)]);
@@ -210,28 +243,29 @@ void jitUniGatherKernel<isa>::generate() {
 
             cmp(regSpecIdxSizeB, vlen);
             jl(lLessThanVector1, T_NEAR);
-                uni_vmovd(reg32IdxIter, xmmSpecIdxB);
-                fillVlenVector();
+            uni_vmovd(reg32IdxIter, xmmSpecIdxB);
+            fillVlenVector();
 
-                process(false, false);
-                jmp(lE1, T_NEAR);
+            process(false, false);
+            jmp(lE1, T_NEAR);
             L(lLessThanVector1);
-                mov(regAux1, ptr[regParams + GET_OFF(permIdxMask)]);
-                uni_vmovups(vmmPermIdxMask, ptr[regAux1]);
-                if (jcp.beforeAxisSize != 1lu) {
-                    mov(regAux1, ptr[regParams + GET_OFF(beforeAxisDiff)]);
-                    uni_vmovups(vmmBeforeAxDiffB, ptr[regAux1]);
-                    if (jcp.dataTypeSize != 1)
-                        uni_vpslld(vmmBeforeAxDiffB, vmmBeforeAxDiffB, dataTypeShift); // multiply by data type size
-                }
-                mov(regAux1, ptr[regParams + GET_OFF(srcAfterBatchSizeB)]);
-                uni_vpbroadcastd(vmmSrcAfterBatchSizeB, ptr[regAux1]);
+            mov(regAux1, ptr[regParams + GET_OFF(permIdxMask)]);
+            uni_vmovups(vmmPermIdxMask, ptr[regAux1]);
+            if (jcp.beforeAxisSize != 1lu) {
+                mov(regAux1, ptr[regParams + GET_OFF(beforeAxisDiff)]);
+                uni_vmovups(vmmBeforeAxDiffB, ptr[regAux1]);
+                if (jcp.dataTypeSize != 1)
+                    uni_vpslld(vmmBeforeAxDiffB, vmmBeforeAxDiffB, dataTypeShift);  // multiply by data type size
+            }
+            mov(regAux1, ptr[regParams + GET_OFF(srcAfterBatchSizeB)]);
+            uni_vpbroadcastd(vmmSrcAfterBatchSizeB, ptr[regAux1]);
 
-                process(true, false);
+            process(true, false);
             L(lE1);
             jmp(lEnd, T_NEAR);
         }
-        L(lBlock); {
+        L(lBlock);
+        {
             mov(regAux1, ptr[regParams + GET_OFF(start)]);
             uni_vpbroadcastd(vmmAfterAxisIdxB, ptr[regAux1]);
             mov(regAux1, reinterpret_cast<uintptr_t>(incVec));
@@ -246,40 +280,40 @@ void jitUniGatherKernel<isa>::generate() {
             uni_vroundps(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, 0x1);
             uni_vfnmadd231ps(vmmAfterAxisIdxB, vmmSrcBeforeAxisSumB, vAux1);
             uni_vcvtps2dq(vmmAfterAxisIdxB, vmmAfterAxisIdxB);
-            uni_vpslld(vmmAfterAxisIdxB, vmmAfterAxisIdxB, idxTypeShift); // multiply by indices type size.
+            uni_vpslld(vmmAfterAxisIdxB, vmmAfterAxisIdxB, idxTypeShift);  // multiply by indices type size.
 
             Xbyak::Label lLessThanVector2, lTail3, lTail4, lE2;
 
             cmp(regAux2, dataElPerVec);
             jl(lLessThanVector2, T_NEAR);
-                uni_vmovd(reg32IdxIter, xmmSpecIdxB);
-                fillVlenVector();
+            uni_vmovd(reg32IdxIter, xmmSpecIdxB);
+            fillVlenVector();
 
-//                process(false, true);
-                jmp(lE2, T_NEAR);
+            //                process(false, true);
+            jmp(lE2, T_NEAR);
             L(lLessThanVector2);
-                auto& vAux2 = vmmAuxContainer[2];
-                // Calculate permute mask
-                uni_vmovd(xAux0, reg32Aux2);
-                uni_vpbroadcastd(vAux1, xAux0);
-                mov(regAux1, reinterpret_cast<uintptr_t>(&idxElPerVec));
-                uni_vpbroadcastd(vAux0, ptr[regAux1]);
-                uni_vpsubd(vmmAfterAxisPermMask, vAux0, vAux1);
-                mov(regAux1, reinterpret_cast<uintptr_t>(incVec));
-                uni_vpaddd(vmmAfterAxisPermMask, vmmAfterAxisPermMask, ptr[regAux1]);
-                for (int i = 0; i < 6; i++) {
-                    if (isa == x64::avx512_core) {
-                        Xbyak::Opmask kMask2 = Xbyak::Opmask(vAux2.getIdx());
-                        vpcmpgtd(kMask2, vAux0, vmmAfterAxisPermMask);
-                        uni_vpsubd(vmmAfterAxisPermMask | kMask2, vmmAfterAxisPermMask, vAux1);
-                    } else {
-                        vpcmpgtd(vAux2, vAux0, vmmAfterAxisPermMask);
-                        vpandn(vAux2, vAux2, vAux1);
-                        uni_vpsubd(vmmAfterAxisPermMask, vmmAfterAxisPermMask, vAux2);
-                    }
+            auto& vAux2 = vmmAuxContainer[2];
+            // Calculate permute mask
+            uni_vmovd(xAux0, reg32Aux2);
+            uni_vpbroadcastd(vAux1, xAux0);
+            mov(regAux1, reinterpret_cast<uintptr_t>(&idxElPerVec));
+            uni_vpbroadcastd(vAux0, ptr[regAux1]);
+            uni_vpsubd(vmmAfterAxisPermMask, vAux0, vAux1);
+            mov(regAux1, reinterpret_cast<uintptr_t>(incVec));
+            uni_vpaddd(vmmAfterAxisPermMask, vmmAfterAxisPermMask, ptr[regAux1]);
+            for (int i = 0; i < 6; i++) {
+                if (isa == x64::avx512_core) {
+                    Xbyak::Opmask kMask2 = Xbyak::Opmask(vAux2.getIdx());
+                    vpcmpgtd(kMask2, vAux0, vmmAfterAxisPermMask);
+                    uni_vpsubd(vmmAfterAxisPermMask | kMask2, vmmAfterAxisPermMask, vAux1);
+                } else {
+                    vpcmpgtd(vAux2, vAux0, vmmAfterAxisPermMask);
+                    vpandn(vAux2, vAux2, vAux1);
+                    uni_vpsubd(vmmAfterAxisPermMask, vmmAfterAxisPermMask, vAux2);
                 }
+            }
 
-                process(true, true);
+            process(true, true);
             L(lE2);
         }
         L(lEnd);
@@ -323,7 +357,7 @@ void jitUniGatherKernel<x64::avx512_core>::normalizeRawIndices(Vmm& vRawIndices,
     }
     // Check boundaries.
     vpcmpgtd(kAuxMask, vmmAxisDim, vRawIndices);
-    vpcmpd(kDstMask | kAuxMask, vmmZeros, vRawIndices, 2); // 2 - LE
+    vpcmpd(kDstMask | kAuxMask, vmmZeros, vRawIndices, 2);  // 2 - LE
     // Multiply by type size.
     if (jcp.dataTypeSize > 1)
         uni_vpslld(vRawIndices, vRawIndices, dataTypeShift);
@@ -338,7 +372,7 @@ void jitUniGatherKernel<x64::avx2>::normWithUpperBound(Vmm& vTarget, Vmm& vMax,
 
 template <>
 void jitUniGatherKernel<x64::avx512_core>::normWithUpperBound(Vmm& vTarget, Vmm& vMax, Vmask& kAuxMask) {
-    vpcmpd(kAuxMask, vMax, vTarget, 2); // 2 -> LE
+    vpcmpd(kAuxMask, vMax, vTarget, 2);  // 2 -> LE
     uni_vpsubd(vTarget | kAuxMask, vTarget, vMax);
 }
 
@@ -359,77 +393,77 @@ void jitUniGatherKernel<x64::avx2>::calcSrcShiftLong(Vmm* vAuxPool, bool shiftFi
     add(regIdxIter, vlen);
     cmp(regIdxIter, regSpecIdxSizeB);
     jge(lIdxStride, T_NEAR);
+    if (jcp.batchDims > 0lu) {
+        uni_vpaddd(vDstShifts, vmmIdxBatchSumB, vmmSpecIdxB);
+        uni_vmovd(reg32Aux1, xmmAuxContainer[vDstShifts.getIdx()]);
+    } else {
+        uni_vmovd(reg32Aux1, xmmSpecIdxB);
+    }
+    vmovdqu(vDstShifts, ptr[regIndices + regAux1]);
+    normalizeRawIndices(vDstShifts, kDstMask, kAuxMask0);
+    if (jcp.beforeAxisSize != 1lu)
+        uni_vpaddd(vDstShifts, vDstShifts, vmmSrcBeforeAxisSumB);
+    jmp(lExit, T_NEAR);
+    L(lIdxStride);
+    sub(regIdxIter, regSpecIdxSizeB);
+    vpcmpeqd(kDstMask, vAux0, vAux0);
+    if (shiftFirst) {
+        vpcmpgtd(vAux0, vmmSpecIdxSizeB, vmmSpecIdxB);
+        vpandn(vAux1, vAux0, vmmSpecIdxSizeB);
+        uni_vpsubd(vAux1, vmmSpecIdxB, vAux1);
+        if (jcp.batchDims > 0lu)
+            uni_vpaddd(vAux1, vmmIdxBatchSumB, vAux1);
+        uni_vpsubd(vmmSpecIdxB, vmmSpecIdxB, vmmSpecIdxSizeB);
+    } else {
         if (jcp.batchDims > 0lu) {
-            uni_vpaddd(vDstShifts, vmmIdxBatchSumB, vmmSpecIdxB);
-            uni_vmovd(reg32Aux1, xmmAuxContainer[vDstShifts.getIdx()]);
+            uni_vpaddd(vAux0, vmmIdxBatchSumB, vmmSpecIdxB);
+            uniVpGatherDd(vDstShifts, ptr[regIndices + vAux0], kDstMask);
         } else {
-            uni_vmovd(reg32Aux1, xmmSpecIdxB);
+            uniVpGatherDd(vDstShifts, ptr[regIndices + vmmSpecIdxB], kDstMask);
         }
-        vmovdqu(vDstShifts, ptr[regIndices + regAux1]);
         normalizeRawIndices(vDstShifts, kDstMask, kAuxMask0);
-        if (jcp.beforeAxisSize != 1lu)
-            uni_vpaddd(vDstShifts, vDstShifts, vmmSrcBeforeAxisSumB);
-    jmp(lExit, T_NEAR);
-    L(lIdxStride);
-        sub(regIdxIter, regSpecIdxSizeB);
-        vpcmpeqd(kDstMask, vAux0, vAux0);
-        if (shiftFirst) {
-            vpcmpgtd(vAux0, vmmSpecIdxSizeB, vmmSpecIdxB);
-            vpandn(vAux1, vAux0, vmmSpecIdxSizeB);
-            uni_vpsubd(vAux1, vmmSpecIdxB, vAux1);
-            if (jcp.batchDims > 0lu)
-                uni_vpaddd(vAux1, vmmIdxBatchSumB, vAux1);
-            uni_vpsubd(vmmSpecIdxB, vmmSpecIdxB, vmmSpecIdxSizeB);
-        } else {
-            if (jcp.batchDims > 0lu) {
-                uni_vpaddd(vAux0, vmmIdxBatchSumB, vmmSpecIdxB);
-                uniVpGatherDd(vDstShifts, ptr[regIndices + vAux0], kDstMask);
-            } else {
-                uniVpGatherDd(vDstShifts, ptr[regIndices + vmmSpecIdxB], kDstMask);
-            }
-            normalizeRawIndices(vDstShifts, kDstMask, kAuxMask0);
 
-            uni_vpbroadcastd(vAux0, xmmSpecIdxB);
-            vpcmpgtd(vAux1, vAux0, vmmSpecIdxB);
-            vpandn(vAux0, vAux1, vmmSpecIdxSizeB);
-            uni_vpsubd(vmmSpecIdxB, vmmSpecIdxB, vAux0);
+        uni_vpbroadcastd(vAux0, xmmSpecIdxB);
+        vpcmpgtd(vAux1, vAux0, vmmSpecIdxB);
+        vpandn(vAux0, vAux1, vmmSpecIdxSizeB);
+        uni_vpsubd(vmmSpecIdxB, vmmSpecIdxB, vAux0);
 
-            if (jcp.beforeAxisSize != 1lu) {
-                uni_vpaddd(vDstShifts, vDstShifts, vmmSrcBeforeAxisSumB);
-                vpandn(vAux0, vAux1, vmmAxisAndAfterAxisSizeB);
-                uni_vpaddd(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, vAux0);
-            }
+        if (jcp.beforeAxisSize != 1lu) {
+            uni_vpaddd(vDstShifts, vDstShifts, vmmSrcBeforeAxisSumB);
+            vpandn(vAux0, vAux1, vmmAxisAndAfterAxisSizeB);
+            uni_vpaddd(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, vAux0);
         }
+    }
 
-        if (jcp.batchDims > 0lu) {
-            Xbyak::Label l1;
-            inc(regBetweenBatchAndAxisIter);
-            cmp(regBetweenBatchAndAxisIter, regBetweenBatchAndAxisSize);
-            jl(l1, T_NEAR);
-                mov(regBetweenBatchAndAxisIter, 0);
-                if (shiftFirst) {
-                    uni_vpaddd(vmmIdxBatchSumB, vmmIdxBatchSumB, vmmSpecIdxSizeB);
-                    vpandn(vDstShifts, vAux0, vmmSpecIdxSizeB);
-                    uni_vpaddd(vAux1, vAux1, vDstShifts);
-                } else {
-                    vpandn(vAux0, vAux1, vmmSpecIdxSizeB);
-                    uni_vpaddd(vmmIdxBatchSumB, vmmIdxBatchSumB, vAux0);
-                }
-            L(l1);
+    if (jcp.batchDims > 0lu) {
+        Xbyak::Label l1;
+        inc(regBetweenBatchAndAxisIter);
+        cmp(regBetweenBatchAndAxisIter, regBetweenBatchAndAxisSize);
+        jl(l1, T_NEAR);
+        mov(regBetweenBatchAndAxisIter, 0);
+        if (shiftFirst) {
+            uni_vpaddd(vmmIdxBatchSumB, vmmIdxBatchSumB, vmmSpecIdxSizeB);
+            vpandn(vDstShifts, vAux0, vmmSpecIdxSizeB);
+            uni_vpaddd(vAux1, vAux1, vDstShifts);
+        } else {
+            vpandn(vAux0, vAux1, vmmSpecIdxSizeB);
+            uni_vpaddd(vmmIdxBatchSumB, vmmIdxBatchSumB, vAux0);
         }
+        L(l1);
+    }
 
-        if (shiftFirst) {
-            uniVpGatherDd(vDstShifts, ptr[regIndices + vAux1], kDstMask);
-            normalizeRawIndices(vDstShifts, kDstMask, kAuxMask0);
+    if (shiftFirst) {
+        uniVpGatherDd(vDstShifts, ptr[regIndices + vAux1], kDstMask);
+        normalizeRawIndices(vDstShifts, kDstMask, kAuxMask0);
 
-            if (jcp.beforeAxisSize != 1lu) {
-                vpandn(vAux0, vAux0, vmmAxisAndAfterAxisSizeB);
-                uni_vpaddd(vAux0, vAux0, vmmSrcBeforeAxisSumB);
-                uni_vpaddd(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, vmmAxisAndAfterAxisSizeB);
+        if (jcp.beforeAxisSize != 1lu) {
+            vpandn(vAux0, vAux0, vmmAxisAndAfterAxisSizeB);
+            uni_vpaddd(vAux0, vAux0, vmmSrcBeforeAxisSumB);
+            uni_vpaddd(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, vmmAxisAndAfterAxisSizeB);
 
-                uni_vpaddd(vDstShifts, vDstShifts, vAux0);
-            }
+            uni_vpaddd(vDstShifts, vDstShifts, vAux0);
         }
+    }
     L(lExit);
 }
 
@@ -451,81 +485,81 @@ void jitUniGatherKernel<x64::avx512_core>::calcSrcShiftLong(Vmm* vAuxPool, bool
     add(regIdxIter, vlen);
     cmp(regIdxIter, regSpecIdxSizeB);
     jge(lIdxStride, T_NEAR);
+    if (jcp.batchDims > 0lu) {
+        uni_vpaddd(vDstShifts, vmmIdxBatchSumB, vmmSpecIdxB);
+        uni_vmovd(reg32Aux1, xmmAuxContainer[vDstShifts.getIdx()]);
+    } else {
+        uni_vmovd(reg32Aux1, xmmSpecIdxB);
+    }
+    vmovdqu64(vDstShifts, ptr[regIndices + regAux1]);
+    normalizeRawIndices(vDstShifts, kDstMask, kAuxMask0);
+    if (jcp.beforeAxisSize != 1lu)
+        uni_vpaddd(vDstShifts, vDstShifts, vmmSrcBeforeAxisSumB);
+    jmp(lExit, T_NEAR);
+    L(lIdxStride);
+    sub(regIdxIter, regSpecIdxSizeB);
+    vpcmpeqd(kDstMask, vDstShifts, vDstShifts);
+    if (shiftFirst) {
+        vpcmpd(kAuxMask1, vmmSpecIdxSizeB, vmmSpecIdxB, 2);  // 2 -> LE
         if (jcp.batchDims > 0lu) {
-            uni_vpaddd(vDstShifts, vmmIdxBatchSumB, vmmSpecIdxB);
-            uni_vmovd(reg32Aux1, xmmAuxContainer[vDstShifts.getIdx()]);
+            uni_vpaddd(vAux1, vmmIdxBatchSumB, vmmSpecIdxB);
+            uni_vpsubd(vAux1 | kAuxMask1, vAux1, vmmSpecIdxSizeB);
         } else {
-            uni_vmovd(reg32Aux1, xmmSpecIdxB);
+            uni_vmovups(vAux1, vmmSpecIdxB);
+            uni_vpsubd(vAux1 | kAuxMask1, vmmSpecIdxB, vmmSpecIdxSizeB);
         }
-        vmovdqu64(vDstShifts, ptr[regIndices + regAux1]);
-        normalizeRawIndices(vDstShifts, kDstMask, kAuxMask0);
-        if (jcp.beforeAxisSize != 1lu)
-            uni_vpaddd(vDstShifts, vDstShifts, vmmSrcBeforeAxisSumB);
-    jmp(lExit, T_NEAR);
-    L(lIdxStride);
-        sub(regIdxIter, regSpecIdxSizeB);
-        vpcmpeqd(kDstMask, vDstShifts, vDstShifts);
-        if (shiftFirst) {
-            vpcmpd(kAuxMask1, vmmSpecIdxSizeB, vmmSpecIdxB, 2); // 2 -> LE
-            if (jcp.batchDims > 0lu) {
-                uni_vpaddd(vAux1, vmmIdxBatchSumB, vmmSpecIdxB);
-                uni_vpsubd(vAux1 | kAuxMask1, vAux1, vmmSpecIdxSizeB);
-            } else {
-                uni_vmovups(vAux1, vmmSpecIdxB);
-                uni_vpsubd(vAux1 | kAuxMask1, vmmSpecIdxB, vmmSpecIdxSizeB);
-            }
-            uni_vpsubd(vmmSpecIdxB, vmmSpecIdxB, vmmSpecIdxSizeB);
+        uni_vpsubd(vmmSpecIdxB, vmmSpecIdxB, vmmSpecIdxSizeB);
+    } else {
+        if (jcp.batchDims > 0lu) {
+            uni_vpaddd(vAux0, vmmIdxBatchSumB, vmmSpecIdxB);
+            uniVpGatherDd(vDstShifts, ptr[regIndices + vAux0], kDstMask);
         } else {
-            if (jcp.batchDims > 0lu) {
-                uni_vpaddd(vAux0, vmmIdxBatchSumB, vmmSpecIdxB);
-                uniVpGatherDd(vDstShifts, ptr[regIndices + vAux0], kDstMask);
-            } else {
-                uniVpGatherDd(vDstShifts, ptr[regIndices + vmmSpecIdxB], kDstMask);
-            }
-            normalizeRawIndices(vDstShifts, kDstMask, kAuxMask0);
+            uniVpGatherDd(vDstShifts, ptr[regIndices + vmmSpecIdxB], kDstMask);
+        }
+        normalizeRawIndices(vDstShifts, kDstMask, kAuxMask0);
 
-            uni_vpbroadcastd(vAux0, xmmSpecIdxB);
-            vpcmpd(kAuxMask1, vAux0, vmmSpecIdxB, 2); // 2 -> LE
-            uni_vpsubd(vmmSpecIdxB | kAuxMask1, vmmSpecIdxB, vmmSpecIdxSizeB);
+        uni_vpbroadcastd(vAux0, xmmSpecIdxB);
+        vpcmpd(kAuxMask1, vAux0, vmmSpecIdxB, 2);  // 2 -> LE
+        uni_vpsubd(vmmSpecIdxB | kAuxMask1, vmmSpecIdxB, vmmSpecIdxSizeB);
 
-            if (jcp.beforeAxisSize != 1lu) {
-                uni_vpaddd(vDstShifts, vDstShifts, vmmSrcBeforeAxisSumB);
-                uni_vpaddd(vmmSrcBeforeAxisSumB | kAuxMask1, vmmSrcBeforeAxisSumB, vmmAxisAndAfterAxisSizeB);
-            }
+        if (jcp.beforeAxisSize != 1lu) {
+            uni_vpaddd(vDstShifts, vDstShifts, vmmSrcBeforeAxisSumB);
+            uni_vpaddd(vmmSrcBeforeAxisSumB | kAuxMask1, vmmSrcBeforeAxisSumB, vmmAxisAndAfterAxisSizeB);
         }
+    }
 
-        if (jcp.batchDims > 0lu) {
-            Xbyak::Label l1;
-            inc(regBetweenBatchAndAxisIter);
-            cmp(regBetweenBatchAndAxisIter, regBetweenBatchAndAxisSize);
-            jl(l1, T_NEAR);
-                mov(regBetweenBatchAndAxisIter, 0);
-                if (shiftFirst) {
-                    uni_vpaddd(vmmIdxBatchSumB, vmmIdxBatchSumB, vmmSpecIdxSizeB);
-                    uni_vpaddd(vAux1 | kAuxMask1, vAux1, vmmSpecIdxSizeB);
-                } else {
-                    uni_vpaddd(vmmIdxBatchSumB | kAuxMask1, vmmIdxBatchSumB, vmmSpecIdxSizeB);
-                }
-            L(l1);
+    if (jcp.batchDims > 0lu) {
+        Xbyak::Label l1;
+        inc(regBetweenBatchAndAxisIter);
+        cmp(regBetweenBatchAndAxisIter, regBetweenBatchAndAxisSize);
+        jl(l1, T_NEAR);
+        mov(regBetweenBatchAndAxisIter, 0);
+        if (shiftFirst) {
+            uni_vpaddd(vmmIdxBatchSumB, vmmIdxBatchSumB, vmmSpecIdxSizeB);
+            uni_vpaddd(vAux1 | kAuxMask1, vAux1, vmmSpecIdxSizeB);
+        } else {
+            uni_vpaddd(vmmIdxBatchSumB | kAuxMask1, vmmIdxBatchSumB, vmmSpecIdxSizeB);
         }
+        L(l1);
+    }
 
-        if (shiftFirst) {
-            uniVpGatherDd(vDstShifts, ptr[regIndices + vAux1], kDstMask);
-            normalizeRawIndices(vDstShifts, kDstMask, kAuxMask0);
+    if (shiftFirst) {
+        uniVpGatherDd(vDstShifts, ptr[regIndices + vAux1], kDstMask);
+        normalizeRawIndices(vDstShifts, kDstMask, kAuxMask0);
 
-            if (jcp.beforeAxisSize != 1lu) {
-                uni_vpaddd(vDstShifts, vDstShifts, vmmSrcBeforeAxisSumB);
-                uni_vpaddd(vDstShifts | kAuxMask1, vDstShifts, vmmAxisAndAfterAxisSizeB);
-                uni_vpaddd(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, vmmAxisAndAfterAxisSizeB);
-            }
+        if (jcp.beforeAxisSize != 1lu) {
+            uni_vpaddd(vDstShifts, vDstShifts, vmmSrcBeforeAxisSumB);
+            uni_vpaddd(vDstShifts | kAuxMask1, vDstShifts, vmmAxisAndAfterAxisSizeB);
+            uni_vpaddd(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, vmmAxisAndAfterAxisSizeB);
         }
+    }
     L(lExit);
 }
 
 template <x64::cpu_isa_t isa>
 void jitUniGatherKernel<isa>::calcSrcShiftLongBlock(Vmm* vAuxPool, bool shiftFirst) {
-    // Most likely there will no significant performance gain vs memcpy in reference implementation on big blocks after axis,
-    // therefore no time was invested to this case yet.
+    // Most likely there will no significant performance gain vs memcpy in reference implementation on big blocks after
+    // axis, therefore no time was invested to this case yet.
     OPENVINO_THROW("Unsupported case.");
 }
 
@@ -541,7 +575,8 @@ void jitUniGatherKernel<isa>::calcSrcShiftShort(Vmm* vAuxPool, bool shiftFirst)
         if (jcp.beforeAxisSize != 1lu)
             uni_vpaddd(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, vmmBeforeAxDiffB);
         // No sense to permute if specIdxSize is one of {1, 2, 4, 8, 16}. 0 is reserved for dynamic case.
-        if (jcp.specIdxSize != 1 && jcp.specIdxSize != 2 && jcp.specIdxSize != 4 && jcp.specIdxSize != 8 && jcp.specIdxSize != 16) {
+        if (jcp.specIdxSize != 1 && jcp.specIdxSize != 2 && jcp.specIdxSize != 4 && jcp.specIdxSize != 8 &&
+            jcp.specIdxSize != 16) {
             vpermd(vmmSpecIdxB, vmmPermIdxMask, vmmSpecIdxB);
             if (jcp.beforeAxisSize != 1lu)
                 vpermd(vmmBeforeAxDiffB, vmmPermIdxMask, vmmBeforeAxDiffB);
@@ -588,7 +623,8 @@ void jitUniGatherKernel<isa>::calcSrcShiftShortBlock(Vmm* vAuxPool, bool shiftFi
             normWithUpperBound(vmmSpecIdxB, vmmSpecIdxSizeB, kAuxMask0);
         }
         // No sense to permute if afterAxisSize is one of {1, 2, 4, 8, 16}. 0 is reserved for dynamic case.
-        if (jcp.afterAxisSize != 1 && jcp.afterAxisSize != 2 && jcp.afterAxisSize != 4 && jcp.afterAxisSize != 8 && jcp.afterAxisSize != 16) {
+        if (jcp.afterAxisSize != 1 && jcp.afterAxisSize != 2 && jcp.afterAxisSize != 4 && jcp.afterAxisSize != 8 &&
+            jcp.afterAxisSize != 16) {
             vpermd(vmmAfterAxisIdxB, vmmAfterAxisPermMask, vmmAfterAxisIdxB);
             if (jcp.specIdxSize != 1)
                 vpermd(vmmSpecIdxDiff, vmmAfterAxisPermMask, vmmSpecIdxDiff);
@@ -600,33 +636,33 @@ void jitUniGatherKernel<isa>::calcSrcShiftShortBlock(Vmm* vAuxPool, bool shiftFi
                     uni_vpaddd(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, vmmBeforeAxDiffB);
                     uni_vmovups(vAux1, vmmSrcBeforeAxisSumB);
                     if (specIdxAndAfterAxisSize != 1 && specIdxAndAfterAxisSize != 2 && specIdxAndAfterAxisSize != 4 &&
-                            specIdxAndAfterAxisSize != 8 && specIdxAndAfterAxisSize != 16)
+                        specIdxAndAfterAxisSize != 8 && specIdxAndAfterAxisSize != 16)
                         vpermd(vmmBeforeAxDiffB, vmmBeforeAxPermMask, vmmBeforeAxDiffB);
                 } else {
                     Xbyak::Label lBeforeAxStep, lBeforeAxStepEnd;
                     add(rSpecIdxAndAfterAxIterB, idxElPerVec * jcp.dataTypeSize);
                     cmp(rSpecIdxAndAfterAxIterB, rSpecIdxAndAfterAxSizeB);
                     jl(lBeforeAxStep, T_NEAR);
-                        sub(rSpecIdxAndAfterAxIterB, rSpecIdxAndAfterAxSizeB);
-
-                        vpmulld(vAux0, vmmSpecIdxB, vmmAfterAxisSize);
-                        uni_vpaddd(vAux0, vAux0, vmmAfterAxisIdxB);
-                        Xbyak::Xmm& xAux0 = xmmAuxContainer[vAux0.getIdx()];
-                        uni_vpbroadcastd(vAux1, xAux0);
-                        if (isa == x64::avx512_core) {
-                            Xbyak::Opmask kMask0 = Xbyak::Opmask(kAuxMask0.getIdx());
-                            vpcmpgtd(kMask0, vAux1, vAux0);
-                            uni_vmovups(vAux1, vmmSrcBeforeAxisSumB);
-                            uni_vpaddd(vAux1 | kMask0, vmmSrcBeforeAxisSumB, vmmAxisAndAfterAxisSizeB);
-                        } else {
-                            vpcmpgtd(vAux1, vAux1, vAux0);
-                            vpand(vAux1, vAux1, vmmAxisAndAfterAxisSizeB);
-                            uni_vpaddd(vAux1, vmmSrcBeforeAxisSumB, vAux1);
-                        }
-                        uni_vpaddd(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, vmmAxisAndAfterAxisSizeB);
-                        jmp(lBeforeAxStepEnd);
-                    L(lBeforeAxStep);
+                    sub(rSpecIdxAndAfterAxIterB, rSpecIdxAndAfterAxSizeB);
+
+                    vpmulld(vAux0, vmmSpecIdxB, vmmAfterAxisSize);
+                    uni_vpaddd(vAux0, vAux0, vmmAfterAxisIdxB);
+                    Xbyak::Xmm& xAux0 = xmmAuxContainer[vAux0.getIdx()];
+                    uni_vpbroadcastd(vAux1, xAux0);
+                    if (isa == x64::avx512_core) {
+                        Xbyak::Opmask kMask0 = Xbyak::Opmask(kAuxMask0.getIdx());
+                        vpcmpgtd(kMask0, vAux1, vAux0);
                         uni_vmovups(vAux1, vmmSrcBeforeAxisSumB);
+                        uni_vpaddd(vAux1 | kMask0, vmmSrcBeforeAxisSumB, vmmAxisAndAfterAxisSizeB);
+                    } else {
+                        vpcmpgtd(vAux1, vAux1, vAux0);
+                        vpand(vAux1, vAux1, vmmAxisAndAfterAxisSizeB);
+                        uni_vpaddd(vAux1, vmmSrcBeforeAxisSumB, vAux1);
+                    }
+                    uni_vpaddd(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, vmmAxisAndAfterAxisSizeB);
+                    jmp(lBeforeAxStepEnd);
+                    L(lBeforeAxStep);
+                    uni_vmovups(vAux1, vmmSrcBeforeAxisSumB);
                     L(lBeforeAxStepEnd);
                 }
             } else {
@@ -648,10 +684,10 @@ void jitUniGatherKernel<isa>::calcSrcShiftShortBlock(Vmm* vAuxPool, bool shiftFi
                 add(rSpecIdxAndAfterAxIterB, idxElPerVec * jcp.dataTypeSize);
                 cmp(rSpecIdxAndAfterAxIterB, rSpecIdxAndAfterAxSizeB);
                 jl(lBeforeAxStepEnd1, T_NEAR);
-                    sub(rSpecIdxAndAfterAxIterB, rSpecIdxAndAfterAxSizeB);
+                sub(rSpecIdxAndAfterAxIterB, rSpecIdxAndAfterAxSizeB);
                 cmp(rSpecIdxAndAfterAxIterB, 0);
                 jne(lBeforeAxStepEnd1, T_NEAR);
-                    uni_vpaddd(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, vmmAxisAndAfterAxisSizeB);
+                uni_vpaddd(vmmSrcBeforeAxisSumB, vmmSrcBeforeAxisSumB, vmmAxisAndAfterAxisSizeB);
                 L(lBeforeAxStepEnd1);
             }
         }
@@ -689,15 +725,15 @@ void jitUniGatherKernel<isa>::process(bool isShortIdx, bool blocked) {
     Xbyak::Label lTailProc, lEndProc;
     cmp(regWorkAmount, dataElPerVec);
     jl(lTailProc, T_NEAR);
-        if (jcp.dataTypeSize == 4)
-            process32b(isShortIdx, blocked);
-        else if (jcp.dataTypeSize == 2)
-            process16b(isShortIdx, blocked);
-        else if (jcp.dataTypeSize == 1)
-            process8b(isShortIdx, blocked);
+    if (jcp.dataTypeSize == 4)
+        process32b(isShortIdx, blocked);
+    else if (jcp.dataTypeSize == 2)
+        process16b(isShortIdx, blocked);
+    else if (jcp.dataTypeSize == 1)
+        process8b(isShortIdx, blocked);
     jmp(lEndProc, T_NEAR);
     L(lTailProc);
-        tail(isShortIdx, false, blocked);
+    tail(isShortIdx, false, blocked);
     L(lEndProc);
 }
 
@@ -735,11 +771,11 @@ void jitUniGatherKernel<isa>::process16b(bool isShortIdx, bool blocked) {
     if (isa == x64::avx512_core) {
         vPermMask = vmmAuxContainer[7];
         vShufMask = vmmAuxContainer[8];
-        vBuff0    = vmmAuxContainer[9];
+        vBuff0 = vmmAuxContainer[9];
     } else {
         vPermMask = vmmAuxContainer[1];
         vShufMask = vmmAuxContainer[4];
-        vBuff0    = vmmAuxContainer[5];
+        vBuff0 = vmmAuxContainer[5];
     }
 
     mov(regAux1, reinterpret_cast<uintptr_t>(shufMask16bitUni));
@@ -799,13 +835,13 @@ void jitUniGatherKernel<isa>::process8b(bool isShortIdx, bool blocked) {
     if (isa == x64::avx512_core) {
         vPermMask = vmmAuxContainer[7];
         vShufMask = vmmAuxContainer[8];
-        vBuff0    = vmmAuxContainer[9];
-        vBuff1    = vmmAuxContainer[10];
+        vBuff0 = vmmAuxContainer[9];
+        vBuff1 = vmmAuxContainer[10];
     } else {
         vPermMask = vmmAuxContainer[1];
         vShufMask = vmmAuxContainer[4];
-        vBuff0    = vmmAuxContainer[5];
-        vBuff1    = vmmAuxContainer[6];
+        vBuff0 = vmmAuxContainer[5];
+        vBuff1 = vmmAuxContainer[6];
     }
     mov(regAux1, reinterpret_cast<uintptr_t>(shufMask8bitUni));
     uni_vmovups(vShufMask, ptr[regAux1]);
@@ -951,24 +987,30 @@ void jitUniGatherKernel<isa>::tail(bool isShortIdx, bool shiftFirst, bool blocke
 }
 
 template <>
-void jitUniGatherKernel<x64::avx512_core>::fillRestWorkMask(Vmask& kDstMask, Vmm& vmmAux, const Xbyak::Reg64& rWorkRest,
-        const Xbyak::Reg64& rAux0, const Xbyak::Reg64& rAux1) {
+void jitUniGatherKernel<x64::avx512_core>::fillRestWorkMask(Vmask& kDstMask,
+                                                            Vmm& vmmAux,
+                                                            const Xbyak::Reg64& rWorkRest,
+                                                            const Xbyak::Reg64& rAux0,
+                                                            const Xbyak::Reg64& rAux1) {
     Xbyak::Label lKmov;
     Xbyak::Reg32 rOnes(rAux1.getIdx());
     mov(rOnes, 0x0000FFFF);
     cmp(rWorkRest, idxElPerVec);
     jge(lKmov);
-        Xbyak::Reg8 rShift(Xbyak::Operand::CL);
-        mov(rShift, idxElPerVec);
-        sub(rShift, rWorkRest);
-        shr(rOnes, rShift);
+    Xbyak::Reg8 rShift(Xbyak::Operand::CL);
+    mov(rShift, idxElPerVec);
+    sub(rShift, rWorkRest);
+    shr(rOnes, rShift);
     L(lKmov);
     kmovw(kDstMask, rOnes);
 }
 
 template <>
-void jitUniGatherKernel<x64::avx2>::fillRestWorkMask(Vmask& kDstMask, Vmm& vAux, const Xbyak::Reg64& rWorkRest,
-        const Xbyak::Reg64& rAux0, const Xbyak::Reg64& rAux1) {
+void jitUniGatherKernel<x64::avx2>::fillRestWorkMask(Vmask& kDstMask,
+                                                     Vmm& vAux,
+                                                     const Xbyak::Reg64& rWorkRest,
+                                                     const Xbyak::Reg64& rAux0,
+                                                     const Xbyak::Reg64& rAux1) {
     Xbyak::Label lEnd;
     mov(rAux0, rWorkRest);
     Xbyak::Reg32 rOnes(rAux1.getIdx());
@@ -990,7 +1032,10 @@ void jitUniGatherKernel<x64::avx2>::fillRestWorkMask(Vmask& kDstMask, Vmm& vAux,
 }
 
 template <x64::cpu_isa_t isa>
-void jitUniGatherKernel<isa>::storeVectorPart(const Xbyak::Reg64& rDst, const Xbyak::Reg64& rToStoreCounter, Vmm& vmmSrc, Vmm& vAux) {
+void jitUniGatherKernel<isa>::storeVectorPart(const Xbyak::Reg64& rDst,
+                                              const Xbyak::Reg64& rToStoreCounter,
+                                              Vmm& vmmSrc,
+                                              Vmm& vAux) {
     Xbyak::Label lEnd;
     Xbyak::Xmm xAux(vAux.getIdx());
     for (size_t j = 0; j < vlen / vlenXmm; j++) {
@@ -1025,7 +1070,7 @@ void jitUniGatherKernel<x64::avx512_core>::fillVlenVector() {
 template <>
 void jitUniGatherKernel<x64::avx2>::fillVlenVector() {
     vpcmpeqd(vmmVecLenB, vmmVecLenB, vmmVecLenB);
-    vpsrld(vmmVecLenB, vmmVecLenB, 31); // Right shift to 1.
+    vpsrld(vmmVecLenB, vmmVecLenB, 31);     // Right shift to 1.
     uni_vpslld(vmmVecLenB, vmmVecLenB, 5);  // Left shift to 32.
 }
 
@@ -1047,5 +1092,5 @@ bool jitUniGatherKernel<isa>::isSupportedConfiguration(uint64_t afterAxisSize) {
 template struct jitUniGatherKernel<x64::avx2>;
 template struct jitUniGatherKernel<x64::avx512_core>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/gather_uni_kernel.hpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/gather_uni_kernel.hpp
index 765efb17d091e2..de8cda30d06499 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/gather_uni_kernel.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/gather_uni_kernel.hpp
@@ -19,12 +19,11 @@
 //      1      |   X   |   X   |   X   |   X   |   X   |   X   |
 //--------------------------------------------------------------
 
-
 #pragma once
 
-#include "jit_kernel_base.hpp"
 #include "cpu/x64/jit_generator.hpp"
 #include "dnnl_types.h"
+#include "jit_kernel_base.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -71,8 +70,8 @@ struct gatherJitExecArgs {
 };
 
 struct jitGatherKernelBase {
-    void (*ker_)(const gatherJitExecArgs *);
-    void operator()(const gatherJitExecArgs *args) {
+    void (*ker_)(const gatherJitExecArgs*);
+    void operator()(const gatherJitExecArgs* args) {
         assert(ker_);
         ker_(args);
     }
@@ -120,8 +119,10 @@ struct jitUniGatherKernel : public jitGatherKernelBase, public dnnl::impl::cpu::
     bool isSupportedConfiguration(uint64_t afterAxisSize) override;
 
 protected:
-    using Vmm = typename dnnl::impl::utils::conditional<isa == dnnl::impl::cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
-    using Vmask = typename dnnl::impl::utils::conditional<isa == dnnl::impl::cpu::x64::avx2, Xbyak::Ymm, Xbyak::Opmask>::type;
+    using Vmm =
+        typename dnnl::impl::utils::conditional<isa == dnnl::impl::cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmask =
+        typename dnnl::impl::utils::conditional<isa == dnnl::impl::cpu::x64::avx2, Xbyak::Ymm, Xbyak::Opmask>::type;
     static const uint32_t vlenXmm = dnnl::impl::cpu::x64::cpu_isa_traits<dnnl::impl::cpu::x64::sse41>::vlen;
     static const uint32_t indicesTypeSize = sizeof(uint32_t);
     static const uint8_t idxTypeShift = 2;
@@ -155,7 +156,8 @@ struct jitUniGatherKernel : public jitGatherKernelBase, public dnnl::impl::cpu::
     // Masks pool. Do not use k0 with gather instruction!
     Vmask masksContainer[8] = {Vmask(0), Vmask(1), Vmask(2), Vmask(3), Vmask(4), Vmask(5), Vmask(6), Vmask(7)};
     // Auxiliary pool.
-    Vmm vmmAuxContainer[12] = {Vmm(0), Vmm(1), Vmm(2), Vmm(3), Vmm(4), Vmm(5), Vmm(6), /*AVX5*/ Vmm(16), Vmm(17), Vmm(18), Vmm(19), Vmm(20)};
+    Vmm vmmAuxContainer[12] =
+        {Vmm(0), Vmm(1), Vmm(2), Vmm(3), Vmm(4), Vmm(5), Vmm(6), /*AVX5*/ Vmm(16), Vmm(17), Vmm(18), Vmm(19), Vmm(20)};
     // Common.
     Vmm vmmZeros = Vmm(7);
     Vmm vmmSrcBeforeAxisSumB = Vmm(8);
@@ -165,13 +167,13 @@ struct jitUniGatherKernel : public jitGatherKernelBase, public dnnl::impl::cpu::
     Vmm vmmAxisAndAfterAxisSizeB = Vmm(12);
 
     // Only short.
-    Vmm  vmmSrcAfterBatchSizeB = Vmm(13);
-    Vmm  vmmPermIdxMask = Vmm(14);
+    Vmm vmmSrcAfterBatchSizeB = Vmm(13);
+    Vmm vmmPermIdxMask = Vmm(14);
     Vmm& vmmBeforeAxDiffB = vmmAxisAndAfterAxisSizeB;
     // Blocked short.
     Vmm& vmmSpecIdxDiff = vmmAuxContainer[4];
     Vmm& vmmAfterAxisSize = vmmAuxContainer[5];
-    Vmm  vmmAfterAxisIdxB = Vmm(15);
+    Vmm vmmAfterAxisIdxB = Vmm(15);
     Vmm& vmmAfterAxisPermMask = vmmPermIdxMask;
     Vmm& vmmBeforeAxPermMask = vmmAuxContainer[6];
     // Only long.
@@ -179,13 +181,13 @@ struct jitUniGatherKernel : public jitGatherKernelBase, public dnnl::impl::cpu::
     Vmm vmmIdxBatchSumB = Vmm(14);
 
     // XMM
-    Xbyak::Xmm xmmAuxContainer[6] = {Xbyak::Xmm(0), Xbyak::Xmm(1), Xbyak::Xmm(2), Xbyak::Xmm(3), Xbyak::Xmm(4), Xbyak::Xmm(16)};
+    Xbyak::Xmm xmmAuxContainer[6] =
+        {Xbyak::Xmm(0), Xbyak::Xmm(1), Xbyak::Xmm(2), Xbyak::Xmm(3), Xbyak::Xmm(4), Xbyak::Xmm(16)};
     Xbyak::Xmm xmmZeros = Xbyak::Xmm(vmmZeros.getIdx());
     Xbyak::Xmm xmmSrcBeforeAxisSum = Xbyak::Xmm(vmmSrcBeforeAxisSumB.getIdx());
     Xbyak::Xmm xmmSpecIdxSizeB = Xbyak::Xmm(vmmSpecIdxSizeB.getIdx());
     Xbyak::Xmm xmmSpecIdxB = Xbyak::Xmm(vmmSpecIdxB.getIdx());
 
-
     void calcSrcShiftLong(Vmm* vAuxPool, bool shiftFirst = true);
     void calcSrcShiftLongBlock(Vmm* vAuxPool, bool shiftFirst = true);
     void calcSrcShiftShort(Vmm* vAuxPool, bool shiftFirst = true);
@@ -199,7 +201,11 @@ struct jitUniGatherKernel : public jitGatherKernelBase, public dnnl::impl::cpu::
     // Aux functions.
     void normalizeRawIndices(Vmm& rawIndices, Vmask& dstMask, Vmask& aux);
     void normWithUpperBound(Vmm& vTarget, Vmm& vMax, Vmask& kAuxMask);
-    void fillRestWorkMask(Vmask& kMask, Vmm& vAux, const Xbyak::Reg64& rWorkRest, const Xbyak::Reg64& rAux0, const Xbyak::Reg64& rAux1);
+    void fillRestWorkMask(Vmask& kMask,
+                          Vmm& vAux,
+                          const Xbyak::Reg64& rWorkRest,
+                          const Xbyak::Reg64& rAux0,
+                          const Xbyak::Reg64& rAux1);
     void storeVectorPart(const Xbyak::Reg64& rDst, const Xbyak::Reg64& rToStoreCounter, Vmm& vmmSrc, Vmm& vAux);
     void uniVpGatherDd(Vmm& vDst, const Xbyak::Address& srcAddr, Vmask& vMask);
     void fillVlenVector();
@@ -208,5 +214,5 @@ struct jitUniGatherKernel : public jitGatherKernelBase, public dnnl::impl::cpu::
     const unsigned* permMask16bitUni;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/grid_sample.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/grid_sample.cpp
index d91688689b86c0..908de00cbb0534 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/grid_sample.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/grid_sample.cpp
@@ -13,8 +13,8 @@ namespace kernel {
 #define GET_OFF(field) offsetof(GridSamplesKernelExecArgs, field)
 
 template <x64::cpu_isa_t isa>
-GridSampleKernel<isa>::GridSampleKernel(const GridSampleKernelConfParams& jcp) :
-        GridSampleKernelBase(jit_name(), jcp, isa) {
+GridSampleKernel<isa>::GridSampleKernel(const GridSampleKernelConfParams& jcp)
+    : GridSampleKernelBase(jit_name(), jcp, isa) {
     vlen = x64::cpu_isa_traits<isa>::vlen;
     dataTypeSize = jcp.inDataPrc.size();
     gridTypeSize = jcp.gridPrc.size();
@@ -39,15 +39,15 @@ void GridSampleKernel<isa>::generate() {
     this->preamble();
     registersPool = RegistersPool::create(isa, {rax, rcx, rsp, rdi, k0});
 
-    regSrc  = getReg64();
+    regSrc = getReg64();
     regGrid = getReg64();
-    regDst  = getReg64();
+    regDst = getReg64();
     regSrcChannelStepB = getReg64();
     regDstChannelStepB = getReg64();
 
-    mov(regSrc,  ptr[regParams + GET_OFF(src)]);
+    mov(regSrc, ptr[regParams + GET_OFF(src)]);
     mov(regGrid, ptr[regParams + GET_OFF(grid)]);
-    mov(regDst,  ptr[regParams + GET_OFF(dst)]);
+    mov(regDst, ptr[regParams + GET_OFF(dst)]);
     mov(regSrcChannelStepB, ptr[regParams + GET_OFF(srcChannelStepB)]);
     mov(regDstChannelStepB, ptr[regParams + GET_OFF(dstChannelStepB)]);
 
@@ -82,7 +82,7 @@ void GridSampleKernel<x64::avx512_core>::initVectors() {
 
     if (one_of(jcp.interpolationMode, GridSampleInterpolationMode::BICUBIC, GridSampleInterpolationMode::BILINEAR)) {
         vOnesF = getVmm();
-        mov(r32Aux, 0x3f800000); // 1.f
+        mov(r32Aux, 0x3f800000);  // 1.f
         vpbroadcastd(vOnesF, r32Aux);
     }
 
@@ -96,11 +96,11 @@ void GridSampleKernel<x64::avx512_core>::initVectors() {
         uni_vpbroadcastd(vHDenormCoefF, ptr[rAux]);
     } else {
         vHalfF = getVmm();
-        mov(r32Aux, 0x3f000000); // 0.5f
+        mov(r32Aux, 0x3f000000);  // 0.5f
         vpbroadcastd(vHalfF, r32Aux);
     }
 
-    static const unsigned gridPermMask[16]  = { 0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15 };
+    static const unsigned gridPermMask[16] = {0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13, 15};
     mov(rAux, reinterpret_cast<uintptr_t>(gridPermMask));
     vGridPermMask = getVmm();
     uni_vmovups(vGridPermMask, ptr[rAux]);
@@ -141,24 +141,24 @@ void GridSampleKernel<x64::avx512_core>::initVectors() {
 
     if (jcp.interpolationMode == GridSampleInterpolationMode::BICUBIC) {
         vConst_0_75 = getVmm();
-        mov(r32Aux, 0xbf400000); // -0.75f
+        mov(r32Aux, 0xbf400000);  // -0.75f
         vpbroadcastd(vConst_0_75, r32Aux);
         vConst_1_25 = getVmm();
-        mov(r32Aux, 0x3fa00000); // 1.25f
+        mov(r32Aux, 0x3fa00000);  // 1.25f
         vpbroadcastd(vConst_1_25, r32Aux);
         vConst_1_50 = getVmm();
-        mov(r32Aux, 0x3fc00000); // 1.5f
+        mov(r32Aux, 0x3fc00000);  // 1.5f
         vpbroadcastd(vConst_1_50, r32Aux);
         vConst_2_00 = getVmm();
-        mov(r32Aux, 0x40000000); // 2.0f
+        mov(r32Aux, 0x40000000);  // 2.0f
         vpbroadcastd(vConst_2_00, r32Aux);
         vConst_2_25 = getVmm();
-        mov(r32Aux, 0x40100000); // 2.25f
+        mov(r32Aux, 0x40100000);  // 2.25f
         vpbroadcastd(vConst_2_25, r32Aux);
     }
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX2, AVX, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX2, AVX, SSE41
 void GridSampleKernel<isa>::initVectors() {
     auto rAux = getReg64();
 
@@ -167,9 +167,10 @@ void GridSampleKernel<isa>::initVectors() {
     uni_vmovups(vSrcWidthF, ptr[rAux]);
 
     if (one_of(jcp.interpolationMode, GridSampleInterpolationMode::BILINEAR, GridSampleInterpolationMode::NEAREST) ||
-        (jcp.interpolationMode == GridSampleInterpolationMode::BICUBIC && (jcp.paddingMode == GridSamplePaddingMode::REFLECTION ||
-                                                                          (jcp.paddingMode == GridSamplePaddingMode::BORDER && !jcp.alignCorners) ||
-                                                                           jcp.paddingMode == GridSamplePaddingMode::ZEROS)) ) {
+        (jcp.interpolationMode == GridSampleInterpolationMode::BICUBIC &&
+         (jcp.paddingMode == GridSamplePaddingMode::REFLECTION ||
+          (jcp.paddingMode == GridSamplePaddingMode::BORDER && !jcp.alignCorners) ||
+          jcp.paddingMode == GridSamplePaddingMode::ZEROS))) {
         vSrcHeightF = getVmm();
         mov(rAux, ptr[regParams + GET_OFF(srcHeightF)]);
         uni_vmovups(vSrcHeightF, ptr[rAux]);
@@ -184,7 +185,8 @@ void GridSampleKernel<isa>::initVectors() {
 
     if (jcp.interpolationMode != GridSampleInterpolationMode::BICUBIC) {
         if (one_of(jcp.paddingMode, GridSamplePaddingMode::BORDER, GridSamplePaddingMode::ZEROS) &&
-            ((isa == x64::avx2 && jcp.interpolationMode == GridSampleInterpolationMode::NEAREST) || one_of(isa, x64::avx, x64::sse41))) {
+            ((isa == x64::avx2 && jcp.interpolationMode == GridSampleInterpolationMode::NEAREST) ||
+             one_of(isa, x64::avx, x64::sse41))) {
             vZeros = getVmm();
             uni_vpxor(vZeros, vZeros, vZeros);
         }
@@ -193,20 +195,21 @@ void GridSampleKernel<isa>::initVectors() {
             mov(rAux, ptr[regParams + GET_OFF(wDenormCoefF)]);
             vWDenormCoefF = getVmm();
             uni_vmovups(vWDenormCoefF, ptr[rAux]);
-            if (!(jcp.interpolationMode == GridSampleInterpolationMode::BILINEAR && jcp.paddingMode == GridSamplePaddingMode::ZEROS)) {
+            if (!(jcp.interpolationMode == GridSampleInterpolationMode::BILINEAR &&
+                  jcp.paddingMode == GridSamplePaddingMode::ZEROS)) {
                 mov(rAux, ptr[regParams + GET_OFF(hDenormCoefF)]);
                 vHDenormCoefF = getVmm();
                 uni_vmovups(vHDenormCoefF, ptr[rAux]);
             }
         } else {
-            static const float halfArr[8] = { 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f };
+            static const float halfArr[8] = {0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f};
             mov(rAux, reinterpret_cast<uintptr_t>(halfArr));
             vHalfF = getVmm();
             uni_vmovups(vHalfF, ptr[rAux]);
         }
 
         if (isa == x64::avx2 && jcp.interpolationMode == GridSampleInterpolationMode::NEAREST) {
-            static const unsigned gridPermMask[8]  = { 0, 2, 4, 6, 1, 3, 5, 7 };
+            static const unsigned gridPermMask[8] = {0, 2, 4, 6, 1, 3, 5, 7};
             mov(rAux, reinterpret_cast<uintptr_t>(gridPermMask));
             vGridPermMask = getVmm();
             uni_vmovups(vGridPermMask, ptr[rAux]);
@@ -214,15 +217,16 @@ void GridSampleKernel<isa>::initVectors() {
     }
 
     if (jcp.interpolationMode == GridSampleInterpolationMode::BICUBIC ||
-        (jcp.interpolationMode == GridSampleInterpolationMode::BILINEAR && jcp.paddingMode != GridSamplePaddingMode::ZEROS)) {
-        static const float onesArr[8] = { 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f };
+        (jcp.interpolationMode == GridSampleInterpolationMode::BILINEAR &&
+         jcp.paddingMode != GridSamplePaddingMode::ZEROS)) {
+        static const float onesArr[8] = {1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f};
         mov(rAux, reinterpret_cast<uintptr_t>(onesArr));
         vOnesF = getVmm();
         uni_vmovups(vOnesF, ptr[rAux]);
     }
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX512, AVX2, AVX, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX512, AVX2, AVX, SSE41
 void GridSampleKernel<isa>::process() {
     regWorkAmount = getReg64();
 
@@ -244,12 +248,12 @@ void GridSampleKernel<isa>::process() {
         spatialLoop();
 
         if (jcp.dynamicShapes) {
-            add(regSrc,  ptr[regParams + GET_OFF(srcBatchStepB)]);
+            add(regSrc, ptr[regParams + GET_OFF(srcBatchStepB)]);
         } else {
             add(regSrc, jcp.srcBatchStepB);
         }
         add(regGrid, ptr[regParams + GET_OFF(gridBatchStepB)]);
-        add(regDst,  ptr[regParams + GET_OFF(dstBatchStepB)]);
+        add(regDst, ptr[regParams + GET_OFF(dstBatchStepB)]);
 
         if (jcp.dynamicBatch) {
             dec(regBatch);
@@ -259,7 +263,7 @@ void GridSampleKernel<isa>::process() {
     }
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX512, AVX2, AVX, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX512, AVX2, AVX, SSE41
 void GridSampleKernel<isa>::spatialLoop() {
     auto vHCoord = getVmm();
     auto vWCoord = getVmm();
@@ -286,7 +290,7 @@ void GridSampleKernel<isa>::spatialLoop() {
     tail();
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX512, AVX2, AVX, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX512, AVX2, AVX, SSE41
 void GridSampleKernel<isa>::interpolation(const Vmm& vWCoord, const Vmm& vHCoord, bool tail) {
     if (jcp.interpolationMode == GridSampleInterpolationMode::BILINEAR) {
         bilinearInterpolation(vWCoord, vHCoord, tail);
@@ -297,7 +301,7 @@ void GridSampleKernel<isa>::interpolation(const Vmm& vWCoord, const Vmm& vHCoord
     }
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX512, AVX2, AVX, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX512, AVX2, AVX, SSE41
 void GridSampleKernel<isa>::tail() {
     Xbyak::Label lEnd;
     cmp(regWorkAmount, 0);
@@ -311,7 +315,7 @@ void GridSampleKernel<isa>::tail() {
     interpolation(vWCoord, vHCoord, true);
 
     if (dataTypeSize > 1)
-        sal(regWorkAmount, dataTypeShift); // Multiply by source data type size.
+        sal(regWorkAmount, dataTypeShift);  // Multiply by source data type size.
     add(regDst, regWorkAmount);
 
     L(lEnd);
@@ -319,15 +323,15 @@ void GridSampleKernel<isa>::tail() {
 
 template <>
 void GridSampleKernel<x64::avx512_core>::getCoordinates(const Vmm& vHCoord, const Vmm& vWCoord) {
-    vpermd(vWCoord, vGridPermMask, ptr[regGrid]);      // Permute to XXXX.XXXX.YYYY.YYYY
-    vshuff64x2(vHCoord, vWCoord, vHCoord, 0B11101110); // Extract Y component
+    vpermd(vWCoord, vGridPermMask, ptr[regGrid]);       // Permute to XXXX.XXXX.YYYY.YYYY
+    vshuff64x2(vHCoord, vWCoord, vHCoord, 0B11101110);  // Extract Y component
 
     add(regGrid, vlen);
 
     auto vAux = getVmm();
-    vpermd(vAux, vGridPermMask, ptr[regGrid]);         // Permute to XXXX.XXXX.YYYY.YYYY
-    vshuff64x2(vWCoord, vWCoord, vAux, 0B01000100);    // Extract X component
-    vshuff64x2(vHCoord, vHCoord, vAux, 0B11100100);    // Extract Y component
+    vpermd(vAux, vGridPermMask, ptr[regGrid]);       // Permute to XXXX.XXXX.YYYY.YYYY
+    vshuff64x2(vWCoord, vWCoord, vAux, 0B01000100);  // Extract X component
+    vshuff64x2(vHCoord, vHCoord, vAux, 0B11100100);  // Extract Y component
 
     add(regGrid, vlen);
 }
@@ -349,19 +353,19 @@ void GridSampleKernel<x64::avx2>::getCoordinates(const Vmm& vHCoord, const Vmm&
         uni_vmovups(vPermMask, ptr[rAux]);
     }
 
-    vpermd(vWCoord, vPermMask, ptr[regGrid]);          // Permute to XXXX.YYYY
-    vperm2f128(vHCoord, vHCoord, vWCoord, 0B00000011); // Extract Y component
+    vpermd(vWCoord, vPermMask, ptr[regGrid]);           // Permute to XXXX.YYYY
+    vperm2f128(vHCoord, vHCoord, vWCoord, 0B00000011);  // Extract Y component
 
     add(regGrid, vlen);
 
-    vpermd(vAux, vPermMask, ptr[regGrid]);             // Permute to XXXX.YYYY
-    vperm2f128(vWCoord, vWCoord, vAux, 0B00100000);    // Extract X component
-    vperm2f128(vHCoord, vHCoord, vAux, 0B00110000);    // Extract Y component
+    vpermd(vAux, vPermMask, ptr[regGrid]);           // Permute to XXXX.YYYY
+    vperm2f128(vWCoord, vWCoord, vAux, 0B00100000);  // Extract X component
+    vperm2f128(vHCoord, vHCoord, vAux, 0B00110000);  // Extract Y component
 
     add(regGrid, vlen);
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX, SSE41
 void GridSampleKernel<isa>::getCoordinates(const Vmm& vHCoord, const Vmm& vWCoord) {
     auto vAux = getVmm();
     Xbyak::Xmm xmmWCoord(vWCoord.getIdx());
@@ -417,12 +421,12 @@ void GridSampleKernel<x64::avx512_core>::getTailCoordinates(const Vmm& vHCoord,
     auto rAux = getReg64();
 
     mov(rAux, regWorkAmount);
-    sal(rAux, 0x1); // Multiply by gridShape[3].
+    sal(rAux, 0x1);  // Multiply by gridShape[3].
     cmp(regWorkAmount, dataElPerVec / 2);
     jl(lRest, T_NEAR);
     {
         vpermd(vWCoord, vGridPermMask, ptr[regGrid]);
-        vshuff64x2(vHCoord, vWCoord, vHCoord, 0B11101110); // Extract Y component
+        vshuff64x2(vHCoord, vWCoord, vHCoord, 0B11101110);  // Extract Y component
 
         add(regGrid, vlen);
         sub(rAux, dataElPerVec);
@@ -433,8 +437,8 @@ void GridSampleKernel<x64::avx512_core>::getTailCoordinates(const Vmm& vHCoord,
         uni_vmovups((Vmm)vAux | kTailMask, ptr[regGrid]);
         vpermd(vAux, vGridPermMask, vAux);
         Xbyak::Ymm ymmAux(vAux.getIdx());
-        vshuff64x2(vWCoord, vWCoord, vAux, 0B01000100);    // Extract X component
-        vshuff64x2(vHCoord, vHCoord, vAux, 0B11100100);    // Extract Y component
+        vshuff64x2(vWCoord, vWCoord, vAux, 0B01000100);  // Extract X component
+        vshuff64x2(vHCoord, vHCoord, vAux, 0B11100100);  // Extract Y component
 
         jmp(lGridShift, T_NEAR);
     }
@@ -443,12 +447,12 @@ void GridSampleKernel<x64::avx512_core>::getTailCoordinates(const Vmm& vHCoord,
         fillRestWorkMask(kTailMask, rAux);
         uni_vmovups(vWCoord | kTailMask, ptr[regGrid]);
         vpermd(vWCoord, vGridPermMask, vWCoord);
-        vshuff64x2(vHCoord, vWCoord, vHCoord, 0B11101110); // Extract Y component
+        vshuff64x2(vHCoord, vWCoord, vHCoord, 0B11101110);  // Extract Y component
     }
 
     L(lGridShift);
     if (dataTypeSize > 1)
-        sal(rAux, dataTypeShift); // Multiply by source data type size.
+        sal(rAux, dataTypeShift);  // Multiply by source data type size.
     add(regGrid, rAux);
 
     L(lEnd);
@@ -475,36 +479,36 @@ void GridSampleKernel<x64::avx2>::getTailCoordinates(const Vmm& vHCoord, const V
     }
 
     mov(rAux, regWorkAmount);
-    sal(rAux, 0x1); // multiply by gridShape[3] == 2
+    sal(rAux, 0x1);  // multiply by gridShape[3] == 2
     cmp(regWorkAmount, dataElPerVec / 2);
     jl(lRest, T_NEAR);
     {
-        vpermd(vWCoord, vPermMask, ptr[regGrid]);          // Permute to XXXX.YYYY
-        vperm2f128(vHCoord, vHCoord, vWCoord, 0B00000011); // Extract Y component
+        vpermd(vWCoord, vPermMask, ptr[regGrid]);           // Permute to XXXX.YYYY
+        vperm2f128(vHCoord, vHCoord, vWCoord, 0B00000011);  // Extract Y component
 
         add(regGrid, vlen);
         sub(rAux, dataElPerVec);
         cmp(rAux, 0);
         jle(lEnd, T_NEAR);
 
-        auto vAux  = getVmm();
+        auto vAux = getVmm();
         load(vAux, ptr[regGrid], rAux, dataTypeSize);
         vpermd(vAux, vPermMask, vAux);
-        vperm2f128(vWCoord, vWCoord, vAux, 0B00100000); // Extract X component
-        vperm2f128(vHCoord, vHCoord, vAux, 0B00110000); // Extract Y component
+        vperm2f128(vWCoord, vWCoord, vAux, 0B00100000);  // Extract X component
+        vperm2f128(vHCoord, vHCoord, vAux, 0B00110000);  // Extract Y component
 
         jmp(lGridShift, T_NEAR);
     }
     L(lRest);
     {
         load(vWCoord, ptr[regGrid], rAux, dataTypeSize);
-        vpermd(vWCoord, vPermMask, vWCoord);               // Permute to XXXX.YYYY
-        vperm2f128(vHCoord, vHCoord, vWCoord, 0B00000011); // Extract Y component
+        vpermd(vWCoord, vPermMask, vWCoord);                // Permute to XXXX.YYYY
+        vperm2f128(vHCoord, vHCoord, vWCoord, 0B00000011);  // Extract Y component
     }
 
     L(lGridShift);
     if (dataTypeSize > 1)
-        sal(rAux, dataTypeShift); // Multiply by source data type size.
+        sal(rAux, dataTypeShift);  // Multiply by source data type size.
     add(regGrid, rAux);
 
     L(lEnd);
@@ -519,7 +523,7 @@ void GridSampleKernel<x64::avx>::getTailCoordinates(const Vmm& vHCoord, const Vm
 
     auto rGridRest = getReg64();
     mov(rGridRest, regWorkAmount);
-    sal(rGridRest, 0x1); // multiply by gridShape[3] == 2
+    sal(rGridRest, 0x1);  // multiply by gridShape[3] == 2
 
     for (size_t i = 0; i < dataElPerVec; i++) {
         cmp(rGridRest, 0);
@@ -566,7 +570,7 @@ void GridSampleKernel<x64::sse41>::getTailCoordinates(const Vmm& vHCoord, const
     auto rAux = getReg64();
 
     mov(rAux, regWorkAmount);
-    sal(rAux, 0x1); // Multiply by gridShape[3] == 2
+    sal(rAux, 0x1);  // Multiply by gridShape[3] == 2
     cmp(regWorkAmount, dataElPerVec / 2);
     jl(lRest, T_NEAR);
     {
@@ -584,31 +588,31 @@ void GridSampleKernel<x64::sse41>::getTailCoordinates(const Vmm& vHCoord, const
         auto vAux = getVmm();
         load(vAux, ptr[regGrid], rAux, dataTypeSize);
         pshufd(vAux, vAux, 0B11011000);
-        shufpd(vWCoord, vAux, 0x0);        // Extract X component
-        shufpd(vHCoord, vAux, 0B00000011); // Extract Y component
+        shufpd(vWCoord, vAux, 0x0);         // Extract X component
+        shufpd(vHCoord, vAux, 0B00000011);  // Extract Y component
 
         jmp(lGridShift, T_NEAR);
         L(lHShuf);
-        shufpd(vHCoord, vHCoord, 0B00000001); // Extract Y component
+        shufpd(vHCoord, vHCoord, 0B00000001);  // Extract Y component
         jmp(lEnd, T_NEAR);
     }
     L(lRest);
     {
         load(vWCoord, ptr[regGrid], rAux, dataTypeSize);
-        pshufd(vWCoord, vWCoord, 0B11011000); // Extract X component
-        shufpd(vHCoord, vWCoord, 0B00000010); // Extract Y component
+        pshufd(vWCoord, vWCoord, 0B11011000);  // Extract X component
+        shufpd(vHCoord, vWCoord, 0B00000010);  // Extract Y component
         shufpd(vHCoord, vHCoord, 0B00000001);
     }
 
     L(lGridShift);
     if (dataTypeSize > 1)
-        sal(rAux, dataTypeShift); // Multiply by source data type size.
+        sal(rAux, dataTypeShift);  // Multiply by source data type size.
     add(regGrid, rAux);
 
     L(lEnd);
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX512, AVX2, AVX, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX512, AVX2, AVX, SSE41
 void GridSampleKernel<isa>::denormalizeRawCoordinates(const Vmm& vWCoord, const Vmm& vHCoord) {
     if (jcp.alignCorners) {
         if (vWDenormCoefF.isInitialized()) {
@@ -640,7 +644,7 @@ void GridSampleKernel<isa>::denormalizeRawCoordinates(const Vmm& vWCoord, const
             halfHolder = getVmm();
             vHalfTmp = halfHolder;
             static const float halfValues[x64::cpu_isa_traits<x64::avx512_core>::vlen / sizeof(float)] =
-                    { 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f };
+                {0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f, 0.5f};
             mov(rAux, reinterpret_cast<uintptr_t>(halfValues));
             uni_vmovups(vHalfTmp, ptr[rAux]);
         }
@@ -671,14 +675,14 @@ void GridSampleKernel<isa>::denormalizeRawCoordinates(const Vmm& vWCoord, const
 
 template <>
 void GridSampleKernel<x64::avx512_core>::zerosPaddingW(const Vmask& kDst, const Vmm& vCoord) {
-    vcmpps(kDst, vCoord, vSrcWidthF, CMP_LT_PS);    // vCoord < vUpperBound
-    vcmpps(kDst | kDst, vZeros, vCoord, CMP_LE_PS); // vCoord >= vZeros
+    vcmpps(kDst, vCoord, vSrcWidthF, CMP_LT_PS);     // vCoord < vUpperBound
+    vcmpps(kDst | kDst, vZeros, vCoord, CMP_LE_PS);  // vCoord >= vZeros
 }
 
 template <>
 void GridSampleKernel<x64::avx512_core>::zerosPaddingH(const Vmask& kDst, const Vmm& vCoord, const Vmask& kMaskW) {
-    vcmpps(kDst | kMaskW, vCoord, vSrcHeightF, CMP_LT_PS); // vCoord < vUpperBound
-    vcmpps(kDst | kDst, vZeros, vCoord, CMP_LE_PS);        // vCoord >= vZeros
+    vcmpps(kDst | kMaskW, vCoord, vSrcHeightF, CMP_LT_PS);  // vCoord < vUpperBound
+    vcmpps(kDst | kDst, vZeros, vCoord, CMP_LE_PS);         // vCoord >= vZeros
 }
 
 template <>
@@ -692,7 +696,7 @@ void GridSampleKernel<x64::sse41>::zerosPaddingW(const Vmask& kDst, const Vmm& v
     auto vAux = getVmm();
 
     if (vSrcWidthF.isInitialized()) {
-        uni_vcmpps(vAux, vWCoord, vSrcWidthF, CMP_LT_PS); // vWCoord < vSrcWidthF
+        uni_vcmpps(vAux, vWCoord, vSrcWidthF, CMP_LT_PS);  // vWCoord < vSrcWidthF
     } else {
         auto rAux = getReg64();
         mov(rAux, ptr[regParams + GET_OFF(srcWidthF)]);
@@ -700,8 +704,8 @@ void GridSampleKernel<x64::sse41>::zerosPaddingW(const Vmask& kDst, const Vmm& v
     }
 
     uni_vpxor(kDst, kDst, kDst);
-    uni_vcmpps(kDst, kDst, vWCoord, CMP_LE_PS);           // vWCoord >= vZeros
-    uni_vpand(kDst, kDst, vAux);                    // vZeros <= vWCoord < vSrcWidthF
+    uni_vcmpps(kDst, kDst, vWCoord, CMP_LE_PS);  // vWCoord >= vZeros
+    uni_vpand(kDst, kDst, vAux);                 // vZeros <= vWCoord < vSrcWidthF
 }
 
 template <>
@@ -709,18 +713,18 @@ void GridSampleKernel<x64::sse41>::zerosPaddingH(const Vmask& kDst, const Vmm& v
     auto vAux = getVmm();
 
     if (vSrcHeightF.isInitialized()) {
-        uni_vcmpps(vAux, vHCoord, vSrcHeightF, CMP_LT_PS); // vHCoord < vSrcHeightF
+        uni_vcmpps(vAux, vHCoord, vSrcHeightF, CMP_LT_PS);  // vHCoord < vSrcHeightF
     } else {
         auto rAux = getReg64();
         mov(rAux, ptr[regParams + GET_OFF(srcHeightF)]);
-        uni_vcmpps(vAux, vHCoord, ptr[rAux], CMP_LT_PS);   // vHCoord < vSrcHeightF
+        uni_vcmpps(vAux, vHCoord, ptr[rAux], CMP_LT_PS);  // vHCoord < vSrcHeightF
     }
 
     uni_vmovups(kDst, kMaskW);
-    uni_vpand(kDst, kDst, vAux); // vHCoord < vSrcHeightF && vZeros <= vWCoord < vSrcWidthF
+    uni_vpand(kDst, kDst, vAux);  // vHCoord < vSrcHeightF && vZeros <= vWCoord < vSrcWidthF
     uni_vpxor(vAux, vAux, vAux);
-    uni_vcmpps(vAux, vAux, vHCoord, CMP_LE_PS); // vHCoord >= vZeros
-    uni_vpand(kDst, kDst, vAux); // vZeros <= vHCoord < vSrcHeightF && vZeros <= vWCoord < vSrcWidthF
+    uni_vcmpps(vAux, vAux, vHCoord, CMP_LE_PS);  // vHCoord >= vZeros
+    uni_vpand(kDst, kDst, vAux);                 // vZeros <= vHCoord < vSrcHeightF && vZeros <= vWCoord < vSrcWidthF
 }
 
 template <>
@@ -729,7 +733,7 @@ void GridSampleKernel<x64::sse41>::zerosPadding(const Vmask& kDst, const Vmm& vH
     zerosPaddingH(kDst, vHCoord, kDst);
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX2, AVX
+template <x64::cpu_isa_t isa>  // Works for AVX2, AVX
 void GridSampleKernel<isa>::zerosPaddingW(const Vmask& kDst, const Vmm& vCoord) {
     auto vAux = getVmm();
     Vmm vZerosTmp;
@@ -743,18 +747,18 @@ void GridSampleKernel<isa>::zerosPaddingW(const Vmask& kDst, const Vmm& vCoord)
     }
 
     if (vSrcWidthF.isInitialized()) {
-        uni_vcmpps(vAux, vCoord, vSrcWidthF, CMP_LT_PS); // vWCoord < vSrcWidthF
+        uni_vcmpps(vAux, vCoord, vSrcWidthF, CMP_LT_PS);  // vWCoord < vSrcWidthF
     } else {
         auto rAux = getReg64();
         mov(rAux, ptr[regParams + GET_OFF(srcWidthF)]);
         uni_vcmpps(vAux, vCoord, ptr[rAux], CMP_LT_PS);  // vWCoord < vSrcWidthF
     }
 
-    uni_vcmpps(kDst, vZerosTmp, vCoord, CMP_LE_PS);      // vWCoord >= vZeros
-    uni_vandps(kDst, kDst, vAux);                  // vZeros <= vWCoord < vSrcWidthF
+    uni_vcmpps(kDst, vZerosTmp, vCoord, CMP_LE_PS);  // vWCoord >= vZeros
+    uni_vandps(kDst, kDst, vAux);                    // vZeros <= vWCoord < vSrcWidthF
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX2, AVX
+template <x64::cpu_isa_t isa>  // Works for AVX2, AVX
 void GridSampleKernel<isa>::zerosPaddingH(const Vmask& kDst, const Vmm& vCoord, const Vmask& kMaskW) {
     auto vAux = getVmm();
     Vmm vZerosTmp;
@@ -768,19 +772,19 @@ void GridSampleKernel<isa>::zerosPaddingH(const Vmask& kDst, const Vmm& vCoord,
     }
 
     if (vSrcHeightF.isInitialized()) {
-        uni_vcmpps(vAux, vCoord, vSrcHeightF, CMP_LT_PS); // vHCoord < vSrcHeightF
+        uni_vcmpps(vAux, vCoord, vSrcHeightF, CMP_LT_PS);  // vHCoord < vSrcHeightF
     } else {
         auto rAux = getReg64();
         mov(rAux, ptr[regParams + GET_OFF(srcHeightF)]);
-        uni_vcmpps(vAux, vCoord, ptr[rAux], CMP_LT_PS);   // vHCoord < vSrcHeightF
+        uni_vcmpps(vAux, vCoord, ptr[rAux], CMP_LT_PS);  // vHCoord < vSrcHeightF
     }
 
     uni_vandps(kDst, kMaskW, vAux);
-    uni_vcmpps(vAux, vZerosTmp, vCoord, CMP_LE_PS);       // vHCoord >= vZeros
+    uni_vcmpps(vAux, vZerosTmp, vCoord, CMP_LE_PS);  // vHCoord >= vZeros
     uni_vandps(kDst, kDst, vAux);
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX2, AVX
+template <x64::cpu_isa_t isa>  // Works for AVX2, AVX
 void GridSampleKernel<isa>::zerosPadding(const Vmask& kDst, const Vmm& vHCoord, const Vmm& vWCoord) {
     bool releaseZeroVec = false;
     if (!vZeros.isInitialized()) {
@@ -799,11 +803,14 @@ void GridSampleKernel<isa>::zerosPadding(const Vmask& kDst, const Vmm& vHCoord,
 
 template <>
 void GridSampleKernel<x64::avx512_core>::borderPadding(const Vmm& vCoordDst, const Vmm& vCoordOrigin, const coord dim) {
-    vrangeps(vCoordDst, vCoordOrigin, dim == coord::w ? vSrcWidthSub1F : vSrcHeightSub1F, 0x0); // vWCoord >= vSrcWidthF
-    vrangeps(vCoordDst, vCoordDst, vZeros, 0x1); // vWCoord < vZeros
+    vrangeps(vCoordDst,
+             vCoordOrigin,
+             dim == coord::w ? vSrcWidthSub1F : vSrcHeightSub1F,
+             0x0);                                // vWCoord >= vSrcWidthF
+    vrangeps(vCoordDst, vCoordDst, vZeros, 0x1);  // vWCoord < vZeros
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX2, AVX, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX2, AVX, SSE41
 void GridSampleKernel<isa>::borderPadding(const Vmm& vCoordDst, const Vmm& vCoordOrigin, const coord dim) {
     auto rAux = getReg64();
     auto vAux = getVmm();
@@ -836,7 +843,7 @@ void GridSampleKernel<isa>::borderPadding(const Vmm& vCoordDst, const Vmm& vCoor
     uni_vaddps(vCoordDst, vCoordDst, vAux);
 
     if (vZeros.isInitialized()) {
-        uni_vcmpps(vAux, vCoordDst, vZeros, 0x6); // vCoord >= vZeros
+        uni_vcmpps(vAux, vCoordDst, vZeros, 0x6);  // vCoord >= vZeros
     } else {
         if (isa == x64::sse41) {
             if (!vAux1.isInitialized()) {
@@ -844,27 +851,29 @@ void GridSampleKernel<isa>::borderPadding(const Vmm& vCoordDst, const Vmm& vCoor
                 vSub1F = vAux1;
             }
             uni_vpxor(vSub1F, vSub1F, vSub1F);
-            uni_vcmpps(vAux, vCoordDst, vSub1F, 0x6); // vCoord >= vZeros
+            uni_vcmpps(vAux, vCoordDst, vSub1F, 0x6);  // vCoord >= vZeros
         } else {
             uni_vpxor(vAux, vAux, vAux);
-            uni_vcmpps(vAux, vCoordDst, vAux, 0x6);   // vCoord >= vZeros
+            uni_vcmpps(vAux, vCoordDst, vAux, 0x6);  // vCoord >= vZeros
         }
     }
     uni_vandps(vCoordDst, vCoordDst, vAux);
 }
 
 template <>
-void GridSampleKernel<x64::avx512_core>::reflectionPadding(const Vmm& vCoordDst, const Vmm& vCoordOrigin, const coord dim) {
+void GridSampleKernel<x64::avx512_core>::reflectionPadding(const Vmm& vCoordDst,
+                                                           const Vmm& vCoordOrigin,
+                                                           const coord dim) {
     auto vAux = getVmm();
     auto kAux = getMask();
     const auto& vSrcDimMul2Sub1F = dim == coord::w ? vSrcWidthMul2Sub1F : vSrcHeightMul2Sub1F;
 
     if (jcp.alignCorners) {
         // abs(x) % D21
-        uni_vandps(vCoordDst, vCoordOrigin, vAbsMask); // abs(x)
+        uni_vandps(vCoordDst, vCoordOrigin, vAbsMask);  // abs(x)
         uni_vdivps(vAux, vCoordDst, vSrcDimMul2Sub1F);
-        uni_vroundps(vAux, vAux, 0x3);                       // Truncation
-        uni_vfnmadd231ps(vCoordDst, vAux, vSrcDimMul2Sub1F); // abs(x) % D21
+        uni_vroundps(vAux, vAux, 0x3);                        // Truncation
+        uni_vfnmadd231ps(vCoordDst, vAux, vSrcDimMul2Sub1F);  // abs(x) % D21
 
         // Check that the result does not exceed the divisor.
         vcmpps(kAux, vSrcDimMul2Sub1F, vCoordDst, CMP_LE_PS);
@@ -876,12 +885,12 @@ void GridSampleKernel<x64::avx512_core>::reflectionPadding(const Vmm& vCoordDst,
         if (vCoordDst.getIdx() != vCoordOrigin.getIdx())
             uni_vmovups(vCoordDst, vCoordOrigin);
         uni_vdivps(vAux, vCoordDst, vSrcDimMul2F);
-        uni_vroundps(vAux, vAux, 0x3);                   // Truncation
-        uni_vfnmadd231ps(vCoordDst, vAux, vSrcDimMul2F); // x % D2
-        uni_vaddps(vCoordDst, vCoordDst, vSrcDimMul2F);  // x % D2 + D2
+        uni_vroundps(vAux, vAux, 0x3);                    // Truncation
+        uni_vfnmadd231ps(vCoordDst, vAux, vSrcDimMul2F);  // x % D2
+        uni_vaddps(vCoordDst, vCoordDst, vSrcDimMul2F);   // x % D2 + D2
         uni_vdivps(vAux, vCoordDst, vSrcDimMul2F);
-        uni_vroundps(vAux, vAux, 0x3);                   // Truncation
-        uni_vfnmadd231ps(vCoordDst, vAux, vSrcDimMul2F); // (x % D2 + D2) % D2
+        uni_vroundps(vAux, vAux, 0x3);                    // Truncation
+        uni_vfnmadd231ps(vCoordDst, vAux, vSrcDimMul2F);  // (x % D2 + D2) % D2
 
         // Check that the result does not exceed the divisor.
         vcmpps(kAux, vSrcDimMul2F, vCoordDst, CMP_LE_PS);
@@ -890,13 +899,13 @@ void GridSampleKernel<x64::avx512_core>::reflectionPadding(const Vmm& vCoordDst,
     }
 
     uni_vsubps(vAux, vSrcDimMul2Sub1F, vCoordDst);
-    vcmpps(kAux, dim == coord::w ? vSrcWidthF : vSrcHeightF, vCoordDst, CMP_LE_PS); // vCoordDst >= vSrcDimF
+    vcmpps(kAux, dim == coord::w ? vSrcWidthF : vSrcHeightF, vCoordDst, CMP_LE_PS);  // vCoordDst >= vSrcDimF
     uni_vmovups(vCoordDst | kAux, vAux);
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX2, AVX, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX2, AVX, SSE41
 void GridSampleKernel<isa>::reflectionPadding(const Vmm& vCoordDst, const Vmm& vCoordOrigin, const coord dim) {
-    auto rAux  = getReg64();
+    auto rAux = getReg64();
     auto vAux0 = getVmm();
     auto vAux1 = getVmm();
 
@@ -904,14 +913,15 @@ void GridSampleKernel<isa>::reflectionPadding(const Vmm& vCoordDst, const Vmm& v
     // D21 = (Dim - 1) * 2
     if (jcp.alignCorners) {
         // x' = abs(x) % D21 - D21
-        static const unsigned absMask[8] = { 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff };
-        if (isa ==x64::sse41) {
-            static const unsigned *absPtr = absMask + (reinterpret_cast<int64_t>(absMask) % 16) / sizeof(unsigned);
+        static const unsigned absMask[8] =
+            {0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff};
+        if (isa == x64::sse41) {
+            static const unsigned* absPtr = absMask + (reinterpret_cast<int64_t>(absMask) % 16) / sizeof(unsigned);
             mov(rAux, reinterpret_cast<uintptr_t>(absPtr));
         } else {
             mov(rAux, reinterpret_cast<uintptr_t>(absMask));
         }
-        uni_vandps(vCoordDst, vCoordOrigin, ptr[rAux]); // abs(x)
+        uni_vandps(vCoordDst, vCoordOrigin, ptr[rAux]);  // abs(x)
 
         Vmm vMul2Sub1;
         if (dim == coord::w) {
@@ -932,8 +942,8 @@ void GridSampleKernel<isa>::reflectionPadding(const Vmm& vCoordDst, const Vmm& v
             }
         }
         uni_vdivps(vAux0, vCoordDst, vMul2Sub1);
-        uni_vroundps(vAux0, vAux0, 0x3);               // Truncation
-        uni_vfnmadd231ps(vCoordDst, vAux0, vMul2Sub1); // abs(x) % D21
+        uni_vroundps(vAux0, vAux0, 0x3);                // Truncation
+        uni_vfnmadd231ps(vCoordDst, vAux0, vMul2Sub1);  // abs(x) % D21
 
         // Check that the result does not exceed the divisor.
         uni_vcmpps(vAux0, vCoordDst, vMul2Sub1, CMP_LT_PS);
@@ -942,7 +952,7 @@ void GridSampleKernel<isa>::reflectionPadding(const Vmm& vCoordDst, const Vmm& v
         uni_vcmpps(vAux0, vAux0, vCoordDst, CMP_LE_PS);
         uni_vandps(vCoordDst, vCoordDst, vAux0);
 
-        uni_vsubps(vAux0, vCoordDst, vMul2Sub1);       // abs(x) % D21 - D21
+        uni_vsubps(vAux0, vCoordDst, vMul2Sub1);  // abs(x) % D21 - D21
     } else {
         // x' = (x % D2 + D2) % D2 - D21
         if (vCoordDst.getIdx() != vCoordOrigin.getIdx())
@@ -966,12 +976,12 @@ void GridSampleKernel<isa>::reflectionPadding(const Vmm& vCoordDst, const Vmm& v
             }
         }
         uni_vdivps(vAux0, vCoordOrigin, vMul2);
-        uni_vroundps(vAux0, vAux0, 0x3);           // Truncation
-        uni_vfnmadd231ps(vCoordDst, vAux0, vMul2); // x % D2
-        uni_vaddps(vCoordDst, vCoordDst, vMul2);   // x % D2 + D2
+        uni_vroundps(vAux0, vAux0, 0x3);            // Truncation
+        uni_vfnmadd231ps(vCoordDst, vAux0, vMul2);  // x % D2
+        uni_vaddps(vCoordDst, vCoordDst, vMul2);    // x % D2 + D2
         uni_vdivps(vAux0, vCoordDst, vMul2);
-        uni_vroundps(vAux0, vAux0, 0x3);           // Truncation
-        uni_vfnmadd231ps(vCoordDst, vAux0, vMul2); // (x % D2 + D2) % D2
+        uni_vroundps(vAux0, vAux0, 0x3);            // Truncation
+        uni_vfnmadd231ps(vCoordDst, vAux0, vMul2);  // (x % D2 + D2) % D2
 
         // Check that the result does not exceed the divisor.
         uni_vcmpps(vAux0, vCoordDst, vMul2, CMP_LT_PS);
@@ -1002,20 +1012,20 @@ void GridSampleKernel<isa>::reflectionPadding(const Vmm& vCoordDst, const Vmm& v
             uni_vcmpps(vAux1, vCoordDst, vSrcWidthF, CMP_LT_PS);  // vCoordDst < vUpperBound
         } else {
             mov(rAux, ptr[regParams + GET_OFF(srcWidthF)]);
-            uni_vcmpps(vAux1, vCoordDst, ptr[rAux], CMP_LT_PS);   // vCoordDst < vUpperBound
+            uni_vcmpps(vAux1, vCoordDst, ptr[rAux], CMP_LT_PS);  // vCoordDst < vUpperBound
         }
     } else {
         if (vSrcHeightF.isInitialized()) {
-            uni_vcmpps(vAux1, vCoordDst, vSrcHeightF, CMP_LT_PS); // vCoordDst < vUpperBound
+            uni_vcmpps(vAux1, vCoordDst, vSrcHeightF, CMP_LT_PS);  // vCoordDst < vUpperBound
         } else {
             mov(rAux, ptr[regParams + GET_OFF(srcHeightF)]);
-            uni_vcmpps(vAux1, vCoordDst, ptr[rAux], CMP_LT_PS);   // vCoordDst < vUpperBound
+            uni_vcmpps(vAux1, vCoordDst, ptr[rAux], CMP_LT_PS);  // vCoordDst < vUpperBound
         }
     }
 
     uni_vandps(vCoordDst, vCoordDst, vAux1);
     uni_vandnps(vAux1, vAux1, vAux0);
-    uni_vsubps(vCoordDst, vCoordDst, vAux1); // set -x' for vCoordDst >= Dim
+    uni_vsubps(vCoordDst, vCoordDst, vAux1);  // set -x' for vCoordDst >= Dim
 }
 
 template <>
@@ -1045,12 +1055,13 @@ void GridSampleKernel<x64::avx512_core>::bicubicCoefficients(const Vmm& vCoef, c
 
 template <>
 void GridSampleKernel<x64::avx2>::bicubicCoefficients(const Vmm& vCoef, const Vmm& vDDim, const uint8_t idx) {
-    static const size_t elPerVec = x64::cpu_isa_traits<x64::avx2>::vlen / sizeof(float);;
-    static const float const_0_75[elPerVec] = { -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f };
-    static const float const_1_25[elPerVec] = { 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f };
-    static const float const_1_50[elPerVec] = { 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f };
-    static const float const_2_00[elPerVec] = { 2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f };
-    static const float const_2_25[elPerVec] = { 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f };
+    static const size_t elPerVec = x64::cpu_isa_traits<x64::avx2>::vlen / sizeof(float);
+    ;
+    static const float const_0_75[elPerVec] = {-0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f};
+    static const float const_1_25[elPerVec] = {1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f};
+    static const float const_1_50[elPerVec] = {1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f};
+    static const float const_2_00[elPerVec] = {2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f};
+    static const float const_2_25[elPerVec] = {2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f};
 
     auto rAux = getReg64();
 
@@ -1088,11 +1099,11 @@ void GridSampleKernel<x64::avx2>::bicubicCoefficients(const Vmm& vCoef, const Vm
 template <>
 void GridSampleKernel<x64::avx>::bicubicCoefficients(const Vmm& vCoef, const Vmm& vDDim, const uint8_t idx) {
     static const size_t elPerVec = x64::cpu_isa_traits<x64::avx>::vlen / sizeof(float);
-    static const float const_0_75[elPerVec] = { -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f };
-    static const float const_1_25[elPerVec] = { 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f };
-    static const float const_1_50[elPerVec] = { 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f };
-    static const float const_2_00[elPerVec] = { 2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f };
-    static const float const_2_25[elPerVec] = { 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f };
+    static const float const_0_75[elPerVec] = {-0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f};
+    static const float const_1_25[elPerVec] = {1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f};
+    static const float const_1_50[elPerVec] = {1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f};
+    static const float const_2_00[elPerVec] = {2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f};
+    static const float const_2_25[elPerVec] = {2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f};
 
     auto rAux = getReg64();
     auto vAux = getVmm();
@@ -1136,11 +1147,11 @@ template <>
 void GridSampleKernel<x64::sse41>::bicubicCoefficients(const Vmm& vCoef, const Vmm& vDDim, const uint8_t idx) {
     static const size_t elToAllocate = 2 * x64::cpu_isa_traits<x64::sse41>::vlen / sizeof(float);
     // Allocation with a margin for address alignment.
-    static const float c_0_75[elToAllocate] = { -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f };
-    static const float c_1_25[elToAllocate] = { 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f };
-    static const float c_1_50[elToAllocate] = { 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f };
-    static const float c_2_00[elToAllocate] = { 2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f };
-    static const float c_2_25[elToAllocate] = { 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f };
+    static const float c_0_75[elToAllocate] = {-0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f, -0.75f};
+    static const float c_1_25[elToAllocate] = {1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f, 1.25f};
+    static const float c_1_50[elToAllocate] = {1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f, 1.5f};
+    static const float c_2_00[elToAllocate] = {2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f, 2.f};
+    static const float c_2_25[elToAllocate] = {2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f, 2.25f};
     // Address alignment for XMM.
     static const float* const_0_75 = c_0_75 + (reinterpret_cast<int64_t>(c_0_75) % 16) / sizeof(float);
     static const float* const_1_25 = c_1_25 + (reinterpret_cast<int64_t>(c_1_25) % 16) / sizeof(float);
@@ -1193,15 +1204,15 @@ void GridSampleKernel<x64::sse41>::bicubicCoefficients(const Vmm& vCoef, const V
     }
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX512, AVX2, AVX, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX512, AVX2, AVX, SSE41
 void GridSampleKernel<isa>::nearestInterpolation(const Vmm& vWCoord, const Vmm& vHCoord, bool tail) {
     const auto& vSrcShift = vWCoord;
-    const auto& vAux      = vHCoord;
-    auto kGatherMask      = getMask();
-    auto kAuxMask         = getMask();
+    const auto& vAux = vHCoord;
+    auto kGatherMask = getMask();
+    auto kAuxMask = getMask();
 
-    uni_vroundps(vWCoord, vWCoord, 0x0); // Round near
-    uni_vroundps(vHCoord, vHCoord, 0x0); // Round near
+    uni_vroundps(vWCoord, vWCoord, 0x0);  // Round near
+    uni_vroundps(vHCoord, vHCoord, 0x0);  // Round near
 
     bool useMask = false, zeroFill = false;
     if (jcp.paddingMode == GridSamplePaddingMode::ZEROS) {
@@ -1272,15 +1283,15 @@ template <>
 void GridSampleKernel<x64::avx512_core>::bilinearInterpolation(const Vmm& vWCoord, const Vmm& vHCoord, bool tail) {
     const auto& vDX = vWCoord;
     const auto& vDY = vHCoord;
-    auto shift00    = getVmm();
-    auto shift01    = getVmm();
-    auto shift10    = getVmm();
-    auto shift11    = getVmm();
-    auto vAux       = getVmm();
+    auto shift00 = getVmm();
+    auto shift01 = getVmm();
+    auto shift10 = getVmm();
+    auto shift11 = getVmm();
+    auto vAux = getVmm();
     RegistersPool::Reg<Vmask> kMask00, kMask01, kMask10, kMask11;
 
-    uni_vroundps(shift00, vWCoord, 0x1); // Round floor
-    uni_vroundps(shift01, vHCoord, 0x1); // Round floor
+    uni_vroundps(shift00, vWCoord, 0x1);  // Round floor
+    uni_vroundps(shift01, vHCoord, 0x1);  // Round floor
     uni_vsubps(vDX, vWCoord, shift00);
     uni_vsubps(vDY, vHCoord, shift01);
     uni_vaddps(shift10, shift00, vOnesF);
@@ -1294,10 +1305,10 @@ void GridSampleKernel<x64::avx512_core>::bilinearInterpolation(const Vmm& vWCoor
         kMask10 = getMask();
         kMask11 = getMask();
 
-        zerosPadding(kMask00, shift01, shift00); // (y; x)
-        zerosPadding(kMask01, shift01, shift10); // (y; x + 1)
-        zerosPadding(kMask11, shift11, shift10); // (y + 1; x + 1)
-        zerosPadding(kMask10, shift11, shift00); // (y + 1; x)
+        zerosPadding(kMask00, shift01, shift00);  // (y; x)
+        zerosPadding(kMask01, shift01, shift10);  // (y; x + 1)
+        zerosPadding(kMask11, shift11, shift10);  // (y + 1; x + 1)
+        zerosPadding(kMask10, shift11, shift00);  // (y + 1; x)
 
         hwShiftPs2dq(shift00, shift01, shift00, vSrcWidthF);
         uni_vpaddd(shift01, shift00, vDataTypeSizeB);
@@ -1330,8 +1341,8 @@ void GridSampleKernel<x64::avx512_core>::bilinearInterpolation(const Vmm& vWCoor
     // PER CHANNEL LOOP
     Xbyak::Label lChannelLoopBegin, lChannelLoopEnd;
     RegistersPool::Reg<Xbyak::Reg64> rChannel;
-    auto rSrcTmp  = getReg64();
-    auto rDstTmp  = getReg64();
+    auto rSrcTmp = getReg64();
+    auto rDstTmp = getReg64();
     mov(rSrcTmp, regSrc);
     mov(rDstTmp, regDst);
 
@@ -1349,11 +1360,11 @@ void GridSampleKernel<x64::avx512_core>::bilinearInterpolation(const Vmm& vWCoor
         if (jcp.paddingMode == GridSamplePaddingMode::ZEROS) {
             kmovw(kAuxMask, kMask00);
         }
-        gatherdd(vQ0, rSrcTmp, shift00, kAuxMask, useMask, zeroFill); // v00 -> vQ0
+        gatherdd(vQ0, rSrcTmp, shift00, kAuxMask, useMask, zeroFill);  // v00 -> vQ0
         if (jcp.inDataPrc == ov::element::i32) {
             uni_vcvtdq2ps(vQ0, vQ0);
         }
-        uni_vfmsub213ps(vQ0, vDX, vQ0); // q0 = -(v00 - dx * v00)
+        uni_vfmsub213ps(vQ0, vDX, vQ0);  // q0 = -(v00 - dx * v00)
 
         // (y; x + 1)
         if (jcp.paddingMode == GridSamplePaddingMode::ZEROS) {
@@ -1363,7 +1374,7 @@ void GridSampleKernel<x64::avx512_core>::bilinearInterpolation(const Vmm& vWCoor
         if (jcp.inDataPrc == ov::element::i32) {
             uni_vcvtdq2ps(vAux, vAux);
         }
-        uni_vfmsub231ps(vQ0, vAux, vDX); // q0 = -q0 + dx * v01
+        uni_vfmsub231ps(vQ0, vAux, vDX);  // q0 = -q0 + dx * v01
 
         // (y + 1; x + 1)
         if (jcp.paddingMode == GridSamplePaddingMode::ZEROS) {
@@ -1383,14 +1394,14 @@ void GridSampleKernel<x64::avx512_core>::bilinearInterpolation(const Vmm& vWCoor
             uni_vcvtdq2ps(vQ1, vQ1);
         }
 
-        uni_vfmsub213ps(vQ1, vDX, vQ1);  // q1 = -(v10 - dx * v10)
-        uni_vfmsub231ps(vQ1, vAux, vDX); // q1 = -q1 + dx * v11
+        uni_vfmsub213ps(vQ1, vDX, vQ1);   // q1 = -(v10 - dx * v10)
+        uni_vfmsub231ps(vQ1, vAux, vDX);  // q1 = -q1 + dx * v11
         // Res = q0 + dy * (q1 - q0)
         uni_vsubps(vQ1, vQ1, vQ0);
         uni_vfmadd132ps(vQ1, vQ0, vDY);
 
         if (jcp.inDataPrc == ov::element::i32) {
-            uni_vroundps(vQ1, vQ1, 0x3); // Truncation
+            uni_vroundps(vQ1, vQ1, 0x3);  // Truncation
             uni_vcvtps2dq(vQ1, vQ1);
         }
 
@@ -1410,20 +1421,20 @@ void GridSampleKernel<x64::avx512_core>::bilinearInterpolation(const Vmm& vWCoor
     }
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX2, AVX, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX2, AVX, SSE41
 void GridSampleKernel<isa>::bilinearInterpolation(const Vmm& vWCoord, const Vmm& vHCoord, bool tail) {
     auto vWRound = getVmm();
     auto vHRound = getVmm();
-    auto& vDX    = vWCoord;
-    auto& vDY    = vHCoord;
-    auto vAux    = getVmm();
+    auto& vDX = vWCoord;
+    auto& vDY = vHCoord;
+    auto vAux = getVmm();
     Vmm shift00, shift01, shift10, shift11;
     RegistersPool::Reg<Vmm> shift10Holder, shift11Holder;
     // For ZEROS padding only.
     RegistersPool::Reg<Vmm> vMask00, vMask01, vMask10, vMask11;
 
-    uni_vroundps(vWRound, vWCoord, 0x1); // Round floor
-    uni_vroundps(vHRound, vHCoord, 0x1); // Round floor
+    uni_vroundps(vWRound, vWCoord, 0x1);  // Round floor
+    uni_vroundps(vHRound, vHCoord, 0x1);  // Round floor
     uni_vsubps(vDX, vDX, vWRound);
     uni_vsubps(vDY, vDY, vHRound);
 
@@ -1444,9 +1455,9 @@ void GridSampleKernel<isa>::bilinearInterpolation(const Vmm& vWCoord, const Vmm&
         useMask = zeroFill = true;
         {
             auto rAux = getReg64();
-            static const float onesArr[8] = { 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f };
-            if (isa ==x64::sse41) {
-                static const float *onesPtr = onesArr + (reinterpret_cast<int64_t>(onesArr) % 16) / sizeof(float);
+            static const float onesArr[8] = {1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f};
+            if (isa == x64::sse41) {
+                static const float* onesPtr = onesArr + (reinterpret_cast<int64_t>(onesArr) % 16) / sizeof(float);
                 mov(rAux, reinterpret_cast<uintptr_t>(onesPtr));
             } else {
                 mov(rAux, reinterpret_cast<uintptr_t>(onesArr));
@@ -1463,10 +1474,10 @@ void GridSampleKernel<isa>::bilinearInterpolation(const Vmm& vWCoord, const Vmm&
         uni_vaddps(vMask00, vWRound, vAux);
         uni_vaddps(vAux, vAux, vHRound);
 
-        zerosPadding(vMask01, vHRound, vMask00); // (y; x + 1)
-        zerosPadding(vMask10, vAux, vWRound);    // (y + 1; x)
-        zerosPadding(vMask11, vAux, vMask00);    // (y + 1; x + 1)
-        zerosPadding(vMask00, vHRound, vWRound); // (y; x)
+        zerosPadding(vMask01, vHRound, vMask00);  // (y; x + 1)
+        zerosPadding(vMask10, vAux, vWRound);     // (y + 1; x)
+        zerosPadding(vMask11, vAux, vMask00);     // (y + 1; x + 1)
+        zerosPadding(vMask00, vHRound, vWRound);  // (y; x)
 
         hwShiftPs2dq(shift00, vHRound, vWRound, vSrcWidthF);
     } else if (jcp.paddingMode == GridSamplePaddingMode::BORDER) {
@@ -1490,17 +1501,17 @@ void GridSampleKernel<isa>::bilinearInterpolation(const Vmm& vWCoord, const Vmm&
     }
 
     auto vGatherMask = getVmm();
-    auto vQ0         = getVmm();
-    auto vQ1         = getVmm();
+    auto vQ0 = getVmm();
+    auto vQ1 = getVmm();
 
     // PER CHANNEL LOOP
     Xbyak::Label lChannelLoopBegin, lChannelLoopEnd;
     RegistersPool::Reg<Xbyak::Reg64> rChannel;
-    auto rSrcTmp   = getReg64();
-    auto rDstTmp   = getReg64();
+    auto rSrcTmp = getReg64();
+    auto rDstTmp = getReg64();
     auto rTypeSize = getReg64();
-    mov(rSrcTmp,   regSrc);
-    mov(rDstTmp,   regDst);
+    mov(rSrcTmp, regSrc);
+    mov(rDstTmp, regDst);
     mov(rTypeSize, ptr[regParams + GET_OFF(dataTypeSize)]);
 
     for (uint64_t ch = 0; ch < jcp.cannelNum; ch++) {
@@ -1517,12 +1528,17 @@ void GridSampleKernel<isa>::bilinearInterpolation(const Vmm& vWCoord, const Vmm&
         if (jcp.paddingMode == GridSamplePaddingMode::ZEROS && isa == x64::avx2) {
             uni_vmovups(vGatherMask, vMask00);
         }
-        gatherdd(vQ0, rSrcTmp, shift00, (isa == x64::avx2 || !vMask00.isInitialized()) ? vGatherMask : vMask00, useMask, zeroFill); // v00 -> vQ0
+        gatherdd(vQ0,
+                 rSrcTmp,
+                 shift00,
+                 (isa == x64::avx2 || !vMask00.isInitialized()) ? vGatherMask : vMask00,
+                 useMask,
+                 zeroFill);  // v00 -> vQ0
         if (jcp.inDataPrc == ov::element::i32) {
             uni_vcvtdq2ps(vQ0, vQ0);
         }
         if (isa == x64::avx2) {
-            uni_vfmsub213ps(vQ0, vDX, vQ0); // q0 = -(v00 - dx * v00)
+            uni_vfmsub213ps(vQ0, vDX, vQ0);  // q0 = -(v00 - dx * v00)
         } else {
             uni_vmulps(vGatherMask, vQ0, vDX);
             uni_vsubps(vQ0, vQ0, vGatherMask);
@@ -1534,13 +1550,17 @@ void GridSampleKernel<isa>::bilinearInterpolation(const Vmm& vWCoord, const Vmm&
             if (isa == x64::avx2)
                 uni_vmovups(vGatherMask, vMask01);
         }
-        gatherdd(vAux, rSrcTmp, jcp.paddingMode != GridSamplePaddingMode::ZEROS ? shift01 : shift10,
-                 (isa == x64::avx2 || !vMask01.isInitialized()) ? vGatherMask : vMask01, useMask, zeroFill);
+        gatherdd(vAux,
+                 rSrcTmp,
+                 jcp.paddingMode != GridSamplePaddingMode::ZEROS ? shift01 : shift10,
+                 (isa == x64::avx2 || !vMask01.isInitialized()) ? vGatherMask : vMask01,
+                 useMask,
+                 zeroFill);
         if (jcp.inDataPrc == ov::element::i32) {
             uni_vcvtdq2ps(vAux, vAux);
         }
         if (isa == x64::avx2) {
-            uni_vfmsub231ps(vQ0, vAux, vDX); // q0 = -q0 + dx * v01
+            uni_vfmsub231ps(vQ0, vAux, vDX);  // q0 = -q0 + dx * v01
         } else {
             uni_vmulps(vAux, vAux, vDX);
             uni_vaddps(vQ0, vQ0, vAux);
@@ -1556,8 +1576,12 @@ void GridSampleKernel<isa>::bilinearInterpolation(const Vmm& vWCoord, const Vmm&
             if (isa == x64::avx2)
                 uni_vmovups(vGatherMask, vMask11);
         }
-        gatherdd(vAux, rSrcTmp, jcp.paddingMode != GridSamplePaddingMode::ZEROS ? shift11 : shift10,
-                 (isa == x64::avx2 || !vMask11.isInitialized()) ? vGatherMask : vMask11, useMask, zeroFill);
+        gatherdd(vAux,
+                 rSrcTmp,
+                 jcp.paddingMode != GridSamplePaddingMode::ZEROS ? shift11 : shift10,
+                 (isa == x64::avx2 || !vMask11.isInitialized()) ? vGatherMask : vMask11,
+                 useMask,
+                 zeroFill);
         if (jcp.inDataPrc == ov::element::i32) {
             uni_vcvtdq2ps(vAux, vAux);
         }
@@ -1568,7 +1592,12 @@ void GridSampleKernel<isa>::bilinearInterpolation(const Vmm& vWCoord, const Vmm&
             if (isa == x64::avx2)
                 uni_vmovups(vGatherMask, vMask10);
         }
-        gatherdd(vQ1, rSrcTmp, shift10, (isa == x64::avx2 || !vMask10.isInitialized()) ? vGatherMask : vMask10, useMask, zeroFill);
+        gatherdd(vQ1,
+                 rSrcTmp,
+                 shift10,
+                 (isa == x64::avx2 || !vMask10.isInitialized()) ? vGatherMask : vMask10,
+                 useMask,
+                 zeroFill);
         if (jcp.inDataPrc == ov::element::i32) {
             uni_vcvtdq2ps(vQ1, vQ1);
         }
@@ -1585,13 +1614,13 @@ void GridSampleKernel<isa>::bilinearInterpolation(const Vmm& vWCoord, const Vmm&
                 uni_vmovups(vQ1, vGatherMask);
             }
         }
-        uni_vfmsub231ps(vQ1, vAux, vDX); // q1 = -q1 + dx * v11
+        uni_vfmsub231ps(vQ1, vAux, vDX);  // q1 = -q1 + dx * v11
         // Res = q0 + dy * (q1 - q0)
         uni_vsubps(vQ1, vQ1, vQ0);
         uni_vfmadd132ps(vQ1, vQ0, vDY);
 
         if (jcp.inDataPrc == ov::element::i32) {
-            uni_vroundps(vQ1, vQ1, 0x3); // Truncation
+            uni_vroundps(vQ1, vQ1, 0x3);  // Truncation
             uni_vcvtps2dq(vQ1, vQ1);
         }
 
@@ -1614,27 +1643,27 @@ void GridSampleKernel<isa>::bilinearInterpolation(const Vmm& vWCoord, const Vmm&
 
 template <>
 void GridSampleKernel<x64::avx512_core>::bicubicInterpolation(const Vmm& vWCoord, const Vmm& vHCoord, bool tail) {
-    auto vHTop      = getVmm();
-    auto vWLeft     = getVmm();
-    auto vDX        = getVmm();
-    auto vDY        = getVmm();
-    auto vXDotProd  = getVmm();
+    auto vHTop = getVmm();
+    auto vWLeft = getVmm();
+    auto vDX = getVmm();
+    auto vDY = getVmm();
+    auto vXDotProd = getVmm();
     auto& vYDotProd = vDX;
     auto vSrcShift0 = getVmm();
-    auto vSrcShift  = getVmm();
-    auto vAux       = getVmm();
-    auto kAuxMask   = getMask();
+    auto vSrcShift = getVmm();
+    auto vAux = getVmm();
+    auto kAuxMask = getMask();
     RegistersPool::Reg<Vmask> kMaskH;
     std::vector<RegistersPool::Reg<Vmask>> wMasks;
 
-    uni_vroundps(vHTop, vHCoord, 0x1);  // Round floor
-    uni_vroundps(vWLeft, vWCoord, 0x1); // Round floor
+    uni_vroundps(vHTop, vHCoord, 0x1);   // Round floor
+    uni_vroundps(vWLeft, vWCoord, 0x1);  // Round floor
     uni_vsubps(vDY, vHCoord, vHTop);
     uni_vsubps(vDX, vWCoord, vWLeft);
     uni_vsubps(vHTop, vHTop, vOnesF);
     uni_vsubps(vWLeft, vWLeft, vOnesF);
 
-    RegistersPool::Reg<Vmm> vCX[4] = {getVmm(), getVmm(), getVmm(), getVmm() };
+    RegistersPool::Reg<Vmm> vCX[4] = {getVmm(), getVmm(), getVmm(), getVmm()};
     for (int i = 0; i < 4; i++) {
         bicubicCoefficients(vCX[i], vDX, i);
     }
@@ -1659,8 +1688,8 @@ void GridSampleKernel<x64::avx512_core>::bicubicInterpolation(const Vmm& vWCoord
     // PER CHANNEL LOOP
     Xbyak::Label lChannelLoopBegin, lChannelLoopEnd;
     RegistersPool::Reg<Xbyak::Reg64> rChannel;
-    auto rSrcTmp  = getReg64();
-    auto rDstTmp  = getReg64();
+    auto rSrcTmp = getReg64();
+    auto rDstTmp = getReg64();
     mov(rSrcTmp, regSrc);
     mov(rDstTmp, regDst);
 
@@ -1742,7 +1771,7 @@ void GridSampleKernel<x64::avx512_core>::bicubicInterpolation(const Vmm& vWCoord
         }
 
         if (jcp.inDataPrc == ov::element::i32) {
-            uni_vroundps(vYDotProd, vYDotProd, 0x3); // Truncation
+            uni_vroundps(vYDotProd, vYDotProd, 0x3);  // Truncation
             uni_vcvtps2dq(vYDotProd, vYDotProd);
         }
 
@@ -1762,15 +1791,15 @@ void GridSampleKernel<x64::avx512_core>::bicubicInterpolation(const Vmm& vWCoord
     }
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX2, AVX, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX2, AVX, SSE41
 void GridSampleKernel<isa>::bicubicInterpolation(const Vmm& vWCoord, const Vmm& vHCoord, bool tail) {
-    auto vHTop  = getVmm();
+    auto vHTop = getVmm();
     auto vWLeft = getVmm();
-    auto vDX    = getVmm();
-    auto vDY    = getVmm();
+    auto vDX = getVmm();
+    auto vDY = getVmm();
 
-    uni_vroundps(vHTop,  vHCoord, 0x1); // Round floor
-    uni_vroundps(vWLeft, vWCoord, 0x1); // Round floor
+    uni_vroundps(vHTop, vHCoord, 0x1);   // Round floor
+    uni_vroundps(vWLeft, vWCoord, 0x1);  // Round floor
     uni_vsubps(vDY, vHCoord, vHTop);
     uni_vsubps(vDX, vWCoord, vWLeft);
     uni_vsubps(vHTop, vHTop, vOnesF);
@@ -1791,7 +1820,7 @@ void GridSampleKernel<isa>::bicubicInterpolation(const Vmm& vWCoord, const Vmm&
         }
 
         auto vW0 = getVmm(), vW1 = getVmm();
-        Vmm vW[4] = { vW0, vW1, vHCoord, vWCoord };
+        Vmm vW[4] = {vW0, vW1, vHCoord, vWCoord};
         for (int w = 0; w < 4; w++) {
             borderPadding(vW[w], vWLeft, coord::w);
             if (w < 3) {
@@ -1806,7 +1835,7 @@ void GridSampleKernel<isa>::bicubicInterpolation(const Vmm& vWCoord, const Vmm&
             mov(rAux, ptr[regParams + GET_OFF(srcHeightSub1F)]);
             uni_vmovups(vSrcHeightSub1F, ptr[rAux]);
         }
-        auto vH  = getVmm();
+        auto vH = getVmm();
 
         size_t bufShift = 0lu;
         for (int h = 0; h < 4; h++) {
@@ -1839,7 +1868,7 @@ void GridSampleKernel<isa>::bicubicInterpolation(const Vmm& vWCoord, const Vmm&
         }
 
         auto vW0 = getVmm(), vW1 = getVmm();
-        Vmm vW[4] = { vW0, vW1, vHCoord, vWCoord };
+        Vmm vW[4] = {vW0, vW1, vHCoord, vWCoord};
         for (int w = 0; w < 4; w++) {
             reflectionPadding(vW[w], vWLeft, coord::w);
             if (w < 3) {
@@ -1860,7 +1889,7 @@ void GridSampleKernel<isa>::bicubicInterpolation(const Vmm& vWCoord, const Vmm&
             mov(rAux, ptr[regParams + GET_OFF(srcHeightMul2Sub1F)]);
             uni_vmovups(vSrcHeightMul2Sub1F, ptr[rAux]);
         }
-        auto vH  = getVmm();
+        auto vH = getVmm();
 
         size_t bufShift = 0lu;
         for (int h = 0; h < 4; h++) {
@@ -1883,7 +1912,7 @@ void GridSampleKernel<isa>::bicubicInterpolation(const Vmm& vWCoord, const Vmm&
     } else if (jcp.paddingMode == GridSamplePaddingMode::ZEROS) {
         useMask = zeroFill = true;
 
-        RegistersPool::Reg<Vmm> vWMask[4] = { getVmm(), getVmm(), getVmm(), getVmm() };
+        RegistersPool::Reg<Vmm> vWMask[4] = {getVmm(), getVmm(), getVmm(), getVmm()};
         for (int w = 0; w < 4; w++) {
             if (w == 0) {
                 zerosPaddingW(vWMask[w], vWLeft);
@@ -1933,21 +1962,21 @@ void GridSampleKernel<isa>::bicubicInterpolation(const Vmm& vWCoord, const Vmm&
         vDataTypeSizeB.release();
     }
 
-    RegistersPool::Reg<Vmm> vCX[4] = { getVmm(), getVmm(), getVmm(), getVmm() };
+    RegistersPool::Reg<Vmm> vCX[4] = {getVmm(), getVmm(), getVmm(), getVmm()};
     for (int w = 0; w < 4; w++) {
         bicubicCoefficients(vCX[w], vDX, w);
     }
     auto vCY0 = getVmm(), vCY1 = getVmm();
-    Vmm vCY[4] = { vCY0, vCY1, vHCoord, vWCoord };
+    Vmm vCY[4] = {vCY0, vCY1, vHCoord, vWCoord};
     for (int h = 0; h < 4; h++) {
         bicubicCoefficients(vCY[h], vDY, h);
     }
 
     const auto& vXDotProd = vDX;
     const auto& vYDotProd = vDY;
-    auto vSrcShift   = getVmm();
+    auto vSrcShift = getVmm();
     auto kGatherMask = getVmm();
-    auto vAux        = getVmm();
+    auto vAux = getVmm();
 
     // PER CHANNEL LOOP
     Xbyak::Label lChannelLoopBegin, lChannelLoopEnd;
@@ -2003,7 +2032,7 @@ void GridSampleKernel<isa>::bicubicInterpolation(const Vmm& vWCoord, const Vmm&
         }
 
         if (jcp.inDataPrc == ov::element::i32) {
-            uni_vroundps(vYDotProd, vYDotProd, 0x3); // Truncation
+            uni_vroundps(vYDotProd, vYDotProd, 0x3);  // Truncation
             uni_vcvtps2dq(vYDotProd, vYDotProd);
         }
 
@@ -2028,7 +2057,7 @@ void GridSampleKernel<isa>::dataTypeShiftPs2Dq(const Vmm& vDst, const Vmm& vSrc)
     if (dataTypeSize == 1)
         return;
 
-    if (isa == x64::avx) { // vpslld works just with XMM for AVX, so use vmulps for YMM
+    if (isa == x64::avx) {  // vpslld works just with XMM for AVX, so use vmulps for YMM
         auto rAux = getReg64();
         static const float val = dataTypeSize;
         static const float dataTypeSizeArr[8] = {val, val, val, val, val, val, val, val};
@@ -2038,7 +2067,7 @@ void GridSampleKernel<isa>::dataTypeShiftPs2Dq(const Vmm& vDst, const Vmm& vSrc)
     } else {
         uni_vcvtps2dq(vDst, vSrc);
         if (dataTypeSize > 1)
-            uni_vpslld(vDst, vDst, dataTypeShift); // multiply by source data type size.
+            uni_vpslld(vDst, vDst, dataTypeShift);  // multiply by source data type size.
     }
 }
 
@@ -2066,7 +2095,7 @@ void GridSampleKernel<isa>::hwShiftPs2dq(const Vmm& vDst, const Vmm& vHCoord, co
         }
     }
 
-    if (isa == x64::avx) { // vpslld works just with XMM for AVX, so use vmulps for YMM
+    if (isa == x64::avx) {  // vpslld works just with XMM for AVX, so use vmulps for YMM
         if (dataTypeSize > 1) {
             auto rAux = getReg64();
             const float val = dataTypeSize;
@@ -2078,7 +2107,7 @@ void GridSampleKernel<isa>::hwShiftPs2dq(const Vmm& vDst, const Vmm& vHCoord, co
     } else {
         uni_vcvtps2dq(vDst, vDst);
         if (dataTypeSize > 1)
-            uni_vpslld(vDst, vDst, dataTypeShift); // multiply by source data type size.
+            uni_vpslld(vDst, vDst, dataTypeShift);  // multiply by source data type size.
     }
 }
 
@@ -2086,6 +2115,6 @@ template class GridSampleKernel<x64::avx512_core>;
 template class GridSampleKernel<x64::avx2>;
 template class GridSampleKernel<x64::sse41>;
 
-}   // namespace kernel
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace kernel
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/grid_sample.hpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/grid_sample.hpp
index cb13d62c3509d1..f276580a837bd2 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/grid_sample.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/grid_sample.hpp
@@ -4,9 +4,10 @@
 
 #pragma once
 
-#include "jit_kernel_base.hpp"
 #include <set>
 
+#include "jit_kernel_base.hpp"
+
 namespace ov {
 namespace intel_cpu {
 
@@ -20,16 +21,16 @@ class GridSampleKernelBase;
 #if defined(OPENVINO_ARCH_X86_64)
 
 struct GridSampleKernelConfParams {
-    bool dynamicShapes  = false;
-    bool dynamicBatch   = false;
+    bool dynamicShapes = false;
+    bool dynamicBatch = false;
     bool dynamicChannel = false;
-    bool alignCorners  = false;
+    bool alignCorners = false;
     GridSampleInterpolationMode interpolationMode = GridSampleInterpolationMode::BILINEAR;
     GridSamplePaddingMode paddingMode = GridSamplePaddingMode::ZEROS;
     ov::element::Type inDataPrc;
     ov::element::Type gridPrc;
-    uint64_t batchNum      = 1lu;
-    uint64_t cannelNum     = 1lu;
+    uint64_t batchNum = 1lu;
+    uint64_t cannelNum = 1lu;
     uint64_t srcBatchStepB = 0lu;
 };
 
@@ -37,13 +38,13 @@ struct GridSamplesKernelExecArgs {
     const void* src;
     const void* grid;
     void* dst;
-    uint64_t batchNum    = 1lu;
+    uint64_t batchNum = 1lu;
     uint64_t channelsNum = 1lu;
     const float* srcWidthF;
     const float* srcHeightF;
-    uint64_t srcBatchStepB   = 0lu;
-    uint64_t gridBatchStepB  = 0lu;
-    uint64_t dstBatchStepB   = 0lu;
+    uint64_t srcBatchStepB = 0lu;
+    uint64_t gridBatchStepB = 0lu;
+    uint64_t dstBatchStepB = 0lu;
     uint64_t srcChannelStepB = 0lu;
     uint64_t dstChannelStepB = 0lu;
     const void* wDenormCoefF;
@@ -60,19 +61,21 @@ struct GridSamplesKernelExecArgs {
     uint64_t workAmount = 0lu;
 };
 
-enum coord {
-    w, h
-};
+enum coord { w, h };
 
-class GridSampleKernelBase: public JitKernelBase {
+class GridSampleKernelBase : public JitKernelBase {
 public:
-    void (*ker_)(const GridSamplesKernelExecArgs *);
-    void operator()(const GridSamplesKernelExecArgs *args) {
+    void (*ker_)(const GridSamplesKernelExecArgs*);
+    void operator()(const GridSamplesKernelExecArgs* args) {
         assert(ker_);
         ker_(args);
     }
-    explicit GridSampleKernelBase(const char* name, const GridSampleKernelConfParams& jcp, dnnl::impl::cpu::x64::cpu_isa_t isa)
-        : JitKernelBase(name, isa), ker_(nullptr), jcp(jcp) {}
+    explicit GridSampleKernelBase(const char* name,
+                                  const GridSampleKernelConfParams& jcp,
+                                  dnnl::impl::cpu::x64::cpu_isa_t isa)
+        : JitKernelBase(name, isa),
+          ker_(nullptr),
+          jcp(jcp) {}
 
     virtual void create_ker() = 0;
     uint64_t getVecLen() {
@@ -87,7 +90,7 @@ class GridSampleKernelBase: public JitKernelBase {
 
 protected:
     GridSampleKernelConfParams jcp;
-    uint64_t vlen         = 16lu;
+    uint64_t vlen = 16lu;
     uint64_t dataTypeSize = 1lu;
     uint64_t gridTypeSize = 1lu;
     uint64_t dataElPerVec = 1lu;
@@ -104,12 +107,16 @@ class GridSampleKernel : public GridSampleKernelBase {
     void create_ker() override;
     void generate() override;
 
-    using Vmm   = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::avx512_core, Xbyak::Zmm,
-                                                           isa == dnnl::impl::cpu::x64::sse41,       Xbyak::Xmm,
-                                                                                                     Xbyak::Ymm>::type;
-    using Vmask = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::avx512_core, Xbyak::Opmask,
-                                                           isa == dnnl::impl::cpu::x64::sse41,       Xbyak::Xmm,
-                                                                                                     Xbyak::Ymm>::type;
+    using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::avx512_core,
+                                                         Xbyak::Zmm,
+                                                         isa == dnnl::impl::cpu::x64::sse41,
+                                                         Xbyak::Xmm,
+                                                         Xbyak::Ymm>::type;
+    using Vmask = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::avx512_core,
+                                                           Xbyak::Opmask,
+                                                           isa == dnnl::impl::cpu::x64::sse41,
+                                                           Xbyak::Xmm,
+                                                           Xbyak::Ymm>::type;
 
 private:
     uint8_t dataTypeShift = 0;
@@ -138,23 +145,23 @@ class GridSampleKernel : public GridSampleKernelBase {
     RegistersPool::Reg<Vmm> vWDenormCoefF;
     RegistersPool::Reg<Vmm> vHDenormCoefF;
     RegistersPool::Reg<Vmm> vGridPermMask;
-    RegistersPool::Reg<Vmm> vDataTypeSizeB;      // for ZEROS padding
-    RegistersPool::Reg<Vmm> vSrcWidthB;          // for ZEROS padding
+    RegistersPool::Reg<Vmm> vDataTypeSizeB;  // for ZEROS padding
+    RegistersPool::Reg<Vmm> vSrcWidthB;      // for ZEROS padding
 
-    RegistersPool::Reg<Vmm> vSrcHeightSub1F;     // for BORDER padding
-    RegistersPool::Reg<Vmm> vSrcWidthSub1F;      // for BORDER padding
+    RegistersPool::Reg<Vmm> vSrcHeightSub1F;  // for BORDER padding
+    RegistersPool::Reg<Vmm> vSrcWidthSub1F;   // for BORDER padding
 
-    RegistersPool::Reg<Vmm> vSrcHeightMul2F;     // for REFLECTION padding
-    RegistersPool::Reg<Vmm> vSrcWidthMul2F;      // for REFLECTION padding
-    RegistersPool::Reg<Vmm> vSrcHeightMul2Sub1F; // for REFLECTION padding
-    RegistersPool::Reg<Vmm> vSrcWidthMul2Sub1F;  // for REFLECTION padding
-    RegistersPool::Reg<Vmm> vAbsMask;            // for REFLECTION padding
+    RegistersPool::Reg<Vmm> vSrcHeightMul2F;      // for REFLECTION padding
+    RegistersPool::Reg<Vmm> vSrcWidthMul2F;       // for REFLECTION padding
+    RegistersPool::Reg<Vmm> vSrcHeightMul2Sub1F;  // for REFLECTION padding
+    RegistersPool::Reg<Vmm> vSrcWidthMul2Sub1F;   // for REFLECTION padding
+    RegistersPool::Reg<Vmm> vAbsMask;             // for REFLECTION padding
 
-    RegistersPool::Reg<Vmm> vConst_0_75;         // for BICUBIC interpolation
-    RegistersPool::Reg<Vmm> vConst_1_25;         // for BICUBIC interpolation
-    RegistersPool::Reg<Vmm> vConst_1_50;         // for BICUBIC interpolation
-    RegistersPool::Reg<Vmm> vConst_2_00;         // for BICUBIC interpolation
-    RegistersPool::Reg<Vmm> vConst_2_25;         // for BICUBIC interpolation
+    RegistersPool::Reg<Vmm> vConst_0_75;  // for BICUBIC interpolation
+    RegistersPool::Reg<Vmm> vConst_1_25;  // for BICUBIC interpolation
+    RegistersPool::Reg<Vmm> vConst_1_50;  // for BICUBIC interpolation
+    RegistersPool::Reg<Vmm> vConst_2_00;  // for BICUBIC interpolation
+    RegistersPool::Reg<Vmm> vConst_2_25;  // for BICUBIC interpolation
 
     void initVectors();
     void process();
@@ -179,8 +186,8 @@ class GridSampleKernel : public GridSampleKernelBase {
     void hwShiftPs2dq(const Vmm& vDst, const Vmm& vHCoord, const Vmm& vWCoord, const Vmm& vWidth);
 };
 
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
-}   // namespace kernel
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace kernel
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel.cpp
index cd8b32d9ad2a38..2eb981007f2217 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel.cpp
@@ -3,9 +3,10 @@
 //
 
 #include "jit_kernel.hpp"
-#include <stdexcept>
-#include <iostream>
+
 #include <cstring>
+#include <iostream>
+#include <stdexcept>
 #include <unordered_set>
 
 using namespace dnnl::impl;
@@ -17,16 +18,16 @@ namespace intel_cpu {
 
 namespace {
 
-template<typename RegType>
+template <typename RegType>
 using registers = std::array<std::reference_wrapper<const RegType>, 16>;
 
 bool isRegAllocable(int id) {
-    return id != abi_param1.getIdx()          // function argument
-            && id != Operand::Code::RSP;      // stack pointer
+    return id != abi_param1.getIdx()     // function argument
+           && id != Operand::Code::RSP;  // stack pointer
 }
 
-template<typename RegType>
-const RegType & reserveReg(jit_kernel::reg_indices & freeRegs, const registers<RegType> & regs) {
+template <typename RegType>
+const RegType& reserveReg(jit_kernel::reg_indices& freeRegs, const registers<RegType>& regs) {
     if (freeRegs.empty())
         throw std::runtime_error("No free registers");
     const auto idx = freeRegs.back();
@@ -34,8 +35,8 @@ const RegType & reserveReg(jit_kernel::reg_indices & freeRegs, const registers<R
     return regs[idx];
 }
 
-template<typename RegType>
-void freeReg(jit_kernel::reg_indices & freeRegs, const registers<RegType> & regs, const RegType & reg) {
+template <typename RegType>
+void freeReg(jit_kernel::reg_indices& freeRegs, const registers<RegType>& regs, const RegType& reg) {
     const auto idx = reg.getIdx();
     // Debug:
     // auto it = std::find(freeRegs.begin(), freeRegs.end(), idx);
@@ -46,105 +47,189 @@ void freeReg(jit_kernel::reg_indices & freeRegs, const registers<RegType> & regs
         OPENVINO_THROW("Some register was freed twice");
 }
 
-const registers<Reg64> & x64regs() {
+const registers<Reg64>& x64regs() {
     using namespace Xbyak::util;
-    static const registers<Reg64> _x64regs {{
-        rax, rcx, rdx, rbx,
-        rsp, rbp, rsi, rdi,
-        r8,  r9,  r10, r11,
-        r12, r13, r14, r15,
+    static const registers<Reg64> _x64regs{{
+        rax,
+        rcx,
+        rdx,
+        rbx,
+        rsp,
+        rbp,
+        rsi,
+        rdi,
+        r8,
+        r9,
+        r10,
+        r11,
+        r12,
+        r13,
+        r14,
+        r15,
     }};
     return _x64regs;
 }
 
-const registers<Reg32> & x32regs() {
+const registers<Reg32>& x32regs() {
     using namespace Xbyak::util;
-    static const registers<Reg32> _x32regs {{
-        eax,  ecx,  edx,  ebx,
-        esp,  ebp,  esi,  edi,
-        r8d,  r9d,  r10d, r11d,
-        r12d, r13d, r14d, r15d,
+    static const registers<Reg32> _x32regs{{
+        eax,
+        ecx,
+        edx,
+        ebx,
+        esp,
+        ebp,
+        esi,
+        edi,
+        r8d,
+        r9d,
+        r10d,
+        r11d,
+        r12d,
+        r13d,
+        r14d,
+        r15d,
     }};
     return _x32regs;
 }
 
-const registers<Reg16> & x16regs() {
+const registers<Reg16>& x16regs() {
     using namespace Xbyak::util;
-    static const registers<Reg16> _x16regs {{
-        ax,   cx,   dx,   bx,
-        sp,   bp,   si,   di,
-        r8w,  r9w,  r10w, r11w,
-        r12w, r13w, r14w, r15w,
+    static const registers<Reg16> _x16regs{{
+        ax,
+        cx,
+        dx,
+        bx,
+        sp,
+        bp,
+        si,
+        di,
+        r8w,
+        r9w,
+        r10w,
+        r11w,
+        r12w,
+        r13w,
+        r14w,
+        r15w,
     }};
     return _x16regs;
 }
 
-const registers<Reg8> & x8regs() {
+const registers<Reg8>& x8regs() {
     using namespace Xbyak::util;
-    static const registers<Reg8> _x8regs {{
-        al,   cl,   dl,   bl,
-        spl,  bpl,  sil,  dil,
-        r8b,  r9b,  r10b, r11b,
-        r12b, r13b, r14b, r15b,
+    static const registers<Reg8> _x8regs{{
+        al,
+        cl,
+        dl,
+        bl,
+        spl,
+        bpl,
+        sil,
+        dil,
+        r8b,
+        r9b,
+        r10b,
+        r11b,
+        r12b,
+        r13b,
+        r14b,
+        r15b,
     }};
     return _x8regs;
 }
 
-const registers<Xmm> & xmmregs() {
-    static const registers<Xmm> _xmmregs {{
-        Xbyak::util::xmm0,  Xbyak::util::xmm1,  Xbyak::util::xmm2,  Xbyak::util::xmm3,
-        Xbyak::util::xmm4,  Xbyak::util::xmm5,  Xbyak::util::xmm6,  Xbyak::util::xmm7,
-        Xbyak::util::xmm8,  Xbyak::util::xmm9,  Xbyak::util::xmm10, Xbyak::util::xmm11,
-        Xbyak::util::xmm12, Xbyak::util::xmm13, Xbyak::util::xmm14, Xbyak::util::xmm15,
+const registers<Xmm>& xmmregs() {
+    static const registers<Xmm> _xmmregs{{
+        Xbyak::util::xmm0,
+        Xbyak::util::xmm1,
+        Xbyak::util::xmm2,
+        Xbyak::util::xmm3,
+        Xbyak::util::xmm4,
+        Xbyak::util::xmm5,
+        Xbyak::util::xmm6,
+        Xbyak::util::xmm7,
+        Xbyak::util::xmm8,
+        Xbyak::util::xmm9,
+        Xbyak::util::xmm10,
+        Xbyak::util::xmm11,
+        Xbyak::util::xmm12,
+        Xbyak::util::xmm13,
+        Xbyak::util::xmm14,
+        Xbyak::util::xmm15,
     }};
     return _xmmregs;
 }
 
-const registers<Ymm> & ymmregs() {
-    static const registers<Ymm> _ymmregs {{
-        Xbyak::util::ymm0,  Xbyak::util::ymm1,  Xbyak::util::ymm2,  Xbyak::util::ymm3,
-        Xbyak::util::ymm4,  Xbyak::util::ymm5,  Xbyak::util::ymm6,  Xbyak::util::ymm7,
-        Xbyak::util::ymm8,  Xbyak::util::ymm9,  Xbyak::util::ymm10, Xbyak::util::ymm11,
-        Xbyak::util::ymm12, Xbyak::util::ymm13, Xbyak::util::ymm14, Xbyak::util::ymm15,
+const registers<Ymm>& ymmregs() {
+    static const registers<Ymm> _ymmregs{{
+        Xbyak::util::ymm0,
+        Xbyak::util::ymm1,
+        Xbyak::util::ymm2,
+        Xbyak::util::ymm3,
+        Xbyak::util::ymm4,
+        Xbyak::util::ymm5,
+        Xbyak::util::ymm6,
+        Xbyak::util::ymm7,
+        Xbyak::util::ymm8,
+        Xbyak::util::ymm9,
+        Xbyak::util::ymm10,
+        Xbyak::util::ymm11,
+        Xbyak::util::ymm12,
+        Xbyak::util::ymm13,
+        Xbyak::util::ymm14,
+        Xbyak::util::ymm15,
     }};
     return _ymmregs;
 }
 
-const registers<Zmm> & zmmregs() {
-    static const registers<Zmm> _zmmregs {{
-        Xbyak::util::zmm0,  Xbyak::util::zmm1,  Xbyak::util::zmm2,  Xbyak::util::zmm3,
-        Xbyak::util::zmm4,  Xbyak::util::zmm5,  Xbyak::util::zmm6,  Xbyak::util::zmm7,
-        Xbyak::util::zmm8,  Xbyak::util::zmm9,  Xbyak::util::zmm10, Xbyak::util::zmm11,
-        Xbyak::util::zmm12, Xbyak::util::zmm13, Xbyak::util::zmm14, Xbyak::util::zmm15,
+const registers<Zmm>& zmmregs() {
+    static const registers<Zmm> _zmmregs{{
+        Xbyak::util::zmm0,
+        Xbyak::util::zmm1,
+        Xbyak::util::zmm2,
+        Xbyak::util::zmm3,
+        Xbyak::util::zmm4,
+        Xbyak::util::zmm5,
+        Xbyak::util::zmm6,
+        Xbyak::util::zmm7,
+        Xbyak::util::zmm8,
+        Xbyak::util::zmm9,
+        Xbyak::util::zmm10,
+        Xbyak::util::zmm11,
+        Xbyak::util::zmm12,
+        Xbyak::util::zmm13,
+        Xbyak::util::zmm14,
+        Xbyak::util::zmm15,
     }};
     return _zmmregs;
 }
 
-}   // namespace
+}  // namespace
 
 namespace internal {
 
-template<>
+template <>
 ov::element::Type type2precision<float>() {
     return ov::element::f32;
 }
 
-template<>
+template <>
 ov::element::Type type2precision<int32_t>() {
     return ov::element::i32;
 }
 
-template<>
+template <>
 ov::element::Type type2precision<bfloat16_t>() {
     return ov::element::bf16;
 }
 
-template<>
+template <>
 ov::element::Type type2precision<uint8_t>() {
     return ov::element::u8;
 }
 
-template<>
+template <>
 ov::element::Type type2precision<int8_t>() {
     return ov::element::i8;
 }
@@ -157,27 +242,24 @@ cpu_isa_t get_current_isa() {
     return cpu_isa_t::sse41;
 }
 
-stack_frame::stack_frame(ov::intel_cpu::jit_kernel & kernel, size_t size, uint32_t alignment)
-    : _kernel(kernel)
-    , _size(size)
-    , _alignment(alignment) {
+stack_frame::stack_frame(ov::intel_cpu::jit_kernel& kernel, size_t size, uint32_t alignment)
+    : _kernel(kernel),
+      _size(size),
+      _alignment(alignment) {
     if (_size || _alignment) {
         if (_size && _alignment == 1) {
             _kernel.sub(_kernel.rsp, _size);
         } else {
             auto tmp = _kernel.var<size_t>();
             tmp = _kernel.rsp;
-            _kernel.sub(_kernel.rsp, sizeof(size_t) + size);        // allocate
-            _kernel.and_(_kernel.rsp, ~(alignment - 1));            // align
-            _kernel.mov(_kernel.ptr[_kernel.rsp + size], tmp);      // remember previous rsp
+            _kernel.sub(_kernel.rsp, sizeof(size_t) + size);    // allocate
+            _kernel.and_(_kernel.rsp, ~(alignment - 1));        // align
+            _kernel.mov(_kernel.ptr[_kernel.rsp + size], tmp);  // remember previous rsp
         }
     }
 }
 
-stack_frame::stack_frame(stack_frame && rhs)
-    : _kernel(rhs._kernel)
-    , _size(rhs._size)
-    , _alignment(rhs._alignment) {
+stack_frame::stack_frame(stack_frame&& rhs) : _kernel(rhs._kernel), _size(rhs._size), _alignment(rhs._alignment) {
     rhs._size = 0;
     rhs._alignment = 0;
 }
@@ -192,25 +274,29 @@ stack_frame::~stack_frame() {
     }
 }
 
-const Xbyak::Reg64 & stack_frame::pointer() const {
+const Xbyak::Reg64& stack_frame::pointer() const {
     return _kernel.rsp;
 }
 
 void stack_frame::clear() const {
     const size_t end = _size & ~(size_t)7u;
 
-    _kernel.foreach(0, end, [&](const Reg64 & idx) {
-        _kernel.mov(_kernel.qword[pointer() + idx], 0);
-    }, sizeof(size_t));
+    _kernel.foreach (
+        0,
+        end,
+        [&](const Reg64& idx) {
+            _kernel.mov(_kernel.qword[pointer() + idx], 0);
+        },
+        sizeof(size_t));
 
     if (end < _size) {
-        _kernel.foreach(end, _size, [&](const Reg64 & idx) {
+        _kernel.foreach (end, _size, [&](const Reg64& idx) {
             _kernel.mov(_kernel.byte[pointer() + idx], 0);
         });
     }
 }
 
-const void * consts_table::store(const void *data, size_t size) {
+const void* consts_table::store(const void* data, size_t size) {
     if (size > chunk_size)
         throw std::runtime_error("Data size is too large");
     const size_t capacity = _chunks.size() * chunk_size;
@@ -218,17 +304,16 @@ const void * consts_table::store(const void *data, size_t size) {
         _size = _chunks.size() * chunk_size;
         _chunks.emplace_back();
     }
-    auto & dst = _chunks.back();
+    auto& dst = _chunks.back();
     const size_t offset = _size % chunk_size;
     memcpy(&dst[offset], data, size);
     _size += size;
     return &dst[offset];
 }
 
-}   // namespace internal
+}  // namespace internal
 
-jit_kernel::jit_kernel(const char* name)
-    : jit_generator(name) {
+jit_kernel::jit_kernel(const char* name) : jit_generator(name) {
     _free_rmmregs.reserve(16);
     _free_rmmregs.reserve(16);
 
@@ -239,73 +324,73 @@ jit_kernel::jit_kernel(const char* name)
     }
 }
 
-template<>
-const Reg64 & jit_kernel::reserve<Reg64>() {
+template <>
+const Reg64& jit_kernel::reserve<Reg64>() {
     return reserveReg(_free_x64regs, x64regs());
 }
 
-template<>
-const Reg32 & jit_kernel::reserve<Reg32>() {
+template <>
+const Reg32& jit_kernel::reserve<Reg32>() {
     return reserveReg(_free_x64regs, x32regs());
 }
 
-template<>
-const Reg16 & jit_kernel::reserve<Reg16>() {
+template <>
+const Reg16& jit_kernel::reserve<Reg16>() {
     return reserveReg(_free_x64regs, x16regs());
 }
 
-template<>
-const Reg8 & jit_kernel::reserve<Reg8>() {
+template <>
+const Reg8& jit_kernel::reserve<Reg8>() {
     return reserveReg(_free_x64regs, x8regs());
 }
 
-template<>
-void jit_kernel::free<Reg64>(const Reg64 & reg) {
+template <>
+void jit_kernel::free<Reg64>(const Reg64& reg) {
     freeReg(_free_x64regs, x64regs(), reg);
 }
 
-template<>
-void jit_kernel::free<Reg32>(const Reg32 & reg) {
+template <>
+void jit_kernel::free<Reg32>(const Reg32& reg) {
     freeReg(_free_x64regs, x32regs(), reg);
 }
 
-template<>
-void jit_kernel::free<Reg16>(const Reg16 & reg) {
+template <>
+void jit_kernel::free<Reg16>(const Reg16& reg) {
     freeReg(_free_x64regs, x16regs(), reg);
 }
 
-template<>
-void jit_kernel::free<Reg8>(const Reg8 & reg) {
+template <>
+void jit_kernel::free<Reg8>(const Reg8& reg) {
     freeReg(_free_x64regs, x8regs(), reg);
 }
 
-template<>
-const Xmm & jit_kernel::reserve<Xmm>() {
+template <>
+const Xmm& jit_kernel::reserve<Xmm>() {
     return reserveReg(_free_rmmregs, xmmregs());
 }
 
-template<>
-void jit_kernel::free<Xmm>(const Xmm & reg) {
+template <>
+void jit_kernel::free<Xmm>(const Xmm& reg) {
     freeReg(_free_rmmregs, xmmregs(), reg);
 }
 
-template<>
-const Ymm & jit_kernel::reserve<Ymm>() {
+template <>
+const Ymm& jit_kernel::reserve<Ymm>() {
     return reserveReg(_free_rmmregs, ymmregs());
 }
 
-template<>
-void jit_kernel::free<Ymm>(const Ymm & reg) {
+template <>
+void jit_kernel::free<Ymm>(const Ymm& reg) {
     freeReg(_free_rmmregs, ymmregs(), reg);
 }
 
-template<>
-const Zmm & jit_kernel::reserve<Zmm>() {
+template <>
+const Zmm& jit_kernel::reserve<Zmm>() {
     return reserveReg(_free_rmmregs, zmmregs());
 }
 
-template<>
-void jit_kernel::free<Zmm>(const Zmm & reg) {
+template <>
+void jit_kernel::free<Zmm>(const Zmm& reg) {
     freeReg(_free_rmmregs, zmmregs(), reg);
 }
 
@@ -317,26 +402,33 @@ void jit_kernel::postamble() {
     }
 }
 
-const AddressFrame & jit_kernel::address_frame(size_t size) const {
-        switch (size) {
-            case 1: return byte;
-            case 2: return word;
-            case 4: return dword;
-            case 8: return qword;
-            case 16: return xword;
-            case 32: return yword;
-            case 64: return zword;
-            default:
-                break;
-        }
-        return ptr;
+const AddressFrame& jit_kernel::address_frame(size_t size) const {
+    switch (size) {
+    case 1:
+        return byte;
+    case 2:
+        return word;
+    case 4:
+        return dword;
+    case 8:
+        return qword;
+    case 16:
+        return xword;
+    case 32:
+        return yword;
+    case 64:
+        return zword;
+    default:
+        break;
+    }
+    return ptr;
 }
 
-const jit_kernel::reg_indices & jit_kernel::free_x64regs() const {
+const jit_kernel::reg_indices& jit_kernel::free_x64regs() const {
     return _free_x64regs;
 }
 
-const jit_kernel::reg_indices & jit_kernel::free_rmmregs() const {
+const jit_kernel::reg_indices& jit_kernel::free_rmmregs() const {
     return _free_rmmregs;
 }
 
@@ -386,5 +478,5 @@ void jit_kernel::uni_vblendps(const Xbyak::Zmm& z1, const Xbyak::Zmm& z2, uint16
     vblendmps(z1 | k1, z1, z2);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel.hpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel.hpp
index 8934bf5dff052b..0073ca91d0b76f 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel.hpp
@@ -3,14 +3,15 @@
 //
 
 #pragma once
-#include "cpu/x64/jit_generator.hpp"
-#include "emitters/plugin/x64/jit_load_store_emitters.hpp"
+#include <array>
 #include <common/nstl.hpp>
-#include <type_traits>
 #include <functional>
-#include <vector>
-#include <array>
 #include <tuple>
+#include <type_traits>
+#include <vector>
+
+#include "cpu/x64/jit_generator.hpp"
+#include "emitters/plugin/x64/jit_load_store_emitters.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -19,113 +20,103 @@ struct jit_kernel;
 
 namespace internal {
 
-template<size_t S>
+template <size_t S>
 struct reg_traits_by_size;
-template<typename T>
+template <typename T>
 struct reg_traits;
-template<typename T, size_t N>
+template <typename T, size_t N>
 struct reg_traits<T[N]>;
-template<dnnl::impl::cpu::x64::cpu_isa_t isa>
+template <dnnl::impl::cpu::x64::cpu_isa_t isa>
 struct isa_traits;
 
-template<>
+template <>
 struct reg_traits_by_size<1> {
     using type = Xbyak::Reg8;
-    constexpr static size_t size = 1;           // in bytes
-    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa
-                        = dnnl::impl::cpu::x64::cpu_isa_t::isa_undef;
+    constexpr static size_t size = 1;  // in bytes
+    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa = dnnl::impl::cpu::x64::cpu_isa_t::isa_undef;
 };
 
-template<>
+template <>
 struct reg_traits_by_size<2> {
     using type = Xbyak::Reg16;
-    constexpr static size_t size = 2;           // in bytes
-    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa
-                        = dnnl::impl::cpu::x64::cpu_isa_t::isa_undef;
+    constexpr static size_t size = 2;  // in bytes
+    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa = dnnl::impl::cpu::x64::cpu_isa_t::isa_undef;
 };
 
-template<>
+template <>
 struct reg_traits_by_size<4> {
     using type = Xbyak::Reg32;
-    constexpr static size_t size = 4;           // in bytes
-    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa
-                        = dnnl::impl::cpu::x64::cpu_isa_t::isa_undef;
+    constexpr static size_t size = 4;  // in bytes
+    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa = dnnl::impl::cpu::x64::cpu_isa_t::isa_undef;
 };
 
-template<>
+template <>
 struct reg_traits_by_size<8> {
     using type = Xbyak::Reg64;
-    constexpr static size_t size = 8;           // in bytes
-    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa
-                        = dnnl::impl::cpu::x64::cpu_isa_t::isa_undef;
+    constexpr static size_t size = 8;  // in bytes
+    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa = dnnl::impl::cpu::x64::cpu_isa_t::isa_undef;
 };
 
-template<>
+template <>
 struct reg_traits_by_size<16> {
     using type = Xbyak::Xmm;
-    constexpr static size_t size = 16;          // in bytes
-    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa
-                        = dnnl::impl::cpu::x64::cpu_isa_t::sse41;
+    constexpr static size_t size = 16;  // in bytes
+    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa = dnnl::impl::cpu::x64::cpu_isa_t::sse41;
 };
 
-template<>
+template <>
 struct reg_traits_by_size<32> {
     using type = Xbyak::Ymm;
-    constexpr static size_t size = 32;          // in bytes
-    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa
-                        = dnnl::impl::cpu::x64::cpu_isa_t::avx2;
+    constexpr static size_t size = 32;  // in bytes
+    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa = dnnl::impl::cpu::x64::cpu_isa_t::avx2;
 };
 
-template<>
+template <>
 struct reg_traits_by_size<64> {
     using type = Xbyak::Zmm;
-    constexpr static size_t size = 64;          // in bytes
-    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa
-                        = dnnl::impl::cpu::x64::cpu_isa_t::avx512_core;
+    constexpr static size_t size = 64;  // in bytes
+    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa = dnnl::impl::cpu::x64::cpu_isa_t::avx512_core;
 };
 
-template<typename T>
+template <typename T>
 struct reg_traits : public reg_traits_by_size<sizeof(T)> {};
 
-template<size_t N>
+template <size_t N>
 struct vec_min_size {
-    constexpr static size_t size = N <= 16 ? 16 :
-                                   N <= 32 ? 32 :
-                                   64;
+    constexpr static size_t size = N <= 16 ? 16 : N <= 32 ? 32 : 64;
 };
 
-template<typename T, size_t N>
+template <typename T, size_t N>
 struct reg_traits<T[N]> : public reg_traits_by_size<vec_min_size<sizeof(T[N])>::size> {};
 
-template<>
+template <>
 struct reg_traits<float> {
     using type = Xbyak::Fpu;
-    constexpr static size_t size = 10;          // in bytes
-    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa
-                        = dnnl::impl::cpu::x64::cpu_isa_t::isa_undef;
+    constexpr static size_t size = 10;  // in bytes
+    constexpr static dnnl::impl::cpu::x64::cpu_isa_t isa = dnnl::impl::cpu::x64::cpu_isa_t::isa_undef;
 };
-template<>
+template <>
 struct reg_traits<double> : public reg_traits<float> {};
 
-template<>
+template <>
 struct isa_traits<dnnl::impl::cpu::x64::cpu_isa_t::sse41> {
     struct reg {
         using type = Xbyak::Xmm;
-        constexpr static size_t size = 4 * 4;   // in bytes
-        constexpr static size_t length = 4;     // in dwords
+        constexpr static size_t size = 4 * 4;  // in bytes
+        constexpr static size_t length = 4;    // in dwords
     };
 };
 
-template<>
+template <>
 struct isa_traits<dnnl::impl::cpu::x64::cpu_isa_t::avx2> {
     struct reg {
         using type = Xbyak::Ymm;
-        constexpr static size_t size = 8 * 4;   // in bytes
-        constexpr static size_t length = 8;     // in dwords
+        constexpr static size_t size = 8 * 4;  // in bytes
+        constexpr static size_t length = 8;    // in dwords
     };
 };
 
-template<>
+template <>
 struct isa_traits<dnnl::impl::cpu::x64::cpu_isa_t::avx512_core> {
     struct reg {
         using type = Xbyak::Zmm;
@@ -134,39 +125,39 @@ struct isa_traits<dnnl::impl::cpu::x64::cpu_isa_t::avx512_core> {
     };
 };
 
-template<typename T, typename Tag>
+template <typename T, typename Tag>
 class variable;
-template<typename T>
+template <typename T>
 class if_expression;
-template<typename T>
+template <typename T>
 class then_expression;
-template<typename Reg>
+template <typename Reg>
 using shared_reg = std::shared_ptr<Reg>;
 
-template<typename Reg>
-shared_reg<Reg> make_shared(Reg & reg, jit_kernel & kernel);
+template <typename Reg>
+shared_reg<Reg> make_shared(Reg& reg, jit_kernel& kernel);
 
-template<typename T>
+template <typename T>
 class boolean_expression {
 public:
     using reg_type = const typename reg_traits<T>::type;
 
     enum class type {
-        eq,     // ==
-        neq,    // !=
-        ls,     // <
-        gt,     // >
-        le,     // <=
-        ge      // >=
+        eq,   // ==
+        neq,  // !=
+        ls,   // <
+        gt,   // >
+        le,   // <=
+        ge    // >=
     };
 
-    boolean_expression(jit_kernel & kernel, type t, const shared_reg<reg_type> & lhs, const shared_reg<reg_type> & rhs);
-    boolean_expression(jit_kernel & kernel, type t, const shared_reg<reg_type> & lhs, T rhs);
+    boolean_expression(jit_kernel& kernel, type t, const shared_reg<reg_type>& lhs, const shared_reg<reg_type>& rhs);
+    boolean_expression(jit_kernel& kernel, type t, const shared_reg<reg_type>& lhs, T rhs);
 
 private:
-    void cmp(const Xbyak::Label & exit) const;
+    void cmp(const Xbyak::Label& exit) const;
 
-    jit_kernel & _kernel;
+    jit_kernel& _kernel;
     type _type;
     shared_reg<reg_type> _lhs;
     shared_reg<reg_type> _rhs;
@@ -176,33 +167,33 @@ class boolean_expression {
     friend class then_expression<T>;
 };
 
-template<typename T>
+template <typename T>
 class then_expression {
 public:
-    then_expression(if_expression<T> & expr);
+    then_expression(if_expression<T>& expr);
 
-    template<typename F>
-    void _else(F && fn);
+    template <typename F>
+    void _else(F&& fn);
 
 private:
-    if_expression<T> & _if_expr;
+    if_expression<T>& _if_expr;
 };
 
-template<typename T>
+template <typename T>
 class if_expression {
 public:
-    if_expression(const boolean_expression<T> & expr)
-        : _expr(expr) {}
+    if_expression(const boolean_expression<T>& expr) : _expr(expr) {}
 
     ~if_expression() {
         try {
             if (!_is_exit_valid)
                 _expr._kernel.assignL(_exit, _else);
-        } catch(...) {}
+        } catch (...) {
+        }
     }
 
-    template<typename F>
-    then_expression<T> _then(F && fn) {
+    template <typename F>
+    then_expression<T> _then(F&& fn) {
         using namespace Xbyak;
 
         _expr.cmp(_else);
@@ -214,7 +205,7 @@ class if_expression {
     }
 
 private:
-    const boolean_expression<T> & _expr;
+    const boolean_expression<T>& _expr;
     Xbyak::Label _exit;
     Xbyak::Label _else;
     bool _is_exit_valid = false;
@@ -222,287 +213,291 @@ class if_expression {
     friend class then_expression<T>;
 };
 
-typedef struct register_tag {} register_tag;
-typedef struct memory_tag {} memory_tag;
+typedef struct register_tag {
+} register_tag;
+typedef struct memory_tag {
+} memory_tag;
 
-template<typename T, typename Tag>
+template <typename T, typename Tag>
 class variable_base;
 
-template<typename T>
+template <typename T>
 class variable_base<T, register_tag> {
 public:
     using reg_type = const typename reg_traits<T>::type;
 
-    variable_base & operator = (const variable_base &) = delete;
+    variable_base& operator=(const variable_base&) = delete;
 
-    variable_base(const variable_base &);
-    variable_base(variable_base &&);
+    variable_base(const variable_base&);
+    variable_base(variable_base&&);
 
-    reg_type & reg() const {
-        return  *_reg;
+    reg_type& reg() const {
+        return *_reg;
     }
 
-    const shared_reg<reg_type> & shreg() const {
+    const shared_reg<reg_type>& shreg() const {
         return _reg;
     }
 
-    operator reg_type &() const {
+    operator reg_type&() const {
         return reg();
     }
 
-    operator Xbyak::RegExp () const {
+    operator Xbyak::RegExp() const {
         return reg();
     }
 
 protected:
-    variable_base(jit_kernel & krnl, const shared_reg<reg_type> & reg);
+    variable_base(jit_kernel& krnl, const shared_reg<reg_type>& reg);
     ~variable_base() = default;
 
-    jit_kernel & _kernel;
+    jit_kernel& _kernel;
     shared_reg<reg_type> _reg;
 };
 
-template<typename T>
+template <typename T>
 class variable_base<T, memory_tag> {
 public:
     using reg_type = const typename reg_traits<T*>::type;
 
-    variable_base & operator = (const variable_base &) = delete;
+    variable_base& operator=(const variable_base&) = delete;
 
-    variable_base(const variable_base &);
-    variable_base(variable_base &&);
+    variable_base(const variable_base&);
+    variable_base(variable_base&&);
 
-    reg_type & reg() const {
-        return  *_addr;
+    reg_type& reg() const {
+        return *_addr;
     }
 
 protected:
-    variable_base(jit_kernel & krnl, const shared_reg<reg_type> & addr);
+    variable_base(jit_kernel& krnl, const shared_reg<reg_type>& addr);
     ~variable_base() = default;
 
-    jit_kernel & _kernel;
+    jit_kernel& _kernel;
     shared_reg<const reg_type> _addr;
 };
 
-template<typename T>
-class variable<T, register_tag> : public variable_base<typename std::enable_if<!std::is_floating_point<T>::value, T>::type, register_tag> {
+template <typename T>
+class variable<T, register_tag>
+    : public variable_base<typename std::enable_if<!std::is_floating_point<T>::value, T>::type, register_tag> {
 public:
     using type = T;
     using base = variable_base<type, register_tag>;
     using reg_type = const typename base::reg_type;
     using arithmetic_type = typename std::conditional<std::is_pointer<T>::value, size_t, T>::type;
 
-    variable(variable &&) = default;
-    variable(jit_kernel & krnl);
-    variable(jit_kernel & krnl, const shared_reg<reg_type> & reg);
+    variable(variable&&) = default;
+    variable(jit_kernel& krnl);
+    variable(jit_kernel& krnl, const shared_reg<reg_type>& reg);
 
-    typename std::conditional<std::is_pointer<T>::value
-                    && !std::is_pointer<typename std::remove_pointer<T>::type>::value,
-                    variable<typename std::remove_pointer<T>::type, memory_tag>, void>::type
-    operator *() const {
+    typename std::conditional<std::is_pointer<T>::value &&
+                                  !std::is_pointer<typename std::remove_pointer<T>::type>::value,
+                              variable<typename std::remove_pointer<T>::type, memory_tag>,
+                              void>::type
+    operator*() const {
         return variable<typename std::remove_pointer<T>::type, memory_tag>(base::_kernel, base::shreg());
     }
 
-    const variable & operator = (reg_type & rhs) const {
+    const variable& operator=(reg_type& rhs) const {
         base::_kernel.mov(base::reg(), rhs);
         return *this;
     }
-    template<typename U>
-    const variable & operator = (U *rhs) const {
+    template <typename U>
+    const variable& operator=(U* rhs) const {
         // interpret pointers as size_t
         base::_kernel.mov(base::reg(), reinterpret_cast<size_t>(rhs));
         return *this;
     }
-    const variable & operator = (arithmetic_type rhs) const {
+    const variable& operator=(arithmetic_type rhs) const {
         base::_kernel.mov(base::reg(), static_cast<size_t>(rhs));
         return *this;
     }
-    const variable & operator += (reg_type & rhs) const {
+    const variable& operator+=(reg_type& rhs) const {
         base::_kernel.add(base::reg(), rhs);
         return *this;
     }
-    variable operator + (reg_type & rhs) const {
+    variable operator+(reg_type& rhs) const {
         variable res(base::_kernel);
         res = base::reg();
         res += rhs;
         return res;
     }
-    const variable & operator += (arithmetic_type rhs) const {
+    const variable& operator+=(arithmetic_type rhs) const {
         base::_kernel.add(base::reg(), rhs);
         return *this;
     }
-    variable operator + (arithmetic_type rhs) const {
+    variable operator+(arithmetic_type rhs) const {
         variable res(base::_kernel);
         res = base::reg();
         res += rhs;
         return res;
     }
-    const variable & operator -= (reg_type & rhs) const {
+    const variable& operator-=(reg_type& rhs) const {
         base::_kernel.sub(base::reg(), rhs);
         return *this;
     }
-    variable operator - (reg_type & rhs) const {
+    variable operator-(reg_type& rhs) const {
         variable res(base::_kernel);
         res = base::reg();
         res -= rhs;
         return res;
     }
-    const variable & operator -= (arithmetic_type rhs) const {
+    const variable& operator-=(arithmetic_type rhs) const {
         base::_kernel.sub(base::reg(), rhs);
         return *this;
     }
-    variable operator - (arithmetic_type rhs) const {
+    variable operator-(arithmetic_type rhs) const {
         variable res(base::_kernel);
         res = base::reg();
         res -= rhs;
         return res;
     }
-    const variable & operator *= (reg_type & rhs) const {
+    const variable& operator*=(reg_type& rhs) const {
         base::_kernel.imul(base::reg(), rhs);
         return *this;
     }
-    variable operator * (reg_type & rhs) const {
+    variable operator*(reg_type& rhs) const {
         variable res(base::_kernel);
         res = base::reg();
         res *= rhs;
         return res;
     }
-    const variable & operator *= (arithmetic_type rhs) const {
+    const variable& operator*=(arithmetic_type rhs) const {
         base::_kernel.imul(base::reg(), base::reg(), static_cast<int>(rhs));
         return *this;
     }
-    variable operator * (arithmetic_type rhs) const {
+    variable operator*(arithmetic_type rhs) const {
         variable res(base::_kernel);
         res = base::reg();
         res *= rhs;
         return res;
     }
-    const variable & operator &= (reg_type & rhs) const {
+    const variable& operator&=(reg_type& rhs) const {
         base::_kernel.and_(base::reg(), rhs);
         return *this;
     }
-    variable operator & (reg_type & rhs) const {
+    variable operator&(reg_type& rhs) const {
         variable res(base::_kernel);
         res = base::reg();
         res &= rhs;
         return res;
     }
-    const variable & operator &= (T rhs) const {
+    const variable& operator&=(T rhs) const {
         base::_kernel.and_(base::reg(), rhs);
         return *this;
     }
-    variable operator & (T rhs) const {
+    variable operator&(T rhs) const {
         variable res(base::_kernel);
         res = base::reg();
         res &= rhs;
         return res;
     }
-    const variable & operator |= (reg_type & rhs) const {
+    const variable& operator|=(reg_type& rhs) const {
         base::_kernel.or_(base::reg(), rhs);
         return *this;
     }
-    variable operator | (reg_type & rhs) const {
+    variable operator|(reg_type& rhs) const {
         variable res(base::_kernel);
         res = base::reg();
         res |= rhs;
         return res;
     }
-    const variable & operator |= (T rhs) const {
+    const variable& operator|=(T rhs) const {
         base::_kernel.or_(base::reg(), rhs);
         return *this;
     }
-    variable operator | (T rhs) const {
+    variable operator|(T rhs) const {
         variable res(base::_kernel);
         res = base::reg();
         res |= rhs;
         return res;
     }
-    const variable & operator >>= (size_t rhs) const {
+    const variable& operator>>=(size_t rhs) const {
         base::_kernel.shr(base::reg(), rhs);
         return *this;
     }
-    variable operator >> (size_t rhs) const {
+    variable operator>>(size_t rhs) const {
         variable res(base::_kernel);
         res = base::reg();
         res >>= rhs;
         return res;
     }
-    const variable & operator <<= (size_t rhs) const {
+    const variable& operator<<=(size_t rhs) const {
         base::_kernel.shl(base::reg(), rhs);
         return *this;
     }
-    variable operator << (size_t rhs) const {
+    variable operator<<(size_t rhs) const {
         variable res(base::_kernel);
         res = base::reg();
         res <<= rhs;
         return res;
     }
 
-    boolean_expression<T> operator == (const variable & rhs) const {
+    boolean_expression<T> operator==(const variable& rhs) const {
         return boolean_expression<T>(base::_kernel, boolean_expression<T>::type::eq, base::shreg(), rhs.shreg());
     }
 
-    boolean_expression<T> operator == (T rhs) const {
+    boolean_expression<T> operator==(T rhs) const {
         return boolean_expression<T>(base::_kernel, boolean_expression<T>::type::eq, base::shreg(), rhs);
     }
 
-    boolean_expression<T> operator != (const variable & rhs) const {
+    boolean_expression<T> operator!=(const variable& rhs) const {
         return boolean_expression<T>(base::_kernel, boolean_expression<T>::type::neq, base::shreg(), rhs.shreg());
     }
 
-    boolean_expression<T> operator != (T rhs) const {
+    boolean_expression<T> operator!=(T rhs) const {
         return boolean_expression<T>(base::_kernel, boolean_expression<T>::type::neq, base::shreg(), rhs);
     }
 
-    boolean_expression<T> operator < (const variable & rhs) const {
+    boolean_expression<T> operator<(const variable& rhs) const {
         return boolean_expression<T>(base::_kernel, boolean_expression<T>::type::ls, base::shreg(), rhs.shreg());
     }
 
-    boolean_expression<T> operator < (T rhs) const {
+    boolean_expression<T> operator<(T rhs) const {
         return boolean_expression<T>(base::_kernel, boolean_expression<T>::type::ls, base::shreg(), rhs);
     }
 
-    boolean_expression<T> operator > (const variable & rhs) const {
+    boolean_expression<T> operator>(const variable& rhs) const {
         return boolean_expression<T>(base::_kernel, boolean_expression<T>::type::gt, base::shreg(), rhs.shreg());
     }
 
-    boolean_expression<T> operator > (T rhs) const {
+    boolean_expression<T> operator>(T rhs) const {
         return boolean_expression<T>(base::_kernel, boolean_expression<T>::type::gt, base::shreg(), rhs);
     }
 
-    boolean_expression<T> operator <= (const variable & rhs) const {
+    boolean_expression<T> operator<=(const variable& rhs) const {
         return boolean_expression<T>(base::_kernel, boolean_expression<T>::type::le, base::shreg(), rhs.shreg());
     }
 
-    boolean_expression<T> operator <= (T rhs) const {
+    boolean_expression<T> operator<=(T rhs) const {
         return boolean_expression<T>(base::_kernel, boolean_expression<T>::type::le, base::shreg(), rhs);
     }
 
-    boolean_expression<T> operator >= (const variable & rhs) const {
+    boolean_expression<T> operator>=(const variable& rhs) const {
         return boolean_expression<T>(base::_kernel, boolean_expression<T>::type::ge, base::shreg(), rhs.shreg());
     }
 
-    boolean_expression<T> operator >= (T rhs) const {
+    boolean_expression<T> operator>=(T rhs) const {
         return boolean_expression<T>(base::_kernel, boolean_expression<T>::type::ge, base::shreg(), rhs);
     }
 
     // TODO: add necessary operations
 };
 
-template<typename T>
+template <typename T>
 class variable<T, memory_tag> : public variable_base<T*, memory_tag> {
 public:
     using type = T;
     using base = variable_base<type*, memory_tag>;
     using reg_type = const typename base::reg_type;
 
-    variable(variable &&) = default;
-    variable(jit_kernel & krnl, const shared_reg<reg_type> & reg);
+    variable(variable&&) = default;
+    variable(jit_kernel& krnl, const shared_reg<reg_type>& reg);
 
-    const variable & operator = (const variable<T, register_tag> & rhs) const;
+    const variable& operator=(const variable<T, register_tag>& rhs) const;
 };
 
-template<typename T, size_t N>
+template <typename T, size_t N>
 class variable<T[N], register_tag> : public variable_base<T[N], register_tag> {
 public:
     using type = T[N];
@@ -510,34 +505,34 @@ class variable<T[N], register_tag> : public variable_base<T[N], register_tag> {
     using reg_type = const typename base::reg_type;
     constexpr static size_t length = N;
 
-    variable(variable &&) = default;
-    variable(jit_kernel & krnl);
-    variable(jit_kernel & krnl, const shared_reg<reg_type> & reg);
+    variable(variable&&) = default;
+    variable(jit_kernel& krnl);
+    variable(jit_kernel& krnl, const shared_reg<reg_type>& reg);
 
-    const variable & operator = (reg_type & rhs) const {
+    const variable& operator=(reg_type& rhs) const {
         base::_kernel.uni_vmovups(base::reg(), rhs);
         return *this;
     }
 
-    const variable & operator = (const type & rhs) const {
-        const type & cref = base::_kernel.constant(rhs);
+    const variable& operator=(const type& rhs) const {
+        const type& cref = base::_kernel.constant(rhs);
         variable<const type*, register_tag> creg(base::_kernel);
         creg = &cref;
         base::_kernel.uni_vmovdqu(base::reg(), base::_kernel.ptr[creg]);
         return *this;
     }
 
-    const variable & blend(reg_type & rhs, uint16_t mask) const {
+    const variable& blend(reg_type& rhs, uint16_t mask) const {
         base::_kernel.uni_vblendps(base::reg(), rhs, mask);
         return *this;
     }
 
-    const variable & permute(const std::array<uint8_t, N> & order) const {
+    const variable& permute(const std::array<uint8_t, N>& order) const {
         base::_kernel.uni_vpermps(base::reg(), order.data(), base::reg());
         return *this;
     }
 
-    const variable & permute(const uint8_t * order) const {
+    const variable& permute(const uint8_t* order) const {
         base::_kernel.uni_vpermps(base::reg(), order, base::reg());
         return *this;
     }
@@ -546,139 +541,132 @@ class variable<T[N], register_tag> : public variable_base<T[N], register_tag> {
 };
 
 class stack_frame {
-    stack_frame(const stack_frame &) = delete;
-    stack_frame & operator = (const stack_frame &) = delete;
+    stack_frame(const stack_frame&) = delete;
+    stack_frame& operator=(const stack_frame&) = delete;
 
 public:
-    stack_frame(jit_kernel & kernel, size_t size, uint32_t alignment = 1);
-    stack_frame(stack_frame && rhs);
+    stack_frame(jit_kernel& kernel, size_t size, uint32_t alignment = 1);
+    stack_frame(stack_frame&& rhs);
     ~stack_frame();
-    const Xbyak::Reg64 & pointer() const;
+    const Xbyak::Reg64& pointer() const;
     void clear() const;
 
 private:
-    jit_kernel & _kernel;
+    jit_kernel& _kernel;
     size_t _size;
     uint32_t _alignment;
 };
 
-template<typename T>
+template <typename T>
 ov::element::Type type2precision();
 
 dnnl::impl::cpu::x64::cpu_isa_t get_current_isa();
 
 class consts_table {
-    consts_table(const consts_table &) = delete;
-    consts_table & operator = (const consts_table &) = delete;
+    consts_table(const consts_table&) = delete;
+    consts_table& operator=(const consts_table&) = delete;
 
 public:
     consts_table() = default;
-    const void * store(const void *data, size_t size);
+    const void* store(const void* data, size_t size);
 
 private:
     static constexpr const size_t chunk_size = 512;
     using chunk = std::array<uint8_t, chunk_size>;
     std::list<chunk> _chunks;
-    size_t _size {};
+    size_t _size{};
 };
 
-}   // namespace internal
+}  // namespace internal
 
 struct jit_kernel : public dnnl::impl::cpu::x64::jit_generator {
     using reg_indices = std::vector<int>;
-    template<typename T>
+    template <typename T>
     using reg_traits = internal::reg_traits<T>;
-    template<size_t S>
+    template <size_t S>
     using reg_traits_by_size = internal::reg_traits_by_size<S>;
-    template<dnnl::impl::cpu::x64::cpu_isa_t isa>
+    template <dnnl::impl::cpu::x64::cpu_isa_t isa>
     using isa_traits = internal::isa_traits<isa>;
     using stack_frame = internal::stack_frame;
     using register_tag = internal::register_tag;
     using memory_tag = internal::memory_tag;
-    template<typename T, typename Tag = register_tag>
+    template <typename T, typename Tag = register_tag>
     using variable = internal::variable<T, Tag>;
-    template<typename T>
+    template <typename T>
     using if_expression = internal::if_expression<T>;
-    template<typename T>
+    template <typename T>
     using boolean_expression = internal::boolean_expression<T>;
 
-    template<typename T, typename U>
+    template <typename T, typename U>
     Xbyak::Address argPtr(U T::*member) const {
         auto memPtr = &(reinterpret_cast<const T*>(0)->*member);
-        const size_t offs =  reinterpret_cast<const char*>(memPtr) - reinterpret_cast<const char*>(0);
+        const size_t offs = reinterpret_cast<const char*>(memPtr) - reinterpret_cast<const char*>(0);
         return address_frame(sizeof(U))[param1 + offs];
     }
 
-    template<typename T, typename U>
+    template <typename T, typename U>
     variable<U> arg(U T::*member) {
         using traits = internal::reg_traits<U>;
         using reg_type = typename traits::type;
-        const auto & res = reserve<reg_type>();
+        const auto& res = reserve<reg_type>();
         if (sizeof(T) < traits::size)
             movzx(res, argPtr(member));
         else
             mov(res, argPtr(member));
-        return { *this, internal::make_shared(res, *this) };
+        return {*this, internal::make_shared(res, *this)};
     }
 
-    template<typename CastU, typename T, typename U>
+    template <typename CastU, typename T, typename U>
     variable<CastU> arg(U T::*member) {
         using traits = internal::reg_traits<U>;
         using reg_type = typename traits::type;
-        const auto & res = reserve<reg_type>();
+        const auto& res = reserve<reg_type>();
         if (sizeof(T) < traits::size)
             movzx(res, argPtr(member));
         else
             mov(res, argPtr(member));
-        return { *this, internal::make_shared(res, *this) };
-    }
-
-    jit_kernel(const char *name);
-
-    template<typename RegType>
-    const RegType & reserve();
-
-    template<typename RegType>
-    void free(const RegType & reg);
-
-    template<typename T>
-    void copy(const Xbyak::Reg64& dst,
-              const Xbyak::Reg64& src,
-              const Xbyak::Reg64& size);
-    template<typename T>
-    void copy(const Xbyak::Address& dst,
-              const Xbyak::Reg64& src,
-              const Xbyak::Reg64& size);
-
-    template<typename DstT, size_t N, typename SrcT>
-    void load(const variable<DstT[N]> & dst, const variable<SrcT> & src, size_t length = N);
-    template<typename DstT, size_t N, typename SrcT>
-    void load(const variable<DstT[N]> & dst, const variable<SrcT> & src, const variable<size_t> & length);
-    template<typename DstT, typename SrcT, size_t N>
-    void store(const variable<DstT> & dst, const variable<SrcT[N]> & src, size_t length = N);
-    template<typename DstT, typename SrcT, size_t N>
-    void store(const variable<DstT> & dst, const variable<SrcT[N]> & src, const variable<size_t> & length);
-
-    template<typename B, typename E, typename S = size_t>
-    void foreach(const B & begin,
-                 const E & end,
-                 std::function<void(const variable<size_t>&)> && fn,
-                 const S & step = 1);
-
-    template<typename T>
+        return {*this, internal::make_shared(res, *this)};
+    }
+
+    jit_kernel(const char* name);
+
+    template <typename RegType>
+    const RegType& reserve();
+
+    template <typename RegType>
+    void free(const RegType& reg);
+
+    template <typename T>
+    void copy(const Xbyak::Reg64& dst, const Xbyak::Reg64& src, const Xbyak::Reg64& size);
+    template <typename T>
+    void copy(const Xbyak::Address& dst, const Xbyak::Reg64& src, const Xbyak::Reg64& size);
+
+    template <typename DstT, size_t N, typename SrcT>
+    void load(const variable<DstT[N]>& dst, const variable<SrcT>& src, size_t length = N);
+    template <typename DstT, size_t N, typename SrcT>
+    void load(const variable<DstT[N]>& dst, const variable<SrcT>& src, const variable<size_t>& length);
+    template <typename DstT, typename SrcT, size_t N>
+    void store(const variable<DstT>& dst, const variable<SrcT[N]>& src, size_t length = N);
+    template <typename DstT, typename SrcT, size_t N>
+    void store(const variable<DstT>& dst, const variable<SrcT[N]>& src, const variable<size_t>& length);
+
+    template <typename B, typename E, typename S = size_t>
+    void foreach (const B& begin, const E& end, std::function<void(const variable<size_t>&)> && fn, const S& step = 1);
+
+    template <typename T>
     variable<T> var();
-    template<typename T>
-    variable<T> var(const T & val);
+    template <typename T>
+    variable<T> var(const T& val);
 
-    template<typename T>
-    const T & constant(const T & c);
-    template<typename T>
-    const T * constant(const T * c, size_t size);
+    template <typename T>
+    const T& constant(const T& c);
+    template <typename T>
+    const T* constant(const T* c, size_t size);
 
     stack_frame stack(size_t size, uint32_t alignment = 1);
 
-    template<typename T>
-    if_expression<T> _if(const boolean_expression<T> & expr) const;
+    template <typename T>
+    if_expression<T> _if(const boolean_expression<T>& expr) const;
 
     void uni_vpermps(const Xbyak::Xmm& x1, const uint8_t mask[4], const Xbyak::Operand& op);
     void uni_vpermps(const Xbyak::Ymm& y1, const uint8_t mask[8], const Xbyak::Operand& op);
@@ -689,9 +677,9 @@ struct jit_kernel : public dnnl::impl::cpu::x64::jit_generator {
 
     void postamble();
 
-    const Xbyak::AddressFrame & address_frame(size_t size) const;
-    const reg_indices & free_x64regs() const;
-    const reg_indices & free_rmmregs() const;
+    const Xbyak::AddressFrame& address_frame(size_t size) const;
+    const reg_indices& free_x64regs() const;
+    const reg_indices& free_rmmregs() const;
 
 private:
     reg_indices _free_x64regs;
@@ -703,44 +691,40 @@ struct jit_kernel : public dnnl::impl::cpu::x64::jit_generator {
 template <>
 const Xbyak::Reg64& jit_kernel::reserve<Xbyak::Reg64>();
 
-template<typename T>
-void jit_kernel::copy(const Xbyak::Reg64& dst,
-                      const Xbyak::Reg64& src,
-                      const Xbyak::Reg64& size) {
-    const auto & addr_frame = address_frame(sizeof(T));
+template <typename T>
+void jit_kernel::copy(const Xbyak::Reg64& dst, const Xbyak::Reg64& src, const Xbyak::Reg64& size) {
+    const auto& addr_frame = address_frame(sizeof(T));
     auto p = reserve<typename reg_traits_by_size<sizeof(T)>::type>();
-    foreach(0, size, [&](const Xbyak::Reg64& idx) {
+    foreach (0, size, [&](const Xbyak::Reg64& idx) {
         mov(p, addr_frame[src + idx * sizeof(T)]);
         mov(addr_frame[dst + idx * sizeof(T)], p);
-    });
+    })
+        ;
     free(p);
 }
 
-template<typename T>
-void jit_kernel::copy(const Xbyak::Address& dst,
-                      const Xbyak::Reg64& src,
-                      const Xbyak::Reg64& size) {
-    const auto & addr_frame = address_frame(sizeof(T));
+template <typename T>
+void jit_kernel::copy(const Xbyak::Address& dst, const Xbyak::Reg64& src, const Xbyak::Reg64& size) {
+    const auto& addr_frame = address_frame(sizeof(T));
     auto p = reserve<typename reg_traits_by_size<sizeof(T)>::type>();
     auto d = reserve<Xbyak::Reg64>();
     lea(d, dst);
-    foreach(0, size, [&](const Xbyak::Reg64& idx) {
+    foreach (0, size, [&](const Xbyak::Reg64& idx) {
         mov(p, addr_frame[src + idx * sizeof(T)]);
         mov(addr_frame[d + idx * sizeof(T)], p);
-    });
+    })
+        ;
     free(d);
     free(p);
 }
 
-template<typename DstT, size_t N, typename SrcT>
-void jit_kernel::load(const variable<DstT[N]> & dst, const variable<SrcT> & src, size_t length) {
+template <typename DstT, size_t N, typename SrcT>
+void jit_kernel::load(const variable<DstT[N]>& dst, const variable<SrcT>& src, size_t length) {
     static_assert(std::is_same<typename variable<SrcT>::reg_type, const Xbyak::Reg64>::value,
-        "Source register must be Reg64");
+                  "Source register must be Reg64");
 
-    using src_type = typename std::remove_cv<
-                        typename std::remove_pointer<SrcT>::type>::type;
-    using dst_type = typename std::remove_cv<
-                        typename std::remove_pointer<DstT>::type>::type;
+    using src_type = typename std::remove_cv<typename std::remove_pointer<SrcT>::type>::type;
+    using dst_type = typename std::remove_cv<typename std::remove_pointer<DstT>::type>::type;
 
     const std::vector<size_t> pool_vec_idxs(_free_rmmregs.begin(), _free_rmmregs.end());
     const std::vector<size_t> pool_gpr_idxs(_free_x64regs.begin(), _free_x64regs.end());
@@ -752,17 +736,15 @@ void jit_kernel::load(const variable<DstT[N]> & dst, const variable<SrcT> & src,
     if (!_emitters[key]) {
         _emitters[key].reset(new jit_load_emitter(this, internal::get_current_isa(), src_prc, dst_prc, length));
     }
-    _emitters[key]->emit_code(
-        { static_cast<size_t>(static_cast<const Xbyak::Operand&>(src).getIdx()) },
-        { static_cast<size_t>(static_cast<const Xbyak::Operand&>(dst).getIdx()) },
-        pool_vec_idxs,
-        pool_gpr_idxs);
+    _emitters[key]->emit_code({static_cast<size_t>(static_cast<const Xbyak::Operand&>(src).getIdx())},
+                              {static_cast<size_t>(static_cast<const Xbyak::Operand&>(dst).getIdx())},
+                              pool_vec_idxs,
+                              pool_gpr_idxs);
 }
 
-template<typename DstT, size_t N, typename SrcT>
-void jit_kernel::load(const variable<DstT[N]> & dst, const variable<SrcT> & src, const variable<size_t> & length) {
-    using src_type = typename std::remove_cv<
-                        typename std::remove_pointer<SrcT>::type>::type;
+template <typename DstT, size_t N, typename SrcT>
+void jit_kernel::load(const variable<DstT[N]>& dst, const variable<SrcT>& src, const variable<size_t>& length) {
+    using src_type = typename std::remove_cv<typename std::remove_pointer<SrcT>::type>::type;
 
     auto s = stack(N * sizeof(src_type));
     s.clear();
@@ -775,15 +757,13 @@ void jit_kernel::load(const variable<DstT[N]> & dst, const variable<SrcT> & src,
     load(dst, tmp);
 }
 
-template<typename DstT, typename SrcT, size_t N>
-void jit_kernel::store(const variable<DstT> & dst, const variable<SrcT[N]> & src, size_t length) {
+template <typename DstT, typename SrcT, size_t N>
+void jit_kernel::store(const variable<DstT>& dst, const variable<SrcT[N]>& src, size_t length) {
     static_assert(std::is_same<typename variable<DstT>::reg_type, const Xbyak::Reg64>::value,
-        "Destination register must be Reg64");
+                  "Destination register must be Reg64");
 
-    using src_type = typename std::remove_cv<
-                        typename std::remove_pointer<SrcT>::type>::type;
-    using dst_type = typename std::remove_cv<
-                        typename std::remove_pointer<DstT>::type>::type;
+    using src_type = typename std::remove_cv<typename std::remove_pointer<SrcT>::type>::type;
+    using dst_type = typename std::remove_cv<typename std::remove_pointer<DstT>::type>::type;
 
     const std::vector<size_t> pool_vec_idxs(_free_rmmregs.begin(), _free_rmmregs.end());
     const std::vector<size_t> pool_gpr_idxs(_free_x64regs.begin(), _free_x64regs.end());
@@ -795,17 +775,15 @@ void jit_kernel::store(const variable<DstT> & dst, const variable<SrcT[N]> & src
     if (!_emitters[key]) {
         _emitters[key].reset(new jit_store_emitter(this, internal::get_current_isa(), src_prc, dst_prc, length));
     }
-    _emitters[key]->emit_code(
-        { static_cast<size_t>(static_cast<const Xbyak::Operand&>(src).getIdx()) },
-        { static_cast<size_t>(static_cast<const Xbyak::Operand&>(dst).getIdx()) },
-        pool_vec_idxs,
-        pool_gpr_idxs);
+    _emitters[key]->emit_code({static_cast<size_t>(static_cast<const Xbyak::Operand&>(src).getIdx())},
+                              {static_cast<size_t>(static_cast<const Xbyak::Operand&>(dst).getIdx())},
+                              pool_vec_idxs,
+                              pool_gpr_idxs);
 }
 
-template<typename DstT, typename SrcT, size_t N>
-void jit_kernel::store(const variable<DstT> & dst, const variable<SrcT[N]> & src, const variable<size_t> & length) {
-    using dst_type = typename std::remove_cv<
-                        typename std::remove_pointer<DstT>::type>::type;
+template <typename DstT, typename SrcT, size_t N>
+void jit_kernel::store(const variable<DstT>& dst, const variable<SrcT[N]>& src, const variable<size_t>& length) {
+    using dst_type = typename std::remove_cv<typename std::remove_pointer<DstT>::type>::type;
 
     auto s = stack(N * sizeof(dst_type));
 
@@ -817,11 +795,11 @@ void jit_kernel::store(const variable<DstT> & dst, const variable<SrcT[N]> & src
     copy<dst_type>(dst, tmp, length);
 }
 
-template<typename B, typename E, typename S>
-void jit_kernel::foreach(const B & begin,
-                         const E & end,
-                         std::function<void(const variable<size_t>&)> && fn,
-                         const S & step) {
+template <typename B, typename E, typename S>
+void jit_kernel::foreach (const B& begin,
+                          const E& end,
+                          std::function<void(const variable<size_t>&)> && fn,
+                          const S& step) {
     using namespace Xbyak;
 
     Label loop, exit;
@@ -841,36 +819,36 @@ void jit_kernel::foreach(const B & begin,
     L(exit);
 }
 
-template<typename T>
+template <typename T>
 jit_kernel::variable<T> jit_kernel::var() {
     using reg_type = typename reg_traits<T>::type;
-    const auto & reg = reserve<reg_type>();
+    const auto& reg = reserve<reg_type>();
     return variable<T>(*this, internal::make_shared(reg, *this));
 }
 
-template<typename T>
-jit_kernel::variable<T> jit_kernel::var(const T & val) {
+template <typename T>
+jit_kernel::variable<T> jit_kernel::var(const T& val) {
     using reg_type = typename reg_traits<T>::type;
-    const auto & reg = reserve<reg_type>();
+    const auto& reg = reserve<reg_type>();
     variable<T> res(*this, internal::make_shared(reg, *this));
     res = val;
     return res;
 }
 
-template<typename T>
-const T & jit_kernel::constant(const T & c) {
+template <typename T>
+const T& jit_kernel::constant(const T& c) {
     auto res = _consts.store(&c, sizeof c);
     return *reinterpret_cast<const T*>(res);
 }
 
-template<typename T>
-const T * jit_kernel::constant(const T * c, size_t size) {
+template <typename T>
+const T* jit_kernel::constant(const T* c, size_t size) {
     auto res = _consts.store(c, size * sizeof(T));
     return reinterpret_cast<const T*>(res);
 }
 
-template<typename T>
-jit_kernel::if_expression<T> jit_kernel::_if(const boolean_expression<T> & expr) const {
+template <typename T>
+jit_kernel::if_expression<T> jit_kernel::_if(const boolean_expression<T>& expr) const {
     return if_expression<T>(expr);
 }
 
@@ -879,12 +857,13 @@ namespace internal {
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // shared_reg
 
-template<typename Reg>
-shared_reg<Reg> make_shared(Reg & reg, jit_kernel & kernel) {
-    std::shared_ptr<Reg> ptr(&reg, [&kernel](Reg *preg) {
+template <typename Reg>
+shared_reg<Reg> make_shared(Reg& reg, jit_kernel& kernel) {
+    std::shared_ptr<Reg> ptr(&reg, [&kernel](Reg* preg) {
         try {
             kernel.free(*preg);
-        } catch(...) {}
+        } catch (...) {
+        }
     });
     return ptr;
 }
@@ -892,68 +871,68 @@ shared_reg<Reg> make_shared(Reg & reg, jit_kernel & kernel) {
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // boolean_expression
 
-template<typename T>
-boolean_expression<T>::boolean_expression(jit_kernel & kernel, type t, const shared_reg<reg_type> & lhs, const shared_reg<reg_type> & rhs)
-    : _kernel(kernel)
-    , _type(t)
-    , _lhs(lhs)
-    , _rhs(rhs)
-    , _rvalue {} {
-}
-
-template<typename T>
-boolean_expression<T>::boolean_expression(jit_kernel & kernel, type t, const shared_reg<reg_type> & lhs, T rhs)
-    : _kernel(kernel)
-    , _type(t)
-    , _lhs(lhs)
-    , _rvalue(rhs) {
-}
-
-template<typename T>
-void boolean_expression<T>::cmp(const Xbyak::Label & exit) const {
+template <typename T>
+boolean_expression<T>::boolean_expression(jit_kernel& kernel,
+                                          type t,
+                                          const shared_reg<reg_type>& lhs,
+                                          const shared_reg<reg_type>& rhs)
+    : _kernel(kernel),
+      _type(t),
+      _lhs(lhs),
+      _rhs(rhs),
+      _rvalue{} {}
+
+template <typename T>
+boolean_expression<T>::boolean_expression(jit_kernel& kernel, type t, const shared_reg<reg_type>& lhs, T rhs)
+    : _kernel(kernel),
+      _type(t),
+      _lhs(lhs),
+      _rvalue(rhs) {}
+
+template <typename T>
+void boolean_expression<T>::cmp(const Xbyak::Label& exit) const {
     if (_rhs)
         _kernel.cmp(*_lhs, *_rhs);
     else
         _kernel.cmp(*_lhs, _rvalue);
 
     switch (_type) {
-        case type::eq: {
-            _kernel.jne(exit, Xbyak::CodeGenerator::T_NEAR);
-            break;
-        }
-        case type::neq: {
-            _kernel.je(exit, Xbyak::CodeGenerator::T_NEAR);
-            break;
-        }
-        case type::ls: {
-            _kernel.jge(exit, Xbyak::CodeGenerator::T_NEAR);
-            break;
-        }
-        case type::gt: {
-            _kernel.jle(exit, Xbyak::CodeGenerator::T_NEAR);
-            break;
-        }
-        case type::le: {
-            _kernel.jg(exit, Xbyak::CodeGenerator::T_NEAR);
-            break;
-        }
-        case type::ge: {
-            _kernel.jl(exit, Xbyak::CodeGenerator::T_NEAR);
-            break;
-        }
+    case type::eq: {
+        _kernel.jne(exit, Xbyak::CodeGenerator::T_NEAR);
+        break;
+    }
+    case type::neq: {
+        _kernel.je(exit, Xbyak::CodeGenerator::T_NEAR);
+        break;
+    }
+    case type::ls: {
+        _kernel.jge(exit, Xbyak::CodeGenerator::T_NEAR);
+        break;
+    }
+    case type::gt: {
+        _kernel.jle(exit, Xbyak::CodeGenerator::T_NEAR);
+        break;
+    }
+    case type::le: {
+        _kernel.jg(exit, Xbyak::CodeGenerator::T_NEAR);
+        break;
+    }
+    case type::ge: {
+        _kernel.jl(exit, Xbyak::CodeGenerator::T_NEAR);
+        break;
+    }
     }
 }
 
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // then_expression
 
-template<typename T>
-then_expression<T>::then_expression(if_expression<T> & expr)
-    : _if_expr(expr) {}
+template <typename T>
+then_expression<T>::then_expression(if_expression<T>& expr) : _if_expr(expr) {}
 
-template<typename T>
-template<typename F>
-void then_expression<T>::_else(F && fn) {
+template <typename T>
+template <typename F>
+void then_expression<T>::_else(F&& fn) {
     fn();
     _if_expr._expr._kernel.L(_if_expr._exit);
     _if_expr._is_exit_valid = true;
@@ -962,75 +941,57 @@ void then_expression<T>::_else(F && fn) {
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // variable
 
-template<typename T>
-variable_base<T, register_tag>::variable_base(jit_kernel & krnl, const shared_reg<reg_type> & reg)
-    : _kernel(krnl)
-    , _reg(reg) {
-}
+template <typename T>
+variable_base<T, register_tag>::variable_base(jit_kernel& krnl, const shared_reg<reg_type>& reg)
+    : _kernel(krnl),
+      _reg(reg) {}
 
-template<typename T>
-variable_base<T, register_tag>::variable_base(const variable_base & rhs)
-    : _kernel(rhs._kernel)
-    , _reg(rhs._reg) {
-}
+template <typename T>
+variable_base<T, register_tag>::variable_base(const variable_base& rhs) : _kernel(rhs._kernel),
+                                                                          _reg(rhs._reg) {}
 
-template<typename T>
-variable_base<T, register_tag>::variable_base(variable_base && rhs)
-    : _kernel(rhs._kernel)
-    , _reg(std::move(rhs._reg)) {
-}
+template <typename T>
+variable_base<T, register_tag>::variable_base(variable_base&& rhs) : _kernel(rhs._kernel),
+                                                                     _reg(std::move(rhs._reg)) {}
 
-template<typename T>
-variable_base<T, memory_tag>::variable_base(jit_kernel & krnl, const shared_reg<reg_type> & addr)
-    : _kernel(krnl)
-    , _addr(addr) {
-}
+template <typename T>
+variable_base<T, memory_tag>::variable_base(jit_kernel& krnl, const shared_reg<reg_type>& addr)
+    : _kernel(krnl),
+      _addr(addr) {}
 
-template<typename T>
-variable_base<T, memory_tag>::variable_base(const variable_base & rhs)
-    : _kernel(rhs._kernel)
-    , _addr(rhs._addr) {
-}
+template <typename T>
+variable_base<T, memory_tag>::variable_base(const variable_base& rhs) : _kernel(rhs._kernel),
+                                                                        _addr(rhs._addr) {}
 
-template<typename T>
-variable_base<T, memory_tag>::variable_base(variable_base && rhs)
-    : _kernel(rhs._kernel)
-    , _addr(std::move(rhs._addr)) {
-}
+template <typename T>
+variable_base<T, memory_tag>::variable_base(variable_base&& rhs) : _kernel(rhs._kernel),
+                                                                   _addr(std::move(rhs._addr)) {}
 
-template<typename T>
-variable<T, register_tag>::variable(jit_kernel & krnl)
-    : base(krnl, make_shared(krnl.reserve<typename reg_traits<T>::type>(), krnl)) {
-}
+template <typename T>
+variable<T, register_tag>::variable(jit_kernel& krnl)
+    : base(krnl, make_shared(krnl.reserve<typename reg_traits<T>::type>(), krnl)) {}
 
-template<typename T>
-variable<T, register_tag>::variable(jit_kernel & krnl, const shared_reg<reg_type> & reg)
-    : base(krnl, reg) {
-}
+template <typename T>
+variable<T, register_tag>::variable(jit_kernel& krnl, const shared_reg<reg_type>& reg) : base(krnl, reg) {}
 
-template<typename T>
-variable<T, memory_tag>::variable(jit_kernel & krnl, const shared_reg<reg_type> & reg)
-    : base(krnl, reg) {
-}
+template <typename T>
+variable<T, memory_tag>::variable(jit_kernel& krnl, const shared_reg<reg_type>& reg) : base(krnl, reg) {}
 
-template<typename T>
-const variable<T, memory_tag> & variable<T, memory_tag>::operator = (const variable<T, register_tag> & rhs) const {
-    const auto & addr_frame = base::_kernel.address_frame(sizeof(T));
+template <typename T>
+const variable<T, memory_tag>& variable<T, memory_tag>::operator=(const variable<T, register_tag>& rhs) const {
+    const auto& addr_frame = base::_kernel.address_frame(sizeof(T));
     base::_kernel.mov(addr_frame[base::reg()], rhs);
     return *this;
 }
 
-template<typename T, size_t N>
-variable<T[N], register_tag>::variable(jit_kernel & krnl)
-    : base(krnl, make_shared(krnl.reserve<typename reg_traits<T[N]>::type>(), krnl)) {
-}
+template <typename T, size_t N>
+variable<T[N], register_tag>::variable(jit_kernel& krnl)
+    : base(krnl, make_shared(krnl.reserve<typename reg_traits<T[N]>::type>(), krnl)) {}
 
-template<typename T, size_t N>
-variable<T[N], register_tag>::variable(jit_kernel & krnl, const shared_reg<reg_type> & reg)
-    : base(krnl, reg) {
-}
+template <typename T, size_t N>
+variable<T[N], register_tag>::variable(jit_kernel& krnl, const shared_reg<reg_type>& reg) : base(krnl, reg) {}
 
-}   // namespace internal
+}  // namespace internal
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel_base.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel_base.cpp
index 8fd3a966e13887..ffc0286431b279 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel_base.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel_base.cpp
@@ -10,14 +10,11 @@ namespace ov {
 namespace intel_cpu {
 namespace kernel {
 
-JitKernelBase::JitKernelBase(const char* name, x64::cpu_isa_t isa)
-        : x64::jit_generator(name, isa), m_isa(isa) {
+JitKernelBase::JitKernelBase(const char* name, x64::cpu_isa_t isa) : x64::jit_generator(name, isa), m_isa(isa) {
     vlen = x64::isa_max_vlen(isa);
 }
 
-void JitKernelBase::uni_vfmsub132ps(const Xbyak::Xmm& v_dst,
-                                    const Xbyak::Xmm& v_src,
-                                    const Xbyak::Operand& op) {
+void JitKernelBase::uni_vfmsub132ps(const Xbyak::Xmm& v_dst, const Xbyak::Xmm& v_src, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx2)) {
         vfmsub132ps(v_dst, v_src, op);
     } else if (isValidIsa(x64::avx)) {
@@ -31,9 +28,7 @@ void JitKernelBase::uni_vfmsub132ps(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vfnmadd132ps(const Xbyak::Xmm& v_dst,
-                                     const Xbyak::Xmm& v_src,
-                                     const Xbyak::Operand& op) {
+void JitKernelBase::uni_vfnmadd132ps(const Xbyak::Xmm& v_dst, const Xbyak::Xmm& v_src, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx2)) {
         vfnmadd132ps(v_dst, v_src, op);
     } else if (isValidIsa(x64::avx)) {
@@ -48,9 +43,7 @@ void JitKernelBase::uni_vfnmadd132ps(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vfmsub231ps(const Xbyak::Xmm& v_dst,
-                                    const Xbyak::Xmm& v_src,
-                                    const Xbyak::Operand& op) {
+void JitKernelBase::uni_vfmsub231ps(const Xbyak::Xmm& v_dst, const Xbyak::Xmm& v_src, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx2)) {
         vfmsub231ps(v_dst, v_src, op);
     } else if (isValidIsa(x64::avx)) {
@@ -65,9 +58,7 @@ void JitKernelBase::uni_vfmsub231ps(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vpaddd(const Xbyak::Ymm& v_dst,
-                               const Xbyak::Ymm& v_src,
-                               const Xbyak::Operand& op) {
+void JitKernelBase::uni_vpaddd(const Xbyak::Ymm& v_dst, const Xbyak::Ymm& v_src, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx2)) {
         vpaddd(v_dst, v_src, op);
     } else if (isValidIsa(x64::avx)) {
@@ -99,9 +90,7 @@ void JitKernelBase::uni_vpaddd(const Xbyak::Ymm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vpaddq(const Xbyak::Xmm& v_dst,
-                               const Xbyak::Xmm& v_src,
-                               const Xbyak::Operand& op) {
+void JitKernelBase::uni_vpaddq(const Xbyak::Xmm& v_dst, const Xbyak::Xmm& v_src, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx2)) {
         vpaddq(v_dst, v_src, op);
     } else {
@@ -112,9 +101,7 @@ void JitKernelBase::uni_vpaddq(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vpsubd(const Xbyak::Ymm& v_dst,
-                               const Xbyak::Ymm& v_src,
-                               const Xbyak::Operand& op) {
+void JitKernelBase::uni_vpsubd(const Xbyak::Ymm& v_dst, const Xbyak::Ymm& v_src, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx2)) {
         vpsubd(v_dst, v_src, op);
     } else if (isValidIsa(x64::avx)) {
@@ -146,9 +133,7 @@ void JitKernelBase::uni_vpsubd(const Xbyak::Ymm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vsubpd(const Xbyak::Xmm& v_dst,
-                               const Xbyak::Xmm& v_src,
-                               const Xbyak::Operand& op) {
+void JitKernelBase::uni_vsubpd(const Xbyak::Xmm& v_dst, const Xbyak::Xmm& v_src, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx)) {
         vsubpd(v_dst, v_src, op);
     } else {
@@ -159,9 +144,7 @@ void JitKernelBase::uni_vsubpd(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vmulpd(const Xbyak::Xmm& v_dst,
-                               const Xbyak::Xmm& v_src,
-                               const Xbyak::Operand& op) {
+void JitKernelBase::uni_vmulpd(const Xbyak::Xmm& v_dst, const Xbyak::Xmm& v_src, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx)) {
         vmulpd(v_dst, v_src, op);
     } else {
@@ -172,9 +155,7 @@ void JitKernelBase::uni_vmulpd(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vpmuludq(const Xbyak::Xmm& v_dst,
-                                 const Xbyak::Xmm& v_src,
-                                 const Xbyak::Operand& op) {
+void JitKernelBase::uni_vpmuludq(const Xbyak::Xmm& v_dst, const Xbyak::Xmm& v_src, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx2)) {
         vpmuludq(v_dst, v_src, op);
     } else {
@@ -185,9 +166,7 @@ void JitKernelBase::uni_vpmuludq(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vdivps(const Xbyak::Xmm& v_dst,
-                               const Xbyak::Operand& op1,
-                               const Xbyak::Operand& op2) {
+void JitKernelBase::uni_vdivps(const Xbyak::Xmm& v_dst, const Xbyak::Operand& op1, const Xbyak::Operand& op2) {
     if (isValidIsa(x64::avx)) {
         vdivps(v_dst, op1, op2);
     } else {
@@ -198,9 +177,7 @@ void JitKernelBase::uni_vdivps(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vdivpd(const Xbyak::Xmm& v_dst,
-                               const Xbyak::Xmm& v_src,
-                               const Xbyak::Operand& op) {
+void JitKernelBase::uni_vdivpd(const Xbyak::Xmm& v_dst, const Xbyak::Xmm& v_src, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx)) {
         vdivpd(v_dst, v_src, op);
     } else {
@@ -211,9 +188,7 @@ void JitKernelBase::uni_vdivpd(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vandps(const Xbyak::Xmm& v_dst,
-                               const Xbyak::Xmm& vSrs,
-                               const Xbyak::Operand &op) {
+void JitKernelBase::uni_vandps(const Xbyak::Xmm& v_dst, const Xbyak::Xmm& vSrs, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx)) {
         vandps(v_dst, vSrs, op);
     } else {
@@ -224,9 +199,7 @@ void JitKernelBase::uni_vandps(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vandnps(const Xbyak::Xmm& v_dst,
-                                const Xbyak::Xmm& vSrs,
-                                const Xbyak::Operand &op) {
+void JitKernelBase::uni_vandnps(const Xbyak::Xmm& v_dst, const Xbyak::Xmm& vSrs, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx)) {
         vandnps(v_dst, vSrs, op);
     } else {
@@ -237,9 +210,9 @@ void JitKernelBase::uni_vandnps(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::gatherdd(const Xbyak::Xmm&    v_dst,
-                             const Xbyak::Reg64&  rSrcPtr,
-                             const Xbyak::Xmm&    vSrcShift,
+void JitKernelBase::gatherdd(const Xbyak::Xmm& v_dst,
+                             const Xbyak::Reg64& rSrcPtr,
+                             const Xbyak::Xmm& vSrcShift,
                              const Xbyak::Opmask& kReadMask,
                              const bool useMask,
                              const bool zeroFill) {
@@ -254,17 +227,18 @@ void JitKernelBase::gatherdd(const Xbyak::Xmm&    v_dst,
     vpgatherdd(v_dst | kReadMask, ptr[rSrcPtr + vSrcShift]);
 }
 
-void JitKernelBase::gatherdd(const Xbyak::Xmm&   v_dst,
+void JitKernelBase::gatherdd(const Xbyak::Xmm& v_dst,
                              const Xbyak::Reg64& rSrcPtr,
-                             const Xbyak::Xmm&   vSrcShift,
-                             const Xbyak::Xmm&   vReadMask,
+                             const Xbyak::Xmm& vSrcShift,
+                             const Xbyak::Xmm& vReadMask,
                              const bool useMask,
                              const bool zeroFill) {
-    if (v_dst.getIdx() == vSrcShift.getIdx() || v_dst.getIdx() == vReadMask.getIdx() || vSrcShift.getIdx() == vReadMask.getIdx()) {
+    if (v_dst.getIdx() == vSrcShift.getIdx() || v_dst.getIdx() == vReadMask.getIdx() ||
+        vSrcShift.getIdx() == vReadMask.getIdx()) {
         OPENVINO_THROW("Any pair of the index, mask, or destination registers cannot be the same.");
     }
     if (zeroFill)
-        pxor(v_dst, v_dst); // Don't use vpxor. It zeros the rest of the YMM register.
+        pxor(v_dst, v_dst);  // Don't use vpxor. It zeros the rest of the YMM register.
 
     if (isValidIsa(x64::avx2)) {
         if (!useMask)
@@ -280,7 +254,7 @@ void JitKernelBase::gatherdd(const Xbyak::Xmm&   v_dst,
             Xbyak::Label lLoopNext;
             if (useMask) {
                 uni_vpextrd(r32Aux, vReadMask, i);
-                cmp(r32Aux, 0); // TODO: check significant bit
+                cmp(r32Aux, 0);  // TODO: check significant bit
                 je(lLoopNext, T_NEAR);
             }
             uni_vpextrd(r32Aux, vSrcShift, i);
@@ -292,13 +266,14 @@ void JitKernelBase::gatherdd(const Xbyak::Xmm&   v_dst,
     }
 }
 
-void JitKernelBase::gatherdd(const Xbyak::Ymm&   v_dst,
+void JitKernelBase::gatherdd(const Xbyak::Ymm& v_dst,
                              const Xbyak::Reg64& rSrcPtr,
-                             const Xbyak::Ymm&   vSrcShift,
-                             const Xbyak::Ymm&   vReadMask,
+                             const Xbyak::Ymm& vSrcShift,
+                             const Xbyak::Ymm& vReadMask,
                              const bool useMask,
                              const bool zeroFill) {
-    if (v_dst.getIdx() == vSrcShift.getIdx() || v_dst.getIdx() == vReadMask.getIdx() || vSrcShift.getIdx() == vReadMask.getIdx()) {
+    if (v_dst.getIdx() == vSrcShift.getIdx() || v_dst.getIdx() == vReadMask.getIdx() ||
+        vSrcShift.getIdx() == vReadMask.getIdx()) {
         OPENVINO_THROW("Any pair of the index, mask, or destination registers cannot be the same.");
     }
     if (isValidIsa(x64::avx2)) {
@@ -309,8 +284,7 @@ void JitKernelBase::gatherdd(const Xbyak::Ymm&   v_dst,
 
         vpgatherdd(v_dst, ptr[rSrcPtr + vSrcShift], vReadMask);
     } else {
-        Xbyak::Xmm xmmDst      = Xbyak::Xmm(v_dst.getIdx()),
-                   xmmSrcShft  = Xbyak::Xmm(vSrcShift.getIdx()),
+        Xbyak::Xmm xmmDst = Xbyak::Xmm(v_dst.getIdx()), xmmSrcShft = Xbyak::Xmm(vSrcShift.getIdx()),
                    xmmReadMask = Xbyak::Xmm(vReadMask.getIdx());
         for (uint8_t i = 0; i < 2; i++) {
             gatherdd(xmmDst, rSrcPtr, xmmSrcShft, xmmReadMask, useMask, zeroFill);
@@ -323,7 +297,7 @@ void JitKernelBase::gatherdd(const Xbyak::Ymm&   v_dst,
     }
 }
 
-void JitKernelBase::uni_vpbroadcastq(const Xbyak::Xmm &x, const Xbyak::Operand &op) {
+void JitKernelBase::uni_vpbroadcastq(const Xbyak::Xmm& x, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx2)) {
         vpbroadcastq(x, op);
     } else {
@@ -332,7 +306,7 @@ void JitKernelBase::uni_vpbroadcastq(const Xbyak::Xmm &x, const Xbyak::Operand &
     }
 }
 
-void JitKernelBase::uni_vpbroadcastd(const Xbyak::Xmm &x, const Xbyak::Operand &op) {
+void JitKernelBase::uni_vpbroadcastd(const Xbyak::Xmm& x, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx2)) {
         vpbroadcastd(x, op);
     } else if (isValidIsa(x64::avx)) {
@@ -348,7 +322,7 @@ void JitKernelBase::uni_vpbroadcastd(const Xbyak::Xmm &x, const Xbyak::Operand &
     }
 }
 
-void JitKernelBase::uni_vpbroadcastd(const Xbyak::Ymm &x, const Xbyak::Operand &op) {
+void JitKernelBase::uni_vpbroadcastd(const Xbyak::Ymm& x, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx2)) {
         vpbroadcastd(x, op);
     } else {
@@ -375,8 +349,7 @@ void JitKernelBase::uni_vroundpd(const Xbyak::Xmm& v_dst, const Xbyak::Operand&
     }
 }
 
-void JitKernelBase::uni_vcvtdq2pd(const Xbyak::Xmm& v_dst,
-                                  const Xbyak::Operand& op) {
+void JitKernelBase::uni_vcvtdq2pd(const Xbyak::Xmm& v_dst, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx)) {
         vcvtdq2pd(v_dst, op);
     } else {
@@ -384,8 +357,7 @@ void JitKernelBase::uni_vcvtdq2pd(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vcvtpd2dq(const Xbyak::Xmm& v_dst,
-                                  const Xbyak::Operand& op) {
+void JitKernelBase::uni_vcvtpd2dq(const Xbyak::Xmm& v_dst, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx)) {
         vcvtpd2dq(v_dst, op);
     } else {
@@ -393,8 +365,7 @@ void JitKernelBase::uni_vcvtpd2dq(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::uni_vpmovzxdq(const Xbyak::Xmm& v_dst,
-                                  const Xbyak::Operand& op) {
+void JitKernelBase::uni_vpmovzxdq(const Xbyak::Xmm& v_dst, const Xbyak::Operand& op) {
     if (isValidIsa(x64::avx2)) {
         vpmovzxdq(v_dst, op);
     } else {
@@ -416,8 +387,7 @@ void JitKernelBase::uni_vshufpd(const Xbyak::Xmm& v_dst,
     }
 }
 
-void JitKernelBase::fillRestWorkMask(const Xbyak::Opmask& dstMask,
-                                     const Xbyak::Reg64& rWorkRest) {
+void JitKernelBase::fillRestWorkMask(const Xbyak::Opmask& dstMask, const Xbyak::Reg64& rWorkRest) {
     auto rOnes = getReg64();
 
     mov(rOnes, 0xFFFFFFFFFFFFFFFF);
@@ -493,11 +463,11 @@ void JitKernelBase::fillRestWorkMask(const Xbyak::Ymm& ymmDstMask,
     L(lEnd);
 }
 
-void JitKernelBase::load(const Xbyak::Xmm&     v_dst,
+void JitKernelBase::load(const Xbyak::Xmm& v_dst,
                          const Xbyak::Address& srcAddr,
-                         const Xbyak::Reg64&   rLoadNum,
-                         const size_t          typeSize,
-                         const bool            zeroFilling) {
+                         const Xbyak::Reg64& rLoadNum,
+                         const size_t typeSize,
+                         const bool zeroFilling) {
     if (!one_of(typeSize, 1u, 2u, 4u, 8u)) {
         OPENVINO_THROW("Could not load data with type size ", typeSize);
     }
@@ -523,11 +493,11 @@ void JitKernelBase::load(const Xbyak::Xmm&     v_dst,
     L(lEnd);
 }
 
-void JitKernelBase::load(const Xbyak::Ymm&     v_dst,
+void JitKernelBase::load(const Xbyak::Ymm& v_dst,
                          const Xbyak::Address& srcAddr,
-                         const Xbyak::Reg64&   rLoadNum,
-                         const size_t          typeSize,
-                         const bool            zeroFilling) {
+                         const Xbyak::Reg64& rLoadNum,
+                         const size_t typeSize,
+                         const bool zeroFilling) {
     if (!one_of(typeSize, 1u, 2u, 4u, 8u)) {
         OPENVINO_THROW("Could not load data with type size ", typeSize);
     }
@@ -564,9 +534,9 @@ void JitKernelBase::load(const Xbyak::Ymm&     v_dst,
 }
 
 void JitKernelBase::store(const Xbyak::Address& dstAddr,
-                          const Xbyak::Xmm&     v_src,
-                          const Xbyak::Reg64&   rToStoreNum,
-                          const size_t          typeSize) {
+                          const Xbyak::Xmm& v_src,
+                          const Xbyak::Reg64& rToStoreNum,
+                          const size_t typeSize) {
     if (!one_of(typeSize, 1u, 2u, 4u, 8u)) {
         OPENVINO_THROW("Could not store data with type size ", typeSize);
     }
@@ -592,9 +562,9 @@ void JitKernelBase::store(const Xbyak::Address& dstAddr,
 }
 
 void JitKernelBase::store(const Xbyak::Address& dstAddr,
-                          const Xbyak::Ymm&     v_src,
-                          const Xbyak::Reg64&   rToStoreNum,
-                          const size_t          typeSize) {
+                          const Xbyak::Ymm& v_src,
+                          const Xbyak::Reg64& rToStoreNum,
+                          const size_t typeSize) {
     if (!one_of(typeSize, 1u, 2u, 4u, 8u)) {
         OPENVINO_THROW("Could not store data with type size ", typeSize);
     }
@@ -631,11 +601,11 @@ void JitKernelBase::store(const Xbyak::Address& dstAddr,
 
 void JitKernelBase::memMovDD(const Xbyak::Reg64& rDst,
                              const Xbyak::Reg64& rSrc,
-                             const Xbyak::Xmm&   vReadMask,
-                             const Xbyak::Xmm&   vSrcShift,
+                             const Xbyak::Xmm& vReadMask,
+                             const Xbyak::Xmm& vSrcShift,
                              const Xbyak::Reg64& rToStoreNum,
-                             const bool          useMask,
-                             const bool          zeroFill) {
+                             const bool useMask,
+                             const bool zeroFill) {
     Xbyak::Label lEnd;
     auto rAux = getReg64();
     Xbyak::Reg32 r32Aux = Xbyak::Reg32(rAux.getIdx());
@@ -671,11 +641,11 @@ void JitKernelBase::memMovDD(const Xbyak::Reg64& rDst,
 
 void JitKernelBase::memMovDD(const Xbyak::Reg64& rDst,
                              const Xbyak::Reg64& rSrc,
-                             const Xbyak::Ymm&   vReadMask,
-                             const Xbyak::Ymm&   vSrcShift,
+                             const Xbyak::Ymm& vReadMask,
+                             const Xbyak::Ymm& vSrcShift,
                              const Xbyak::Reg64& rToStoreNum,
-                             const bool          useMask,
-                             const bool          zeroFill) {
+                             const bool useMask,
+                             const bool zeroFill) {
     Xbyak::Label lEnd;
     if (isValidIsa(x64::avx2)) {
         auto vAux = RegistersPool::Reg<Xbyak::Ymm>(registersPool);
@@ -684,8 +654,7 @@ void JitKernelBase::memMovDD(const Xbyak::Reg64& rDst,
     } else if (isValidIsa(x64::avx)) {
         const uint8_t typeSize = sizeof(int);
         const uint8_t elPerXmm = x64::cpu_isa_traits<x64::sse41>::vlen / typeSize;
-        Xbyak::Xmm xmmReadMask  = Xbyak::Xmm(vReadMask.getIdx()),
-                   xmmSrcShft   = Xbyak::Xmm(vSrcShift.getIdx());
+        Xbyak::Xmm xmmReadMask = Xbyak::Xmm(vReadMask.getIdx()), xmmSrcShft = Xbyak::Xmm(vSrcShift.getIdx());
         for (uint8_t i = 0; i < 2; i++) {
             memMovDD(rDst, rSrc, xmmReadMask, xmmSrcShft, rToStoreNum, useMask, zeroFill);
 
@@ -707,6 +676,6 @@ void JitKernelBase::memMovDD(const Xbyak::Reg64& rDst,
     L(lEnd);
 }
 
-} // namespace kernel
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace kernel
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel_base.hpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel_base.hpp
index 260d7196331a7f..eee4ff4d8c0708 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel_base.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/jit_kernel_base.hpp
@@ -7,9 +7,9 @@
 #include "openvino/core/visibility.hpp"
 
 #if defined(OPENVINO_ARCH_X86_64)
-#include "cpu/x64/jit_generator.hpp"
-#include "registers_pool.hpp"
-#endif // OPENVINO_ARCH_X86_64
+#    include "cpu/x64/jit_generator.hpp"
+#    include "registers_pool.hpp"
+#endif  // OPENVINO_ARCH_X86_64
 
 namespace ov {
 namespace intel_cpu {
@@ -19,18 +19,22 @@ class JitKernelBase;
 
 #if defined(OPENVINO_ARCH_X86_64)
 
-#define getReg64() RegistersPool::Reg<Xbyak::Reg64>(registersPool)
-#define getReg32() RegistersPool::Reg<Xbyak::Reg32>(registersPool)
-#define getVmm()   RegistersPool::Reg<Vmm>(registersPool)
-#define getMask()  RegistersPool::Reg<Vmask>(registersPool)
+#    define getReg64() RegistersPool::Reg<Xbyak::Reg64>(registersPool)
+#    define getReg32() RegistersPool::Reg<Xbyak::Reg32>(registersPool)
+#    define getVmm()   RegistersPool::Reg<Vmm>(registersPool)
+#    define getMask()  RegistersPool::Reg<Vmask>(registersPool)
 
-class JitKernelBase: public dnnl::impl::cpu::x64::jit_generator {
+class JitKernelBase : public dnnl::impl::cpu::x64::jit_generator {
 public:
     JitKernelBase(const char* name, dnnl::impl::cpu::x64::cpu_isa_t max_cpu_isa);
 
-    dnnl::impl::cpu::x64::cpu_isa_t getIsa() { return m_isa; }
+    dnnl::impl::cpu::x64::cpu_isa_t getIsa() {
+        return m_isa;
+    }
 
-    size_t getVectorLen() { return vlen; }
+    size_t getVectorLen() {
+        return vlen;
+    }
 
     void uni_vfmsub132ps(const Xbyak::Xmm& vDst, const Xbyak::Xmm& vSrc, const Xbyak::Operand& op);
 
@@ -62,9 +66,9 @@ class JitKernelBase: public dnnl::impl::cpu::x64::jit_generator {
 
     void uni_vdivpd(const Xbyak::Xmm& v_dst, const Xbyak::Xmm& v_src, const Xbyak::Operand& op2);
 
-    void uni_vandps(const Xbyak::Xmm& vDst, const Xbyak::Xmm& vSrs, const Xbyak::Operand &op);
+    void uni_vandps(const Xbyak::Xmm& vDst, const Xbyak::Xmm& vSrs, const Xbyak::Operand& op);
 
-    void uni_vandnps(const Xbyak::Xmm& vDst, const Xbyak::Xmm& vSrs, const Xbyak::Operand &op);
+    void uni_vandnps(const Xbyak::Xmm& vDst, const Xbyak::Xmm& vSrs, const Xbyak::Operand& op);
 
     void uni_kmovd(const Xbyak::Opmask& kDst, const Xbyak::Opmask& kSrc) {
         kmovd(kDst, kSrc);
@@ -82,11 +86,11 @@ class JitKernelBase: public dnnl::impl::cpu::x64::jit_generator {
         uni_vandps(kDst, kSrc1, kSrc2);
     }
 
-    void uni_vpbroadcastd(const Xbyak::Xmm &x, const Xbyak::Operand &op);
+    void uni_vpbroadcastd(const Xbyak::Xmm& x, const Xbyak::Operand& op);
 
-    void uni_vpbroadcastd(const Xbyak::Ymm &x, const Xbyak::Operand &op);
+    void uni_vpbroadcastd(const Xbyak::Ymm& x, const Xbyak::Operand& op);
 
-    void uni_vpbroadcastq(const Xbyak::Xmm &x, const Xbyak::Operand &op);
+    void uni_vpbroadcastq(const Xbyak::Xmm& x, const Xbyak::Operand& op);
 
     void uni_vroundpd(const Xbyak::Xmm& v_dst, const Xbyak::Operand& op, const uint8_t imm);
 
@@ -98,76 +102,71 @@ class JitKernelBase: public dnnl::impl::cpu::x64::jit_generator {
 
     void uni_vshufpd(const Xbyak::Xmm& v_dst, const Xbyak::Xmm& v_srs, const Xbyak::Operand& op, uint8_t imm);
 
-    void gatherdd(const Xbyak::Xmm&    vDst,
-                  const Xbyak::Reg64&  rSrcPtr,
-                  const Xbyak::Xmm&    vSrcShift,
+    void gatherdd(const Xbyak::Xmm& vDst,
+                  const Xbyak::Reg64& rSrcPtr,
+                  const Xbyak::Xmm& vSrcShift,
                   const Xbyak::Opmask& kReadMask,
-                  const bool useMask   = true,
-                  const bool zeroFill  = false);
+                  const bool useMask = true,
+                  const bool zeroFill = false);
 
-    void gatherdd(const Xbyak::Xmm&   vDst,
+    void gatherdd(const Xbyak::Xmm& vDst,
                   const Xbyak::Reg64& rSrcPtr,
-                  const Xbyak::Xmm&   vSrcShift,
-                  const Xbyak::Xmm&   vReadMask,
-                  const bool useMask  = true,
+                  const Xbyak::Xmm& vSrcShift,
+                  const Xbyak::Xmm& vReadMask,
+                  const bool useMask = true,
                   const bool zeroFill = false);
 
-    void gatherdd(const Xbyak::Ymm&   vDst,
+    void gatherdd(const Xbyak::Ymm& vDst,
                   const Xbyak::Reg64& rSrcPtr,
-                  const Xbyak::Ymm&   vSrcShift,
-                  const Xbyak::Ymm&   vReadMask,
-                  const bool useMask  = true,
+                  const Xbyak::Ymm& vSrcShift,
+                  const Xbyak::Ymm& vReadMask,
+                  const bool useMask = true,
                   const bool zeroFill = false);
 
-    void fillRestWorkMask(const Xbyak::Opmask& kDstMask,
-                          const Xbyak::Reg64& rWorkRest);
+    void fillRestWorkMask(const Xbyak::Opmask& kDstMask, const Xbyak::Reg64& rWorkRest);
 
-    void fillRestWorkMask(const Xbyak::Xmm& ymmDstMask,
-                          const Xbyak::Reg64& rWorkRest,
-                          const uint64_t typeSize = 4);
+    void fillRestWorkMask(const Xbyak::Xmm& ymmDstMask, const Xbyak::Reg64& rWorkRest, const uint64_t typeSize = 4);
 
-    void fillRestWorkMask(const Xbyak::Ymm& ymmDstMask,
-                          const Xbyak::Reg64& rWorkRest,
-                          const uint64_t typeSize = 4);
+    void fillRestWorkMask(const Xbyak::Ymm& ymmDstMask, const Xbyak::Reg64& rWorkRest, const uint64_t typeSize = 4);
 
-    void load(const Xbyak::Xmm&     vDst,
+    void load(const Xbyak::Xmm& vDst,
               const Xbyak::Address& srcAddr,
-              const Xbyak::Reg64&   rLoadNum,
-              const size_t          typeSize,
+              const Xbyak::Reg64& rLoadNum,
+              const size_t typeSize,
               const bool zeroFill = false);
 
-    void load(const Xbyak::Ymm&     vDst,
+    void load(const Xbyak::Ymm& vDst,
               const Xbyak::Address& srcAddr,
-              const Xbyak::Reg64&   rLoadNum,
-              const size_t          typeSize,
+              const Xbyak::Reg64& rLoadNum,
+              const size_t typeSize,
               const bool zeroFill = false);
 
     void store(const Xbyak::Address& dstAddr,
-               const Xbyak::Xmm&     vSrc,
-               const Xbyak::Reg64&   rToStoreNum,
-               const size_t          typeSize);
+               const Xbyak::Xmm& vSrc,
+               const Xbyak::Reg64& rToStoreNum,
+               const size_t typeSize);
 
     void store(const Xbyak::Address& dstAddr,
-               const Xbyak::Ymm&     vSrc,
-               const Xbyak::Reg64&   rToStoreNum,
-               const size_t          typeSize);
+               const Xbyak::Ymm& vSrc,
+               const Xbyak::Reg64& rToStoreNum,
+               const size_t typeSize);
 
     // Makes gather from memory under the vReadMask and writes to the memory m128.
     void memMovDD(const Xbyak::Reg64& rDst,
                   const Xbyak::Reg64& rSrc,
-                  const Xbyak::Xmm&   vReadMask,
-                  const Xbyak::Xmm&   vSrcShift,
+                  const Xbyak::Xmm& vReadMask,
+                  const Xbyak::Xmm& vSrcShift,
                   const Xbyak::Reg64& rToStoreCounter,
-                  const bool useMask  = true,
+                  const bool useMask = true,
                   const bool zeroFill = false);
 
     // Makes gather from the memory under the vReadMask and writes to the memory m256.
     void memMovDD(const Xbyak::Reg64& rDst,
                   const Xbyak::Reg64& rSrc,
-                  const Xbyak::Ymm&   vReadMask,
-                  const Xbyak::Ymm&   vSrcShift,
+                  const Xbyak::Ymm& vReadMask,
+                  const Xbyak::Ymm& vSrcShift,
                   const Xbyak::Reg64& rToStoreCounter,
-                  const bool useMask  = true,
+                  const bool useMask = true,
                   const bool zeroFill = false);
 
 protected:
@@ -181,32 +180,37 @@ class JitKernelBase: public dnnl::impl::cpu::x64::jit_generator {
 
     enum {
         // Comparison predicate operand (immediate byte) for single-precision floating-point values.
-        CMP_EQ_PS = 0, // Equal (ordered, non-signaling)
-        CMP_LT_PS,     // Less-than (ordered, signaling)
-        CMP_LE_PS,     // Less-than-or-equal (ordered, signaling)
-        CMP_UNORD_PS,  // Unordered (non-signaling)
-        CMP_NEQ_PS,    // Not-equal (unordered, non-signaling)
-        CMP_NLT_PS,    // Not-less-than (unordered, signaling)
-        CMP_NLE_PS,    // Not-less-than-or-equal (unordered, signaling)
-        CMP_ORD_PS     // Ordered (non-signaling)
+        CMP_EQ_PS = 0,  // Equal (ordered, non-signaling)
+        CMP_LT_PS,      // Less-than (ordered, signaling)
+        CMP_LE_PS,      // Less-than-or-equal (ordered, signaling)
+        CMP_UNORD_PS,   // Unordered (non-signaling)
+        CMP_NEQ_PS,     // Not-equal (unordered, non-signaling)
+        CMP_NLT_PS,     // Not-less-than (unordered, signaling)
+        CMP_NLE_PS,     // Not-less-than-or-equal (unordered, signaling)
+        CMP_ORD_PS      // Ordered (non-signaling)
     };
 };
 
-template<typename CompileParams, typename CallArgs>
+template <typename CompileParams, typename CallArgs>
 class JitKernel : public JitKernelBase {
 public:
-    using KernelFunc = void (*)(const CallArgs *);
+    using KernelFunc = void (*)(const CallArgs*);
 
     explicit JitKernel(const char* name, const CompileParams& jcp, dnnl::impl::cpu::x64::cpu_isa_t max_cpu_isa)
-        : JitKernelBase{name, max_cpu_isa}, m_jcp{jcp}, m_func{nullptr} {}
+        : JitKernelBase{name, max_cpu_isa},
+          m_jcp{jcp},
+          m_func{nullptr} {}
 
     ~JitKernel() override = default;
 
     dnnl::impl::status_t create_kernel() override {
         const dnnl::impl::status_t code = jit_generator::create_kernel();
         if (code != dnnl::impl::status::success) {
-            OPENVINO_THROW("Could not create kernel. Error code: ", std::to_string(code), ". ",
-                       "Xbyak error code: ", Xbyak::ConvertErrorToString(Xbyak::GetError()));
+            OPENVINO_THROW("Could not create kernel. Error code: ",
+                           std::to_string(code),
+                           ". ",
+                           "Xbyak error code: ",
+                           Xbyak::ConvertErrorToString(Xbyak::GetError()));
         }
         m_func = (decltype(m_func))jit_ker();
         return code;
@@ -221,21 +225,21 @@ class JitKernel : public JitKernelBase {
         this->operator()(&args);
     }
 
-    template <template<dnnl::impl::cpu::x64::cpu_isa_t isa> class KernelT>
+    template <template <dnnl::impl::cpu::x64::cpu_isa_t isa> class KernelT>
     static std::shared_ptr<JitKernel<CompileParams, CallArgs>> createInstance(const CompileParams& jcp) {
         std::shared_ptr<JitKernel<CompileParams, CallArgs>> res;
 
         try {
-#define IF_ISA_CASE(ISA)                                \
-            if (dnnl::impl::cpu::x64::mayiuse(ISA))     \
-                res.reset(new KernelT<ISA>(jcp));       \
-            else
+#    define IF_ISA_CASE(ISA)                    \
+        if (dnnl::impl::cpu::x64::mayiuse(ISA)) \
+            res.reset(new KernelT<ISA>(jcp));   \
+        else
 
             IF_ISA_CASE(dnnl::impl::cpu::x64::avx512_core)
             IF_ISA_CASE(dnnl::impl::cpu::x64::avx2)
             IF_ISA_CASE(dnnl::impl::cpu::x64::sse41);
 
-#undef IF_ISA_CASE
+#    undef IF_ISA_CASE
 
             if (res) {
                 res->create_kernel();
@@ -254,8 +258,8 @@ class JitKernel : public JitKernelBase {
     KernelFunc m_func;
 };
 
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
-} // namespace kernel
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace kernel
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/mlp_kernel.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/mlp_kernel.cpp
index fd00fca8431ff0..089461bc504172 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/mlp_kernel.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/mlp_kernel.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "mlp_kernel.hpp"
+
 #include "emitters/plugin/x64/jit_dnnl_emitters.hpp"
 #include "mlp_utils.hpp"
 #include "openvino/core/parallel.hpp"
@@ -156,17 +157,17 @@ void MKernel::tile_config_M(TileConfig& tile_cfg, int M) {
         }
     }
     tile_cfg.reset(1,
-                    0,
-                    {
-                        {rows0, 64},  // C00:0
-                        {rows0, 64},  // C01:1
-                        {rows1, 64},  // C10:2
-                        {rows1, 64},  // C11:3
-                        {rows0, 64},  // A0:4
-                        {rows1, 64},  // A1:5
-                        {16, 64},     // B0:6
-                        {16, 64},     // B1:7
-                    });
+                   0,
+                   {
+                       {rows0, 64},  // C00:0
+                       {rows0, 64},  // C01:1
+                       {rows1, 64},  // C10:2
+                       {rows1, 64},  // C11:3
+                       {rows0, 64},  // A0:4
+                       {rows1, 64},  // A1:5
+                       {16, 64},     // B0:6
+                       {16, 64},     // B1:7
+                   });
 }
 
 void MKernel::generate_1x2() {
@@ -200,7 +201,8 @@ void MKernel::generate_1x2() {
         mov(reg_ktiles, ptr[abi_param1 + offsetof(call_args, k_tiles)]);
 
         mov(reg_tmp, ptr[abi_param1 + offsetof(call_args, do_accumulation)]);
-        // new: bit0: 0-skip load from mem, 1-load from mem; bit1: 0-skip tilezero, 1-tilezero; bit2: 0-skip store, 1-store
+        // new: bit0: 0-skip load from mem, 1-load from mem; bit1: 0-skip tilezero, 1-tilezero; bit2: 0-skip store,
+        // 1-store
         mov(abi_param1, reg_tmp);
         and_(reg_tmp, 1);
         jz(skip_load);
@@ -341,14 +343,14 @@ static void repackB(int8_t* dst, int8_t* src, int N_stride, int N, int K) {
     }
 }
 
-template<typename Tdst>
+template <typename Tdst>
 void MKernel::BMatrix::setup(Tdst* ext_buff, ov::float16* p_weight, int weight_stride_in_bytes, int N, int K) {
     OPENVINO_ASSERT((N % 32) == 0);
     OPENVINO_ASSERT((K % 32) == 0);
 
     this->ptr = reinterpret_cast<uint8_t*>(ext_buff);
-    this->Bpair_rows = K/32;
-    this->Bpair_cols = N/32;
+    this->Bpair_rows = K / 32;
+    this->Bpair_cols = N / 32;
 
     const int k_step = 32;
     auto N_stride = weight_stride_in_bytes / sizeof(Tdst);
@@ -376,8 +378,8 @@ void MKernel::BMatrix::setup(int8_t* ext_buff, int8_t* p_weight, int weight_stri
     OPENVINO_ASSERT((K % 64) == 0);
 
     this->ptr = reinterpret_cast<uint8_t*>(ext_buff);
-    this->Bpair_rows = K/64;
-    this->Bpair_cols = N/32;
+    this->Bpair_rows = K / 64;
+    this->Bpair_cols = N / 32;
 
     const int k_step = 64;
     auto N_stride = weight_stride_in_bytes / sizeof(int8_t);
@@ -398,7 +400,7 @@ void MKernel::BMatrix::setup(int8_t* ext_buff, int8_t* p_weight, int weight_stri
 }
 
 // interleaving two weights into one in unit of 16-column
-template<typename Tdst>
+template <typename Tdst>
 void MKernel::BMatrix::setup(Tdst* ext_buff,
                              ov::float16* p_weight_B0,
                              ov::float16* p_weight_B1,
@@ -506,14 +508,14 @@ void MatrixDynQuantPerRow::quantize(size_t BM, ov::bfloat16* psrc, int src_strid
         size_t start{0}, end{0};
         splitter(BM, nthr, ithr, start, end);
         ov::Extensions::Cpu::XARCH::llm_mlp_quantize_bf16_i8(psrc + start * src_stride,
-                                                            src_stride,
-                                                            data + start * K,
-                                                            K,
-                                                            end - start,
-                                                            K,
-                                                            scale + start,
-                                                            zp + start,
-                                                            asym);
+                                                             src_stride,
+                                                             data + start * K,
+                                                             K,
+                                                             end - start,
+                                                             K,
+                                                             scale + start,
+                                                             zp + start,
+                                                             asym);
     });
 }
 
@@ -620,7 +622,7 @@ void ReduceAdd2bh::generate() {
                 vcvtps2ph(ptr[dst + loop_i * 2], zmm0, 0x4);
                 vcvtps2ph(ptr[dst + loop_i * 2 + 32], zmm2, 0x4);
                 prefetchwt1(ptr[prefetch_dst + loop_i * 2]);
-           } else {
+            } else {
                 vcvtne2ps2bf16(zmm4, zmm2, zmm0);
                 prefetchwt1(ptr[prefetch_dst + loop_i * 2]);
                 vmovups(ptr[dst + loop_i * 2], zmm4);
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/mlp_kernel.hpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/mlp_kernel.hpp
index 26b6c1b0cc17a2..768d2e2dc3d7f4 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/mlp_kernel.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/mlp_kernel.hpp
@@ -4,13 +4,13 @@
 
 #pragma once
 
+#include "../scaled_attn/executor_pa_common.hpp"
 #include "cpu/x64/cpu_isa_traits.hpp"
 #include "cpu/x64/jit_generator.hpp"
-#include "../scaled_attn/executor_pa_common.hpp"
 #include "utils/plain_tensor.hpp"
 
 // register blocking size for K dimension (1x2 AMX B-tiles)
-#define REG_BLK_K_SIZE 32
+#define REG_BLK_K_SIZE    32
 #define REG_BLK_K_SIZE_I8 64
 
 // register blocking size for N dimension (1x2 AMX B-tiles)
@@ -64,23 +64,23 @@ class MKernel : public dnnl::impl::cpu::x64::jit_generator {
 
     void tmul(const Xbyak::Tmm& x1, const Xbyak::Tmm& x2, const Xbyak::Tmm& x3) {
         switch (m_tmul_type) {
-            case TMUL_TYPE::SSD:
-                tdpbssd(x1, x2, x3);
+        case TMUL_TYPE::SSD:
+            tdpbssd(x1, x2, x3);
             break;
-            case TMUL_TYPE::USD:
-                tdpbusd(x1, x2, x3);
+        case TMUL_TYPE::USD:
+            tdpbusd(x1, x2, x3);
             break;
-            case TMUL_TYPE::SUD:
-                tdpbsud(x1, x2, x3);
+        case TMUL_TYPE::SUD:
+            tdpbsud(x1, x2, x3);
             break;
-            case TMUL_TYPE::UUD:
-                tdpbuud(x1, x2, x3);
+        case TMUL_TYPE::UUD:
+            tdpbuud(x1, x2, x3);
             break;
-            case TMUL_TYPE::FP16:
-                tdpfp16ps(x1, x2, x3);
+        case TMUL_TYPE::FP16:
+            tdpfp16ps(x1, x2, x3);
             break;
-            case TMUL_TYPE::BF16:
-                tdpbf16ps(x1, x2, x3);
+        case TMUL_TYPE::BF16:
+            tdpbf16ps(x1, x2, x3);
             break;
         }
     }
@@ -103,7 +103,8 @@ class MKernel : public dnnl::impl::cpu::x64::jit_generator {
         } else {
             // next block size: 32 * N * sizeof(ov::bfloat16),
             // call number: N / 32 * M / 32
-            // each call needs fetch: 32 * N * sizeof(ov::bfloat16) / (N / 32 * M / 32) = 32 * 1024 * sizeof(ov::bfloat16) / M
+            // each call needs fetch: 32 * N * sizeof(ov::bfloat16) / (N / 32 * M / 32) = 32 * 1024 *
+            // sizeof(ov::bfloat16) / M
             m_prefetch_Blines = 32768 * sizeof(ov::bfloat16) / 64 / M_hint;
         }
 
@@ -132,21 +133,22 @@ class MKernel : public dnnl::impl::cpu::x64::jit_generator {
     };
 
     // each 32x16(64x16) sub-matrix in [K, N]-shaped BMatrix to be loaded as B-tile is packed into AMX B-tile layout
-    // and two neighboring B-tiles in same row are grouped as a pair (B0-B1), and all such pairs are arranged in [nN, nK] shape
+    // and two neighboring B-tiles in same row are grouped as a pair (B0-B1), and all such pairs are arranged in [nN,
+    // nK] shape
     struct BMatrix {
-        uint8_t * ptr;
+        uint8_t* ptr;
         // Bpair is two 1KB sub-matrixes repacked in AMX-Btile layout
         const size_t Bpair_size = 2048;
         size_t Bpair_rows;
         size_t Bpair_cols;
 
         // convert
-        template<typename Tdst>
+        template <typename Tdst>
         void setup(Tdst* ext_buff, ov::float16* p_weight, int stride, int N, int K);
 
         void setup(int8_t* ext_buff, int8_t* p_weight, int stride, int N, int K);
         // two B tiles in each pair (B0 & B1) comes from different raw weight matrix
-        template<typename Tdst>
+        template <typename Tdst>
         void setup(Tdst* ext_buff, ov::float16* p_weight_B0, ov::float16* p_weight_B1, int stride, int N, int K);
 
         void setup(int8_t* ext_buff, int8_t* p_weight_B0, int8_t* p_weight_B1, int stride, int N, int K);
@@ -196,8 +198,10 @@ struct Work {
         static MKernel jit_amx_bf16(BM, TMUL_TYPE::BF16);
         static MKernel jit_amx_f16(BM, TMUL_TYPE::FP16);
         static MKernel jit_amx_i8(BM, TMUL_TYPE::SSD);
-        if (quant_i8) return jit_amx_i8;
-        if (is_f16) return jit_amx_f16;
+        if (quant_i8)
+            return jit_amx_i8;
+        if (is_f16)
+            return jit_amx_f16;
         return jit_amx_bf16;
     }
 
@@ -205,8 +209,10 @@ struct Work {
         static MKernel jit_amx_bf16(16, TMUL_TYPE::BF16);
         static MKernel jit_amx_f16(16, TMUL_TYPE::FP16);
         static MKernel jit_amx_i8(16, TMUL_TYPE::SSD);
-        if (quant_i8) return jit_amx_i8;
-        if (is_f16) return jit_amx_f16;
+        if (quant_i8)
+            return jit_amx_i8;
+        if (is_f16)
+            return jit_amx_f16;
         return jit_amx_bf16;
     }
 
@@ -219,7 +225,7 @@ struct Work {
 
         if (do_sum_per_oc) {
             w_sum_per_oc.resize<float>({static_cast<size_t>(n1 - n0)});
-            auto * p_wsum_per_oc = w_sum_per_oc.ptr<float>();
+            auto* p_wsum_per_oc = w_sum_per_oc.ptr<float>();
             auto* pw_temp = pw;
             for (int n = n0; n < n1; n++, pw_temp += stride_in_bytes / sizeof(Tsrc)) {
                 float fsum = 0;
@@ -234,7 +240,7 @@ struct Work {
         for (int k = k0, ki = 0; k < k1;) {
             auto subK = std::min(blk_K_size, k1 - k);
             weights[ki].setup(dst, pw + k, stride_in_bytes, BN, subK);
-            dst += BN*subK;
+            dst += BN * subK;
             k += subK;
             ki++;
         }
@@ -250,24 +256,26 @@ struct Work {
     void setup(Tdst* dst, Tsrc* p_weight1, Tsrc* p_weight2, int stride_in_bytes, bool do_sum_per_oc = false) {
         auto& mkernel = get_MKernel();
         auto num_blk_K = (k1 - k0 + blk_K_size - 1) / blk_K_size;
-        auto* pw1 = p_weight1 + (n0/2) * stride_in_bytes / sizeof(Tsrc);
-        auto* pw2 = p_weight2 + (n0/2) * stride_in_bytes / sizeof(Tsrc);
+        auto* pw1 = p_weight1 + (n0 / 2) * stride_in_bytes / sizeof(Tsrc);
+        auto* pw2 = p_weight2 + (n0 / 2) * stride_in_bytes / sizeof(Tsrc);
 
         if (do_sum_per_oc) {
             w_sum_per_oc.resize<float>({static_cast<size_t>(n1 - n0)});
-            auto * p_wsum_per_oc = w_sum_per_oc.ptr<float>();
+            auto* p_wsum_per_oc = w_sum_per_oc.ptr<float>();
             auto* pw1_temp = pw1;
             auto* pw2_temp = pw2;
             auto stride_temp = stride_in_bytes / sizeof(Tsrc);
-            for (int n = n0; n < n1; n+=32) {
+            for (int n = n0; n < n1; n += 32) {
                 for (int dn = 0; dn < 16; dn++, pw1_temp += stride_temp) {
                     float fsum = 0;
-                    for (int k = k0; k < k1; k++) fsum += pw1_temp[k];
+                    for (int k = k0; k < k1; k++)
+                        fsum += pw1_temp[k];
                     *p_wsum_per_oc++ = fsum;
                 }
                 for (int dn = 0; dn < 16; dn++, pw2_temp += stride_temp) {
                     float fsum = 0;
-                    for (int k = k0; k < k1; k++) fsum += pw2_temp[k];
+                    for (int k = k0; k < k1; k++)
+                        fsum += pw2_temp[k];
                     *p_wsum_per_oc++ = fsum;
                 }
             }
@@ -278,7 +286,7 @@ struct Work {
         for (int k = k0, ki = 0; k < k1;) {
             auto subK = std::min(blk_K_size, k1 - k);
             weights[ki].setup(dst, pw1 + k, pw2 + k, stride_in_bytes, BN, subK);
-            dst += BN*subK;
+            dst += BN * subK;
             k += subK;
             ki++;
         }
@@ -293,7 +301,7 @@ struct Work {
 
     PlainTensor m_C;
 
-    size_t set_C(int M, float * ext_buff) {
+    size_t set_C(int M, float* ext_buff) {
         auto Mtails = M % 32;
         auto Mbody = M - Mtails;
         auto C_M = Mbody + (Mtails ? 32 : 0);
@@ -318,7 +326,7 @@ struct Work {
 
         pA += k0 * element_size;
 
-        if (M > 16 || num_blk_K ==1) {
+        if (M > 16 || num_blk_K == 1) {
             bool do_accumulation = false;
             for (size_t ki = 0; ki < num_blk_K; ki++) {
                 auto& blockB = weights[ki];
@@ -355,8 +363,8 @@ struct Work {
             auto num_blkN = blockB.Bpair_cols;
             m_tile_configer.do_config(&m_tcfg[Mtails]);
             // original: bit0: 0-tilezero+skip load from mem, 1-tilezero+load from mem; tilestore
-            // new: bit0: 0-skip load from mem, 1-load from mem; bit1: 0-skip tilezero, 1-tilezero; bit2: 0-skip store, 1-store
-            // if M > 32, firstK: 1 1 0(store, tilezero, skip load)
+            // new: bit0: 0-skip load from mem, 1-load from mem; bit1: 0-skip tilezero, 1-tilezero; bit2: 0-skip store,
+            // 1-store if M > 32, firstK: 1 1 0(store, tilezero, skip load)
             //      the otherK except last: 1 0 1(store, skip tilezero, load) lastK: 1 0 1
             // else
             //      firstK: 0 1 0(skip store, tilezero, skip load), the otherK except last: 0 0 0(skip all),
@@ -400,14 +408,14 @@ struct WeightBuffer {
         }
         buffer.resize<int8_t>({weight_size});
     }
-    template<typename T = ov::bfloat16>
+    template <typename T = ov::bfloat16>
     T* get(int work_id) {
         return reinterpret_cast<T*>(buffer.ptr<int8_t>() + offsets[work_id]);
     }
 };
 
 struct ScratchBuffAllocator {
-    using CallBack = std::function<void(void * ptr)>;
+    using CallBack = std::function<void(void* ptr)>;
     std::vector<CallBack> m_allocs;
     std::vector<size_t> m_sizes;
     size_t m_total_size = 0;
@@ -435,25 +443,25 @@ struct MatrixDynQuantPerRow {
     // M x K
     int M;
     int K;
-    int8_t * data;
-    float * scale;
-    float * zp;
+    int8_t* data;
+    float* scale;
+    float* zp;
     bool asym = true;
 
     MatrixDynQuantPerRow() = default;
 
     size_t size() {
         // size of data & scale & zp
-        return M*K + M*sizeof(float)*2;
+        return M * K + M * sizeof(float) * 2;
     }
 
     size_t stride() {
         return K;
     }
 
-    void setup(void * ext_buf) {
+    void setup(void* ext_buf) {
         data = reinterpret_cast<int8_t*>(ext_buf);
-        scale = reinterpret_cast<float*>(data + M*K);
+        scale = reinterpret_cast<float*>(data + M * K);
         zp = reinterpret_cast<float*>(scale + M);
     }
 
@@ -470,13 +478,16 @@ class GateUpCombine : public dnnl::impl::cpu::x64::jit_generator {
     const dnnl_alg_kind_t m_act_alg;
     const bool m_to_f16;
 
-    GateUpCombine(dnnl_alg_kind_t act_alg, bool to_f16) : jit_generator(jit_name()), m_act_alg(act_alg), m_to_f16(to_f16) {
+    GateUpCombine(dnnl_alg_kind_t act_alg, bool to_f16)
+        : jit_generator(jit_name()),
+          m_act_alg(act_alg),
+          m_to_f16(to_f16) {
         create_kernel();
     }
 
     void generate() override;
 
-    void call(float* src, size_t src_stride, void * pv_dst, size_t dst_stride, int num_rows, int num_cols) {
+    void call(float* src, size_t src_stride, void* pv_dst, size_t dst_stride, int num_rows, int num_cols) {
         auto* dst = reinterpret_cast<int16_t*>(pv_dst);
         for (int m = 0; m < num_rows; m++, src += src_stride, dst += dst_stride) {
             auto* prefetch_dst = (m + 1 < num_rows) ? (dst + dst_stride) : (dst);
@@ -509,7 +520,8 @@ class ReduceAdd2bh : public dnnl::impl::cpu::x64::jit_generator {
     void generate() override;
 
     // add two float input eltwise and convert to bf16 : ConvertFP32toBF16(src0 + src1)
-    void call(float * src0, float * src1, size_t src_stride, void * pf16_dst, size_t dst_stride, int num_rows, int num_cols) {
+    void
+    call(float* src0, float* src1, size_t src_stride, void* pf16_dst, size_t dst_stride, int num_rows, int num_cols) {
         auto* dst = reinterpret_cast<int16_t*>(pf16_dst);
         for (int m = 0; m < num_rows; m++, src0 += src_stride, src1 += src_stride, dst += dst_stride) {
             // the prefetch distance is increased to ensure by the time store happens
@@ -520,7 +532,7 @@ class ReduceAdd2bh : public dnnl::impl::cpu::x64::jit_generator {
     }
 
     // convert tensor to bf16: ConvertFP32toBF16(src0)
-    void call(float * src0, size_t src_stride, void * pf16_dst, size_t dst_stride, int num_rows, int num_cols) {
+    void call(float* src0, size_t src_stride, void* pf16_dst, size_t dst_stride, int num_rows, int num_cols) {
         auto* dst = reinterpret_cast<int16_t*>(pf16_dst);
         for (int m = 0; m < num_rows; m++, src0 += src_stride, dst += dst_stride) {
             // the prefetch distance is increased to ensure by the time store happens
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/non_max_suppression.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/non_max_suppression.cpp
index 6ec25067cec279..92c1c895ffd19e 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/non_max_suppression.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/non_max_suppression.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "non_max_suppression.hpp"
+
 #include "utils/general_utils.h"
 
 using namespace dnnl::impl::cpu;
@@ -18,13 +19,15 @@ void NonMaxSuppression<isa>::generate() {
     load_vector_emitter.reset(new jit_load_emitter(this, isa, ov::element::f32, ov::element::f32, vector_step));
     load_scalar_emitter.reset(new jit_load_emitter(this, isa, ov::element::f32, ov::element::f32, scalar_step));
 
-    exp_injector.reset(new x64::jit_uni_eltwise_injector_f32<isa>(this, dnnl::impl::alg_kind::eltwise_exp, 0.f, 0.f, 1.f));
+    exp_injector.reset(
+        new x64::jit_uni_eltwise_injector_f32<isa>(this, dnnl::impl::alg_kind::eltwise_exp, 0.f, 0.f, 1.f));
 
     this->preamble();
 
     uni_vpxor(vmm_zero, vmm_zero, vmm_zero);
 
-    load_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx()), static_cast<size_t>(reg_load_table.getIdx())};
+    load_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx()),
+                          static_cast<size_t>(reg_load_table.getIdx())};
     store_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx())};
     store_pool_vec_idxs = {static_cast<size_t>(vmm_zero.getIdx())};
 
@@ -67,8 +70,8 @@ void NonMaxSuppression<isa>::generate() {
         uni_vmovups(vmm_candidate_coord3, vmm_temp2);
     } else {
         // box format: x_center, y_center, width, height --> y1, x1, y2, x2
-        uni_vmulps(vmm_temp1, vmm_candidate_coord2, ptr[reg_table]);   // width/2
-        uni_vmulps(vmm_temp2, vmm_candidate_coord3, ptr[reg_table]);   // height/2
+        uni_vmulps(vmm_temp1, vmm_candidate_coord2, ptr[reg_table]);  // width/2
+        uni_vmulps(vmm_temp2, vmm_candidate_coord3, ptr[reg_table]);  // height/2
 
         uni_vaddps(vmm_temp3, vmm_candidate_coord0, vmm_temp1);  // x_center + width/2
         uni_vmovups(vmm_candidate_coord3, vmm_temp3);
@@ -116,7 +119,6 @@ void NonMaxSuppression<isa>::generate() {
     exp_injector->prepare_table();
 }
 
-
 template <x64::cpu_isa_t isa>
 void NonMaxSuppression<isa>::hard_nms() {
     Xbyak::Label main_loop_label_hard;
@@ -290,10 +292,10 @@ void NonMaxSuppression<isa>::soft_nms() {
 template <x64::cpu_isa_t isa>
 void NonMaxSuppression<isa>::suppressed_by_iou(bool is_scalar) {
     if (x64::mayiuse(x64::avx512_core)) {
-        vcmpps(k_mask, vmm_temp3, vmm_iou_threshold, 0x0D); // _CMP_GE_OS. vcmpps w/ kmask only on V5
+        vcmpps(k_mask, vmm_temp3, vmm_iou_threshold, 0x0D);  // _CMP_GE_OS. vcmpps w/ kmask only on V5
         if (is_scalar)
             kandw(k_mask, k_mask, k_mask_one);
-        kortestw(k_mask, k_mask);    // bitwise check if all zero
+        kortestw(k_mask, k_mask);  // bitwise check if all zero
     } else if (x64::mayiuse(x64::avx)) {
         // vex instructions with xmm on avx and ymm on avx2
         vcmpps(vmm_temp4, vmm_temp3, vmm_iou_threshold, 0x0D);  // xmm and ymm only on V1.
@@ -301,7 +303,8 @@ void NonMaxSuppression<isa>::suppressed_by_iou(bool is_scalar) {
             uni_vpextrd(reg_temp_32, Xbyak::Xmm(vmm_temp4.getIdx()), 0);
             test(reg_temp_32, reg_temp_32);
         } else {
-            uni_vtestps(vmm_temp4, vmm_temp4);  // vtestps: sign bit check if all zeros, ymm and xmm only on V1, N/A on V5
+            uni_vtestps(vmm_temp4,
+                        vmm_temp4);  // vtestps: sign bit check if all zeros, ymm and xmm only on V1, N/A on V5
         }
     } else {
         // pure sse path, make sure don't spoil vmm_temp3, which may used in after soft-suppression
@@ -309,7 +312,7 @@ void NonMaxSuppression<isa>::suppressed_by_iou(bool is_scalar) {
         cmpps(vmm_temp4, vmm_iou_threshold, 0x07);  // order compare, 0 for at least one is NaN
 
         uni_vmovups(vmm_temp2, vmm_temp3);
-        cmpps(vmm_temp2, vmm_iou_threshold, 0x05);   // _CMP_GE_US on sse, no direct _CMP_GE_OS supported.
+        cmpps(vmm_temp2, vmm_iou_threshold, 0x05);  // _CMP_GE_US on sse, no direct _CMP_GE_OS supported.
 
         uni_vandps(vmm_temp4, vmm_temp4, vmm_temp2);
         if (is_scalar) {
@@ -324,9 +327,12 @@ void NonMaxSuppression<isa>::suppressed_by_iou(bool is_scalar) {
 template <x64::cpu_isa_t isa>
 void NonMaxSuppression<isa>::suppressed_by_score() {
     if (x64::mayiuse(x64::avx512_core)) {
-        vcmpps(k_mask, vmm_temp3, vmm_score_threshold, 0x02); // vcmpps w/ kmask only on V5, w/o kmask version N/A on V5
+        vcmpps(k_mask,
+               vmm_temp3,
+               vmm_score_threshold,
+               0x02);  // vcmpps w/ kmask only on V5, w/o kmask version N/A on V5
         kandw(k_mask, k_mask, k_mask_one);
-        kortestw(k_mask, k_mask);    // bitwise check if all zero
+        kortestw(k_mask, k_mask);  // bitwise check if all zero
     } else if (x64::mayiuse(x64::avx)) {
         vcmpps(vmm_temp4, vmm_temp3, vmm_score_threshold, 0x02);
         uni_vpextrd(reg_temp_32, Xbyak::Xmm(vmm_temp4.getIdx()), 0);
@@ -342,11 +348,15 @@ template <x64::cpu_isa_t isa>
 void NonMaxSuppression<isa>::iou(int ele_num) {
     auto load = [&](Xbyak::Reg64 reg_src, Vmm vmm_dst) {
         if (ele_num != scalar_step && ele_num != vector_step)
-            OPENVINO_THROW("NMS JIT implementation supports load emitter with only element count scalar_step or vector_step! Get: ", ele_num);
+            OPENVINO_THROW("NMS JIT implementation supports load emitter with only element count scalar_step or "
+                           "vector_step! Get: ",
+                           ele_num);
 
         const auto& load_emitter = ele_num == 1 ? load_scalar_emitter : load_vector_emitter;
-        load_emitter->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_dst.getIdx())},
-            {}, {load_pool_gpr_idxs});
+        load_emitter->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                {static_cast<size_t>(vmm_dst.getIdx())},
+                                {},
+                                {load_pool_gpr_idxs});
     };
     load(reg_boxes_coord0, vmm_boxes_coord0);
     load(reg_boxes_coord1, vmm_boxes_coord1);
@@ -366,8 +376,8 @@ void NonMaxSuppression<isa>::iou(int ele_num) {
         uni_vmovups(vmm_boxes_coord3, vmm_temp2);
     } else {
         // box format: x_center, y_center, width, height --> y1, x1, y2, x2
-        uni_vmulps(vmm_temp1, vmm_boxes_coord2, ptr[reg_table]);   // width/2
-        uni_vmulps(vmm_temp2, vmm_boxes_coord3, ptr[reg_table]);   // height/2
+        uni_vmulps(vmm_temp1, vmm_boxes_coord2, ptr[reg_table]);  // width/2
+        uni_vmulps(vmm_temp2, vmm_boxes_coord3, ptr[reg_table]);  // height/2
 
         uni_vaddps(vmm_temp3, vmm_boxes_coord0, vmm_temp1);  // x_center + width/2
         uni_vmovups(vmm_boxes_coord3, vmm_temp3);
@@ -395,13 +405,13 @@ void NonMaxSuppression<isa>::iou(int ele_num) {
     // y of intersection
     uni_vminps(vmm_temp3, vmm_boxes_coord2, vmm_candidate_coord2);  // min(Ymax)
     uni_vmaxps(vmm_temp4, vmm_boxes_coord0, vmm_candidate_coord0);  // max(Ymin)
-    uni_vsubps(vmm_temp3, vmm_temp3, vmm_temp4);  // min(Ymax) - max(Ymin)
+    uni_vsubps(vmm_temp3, vmm_temp3, vmm_temp4);                    // min(Ymax) - max(Ymin)
     uni_vmaxps(vmm_temp3, vmm_temp3, vmm_zero);
 
     // x of intersection
     uni_vminps(vmm_temp4, vmm_boxes_coord3, vmm_candidate_coord3);  // min(Xmax)
     uni_vmaxps(vmm_temp2, vmm_boxes_coord1, vmm_candidate_coord1);  // max(Xmin)
-    uni_vsubps(vmm_temp4, vmm_temp4, vmm_temp2);  // min(Xmax) - max(Xmin)
+    uni_vsubps(vmm_temp4, vmm_temp4, vmm_temp2);                    // min(Xmax) - max(Xmin)
     uni_vmaxps(vmm_temp4, vmm_temp4, vmm_zero);
 
     // intersection_area
@@ -421,11 +431,11 @@ void NonMaxSuppression<isa>::soft_coeff() {
 }
 
 template <x64::cpu_isa_t isa>
-void NonMaxSuppression<isa>::horizontal_mul_xmm(const Xbyak::Xmm &xmm_weight, const Xbyak::Xmm &xmm_aux) {
-    uni_vmovshdup(xmm_aux, xmm_weight);              //  weight:1,2,3,4; aux:2,2,4,4
-    uni_vmulps(xmm_weight, xmm_weight, xmm_aux);     //  weight:1*2,2*2,3*4,4*4
-    uni_vmovhlps(xmm_aux, xmm_aux, xmm_weight);      //  aux:3*4,4*4,4,4
-    uni_vmulps(xmm_weight, xmm_weight, xmm_aux);     //  weight:1*2*3*4,...
+void NonMaxSuppression<isa>::horizontal_mul_xmm(const Xbyak::Xmm& xmm_weight, const Xbyak::Xmm& xmm_aux) {
+    uni_vmovshdup(xmm_aux, xmm_weight);           //  weight:1,2,3,4; aux:2,2,4,4
+    uni_vmulps(xmm_weight, xmm_weight, xmm_aux);  //  weight:1*2,2*2,3*4,4*4
+    uni_vmovhlps(xmm_aux, xmm_aux, xmm_weight);   //  aux:3*4,4*4,4,4
+    uni_vmulps(xmm_weight, xmm_weight, xmm_aux);  //  weight:1*2*3*4,...
 }
 
 // horizontal mul for vmm_weight(Vmm(3)), temp1 and temp2 as aux
@@ -459,6 +469,6 @@ template class NonMaxSuppression<x64::avx512_core>;
 template class NonMaxSuppression<x64::avx2>;
 template class NonMaxSuppression<x64::sse41>;
 
-}   // namespace kernel
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace kernel
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/non_max_suppression.hpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/non_max_suppression.hpp
index 2b5cf495c426e2..a47120de5a9040 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/non_max_suppression.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/non_max_suppression.hpp
@@ -7,17 +7,14 @@
 #include "jit_kernel_base.hpp"
 
 #if defined(OPENVINO_ARCH_X86_64)
-#include "emitters/plugin/x64/jit_load_store_emitters.hpp"
-#include "cpu/x64/injectors/jit_uni_eltwise_injector.hpp"
-#endif // OPENVINO_ARCH_X86_64
+#    include "cpu/x64/injectors/jit_uni_eltwise_injector.hpp"
+#    include "emitters/plugin/x64/jit_load_store_emitters.hpp"
+#endif  // OPENVINO_ARCH_X86_64
 
 namespace ov {
 namespace intel_cpu {
 
-enum class NMSBoxEncodeType {
-    CORNER,
-    CENTER
-};
+enum class NMSBoxEncodeType { CORNER, CENTER };
 
 #if defined(OPENVINO_ARCH_X86_64)
 
@@ -40,7 +37,6 @@ struct NmsCallArgs {
     void* score;
 };
 
-
 template <dnnl::impl::cpu::x64::cpu_isa_t isa>
 class NonMaxSuppression : public JitKernel<NmsCompileParams, NmsCallArgs> {
 public:
@@ -51,9 +47,11 @@ class NonMaxSuppression : public JitKernel<NmsCompileParams, NmsCallArgs> {
     void generate() override;
 
 private:
-    using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::avx512_core, Xbyak::Zmm,
-                                                         isa == dnnl::impl::cpu::x64::avx2,        Xbyak::Ymm,
-                                                                                                   Xbyak::Xmm>::type;
+    using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::avx512_core,
+                                                         Xbyak::Zmm,
+                                                         isa == dnnl::impl::cpu::x64::avx2,
+                                                         Xbyak::Ymm,
+                                                         Xbyak::Xmm>::type;
     uint32_t vlen = dnnl::impl::cpu::x64::cpu_isa_traits<isa>::vlen;
     const int vector_step = vlen / sizeof(float);
     const int scalar_step = 1;
@@ -139,14 +137,14 @@ class NonMaxSuppression : public JitKernel<NmsCompileParams, NmsCallArgs> {
 
         align(64);
         L(l_table_constant);
-        broadcast_d(0x3f000000);   // 0.5f
+        broadcast_d(0x3f000000);  // 0.5f
         dw(0x0001);
     }
 };
 
-}   // namespace kernel
+}  // namespace kernel
 
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/random_uniform.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/random_uniform.cpp
index b0cca95d1b3636..aa5edf2cb69555 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/random_uniform.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/random_uniform.cpp
@@ -13,9 +13,7 @@ namespace kernel {
 #define GET_OFF(field) offsetof(RandomUniformCallArgs, field)
 
 template <x64::cpu_isa_t isa>
-RandomUniform<isa>::RandomUniform(const RandomUniformCompileParams& jcp) :
-        JitKernel(jit_name(), jcp, isa) {
-}
+RandomUniform<isa>::RandomUniform(const RandomUniformCompileParams& jcp) : JitKernel(jit_name(), jcp, isa) {}
 
 template <x64::cpu_isa_t isa>
 void RandomUniform<isa>::generate() {
@@ -26,7 +24,7 @@ void RandomUniform<isa>::generate() {
     r64_work_amount = getReg64();
 
     mov(r64_work_amount, ptr[r64_params + GET_OFF(work_amount)]);
-    mov(r64_dst,  ptr[r64_params + GET_OFF(dst_ptr)]);
+    mov(r64_dst, ptr[r64_params + GET_OFF(dst_ptr)]);
 
     initVectors();
     process();
@@ -43,15 +41,15 @@ void RandomUniform<x64::avx512_core>::initVectors() {
 
     v_max_mul_n_64 = getVmm();
     v_max_mul_c_64 = getVmm();
-    v_add_low_k    = getVmm();
-    v_add_up_k     = getVmm();
-    v_n_inc        = getVmm();
-    v_range        = getVmm();
-    v_min          = getVmm();
-    v_key_64       = getVmm();
-    v_counter_64   = getVmm();
-    v_n_64         = getVmm();
-    v_res_perm     = getVmm();
+    v_add_low_k = getVmm();
+    v_add_up_k = getVmm();
+    v_n_inc = getVmm();
+    v_range = getVmm();
+    v_min = getVmm();
+    v_key_64 = getVmm();
+    v_counter_64 = getVmm();
+    v_n_64 = getVmm();
+    v_res_perm = getVmm();
 
     if (m_jcp.out_data_type.is_real()) {
         v_convert_0 = getVmm();
@@ -59,29 +57,29 @@ void RandomUniform<x64::avx512_core>::initVectors() {
     }
 
     // Initialize constants.
-#define BROADCAST_R(F, V, R, C)           \
-    mov(R, C);                            \
+#define BROADCAST_R(F, V, R, C) \
+    mov(R, C);                  \
     F(V, R);
 #define BROADCAST_P(F, V, R, C)           \
-    mov(R, ptr[r64_params + GET_OFF(C)]);  \
+    mov(R, ptr[r64_params + GET_OFF(C)]); \
     F(V, ptr[R]);
 
     BROADCAST_R(vpbroadcastq, v_max_mul_n_64, r64_aux, STATISTIC_MAXIMIZING_MULTIPLIER_N)
     BROADCAST_R(vpbroadcastq, v_max_mul_c_64, r64_aux, STATISTIC_MAXIMIZING_MULTIPLIER_COUNTER)
-    BROADCAST_R(vpbroadcastd, v_add_low_k,    r32_aux, CRUSH_RESISTANCE_CONST_LOWER_VALUE)
-    BROADCAST_R(vpbroadcastd, v_add_up_k,     r32_aux, CRUSH_RESISTANCE_CONST_UPPER_VALUE)
-    BROADCAST_R(vpbroadcastq, v_n_inc,        r64_aux, 0x00000008)
+    BROADCAST_R(vpbroadcastd, v_add_low_k, r32_aux, CRUSH_RESISTANCE_CONST_LOWER_VALUE)
+    BROADCAST_R(vpbroadcastd, v_add_up_k, r32_aux, CRUSH_RESISTANCE_CONST_UPPER_VALUE)
+    BROADCAST_R(vpbroadcastq, v_n_inc, r64_aux, 0x00000008)
 
     if (m_jcp.out_data_type == element::f32) {
         BROADCAST_R(vpbroadcastd, v_convert_0, r32_aux, 0x3f800000)
         BROADCAST_R(vpbroadcastd, v_convert_1, r32_aux, 0x007fffff)
-        BROADCAST_P(vpbroadcastd, v_range,     r64_aux, range_ptr)
-        BROADCAST_P(vpbroadcastd, v_min,       r64_aux, min_ptr)
+        BROADCAST_P(vpbroadcastd, v_range, r64_aux, range_ptr)
+        BROADCAST_P(vpbroadcastd, v_min, r64_aux, min_ptr)
     } else if (m_jcp.out_data_type == element::f16 && x64::mayiuse(x64::avx512_core_fp16)) {
         BROADCAST_R(vpbroadcastw, v_convert_0, r16_aux, 0x3c00)
         BROADCAST_R(vpbroadcastw, v_convert_1, r16_aux, 0x03ff)
-        BROADCAST_P(vpbroadcastw, v_range,     r64_aux, range_ptr)
-        BROADCAST_P(vpbroadcastw, v_min,       r64_aux, min_ptr)
+        BROADCAST_P(vpbroadcastw, v_range, r64_aux, range_ptr)
+        BROADCAST_P(vpbroadcastw, v_min, r64_aux, min_ptr)
     } else if (m_jcp.out_data_type == element::bf16 && x64::mayiuse(x64::avx512_core_bf16)) {
         v_convert_2 = getVmm();
         const auto ymm_min = Xbyak::Ymm(v_min.getIdx());
@@ -102,39 +100,57 @@ void RandomUniform<x64::avx512_core>::initVectors() {
         const auto ymm_range = Xbyak::Ymm(v_range.getIdx());
 
         BROADCAST_P(vpbroadcastd, v_range, r64_aux, range_ptr)
-        BROADCAST_P(vpbroadcastd, v_min,   r64_aux, min_ptr)
+        BROADCAST_P(vpbroadcastd, v_min, r64_aux, min_ptr)
 
         uni_vcvtdq2pd(v_range, ymm_range);
     } else {
-        OPENVINO_THROW("RandomUniform kernel does not support precision ", m_jcp.out_data_type, " for ", x64::get_isa_info());
+        OPENVINO_THROW("RandomUniform kernel does not support precision ",
+                       m_jcp.out_data_type,
+                       " for ",
+                       x64::get_isa_info());
     }
 
     // Initialize inputs.
-    BROADCAST_P(vpbroadcastq, v_key_64,     r64_aux, key_ptr)
+    BROADCAST_P(vpbroadcastq, v_key_64, r64_aux, key_ptr)
     BROADCAST_P(vpbroadcastq, v_counter_64, r64_aux, counter_ptr)
-    BROADCAST_P(vpbroadcastq, v_n_64,       r64_aux, n_ptr)
+    BROADCAST_P(vpbroadcastq, v_n_64, r64_aux, n_ptr)
 
     if (m_jcp.out_data_type.size() <= 4) {
-        static const uint64_t n_inc_arr[8]  = { 0, 1, 2, 3, 4, 5, 6, 7 };
+        static const uint64_t n_inc_arr[8] = {0, 1, 2, 3, 4, 5, 6, 7};
         mov(r64_aux, reinterpret_cast<uintptr_t>(n_inc_arr));
     } else {
-        static const uint64_t n_inc_arr[8]  = { 0, 1, 2, 3, 4, 5, 6, 7 }; // TODO: i64
+        static const uint64_t n_inc_arr[8] = {0, 1, 2, 3, 4, 5, 6, 7};  // TODO: i64
         mov(r64_aux, reinterpret_cast<uintptr_t>(n_inc_arr));
     }
     uni_vpaddq(v_n_64, v_n_64, ptr[r64_aux]);
 
     // Initialize auxiliary vectors.
-    static const uint32_t res_perm_mask[16] = { 0b00000000, 0b00010000, 0b00001000, 0b00011000, 0b00000010, 0b00010010, 0b00001010, 0b00011010,
-                                                0b00000100, 0b00010100, 0b00001100, 0b00011100, 0b00000110, 0b00010110, 0b00001110, 0b00011110 };
+    static const uint32_t res_perm_mask[16] = {0b00000000,
+                                               0b00010000,
+                                               0b00001000,
+                                               0b00011000,
+                                               0b00000010,
+                                               0b00010010,
+                                               0b00001010,
+                                               0b00011010,
+                                               0b00000100,
+                                               0b00010100,
+                                               0b00001100,
+                                               0b00011100,
+                                               0b00000110,
+                                               0b00010110,
+                                               0b00001110,
+                                               0b00011110};
     mov(r64_aux, reinterpret_cast<uintptr_t>(res_perm_mask));
     uni_vmovups(v_res_perm, ptr[r64_aux]);
 
     if (m_jcp.out_data_type == element::f16 && x64::mayiuse(x64::avx512_core_fp16)) {
         v_perm_16 = getVmm();
-        static const uint16_t perm_16[32] = { 0b00000000, 0b00000010, 0b00000100, 0b00000110, 0b00001000, 0b00001010, 0b00001100, 0b00001110,
-                                              0b00010000, 0b00010010, 0b00010100, 0b00010110, 0b00011000, 0b00011010, 0b00011100, 0b00011110,
-                                              0b00100000, 0b00100010, 0b00100100, 0b00100110, 0b00101000, 0b00101010, 0b00101100, 0b00101110,
-                                              0b00110000, 0b00110010, 0b00110100, 0b00110110, 0b00111000, 0b00111010, 0b00111100, 0b00111110 };
+        static const uint16_t perm_16[32] = {
+            0b00000000, 0b00000010, 0b00000100, 0b00000110, 0b00001000, 0b00001010, 0b00001100, 0b00001110,
+            0b00010000, 0b00010010, 0b00010100, 0b00010110, 0b00011000, 0b00011010, 0b00011100, 0b00011110,
+            0b00100000, 0b00100010, 0b00100100, 0b00100110, 0b00101000, 0b00101010, 0b00101100, 0b00101110,
+            0b00110000, 0b00110010, 0b00110100, 0b00110110, 0b00111000, 0b00111010, 0b00111100, 0b00111110};
         mov(r64_aux, reinterpret_cast<uintptr_t>(perm_16));
         uni_vmovups(v_perm_16, ptr[r64_aux]);
     }
@@ -143,29 +159,29 @@ void RandomUniform<x64::avx512_core>::initVectors() {
 #undef BROADCAST_P
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX2, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX2, SSE41
 void RandomUniform<isa>::initVectors() {
     const auto r64_aux = getReg64();
 
     v_max_mul_n_64 = getVmm();
     v_max_mul_c_64 = getVmm();
-    v_add_low_k    = getVmm();
-    v_add_up_k     = getVmm();
-    v_range        = getVmm();
-    v_key_64       = getVmm();
-    v_counter_64   = getVmm();
-    v_n_64         = getVmm();
-
-    r64_n_inc      = getReg64();
-    r64_min        = getReg64();
-
-#define INIT_ARR(A, V, R, T)                                                                \
-    static const T A[8] = { V, V, V, V, V, V, V, V };                                       \
-    if (isa == x64::avx2) {                                                                 \
-        mov(R, reinterpret_cast<uintptr_t>(A));                                             \
-    } else {                                                                                \
-        static const T* A##_aligned = A + (reinterpret_cast<int64_t>(A) % 16) / sizeof(T);  \
-        mov(R, reinterpret_cast<uintptr_t>(A##_aligned));                                   \
+    v_add_low_k = getVmm();
+    v_add_up_k = getVmm();
+    v_range = getVmm();
+    v_key_64 = getVmm();
+    v_counter_64 = getVmm();
+    v_n_64 = getVmm();
+
+    r64_n_inc = getReg64();
+    r64_min = getReg64();
+
+#define INIT_ARR(A, V, R, T)                                                               \
+    static const T A[8] = {V, V, V, V, V, V, V, V};                                        \
+    if (isa == x64::avx2) {                                                                \
+        mov(R, reinterpret_cast<uintptr_t>(A));                                            \
+    } else {                                                                               \
+        static const T* A##_aligned = A + (reinterpret_cast<int64_t>(A) % 16) / sizeof(T); \
+        mov(R, reinterpret_cast<uintptr_t>(A##_aligned));                                  \
     }
 
     // Initialize constants.
@@ -184,8 +200,8 @@ void RandomUniform<isa>::initVectors() {
     INIT_ARR(n_inc_step, isa == x64::avx2 ? 4 : 2, r64_n_inc, uint64_t);
 
     if (m_jcp.out_data_type == element::f32) {
-        r64_convert_0  = getReg64();
-        r64_convert_1  = getReg64();
+        r64_convert_0 = getReg64();
+        r64_convert_1 = getReg64();
 
         INIT_ARR(convert_0, 0x3f800000, r64_convert_0, uint32_t);
         INIT_ARR(convert_1, 0x007fffff, r64_convert_1, uint32_t);
@@ -217,7 +233,10 @@ void RandomUniform<isa>::initVectors() {
 
         uni_vcvtdq2pd(v_range, xmm_range);
     } else {
-        OPENVINO_THROW("RandomUniform kernel does not support precision ", m_jcp.out_data_type, " for ", x64::get_isa_info());
+        OPENVINO_THROW("RandomUniform kernel does not support precision ",
+                       m_jcp.out_data_type,
+                       " for ",
+                       x64::get_isa_info());
     }
 
     // Initialize inputs.
@@ -232,17 +251,18 @@ void RandomUniform<isa>::initVectors() {
 
     if (m_jcp.out_data_type.size() <= 4) {
         if (isa == x64::avx2) {
-            static const uint64_t n_inc_arr[4]  = { 0, 1, 2, 3 };
+            static const uint64_t n_inc_arr[4] = {0, 1, 2, 3};
             mov(r64_aux, reinterpret_cast<uintptr_t>(n_inc_arr));
         } else {
             static uint64_t n_inc_arr[4];
-            static uint64_t* n_inc_arr_aligned = n_inc_arr + (reinterpret_cast<int64_t>(n_inc_arr) % 16) / sizeof(uint64_t);
+            static uint64_t* n_inc_arr_aligned =
+                n_inc_arr + (reinterpret_cast<int64_t>(n_inc_arr) % 16) / sizeof(uint64_t);
             n_inc_arr_aligned[0] = 0;
             n_inc_arr_aligned[1] = 1;
             mov(r64_aux, reinterpret_cast<uintptr_t>(n_inc_arr_aligned));
         }
     } else {
-        static const uint64_t n_inc_arr[4]  = { 0, 1, 2, 3 }; // TODO: i64
+        static const uint64_t n_inc_arr[4] = {0, 1, 2, 3};  // TODO: i64
         mov(r64_aux, reinterpret_cast<uintptr_t>(n_inc_arr));
     }
 
@@ -255,7 +275,7 @@ template <x64::cpu_isa_t isa>
 void RandomUniform<isa>::process() {
     auto v_dst_0 = getVmm();
     auto v_dst_1 = getVmm();
-    std::vector<Vmm> v_res{ v_dst_0, v_dst_1 };
+    std::vector<Vmm> v_res{v_dst_0, v_dst_1};
 
     auto step = vlen;
     if (one_of(m_jcp.out_data_type.size(), 2lu, 4lu)) {
@@ -265,7 +285,8 @@ void RandomUniform<isa>::process() {
     }
 
     Xbyak::Label l_loop, l_tail;
-    L(l_loop); {
+    L(l_loop);
+    {
         cmp(r64_work_amount, step);
         jl(l_tail, T_NEAR);
 
@@ -294,22 +315,31 @@ void RandomUniform<isa>::process() {
 }
 
 template <x64::cpu_isa_t isa>
-void RandomUniform<isa>::calculateRound(const Vmm& vmm_k_0, const Vmm& vmm_k_1, const Vmm& vmm_c_0, const Vmm& vmm_c_1,
-                                        const Vmm& vmm_n_0, const Vmm& vmm_n_1, const Vmm& vmm_aux_0, const Vmm& vmm_aux_1) {
+void RandomUniform<isa>::calculateRound(const Vmm& vmm_k_0,
+                                        const Vmm& vmm_k_1,
+                                        const Vmm& vmm_c_0,
+                                        const Vmm& vmm_c_1,
+                                        const Vmm& vmm_n_0,
+                                        const Vmm& vmm_n_1,
+                                        const Vmm& vmm_aux_0,
+                                        const Vmm& vmm_aux_1) {
     uni_vpmuludq(vmm_aux_0, vmm_n_0, v_max_mul_n_64);  // {p0,p1,p0,p1} = {n0,_,n0,_} * {m0,_,m0,_}
     uni_vpmuludq(vmm_aux_1, vmm_c_0, v_max_mul_c_64);  // {r0,r1,r0,r1} = {c0,_,c0,_} * {m0,_,m0,_}
 
-    uni_vpshufd(vmm_c_0, vmm_aux_0, 0b10110001);       // {p1,p0,p1,p0} = shuf {p0,p1,p0,p1}
-    uni_vxorps(vmm_c_0, vmm_c_0, vmm_c_1);             // {c0,_,c0,_} = {p1,_,p1,_} ^ {c1,_,c1,_}
-    uni_vxorps(vmm_c_0, vmm_c_0, vmm_k_1);             // {c0,_,c0,_} = {c0,_,c0,_} ^ {k1,_,k1,_}
+    uni_vpshufd(vmm_c_0, vmm_aux_0, 0b10110001);  // {p1,p0,p1,p0} = shuf {p0,p1,p0,p1}
+    uni_vxorps(vmm_c_0, vmm_c_0, vmm_c_1);        // {c0,_,c0,_} = {p1,_,p1,_} ^ {c1,_,c1,_}
+    uni_vxorps(vmm_c_0, vmm_c_0, vmm_k_1);        // {c0,_,c0,_} = {c0,_,c0,_} ^ {k1,_,k1,_}
 
-    uni_vpshufd(vmm_n_0, vmm_aux_1, 0b10110001);       // {r1,r0,r1,r0} = shuf {r0,r1,r0,r1}
-    uni_vxorps(vmm_n_0, vmm_n_0, vmm_n_1);             // {n0,_,n0,_} = {r1,_,r1,_} ^ {n1,_,n1,_}
-    uni_vxorps(vmm_n_0, vmm_n_0, vmm_k_0);             // {n0,_,n0,_} = {n0,_,n0,_} ^ {k0,_,k0,_}
+    uni_vpshufd(vmm_n_0, vmm_aux_1, 0b10110001);  // {r1,r0,r1,r0} = shuf {r0,r1,r0,r1}
+    uni_vxorps(vmm_n_0, vmm_n_0, vmm_n_1);        // {n0,_,n0,_} = {r1,_,r1,_} ^ {n1,_,n1,_}
+    uni_vxorps(vmm_n_0, vmm_n_0, vmm_k_0);        // {n0,_,n0,_} = {n0,_,n0,_} ^ {k0,_,k0,_}
 }
 
 template <x64::cpu_isa_t isa>
-void RandomUniform<isa>::runPhilox(const std::vector<Vmm>& vmm_dst, const Vmm& vmm_key, const Vmm& vmm_counter, const Vmm& vmm_n) {
+void RandomUniform<isa>::runPhilox(const std::vector<Vmm>& vmm_dst,
+                                   const Vmm& vmm_key,
+                                   const Vmm& vmm_counter,
+                                   const Vmm& vmm_n) {
     auto vmm_k_0 = getVmm();
     auto vmm_k_1 = getVmm();
     auto vmm_n_0 = getVmm();
@@ -319,19 +349,19 @@ void RandomUniform<isa>::runPhilox(const std::vector<Vmm>& vmm_dst, const Vmm& v
     auto vmm_aux_0 = getVmm();
     auto vmm_aux_1 = vmm_dst[1];
 
-    uni_vmovups(vmm_k_0, vmm_key);                        // {k0,k1,k0,k1} -> {k0,_,k0,_}
-    uni_vpshufd(vmm_k_1, vmm_key, 0b10110001);            // {k0,k1,k0,k1} -> {k1,_,k1,_}
+    uni_vmovups(vmm_k_0, vmm_key);              // {k0,k1,k0,k1} -> {k0,_,k0,_}
+    uni_vpshufd(vmm_k_1, vmm_key, 0b10110001);  // {k0,k1,k0,k1} -> {k1,_,k1,_}
 
-    uni_vpmuludq(vmm_aux_0, vmm_n, v_max_mul_n_64);       // {p0,p1,p0,p1} = {n0,_,n0,_} * {m0,_,m0,_}
-    uni_vpmuludq(vmm_aux_1, vmm_counter, v_max_mul_c_64); // {r0,r1,r0,r1} = {c0,_,c0,_} * {m0,_,m0,_}
+    uni_vpmuludq(vmm_aux_0, vmm_n, v_max_mul_n_64);        // {p0,p1,p0,p1} = {n0,_,n0,_} * {m0,_,m0,_}
+    uni_vpmuludq(vmm_aux_1, vmm_counter, v_max_mul_c_64);  // {r0,r1,r0,r1} = {c0,_,c0,_} * {m0,_,m0,_}
 
-    uni_vxorps(vmm_c_0, vmm_aux_0, vmm_counter);          // {_,c0,_,c0} = {_,p1,_,p1} ^ {_,c1,_,c1}
-    uni_vxorps(vmm_c_0, vmm_c_0, vmm_key);                // {_,c0,_,c0} = {_,c0,_,c0} ^ {_,k1,_,k1}
-    uni_vpshufd(vmm_c_0, vmm_c_0, 0b10110001);            // {_,c0,_,c0} -> {c0,_,c0,_}
+    uni_vxorps(vmm_c_0, vmm_aux_0, vmm_counter);  // {_,c0,_,c0} = {_,p1,_,p1} ^ {_,c1,_,c1}
+    uni_vxorps(vmm_c_0, vmm_c_0, vmm_key);        // {_,c0,_,c0} = {_,c0,_,c0} ^ {_,k1,_,k1}
+    uni_vpshufd(vmm_c_0, vmm_c_0, 0b10110001);    // {_,c0,_,c0} -> {c0,_,c0,_}
 
-    uni_vxorps(vmm_n_0, vmm_aux_1, vmm_n);                // {_,n0,_,n0} = {_,r1,_,r1} ^ {_,n1,_,n1}
-    uni_vpshufd(vmm_n_0, vmm_n_0, 0b10110001);            // {_,n0,_,n0} -> {n0,_,n0,_}
-    uni_vxorps(vmm_n_0, vmm_n_0, vmm_key);                // {n0,_,n0,_} = {n0,_,n0,_} ^ {k0,_,k0,_}
+    uni_vxorps(vmm_n_0, vmm_aux_1, vmm_n);      // {_,n0,_,n0} = {_,r1,_,r1} ^ {_,n1,_,n1}
+    uni_vpshufd(vmm_n_0, vmm_n_0, 0b10110001);  // {_,n0,_,n0} -> {n0,_,n0,_}
+    uni_vxorps(vmm_n_0, vmm_n_0, vmm_key);      // {n0,_,n0,_} = {n0,_,n0,_} ^ {k0,_,k0,_}
 
     for (size_t i = 0lu; i < ROUNDS_NUMBER - 1; i++) {
         raiseKey(vmm_k_0, vmm_k_1);
@@ -353,10 +383,10 @@ void RandomUniform<isa>::runPhilox(const std::vector<Vmm>& vmm_dst, const Vmm& v
         auto ymm_dst_1 = Xbyak::Ymm(vmm_dst[1].getIdx());
         auto ymm_c_0 = Xbyak::Ymm(vmm_c_0.getIdx());
 
-        uni_vshufps(vmm_n_0, vmm_n_0, vmm_n_1, 0b10001000);   // {n0,n0,n1,n1} = shuf {n0,_,n0,_} {n1,_,n1,_}
-        uni_vshufps(vmm_c_0, vmm_c_0, vmm_c_1, 0b10001000);   // {c0,c0,c1,c1} = shuf {c0,_,c0,_} {c1,_,c1,_}
-        uni_vshufps(ymm_dst_1, vmm_n_0, vmm_c_0, 0b10001000); // {n0,n1,c0,c1} = shuf {n0,n0,n1,n1} {c0,c0,c1,c1}
-        uni_vshufps(vmm_c_0, vmm_n_0, vmm_c_0, 0b11011101);   // {n0,n1,c0,c1} = shuf {n0,n0,n1,n1} {c0,c0,c1,c1}
+        uni_vshufps(vmm_n_0, vmm_n_0, vmm_n_1, 0b10001000);    // {n0,n0,n1,n1} = shuf {n0,_,n0,_} {n1,_,n1,_}
+        uni_vshufps(vmm_c_0, vmm_c_0, vmm_c_1, 0b10001000);    // {c0,c0,c1,c1} = shuf {c0,_,c0,_} {c1,_,c1,_}
+        uni_vshufps(ymm_dst_1, vmm_n_0, vmm_c_0, 0b10001000);  // {n0,n1,c0,c1} = shuf {n0,n0,n1,n1} {c0,c0,c1,c1}
+        uni_vshufps(vmm_c_0, vmm_n_0, vmm_c_0, 0b11011101);    // {n0,n1,c0,c1} = shuf {n0,n0,n1,n1} {c0,c0,c1,c1}
         vperm2f128(ymm_dst_0, ymm_dst_1, ymm_c_0, 0b00100000);
         vperm2f128(ymm_dst_1, ymm_dst_1, ymm_c_0, 0b00110001);
     } else {
@@ -369,8 +399,8 @@ void RandomUniform<isa>::runPhilox(const std::vector<Vmm>& vmm_dst, const Vmm& v
 
 template <x64::cpu_isa_t isa>
 void RandomUniform<isa>::raiseKey(const Vmm& vmm_k_0, const Vmm& vmm_k_1) {
-    uni_vpaddd(vmm_k_0, vmm_k_0, v_add_low_k); // {k0,_,k0,_} + {l0,_,l0,_}
-    uni_vpaddd(vmm_k_1, vmm_k_1, v_add_up_k);  // {k1,_,k1,_} + {u0,_,u0,_}
+    uni_vpaddd(vmm_k_0, vmm_k_0, v_add_low_k);  // {k0,_,k0,_} + {l0,_,l0,_}
+    uni_vpaddd(vmm_k_1, vmm_k_1, v_add_up_k);   // {k1,_,k1,_} + {u0,_,u0,_}
 }
 
 template <>
@@ -410,7 +440,10 @@ void RandomUniform<x64::avx512_core>::convert(const std::vector<Vmm>& v_dst, con
 
                 uni_vpaddd(vmm_dst, vmm_dst, v_min);
             } else {
-                OPENVINO_THROW("RandomUniform kernel does not support precision ", m_jcp.out_data_type, " for ", x64::get_isa_info());
+                OPENVINO_THROW("RandomUniform kernel does not support precision ",
+                               m_jcp.out_data_type,
+                               " for ",
+                               x64::get_isa_info());
             }
         }
     } else if (m_jcp.out_data_type.size() == 2) {
@@ -440,19 +473,28 @@ void RandomUniform<x64::avx512_core>::convert(const std::vector<Vmm>& v_dst, con
 
             vcvtne2ps2bf16(v_dst[0], v_dst[1], v_dst[0]);
         } else {
-            OPENVINO_THROW("RandomUniform kernel does not support precision ", m_jcp.out_data_type, " for ", x64::get_isa_info());
+            OPENVINO_THROW("RandomUniform kernel does not support precision ",
+                           m_jcp.out_data_type,
+                           " for ",
+                           x64::get_isa_info());
         }
     } else if (m_jcp.out_data_type.size() == 8) {
         if (m_jcp.out_data_type == element::i64) {
             // TODO: in scope of i64 enabling.
         }
-        OPENVINO_THROW("RandomUniform kernel does not support precision ", m_jcp.out_data_type, " for ", x64::get_isa_info());
+        OPENVINO_THROW("RandomUniform kernel does not support precision ",
+                       m_jcp.out_data_type,
+                       " for ",
+                       x64::get_isa_info());
     } else {
-        OPENVINO_THROW("RandomUniform kernel does not support precision ", m_jcp.out_data_type, " for ", x64::get_isa_info());
+        OPENVINO_THROW("RandomUniform kernel does not support precision ",
+                       m_jcp.out_data_type,
+                       " for ",
+                       x64::get_isa_info());
     }
 }
 
-template <x64::cpu_isa_t isa> // Works for AVX2, SSE41
+template <x64::cpu_isa_t isa>  // Works for AVX2, SSE41
 void RandomUniform<isa>::convert(const std::vector<Vmm>& v_dst, const std::vector<Vmm>& v_src) {
     if (m_jcp.out_data_type.size() == 4) {
         for (size_t i = 0lu; i < v_src.size(); i++) {
@@ -522,16 +564,25 @@ void RandomUniform<isa>::convert(const std::vector<Vmm>& v_dst, const std::vecto
 
                 uni_vpaddd(vmm_dst, vmm_dst, ptr[r64_min]);
             } else {
-                OPENVINO_THROW("RandomUniform kernel does not support precision ", m_jcp.out_data_type, " for ", x64::get_isa_info());
+                OPENVINO_THROW("RandomUniform kernel does not support precision ",
+                               m_jcp.out_data_type,
+                               " for ",
+                               x64::get_isa_info());
             }
         }
     } else if (m_jcp.out_data_type.size() == 8) {
         if (m_jcp.out_data_type == element::i64) {
             // TODO: in scope of i64 enabling.
         }
-        OPENVINO_THROW("RandomUniform kernel does not support precision ", m_jcp.out_data_type, " for ", x64::get_isa_info());
+        OPENVINO_THROW("RandomUniform kernel does not support precision ",
+                       m_jcp.out_data_type,
+                       " for ",
+                       x64::get_isa_info());
     } else {
-        OPENVINO_THROW("RandomUniform kernel does not support precision ", m_jcp.out_data_type, " for ", x64::get_isa_info());
+        OPENVINO_THROW("RandomUniform kernel does not support precision ",
+                       m_jcp.out_data_type,
+                       " for ",
+                       x64::get_isa_info());
     }
 }
 
@@ -595,7 +646,7 @@ void RandomUniform<x64::avx2>::tail(const std::vector<Vmm>& vmm_dst) {
 
     L(l_0);
     fillRestWorkMask(v_rest_mask, r64_work_amount, m_jcp.out_data_type.size());
-    vmaskmovps(ptr[r64_dst],  v_rest_mask, vmm_dst[0]);
+    vmaskmovps(ptr[r64_dst], v_rest_mask, vmm_dst[0]);
 
     L(l_end);
 }
@@ -630,6 +681,6 @@ template class RandomUniform<x64::avx512_core>;
 template class RandomUniform<x64::avx2>;
 template class RandomUniform<x64::sse41>;
 
-}   // namespace kernel
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace kernel
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/random_uniform.hpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/random_uniform.hpp
index b25747730e33fb..4b447ef7b459ea 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/random_uniform.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/random_uniform.hpp
@@ -36,12 +36,16 @@ class RandomUniform : public JitKernel<RandomUniformCompileParams, RandomUniform
     void generate() override;
 
 private:
-    using Vmm   = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::avx512_core, Xbyak::Zmm,
-                                                           isa == dnnl::impl::cpu::x64::sse41,       Xbyak::Xmm,
-                                                                                                     Xbyak::Ymm>::type;
-    using Vmask = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::avx512_core, Xbyak::Opmask,
-                                                           isa == dnnl::impl::cpu::x64::sse41,       Xbyak::Xmm,
-                                                                                                     Xbyak::Ymm>::type;
+    using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::avx512_core,
+                                                         Xbyak::Zmm,
+                                                         isa == dnnl::impl::cpu::x64::sse41,
+                                                         Xbyak::Xmm,
+                                                         Xbyak::Ymm>::type;
+    using Vmask = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::avx512_core,
+                                                           Xbyak::Opmask,
+                                                           isa == dnnl::impl::cpu::x64::sse41,
+                                                           Xbyak::Xmm,
+                                                           Xbyak::Ymm>::type;
 
     RegistersPool::Reg<Xbyak::Reg64> r64_dst;
     RegistersPool::Reg<Xbyak::Reg64> r64_work_amount;
@@ -76,8 +80,14 @@ class RandomUniform : public JitKernel<RandomUniformCompileParams, RandomUniform
 
     void runPhilox(const std::vector<Vmm>& vmm_res, const Vmm& vmm_key, const Vmm& vmm_counter, const Vmm& vmm_n);
 
-    void calculateRound(const Vmm& vmm_k_0, const Vmm& vmm_k_1, const Vmm& vmm_c_0, const Vmm& vmm_c_1,
-                        const Vmm& vmm_n_0, const Vmm& vmm_n_1, const Vmm& vmm_aux_0, const Vmm& vmm_aux_1);
+    void calculateRound(const Vmm& vmm_k_0,
+                        const Vmm& vmm_k_1,
+                        const Vmm& vmm_c_0,
+                        const Vmm& vmm_c_1,
+                        const Vmm& vmm_n_0,
+                        const Vmm& vmm_n_1,
+                        const Vmm& vmm_aux_0,
+                        const Vmm& vmm_aux_1);
 
     void raiseKey(const Vmm& vmm_k_0, const Vmm& vmm_k_1);
 
@@ -92,8 +102,8 @@ class RandomUniform : public JitKernel<RandomUniformCompileParams, RandomUniform
     static constexpr uint64_t STATISTIC_MAXIMIZING_MULTIPLIER_COUNTER = 0xCD9E8D57;
 };
 
-}   // namespace kernel
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace kernel
+}  // namespace intel_cpu
+}  // namespace ov
 
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/rdft_kernel.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/rdft_kernel.cpp
index acf9d7bc9e6c7c..b3df542c7a62d1 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/rdft_kernel.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/rdft_kernel.cpp
@@ -11,7 +11,7 @@ namespace ov {
 namespace intel_cpu {
 
 #ifndef OPENVINO_ARCH_ARM64
-#define GET_OFF(field) offsetof(jit_dft_args, field)
+#    define GET_OFF(field) offsetof(jit_dft_args, field)
 
 template <cpu_isa_t isa>
 void jit_dft_kernel_f32<isa>::generate() {
@@ -119,7 +119,7 @@ void jit_dft_kernel_f32<isa>::generate() {
             uni_vpxor(output, output, output);
         }
 
-        auto c2r_kernel = [&] (bool backwards) {
+        auto c2r_kernel = [&](bool backwards) {
             // if backwards == false:
             //     output_real += input_real * cos(..) - input_imag * sin(..)
             // else:
@@ -137,7 +137,7 @@ void jit_dft_kernel_f32<isa>::generate() {
             add(twiddles_ptr, 2 * vlen);
         };
 
-        auto c2c_kernel = [&] (bool backwards) {
+        auto c2c_kernel = [&](bool backwards) {
             // if backwards == false:
             //     output_real += input_real * cos(..) - input_imag * sin(..)
             //     output_imag += input_imag * cos(..) + input_real * sin(..)
@@ -233,7 +233,7 @@ void jit_dft_kernel_f32<isa>::generate() {
     auto nonsimd_loop = [&] {
         uni_vxorps(xmm_output, xmm_output, xmm_output);
 
-        auto c2r_kernel = [&] (bool backwards) {
+        auto c2r_kernel = [&](bool backwards) {
             // if backwards == false:
             //     output_real += input_real * cos(..) - input_imag * sin(..)
             // else:
@@ -249,7 +249,7 @@ void jit_dft_kernel_f32<isa>::generate() {
             uni_vaddss(xmm_output, xmm_output, xmm_input);
         };
 
-        auto c2c_kernel = [&] (bool backwards) {
+        auto c2c_kernel = [&](bool backwards) {
             // if backwards == false:
             //     output_real += input_real * cos(..) - input_imag * sin(..)
             //     output_imag += input_imag * cos(..) + input_real * sin(..)
@@ -377,7 +377,10 @@ void jit_dft_kernel_f32<isa>::generate() {
 // imag = [11, 12, 13, 14, 15, 16, 17, 18]
 // interleaved = [1, 11, 2, 12, 3, 13, 4, 14, 5, 15, 6, 16, 7, 17, 8, 18]
 template <>
-void jit_dft_kernel_f32<avx512_core>::interleave_and_store(const Vmm& real, const Vmm& imag, const Xbyak::RegExp& reg_exp, const Vmm& tmp) {
+void jit_dft_kernel_f32<avx512_core>::interleave_and_store(const Vmm& real,
+                                                           const Vmm& imag,
+                                                           const Xbyak::RegExp& reg_exp,
+                                                           const Vmm& tmp) {
     const Vmm& low = tmp;
     const Vmm& high = real;
     uni_vmovups(low, real);
@@ -388,7 +391,10 @@ void jit_dft_kernel_f32<avx512_core>::interleave_and_store(const Vmm& real, cons
 }
 
 template <>
-void jit_dft_kernel_f32<avx2>::interleave_and_store(const Vmm& real, const Vmm& imag, const Xbyak::RegExp& reg_exp, const Vmm& tmp) {
+void jit_dft_kernel_f32<avx2>::interleave_and_store(const Vmm& real,
+                                                    const Vmm& imag,
+                                                    const Xbyak::RegExp& reg_exp,
+                                                    const Vmm& tmp) {
     const Vmm& low = real;
     const Vmm& high = imag;
     vunpcklps(tmp, real, imag);
@@ -400,7 +406,10 @@ void jit_dft_kernel_f32<avx2>::interleave_and_store(const Vmm& real, const Vmm&
 }
 
 template <>
-void jit_dft_kernel_f32<sse41>::interleave_and_store(const Vmm& real, const Vmm& imag, const Xbyak::RegExp& reg_exp, const Vmm& tmp) {
+void jit_dft_kernel_f32<sse41>::interleave_and_store(const Vmm& real,
+                                                     const Vmm& imag,
+                                                     const Xbyak::RegExp& reg_exp,
+                                                     const Vmm& tmp) {
     const Vmm& low = tmp;
     const Vmm& high = real;
     uni_vmovups(low, real);
@@ -415,5 +424,5 @@ template struct jit_dft_kernel_f32<cpu::x64::avx2>;
 template struct jit_dft_kernel_f32<cpu::x64::avx512_core>;
 
 #endif
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/rdft_kernel.hpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/rdft_kernel.hpp
index 0ded311c0a7dd5..c5df00739275d9 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/rdft_kernel.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/rdft_kernel.hpp
@@ -5,8 +5,8 @@
 #pragma once
 
 #ifndef OPENVINO_ARCH_ARM64
-#include "cpu/x64/jit_generator.hpp"
-#include "dnnl_types.h"
+#    include "cpu/x64/jit_generator.hpp"
+#    include "dnnl_types.h"
 #endif
 
 namespace ov {
@@ -55,53 +55,58 @@ struct jit_dft_kernel {
 
 template <dnnl::impl::cpu::x64::cpu_isa_t isa>
 struct jit_dft_kernel_f32 : public jit_dft_kernel, public dnnl::impl::cpu::x64::jit_generator {
-    public:
-        DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_dft_kernel_f32)
-
-        jit_dft_kernel_f32(bool is_inverse, enum dft_type type) : jit_dft_kernel(is_inverse, type), jit_generator(jit_name()) {
-            constexpr int simd_size = vlen / type_size;
-            perm_low_values.reserve(simd_size);
-            perm_high_values.reserve(simd_size);
-            for (int i = 0; i < simd_size / 2; i++) {
-                perm_low_values.push_back(i);
-                perm_low_values.push_back(i + simd_size);
-                perm_high_values.push_back(i + simd_size / 2);
-                perm_high_values.push_back(i + simd_size / 2 + simd_size);
-            }
+public:
+    DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_dft_kernel_f32)
+
+    jit_dft_kernel_f32(bool is_inverse, enum dft_type type)
+        : jit_dft_kernel(is_inverse, type),
+          jit_generator(jit_name()) {
+        constexpr int simd_size = vlen / type_size;
+        perm_low_values.reserve(simd_size);
+        perm_high_values.reserve(simd_size);
+        for (int i = 0; i < simd_size / 2; i++) {
+            perm_low_values.push_back(i);
+            perm_low_values.push_back(i + simd_size);
+            perm_high_values.push_back(i + simd_size / 2);
+            perm_high_values.push_back(i + simd_size / 2 + simd_size);
         }
+    }
 
-        void create_ker() override {
-            jit_generator::create_kernel();
-            ker_ = (decltype(ker_))jit_ker();
-        }
+    void create_ker() override {
+        jit_generator::create_kernel();
+        ker_ = (decltype(ker_))jit_ker();
+    }
 
-        void generate() override;
+    void generate() override;
 
-    private:
-        using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41, Xbyak::Xmm,
-                                          isa == dnnl::impl::cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
+private:
+    using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,
+                                                         Xbyak::Xmm,
+                                                         isa == dnnl::impl::cpu::x64::avx2,
+                                                         Xbyak::Ymm,
+                                                         Xbyak::Zmm>::type;
 
-        void interleave_and_store(const Vmm& real, const Vmm& imag, const Xbyak::RegExp& reg_exp, const Vmm& tmp);
+    void interleave_and_store(const Vmm& real, const Vmm& imag, const Xbyak::RegExp& reg_exp, const Vmm& tmp);
 
-        static constexpr int type_size = sizeof(float);
-        static constexpr int vlen = dnnl::impl::cpu::x64::cpu_isa_traits<isa>::vlen;
+    static constexpr int type_size = sizeof(float);
+    static constexpr int vlen = dnnl::impl::cpu::x64::cpu_isa_traits<isa>::vlen;
 
-        Xbyak::Reg8 is_signal_size_even = al;
-        Xbyak::Reg64 input_ptr = rbx;
-        Xbyak::Reg64 input_size = r8;
-        Xbyak::Reg64 output_ptr = r9;
-        Xbyak::Reg64 twiddles_ptr = r10;
-        Xbyak::Reg64 signal_size = r11;
-        Xbyak::Reg64 output_start = r12;
-        Xbyak::Reg64 output_end = r13;
+    Xbyak::Reg8 is_signal_size_even = al;
+    Xbyak::Reg64 input_ptr = rbx;
+    Xbyak::Reg64 input_size = r8;
+    Xbyak::Reg64 output_ptr = r9;
+    Xbyak::Reg64 twiddles_ptr = r10;
+    Xbyak::Reg64 signal_size = r11;
+    Xbyak::Reg64 output_start = r12;
+    Xbyak::Reg64 output_end = r13;
 
-        std::vector<int> perm_low_values;
-        std::vector<int> perm_high_values;
+    std::vector<int> perm_low_values;
+    std::vector<int> perm_high_values;
 
-        Vmm perm_low;
-        Vmm perm_high;
+    Vmm perm_low;
+    Vmm perm_high;
 };
 
 #endif
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/registers_pool.hpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/registers_pool.hpp
index 59a318dfc4d7aa..ab194a43684663 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/registers_pool.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/registers_pool.hpp
@@ -4,10 +4,11 @@
 
 #pragma once
 
+#include <utility>
+
 #include "cpu/x64/jit_generator.hpp"
-#include "utils/cpu_utils.hpp"
 #include "dnnl_types.h"
-#include <utility>
+#include "utils/cpu_utils.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -39,25 +40,44 @@ class RegistersPool {
      *      reg.release();
      * @tparam TReg Xbyak register class
      */
-    template<typename TReg>
+    template <typename TReg>
     class Reg {
         friend class RegistersPool;
+
     public:
         Reg() {}
-        Reg(const RegistersPool::Ptr& regPool) { initialize(regPool); }
-        Reg(const RegistersPool::Ptr& regPool, int requestedIdx) { initialize(regPool, requestedIdx); }
-        ~Reg() { release(); }
-        Reg& operator=(Reg&& other)  noexcept {
+        Reg(const RegistersPool::Ptr& regPool) {
+            initialize(regPool);
+        }
+        Reg(const RegistersPool::Ptr& regPool, int requestedIdx) {
+            initialize(regPool, requestedIdx);
+        }
+        ~Reg() {
+            release();
+        }
+        Reg& operator=(Reg&& other) noexcept {
             release();
             reg = other.reg;
             regPool = std::move(other.regPool);
             return *this;
         }
-        Reg(Reg&& other)  noexcept : reg(other.reg), regPool(std::move(other.regPool)) {}
-        operator TReg&() { ensureValid(); return reg; }
-        operator const TReg&() const { ensureValid(); return reg; }
-        operator Xbyak::RegExp() const { ensureValid(); return reg; }
-        int getIdx() const { ensureValid(); return reg.getIdx(); }
+        Reg(Reg&& other) noexcept : reg(other.reg), regPool(std::move(other.regPool)) {}
+        operator TReg&() {
+            ensureValid();
+            return reg;
+        }
+        operator const TReg&() const {
+            ensureValid();
+            return reg;
+        }
+        operator Xbyak::RegExp() const {
+            ensureValid();
+            return reg;
+        }
+        int getIdx() const {
+            ensureValid();
+            return reg.getIdx();
+        }
         friend Xbyak::RegExp operator+(const Reg& lhs, const Xbyak::RegExp& rhs) {
             lhs.ensureValid();
             return lhs.operator Xbyak::RegExp() + rhs;
@@ -68,7 +88,9 @@ class RegistersPool {
                 regPool.reset();
             }
         }
-        bool isInitialized() const { return !regPool.expired(); }
+        bool isInitialized() const {
+            return !regPool.expired();
+        }
 
     private:
         void ensureValid() const {
@@ -78,8 +100,15 @@ class RegistersPool {
         }
 
         void initialize(const RegistersPool::Ptr& pool, int requestedIdx = anyIdx) {
-            static_assert(is_any_of<TReg, Xbyak::Xmm, Xbyak::Ymm, Xbyak::Zmm,
-                                  Xbyak::Reg8, Xbyak::Reg16, Xbyak::Reg32, Xbyak::Reg64, Xbyak::Opmask>::value,
+            static_assert(is_any_of<TReg,
+                                    Xbyak::Xmm,
+                                    Xbyak::Ymm,
+                                    Xbyak::Zmm,
+                                    Xbyak::Reg8,
+                                    Xbyak::Reg16,
+                                    Xbyak::Reg32,
+                                    Xbyak::Reg64,
+                                    Xbyak::Opmask>::value,
                           "Unsupported TReg by RegistersPool::Reg. Please, use the following Xbyak registers either "
                           "Reg8, Reg16, Reg32, Reg64, Xmm, Ymm, Zmm or Opmask");
             release();
@@ -101,10 +130,17 @@ class RegistersPool {
 
     static Ptr create(dnnl::impl::cpu::x64::cpu_isa_t isa, std::initializer_list<Xbyak::Reg> regsToExclude);
 
-    template<typename TReg>
+    template <typename TReg>
     size_t countFree() const {
-        static_assert(is_any_of<TReg, Xbyak::Xmm, Xbyak::Ymm, Xbyak::Zmm,
-                              Xbyak::Reg8, Xbyak::Reg16, Xbyak::Reg32, Xbyak::Reg64, Xbyak::Opmask>::value,
+        static_assert(is_any_of<TReg,
+                                Xbyak::Xmm,
+                                Xbyak::Ymm,
+                                Xbyak::Zmm,
+                                Xbyak::Reg8,
+                                Xbyak::Reg16,
+                                Xbyak::Reg32,
+                                Xbyak::Reg64,
+                                Xbyak::Opmask>::value,
                       "Unsupported TReg by RegistersPool::Reg. Please, use the following Xbyak registers either "
                       "Reg8, Reg16, Reg32, Reg64, Xmm, Ymm, Zmm or Opmask");
         if (std::is_base_of<Xbyak::Mmx, TReg>::value) {
@@ -184,12 +220,17 @@ class RegistersPool {
         std::vector<bool> isFreeIndexVector;
     };
 
-    virtual int getFreeOpmask(int requestedIdx) { OPENVINO_THROW("getFreeOpmask: The Opmask is not supported in current instruction set"); }
-    virtual void returnOpmaskToPool(int idx) { OPENVINO_THROW("returnOpmaskToPool: The Opmask is not supported in current instruction set"); }
-    virtual size_t countUnusedOpmask() const { OPENVINO_THROW("countUnusedOpmask: The Opmask is not supported in current instruction set"); }
+    virtual int getFreeOpmask(int requestedIdx) {
+        OPENVINO_THROW("getFreeOpmask: The Opmask is not supported in current instruction set");
+    }
+    virtual void returnOpmaskToPool(int idx) {
+        OPENVINO_THROW("returnOpmaskToPool: The Opmask is not supported in current instruction set");
+    }
+    virtual size_t countUnusedOpmask() const {
+        OPENVINO_THROW("countUnusedOpmask: The Opmask is not supported in current instruction set");
+    }
 
-    RegistersPool(int simdRegistersNumber)
-            : simdSet(simdRegistersNumber) {
+    RegistersPool(int simdRegistersNumber) : simdSet(simdRegistersNumber) {
         checkUniqueAndUpdate();
         generalSet.exclude(Xbyak::Reg64(Xbyak::Operand::RSP));
         generalSet.exclude(Xbyak::Reg64(Xbyak::Operand::RAX));
@@ -199,7 +240,7 @@ class RegistersPool {
     }
 
     RegistersPool(std::initializer_list<Xbyak::Reg> regsToExclude, int simdRegistersNumber)
-            : simdSet(simdRegistersNumber) {
+        : simdSet(simdRegistersNumber) {
         checkUniqueAndUpdate();
         for (auto& reg : regsToExclude) {
             if (reg.isXMM() || reg.isYMM() || reg.isZMM()) {
@@ -212,7 +253,7 @@ class RegistersPool {
     }
 
 private:
-    template<typename TReg>
+    template <typename TReg>
     int getFree(int requestedIdx) {
         if (std::is_base_of<Xbyak::Mmx, TReg>::value) {
             auto idx = simdSet.getUnused(requestedIdx);
@@ -228,7 +269,7 @@ class RegistersPool {
         }
     }
 
-    template<typename TReg>
+    template <typename TReg>
     void returnToPool(const TReg& reg) {
         if (std::is_base_of<Xbyak::Mmx, TReg>::value) {
             simdSet.setAsUnused(reg.getIdx());
@@ -252,25 +293,29 @@ class RegistersPool {
         }
     }
 
-    PhysicalSet generalSet {16};
+    PhysicalSet generalSet{16};
     PhysicalSet simdSet;
 };
 
 template <dnnl::impl::cpu::x64::cpu_isa_t isa>
 class IsaRegistersPool : public RegistersPool {
 public:
-    IsaRegistersPool(std::initializer_list<Xbyak::Reg> regsToExclude) : RegistersPool(regsToExclude, dnnl::impl::cpu::x64::cpu_isa_traits<isa>::n_vregs) {}
+    IsaRegistersPool(std::initializer_list<Xbyak::Reg> regsToExclude)
+        : RegistersPool(regsToExclude, dnnl::impl::cpu::x64::cpu_isa_traits<isa>::n_vregs) {}
 };
 
 template <>
 class IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core> : public RegistersPool {
 public:
-    IsaRegistersPool() : RegistersPool(dnnl::impl::cpu::x64::cpu_isa_traits<dnnl::impl::cpu::x64::avx512_core>::n_vregs) {
-        opmaskSet.exclude(Xbyak::Opmask(0)); // the Opmask(0) has special meaning for some instructions, like gather instruction
+    IsaRegistersPool()
+        : RegistersPool(dnnl::impl::cpu::x64::cpu_isa_traits<dnnl::impl::cpu::x64::avx512_core>::n_vregs) {
+        opmaskSet.exclude(
+            Xbyak::Opmask(0));  // the Opmask(0) has special meaning for some instructions, like gather instruction
     }
 
     IsaRegistersPool(std::initializer_list<Xbyak::Reg> regsToExclude)
-        : RegistersPool(regsToExclude, dnnl::impl::cpu::x64::cpu_isa_traits<dnnl::impl::cpu::x64::avx512_core>::n_vregs) {
+        : RegistersPool(regsToExclude,
+                        dnnl::impl::cpu::x64::cpu_isa_traits<dnnl::impl::cpu::x64::avx512_core>::n_vregs) {
         for (auto& reg : regsToExclude) {
             if (reg.isOPMASK()) {
                 opmaskSet.exclude(reg);
@@ -293,20 +338,24 @@ class IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core> : public RegistersPool
     }
 
 protected:
-    PhysicalSet opmaskSet {8};
+    PhysicalSet opmaskSet{8};
 };
 
 template <>
-class IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core_vnni> : public IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core> {
+class IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core_vnni>
+    : public IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core> {
 public:
-    IsaRegistersPool(std::initializer_list<Xbyak::Reg> regsToExclude) : IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core>(regsToExclude) {}
+    IsaRegistersPool(std::initializer_list<Xbyak::Reg> regsToExclude)
+        : IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core>(regsToExclude) {}
     IsaRegistersPool() : IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core>() {}
 };
 
 template <>
-class IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core_bf16> : public IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core> {
+class IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core_bf16>
+    : public IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core> {
 public:
-    IsaRegistersPool(std::initializer_list<Xbyak::Reg> regsToExclude) : IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core>(regsToExclude) {}
+    IsaRegistersPool(std::initializer_list<Xbyak::Reg> regsToExclude)
+        : IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core>(regsToExclude) {}
     IsaRegistersPool() : IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core>() {}
 };
 
@@ -315,9 +364,11 @@ RegistersPool::Ptr RegistersPool::create(std::initializer_list<Xbyak::Reg> regsT
     return std::make_shared<IsaRegistersPool<isa>>(regsToExclude);
 }
 
-inline
-RegistersPool::Ptr RegistersPool::create(dnnl::impl::cpu::x64::cpu_isa_t isa, std::initializer_list<Xbyak::Reg> regsToExclude) {
-#define ISA_SWITCH_CASE(isa) case isa: return std::make_shared<IsaRegistersPool<isa>>(regsToExclude);
+inline RegistersPool::Ptr RegistersPool::create(dnnl::impl::cpu::x64::cpu_isa_t isa,
+                                                std::initializer_list<Xbyak::Reg> regsToExclude) {
+#define ISA_SWITCH_CASE(isa) \
+    case isa:                \
+        return std::make_shared<IsaRegistersPool<isa>>(regsToExclude);
     switch (isa) {
         ISA_SWITCH_CASE(dnnl::impl::cpu::x64::sse41)
         ISA_SWITCH_CASE(dnnl::impl::cpu::x64::avx)
@@ -327,23 +378,25 @@ RegistersPool::Ptr RegistersPool::create(dnnl::impl::cpu::x64::cpu_isa_t isa, st
         ISA_SWITCH_CASE(dnnl::impl::cpu::x64::avx512_core_vnni)
         ISA_SWITCH_CASE(dnnl::impl::cpu::x64::avx512_core_bf16)
         ISA_SWITCH_CASE(dnnl::impl::cpu::x64::avx512_core_fp16)
-        case dnnl::impl::cpu::x64::avx512_core_bf16_ymm:
-            return std::make_shared<IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core>>(regsToExclude);
-        case dnnl::impl::cpu::x64::avx512_core_amx: return std::make_shared<IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core>>(regsToExclude);
-        case dnnl::impl::cpu::x64::avx512_vpopcnt: return std::make_shared<IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core>>(regsToExclude);
-        case dnnl::impl::cpu::x64::isa_undef:
-        case dnnl::impl::cpu::x64::amx_tile:
-        case dnnl::impl::cpu::x64::amx_int8:
-        case dnnl::impl::cpu::x64::amx_bf16:
-        case dnnl::impl::cpu::x64::avx2_vnni_2:
-        case dnnl::impl::cpu::x64::amx_fp16:
-        case dnnl::impl::cpu::x64::avx512_core_amx_fp16:
-        case dnnl::impl::cpu::x64::isa_all:
-            OPENVINO_THROW("Invalid isa argument in RegistersPool::create()");
-        }
+    case dnnl::impl::cpu::x64::avx512_core_bf16_ymm:
+        return std::make_shared<IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core>>(regsToExclude);
+    case dnnl::impl::cpu::x64::avx512_core_amx:
+        return std::make_shared<IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core>>(regsToExclude);
+    case dnnl::impl::cpu::x64::avx512_vpopcnt:
+        return std::make_shared<IsaRegistersPool<dnnl::impl::cpu::x64::avx512_core>>(regsToExclude);
+    case dnnl::impl::cpu::x64::isa_undef:
+    case dnnl::impl::cpu::x64::amx_tile:
+    case dnnl::impl::cpu::x64::amx_int8:
+    case dnnl::impl::cpu::x64::amx_bf16:
+    case dnnl::impl::cpu::x64::avx2_vnni_2:
+    case dnnl::impl::cpu::x64::amx_fp16:
+    case dnnl::impl::cpu::x64::avx512_core_amx_fp16:
+    case dnnl::impl::cpu::x64::isa_all:
+        OPENVINO_THROW("Invalid isa argument in RegistersPool::create()");
+    }
     OPENVINO_THROW("Invalid isa argument in RegistersPool::create()");
 #undef ISA_SWITCH_CASE
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/rms_kernel.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/rms_kernel.cpp
index 30a7870a1a4b54..7778ebb12450f0 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/rms_kernel.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/rms_kernel.cpp
@@ -14,8 +14,7 @@ namespace kernel {
 #define GET_OFF(field) offsetof(jit_rms_call_args, field)
 
 template <cpu_isa_t isa>
-void jit_rms_kernel<isa>::reduce_zmm_to_ymm(
-        const Xmm &acc, const Xmm &tmp) {
+void jit_rms_kernel<isa>::reduce_zmm_to_ymm(const Xmm& acc, const Xmm& tmp) {
     const Zmm zmm_acc(acc.getIdx());
     const Ymm ymm_acc(acc.getIdx());
     const Ymm ymm_to_acc(tmp.getIdx());
@@ -24,8 +23,7 @@ void jit_rms_kernel<isa>::reduce_zmm_to_ymm(
 }
 
 template <cpu_isa_t isa>
-void jit_rms_kernel<isa>::reduce_ymm_to_xmm(
-        const Xmm &acc, const Xmm &tmp) {
+void jit_rms_kernel<isa>::reduce_ymm_to_xmm(const Xmm& acc, const Xmm& tmp) {
     const Ymm ymm_acc(acc.getIdx());
     const Xmm xmm_acc(acc.getIdx());
     const Xmm xmm_to_acc(tmp.getIdx());
@@ -34,16 +32,16 @@ void jit_rms_kernel<isa>::reduce_ymm_to_xmm(
 }
 
 template <cpu_isa_t isa>
-void jit_rms_kernel<isa>::reduce_xmm_to_scalar(const Xmm &acc,
-        const Xmm &tmp, const std::size_t number_of_values_to_reduce) {
+void jit_rms_kernel<isa>::reduce_xmm_to_scalar(const Xmm& acc,
+                                               const Xmm& tmp,
+                                               const std::size_t number_of_values_to_reduce) {
     assert(number_of_values_to_reduce <= number_of_f32_in_xmm_);
 
     const Xmm xmm_acc(acc.getIdx());
     const Xmm ymm_to_acc(tmp.getIdx());
 
     static constexpr int number_of_f32_to_move = number_of_f32_in_xmm_ - 1;
-    static constexpr uint8_t insertps_configuration[number_of_f32_to_move]
-            = {0b01001110, 0b10001110, 0b11001110};
+    static constexpr uint8_t insertps_configuration[number_of_f32_to_move] = {0b01001110, 0b10001110, 0b11001110};
 
     for (std::size_t i = 0; i < number_of_values_to_reduce - 1; i++) {
         vinsertps(ymm_to_acc, ymm_to_acc, xmm_acc, insertps_configuration[i]);
@@ -52,9 +50,10 @@ void jit_rms_kernel<isa>::reduce_xmm_to_scalar(const Xmm &acc,
 }
 
 template <cpu_isa_t isa>
-void jit_rms_kernel<isa>::reduce_ymm_to_scalar(
-        const Xbyak::Xmm &acc, const Xbyak::Xmm &tmp1, const Xbyak::Xmm &tmp2,
-        const std::size_t number_of_values_to_reduce) {
+void jit_rms_kernel<isa>::reduce_ymm_to_scalar(const Xbyak::Xmm& acc,
+                                               const Xbyak::Xmm& tmp1,
+                                               const Xbyak::Xmm& tmp2,
+                                               const std::size_t number_of_values_to_reduce) {
     assert(number_of_values_to_reduce <= number_of_f32_in_ymm_);
 
     const Ymm ymm_acc(acc.getIdx());
@@ -68,8 +67,7 @@ void jit_rms_kernel<isa>::reduce_ymm_to_scalar(
     } else if (number_of_values_to_reduce > number_of_f32_in_xmm_) {
         vextractf128(xmm_acc_upper_half, ymm_acc, 1);
         reduce_xmm_to_scalar(xmm_acc, xmm_tmp);
-        reduce_xmm_to_scalar(xmm_acc_upper_half, xmm_tmp,
-                number_of_values_to_reduce - number_of_f32_in_xmm_);
+        reduce_xmm_to_scalar(xmm_acc_upper_half, xmm_tmp, number_of_values_to_reduce - number_of_f32_in_xmm_);
         vaddss(xmm_acc, xmm_acc, xmm_acc_upper_half);
     } else if (number_of_values_to_reduce <= number_of_f32_in_xmm_) {
         reduce_xmm_to_scalar(xmm_acc, xmm_tmp, number_of_values_to_reduce);
@@ -77,9 +75,11 @@ void jit_rms_kernel<isa>::reduce_ymm_to_scalar(
 }
 
 template <cpu_isa_t isa>
-void jit_rms_kernel<isa>::reduce_vmm_to_scalar(
-        const Xbyak::Xmm &acc, const Xbyak::Xmm &tmp1, const Xbyak::Xmm &tmp2,
-        const Xbyak::Xmm &tmp3, const std::size_t number_of_values_to_reduce) {
+void jit_rms_kernel<isa>::reduce_vmm_to_scalar(const Xbyak::Xmm& acc,
+                                               const Xbyak::Xmm& tmp1,
+                                               const Xbyak::Xmm& tmp2,
+                                               const Xbyak::Xmm& tmp3,
+                                               const std::size_t number_of_values_to_reduce) {
     assert(number_of_values_to_reduce <= number_of_f32_in_zmm_);
 
     const Zmm zmm_acc(acc.getIdx());
@@ -98,12 +98,13 @@ void jit_rms_kernel<isa>::reduce_vmm_to_scalar(
     } else if (number_of_values_to_reduce > number_of_f32_in_ymm_) {
         vextractf64x4(ymm_acc_upper_half, zmm_acc, 1);
         reduce_ymm_to_scalar(ymm_acc, xmm_tmp1, xmm_tmp2);
-        reduce_ymm_to_scalar(ymm_acc_upper_half, xmm_tmp1, xmm_tmp2,
-                number_of_values_to_reduce - number_of_f32_in_ymm_);
+        reduce_ymm_to_scalar(ymm_acc_upper_half,
+                             xmm_tmp1,
+                             xmm_tmp2,
+                             number_of_values_to_reduce - number_of_f32_in_ymm_);
         vaddps(xmm_acc, xmm_acc, xmm_acc_upper_half);
     } else if (number_of_values_to_reduce <= number_of_f32_in_ymm_) {
-        reduce_ymm_to_scalar(
-                ymm_acc, xmm_tmp1, xmm_tmp2, number_of_values_to_reduce);
+        reduce_ymm_to_scalar(ymm_acc, xmm_tmp1, xmm_tmp2, number_of_values_to_reduce);
     }
 }
 
@@ -221,28 +222,42 @@ void jit_rms_kernel<isa>::generate() {
 }
 
 template <cpu_isa_t isa>
-void jit_rms_kernel<isa>::load(const Vmm& vmm_dst, const Xbyak::Reg64& reg_src, ov::element::Type src_prc, const int& elt_num, bool fill, size_t offset) {
+void jit_rms_kernel<isa>::load(const Vmm& vmm_dst,
+                               const Xbyak::Reg64& reg_src,
+                               ov::element::Type src_prc,
+                               const int& elt_num,
+                               bool fill,
+                               size_t offset) {
     const auto seed = load_emitter_params(src_prc, ov::element::f32, elt_num, fill, "float_min").hash();
     if (!emitters[seed]) {
-        emitters[seed].reset(new jit_load_emitter(this, isa, src_prc, ov::element::f32, elt_num, ov::element::f32, fill, "float_min"));
+        emitters[seed].reset(
+            new jit_load_emitter(this, isa, src_prc, ov::element::f32, elt_num, ov::element::f32, fill, "float_min"));
     }
-    emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), offset}, {static_cast<size_t>(vmm_dst.getIdx())},
-                                pool_aux_vmm_idxs, pool_aux_gpr_idxs);
+    emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), offset},
+                              {static_cast<size_t>(vmm_dst.getIdx())},
+                              pool_aux_vmm_idxs,
+                              pool_aux_gpr_idxs);
 }
 
 template <cpu_isa_t isa>
-void jit_rms_kernel<isa>::store(const Xbyak::Reg64& reg_dst, const Vmm& vmm_src, ov::element::Type dst_prc, const int& elt_num, size_t offset) {
+void jit_rms_kernel<isa>::store(const Xbyak::Reg64& reg_dst,
+                                const Vmm& vmm_src,
+                                ov::element::Type dst_prc,
+                                const int& elt_num,
+                                size_t offset) {
     const auto seed = store_emitter_params(ov::element::f32, dst_prc, elt_num).hash();
     if (!emitters[seed]) {
         emitters[seed].reset(new jit_store_emitter(this, isa, ov::element::f32, dst_prc, elt_num));
     }
-    emitters[seed]->emit_code({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(reg_dst.getIdx()), offset},
-                                pool_aux_vmm_idxs, pool_aux_gpr_idxs);
+    emitters[seed]->emit_code({static_cast<size_t>(vmm_src.getIdx())},
+                              {static_cast<size_t>(reg_dst.getIdx()), offset},
+                              pool_aux_vmm_idxs,
+                              pool_aux_gpr_idxs);
 }
 
 template struct jit_rms_kernel<cpu_isa_t::avx512_core>;
 template struct jit_rms_kernel<cpu_isa_t::avx2>;
 
-}   // namespace kernel
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace kernel
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/rms_kernel.hpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/rms_kernel.hpp
index c80d0f5502cb12..417b55de192f32 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/rms_kernel.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/rms_kernel.hpp
@@ -4,9 +4,8 @@
 
 #pragma once
 
-#include "jit_kernel_base.hpp"
-
 #include "emitters/plugin/x64/jit_load_store_emitters.hpp"
+#include "jit_kernel_base.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -36,21 +35,40 @@ struct jit_rms_kernel : public JitKernel<jit_rms_compile_params, jit_rms_call_ar
 
 private:
     using Xmm = Xbyak::Xmm;
-    using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,  Xbyak::Xmm,
-        isa == dnnl::impl::cpu::x64::avx2,  Xbyak::Ymm,  Xbyak::Zmm>::type;
+    using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,
+                                                         Xbyak::Xmm,
+                                                         isa == dnnl::impl::cpu::x64::avx2,
+                                                         Xbyak::Ymm,
+                                                         Xbyak::Zmm>::type;
 
     void generate() override;
-    void load(const Vmm& vmm_dst, const Xbyak::Reg64& reg_src, ov::element::Type src_prc, const int& elt_num, bool fill, size_t offset = 0);
-    void store(const Xbyak::Reg64& reg_dst, const Vmm& vmm_src, ov::element::Type dst_prc, const int& elt_num, size_t offset = 0);
+    void load(const Vmm& vmm_dst,
+              const Xbyak::Reg64& reg_src,
+              ov::element::Type src_prc,
+              const int& elt_num,
+              bool fill,
+              size_t offset = 0);
+    void store(const Xbyak::Reg64& reg_dst,
+               const Vmm& vmm_src,
+               ov::element::Type dst_prc,
+               const int& elt_num,
+               size_t offset = 0);
 
     // from onednn
-    void reduce_zmm_to_ymm(const Xmm &acc, const Xmm &tmp);
-    void reduce_ymm_to_xmm(const Xmm &acc, const Xmm &tmp);
-    void reduce_xmm_to_scalar(const Xmm &acc, const Xmm &tmp, const std::size_t number_of_values_to_reduce = number_of_f32_in_xmm_);
-    void reduce_ymm_to_scalar(const Xbyak::Xmm &acc, const Xbyak::Xmm &tmp1, const Xbyak::Xmm &tmp2,
-        const std::size_t number_of_values_to_reduce = number_of_f32_in_ymm_);
-    void reduce_vmm_to_scalar(const Xbyak::Xmm &acc, const Xbyak::Xmm &tmp1, const Xbyak::Xmm &tmp2,
-        const Xbyak::Xmm &tmp3, const std::size_t number_of_values_to_reduce = number_of_f32_in_zmm_);
+    void reduce_zmm_to_ymm(const Xmm& acc, const Xmm& tmp);
+    void reduce_ymm_to_xmm(const Xmm& acc, const Xmm& tmp);
+    void reduce_xmm_to_scalar(const Xmm& acc,
+                              const Xmm& tmp,
+                              const std::size_t number_of_values_to_reduce = number_of_f32_in_xmm_);
+    void reduce_ymm_to_scalar(const Xbyak::Xmm& acc,
+                              const Xbyak::Xmm& tmp1,
+                              const Xbyak::Xmm& tmp2,
+                              const std::size_t number_of_values_to_reduce = number_of_f32_in_ymm_);
+    void reduce_vmm_to_scalar(const Xbyak::Xmm& acc,
+                              const Xbyak::Xmm& tmp1,
+                              const Xbyak::Xmm& tmp2,
+                              const Xbyak::Xmm& tmp3,
+                              const std::size_t number_of_values_to_reduce = number_of_f32_in_zmm_);
     static constexpr std::size_t number_of_f32_in_xmm_ = 4;
     static constexpr std::size_t number_of_f32_in_ymm_ = 8;
     static constexpr std::size_t number_of_f32_in_zmm_ = 16;
@@ -73,10 +91,10 @@ struct jit_rms_kernel : public JitKernel<jit_rms_compile_params, jit_rms_call_ar
     const Xbyak::Reg64 reg_tmp = rdx;
 
     std::unordered_map<size_t, std::unique_ptr<jit_emitter>> emitters;
-    const std::vector<size_t> pool_aux_gpr_idxs = { static_cast<size_t>(rax.getIdx()), static_cast<size_t>(r9.getIdx()) };
-    const std::vector<size_t> pool_aux_vmm_idxs = { 7 };
+    const std::vector<size_t> pool_aux_gpr_idxs = {static_cast<size_t>(rax.getIdx()), static_cast<size_t>(r9.getIdx())};
+    const std::vector<size_t> pool_aux_vmm_idxs = {7};
 };
 
-}   // namespace kernel
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace kernel
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.cpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.cpp
index 4115dd27126089..be21592947e6f2 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.cpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.cpp
@@ -29,9 +29,7 @@ void jit_rotary_kernel<isa>::generate() {
         //      0-2        4-6        8-10       12-14
         // higher 64bit/128 lane
         //           16-18      20-22      24-26       28-30
-        static const uint64_t mask_zmm[] = {
-            0, 4, 1, 5, 2, 6, 3, 7
-        };
+        static const uint64_t mask_zmm[] = {0, 4, 1, 5, 2, 6, 3, 7};
         if (isa == cpu_isa_t::avx512_core) {
             mov(reg_tmp, reinterpret_cast<uintptr_t>(mask_zmm));
             uni_vmovups(vmm_idx, ptr[reg_tmp]);
@@ -106,7 +104,7 @@ void jit_rotary_kernel<isa>::rotary_interleave(size_t step) {
     // }
     load(vmm_src0, reg_src, m_jcp.src_prc, step, false);
     load(vmm_src1, reg_src, m_jcp.src_prc, step, false, step * m_jcp.src_prc.size());
-    auto deinterlace = [&] (const Vmm& src0, const Vmm& src1, const Vmm& tmp0, const Vmm& tmp1) {
+    auto deinterlace = [&](const Vmm& src0, const Vmm& src1, const Vmm& tmp0, const Vmm& tmp1) {
         if (isa == cpu_isa_t::avx2) {
             // src0: 0 1  2  3  4  5  6  7
             // src1: 8 9 10 11 12 13 14 15
@@ -186,28 +184,42 @@ void jit_rotary_kernel<isa>::rotary_interleave(size_t step) {
 }
 
 template <cpu_isa_t isa>
-void jit_rotary_kernel<isa>::load(const Vmm& vmm_dst, const Xbyak::Reg64& reg_src, ov::element::Type src_prc, const int& elt_num, bool fill, size_t offset) {
+void jit_rotary_kernel<isa>::load(const Vmm& vmm_dst,
+                                  const Xbyak::Reg64& reg_src,
+                                  ov::element::Type src_prc,
+                                  const int& elt_num,
+                                  bool fill,
+                                  size_t offset) {
     const auto seed = load_emitter_params(src_prc, ov::element::f32, elt_num, fill, "float_min").hash();
     if (!emitters[seed]) {
-        emitters[seed].reset(new jit_load_emitter(this, isa, src_prc, ov::element::f32, elt_num, ov::element::f32, fill, "float_min"));
+        emitters[seed].reset(
+            new jit_load_emitter(this, isa, src_prc, ov::element::f32, elt_num, ov::element::f32, fill, "float_min"));
     }
-    emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), offset}, {static_cast<size_t>(vmm_dst.getIdx())},
-                                pool_aux_vmm_idxs, pool_aux_gpr_idxs);
+    emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), offset},
+                              {static_cast<size_t>(vmm_dst.getIdx())},
+                              pool_aux_vmm_idxs,
+                              pool_aux_gpr_idxs);
 }
 
 template <cpu_isa_t isa>
-void jit_rotary_kernel<isa>::store(const Xbyak::Reg64& reg_dst, const Vmm& vmm_src, ov::element::Type dst_prc, const int& elt_num, size_t offset) {
+void jit_rotary_kernel<isa>::store(const Xbyak::Reg64& reg_dst,
+                                   const Vmm& vmm_src,
+                                   ov::element::Type dst_prc,
+                                   const int& elt_num,
+                                   size_t offset) {
     const auto seed = store_emitter_params(ov::element::f32, dst_prc, elt_num).hash();
     if (!emitters[seed]) {
         emitters[seed].reset(new jit_store_emitter(this, isa, ov::element::f32, dst_prc, elt_num));
     }
-    emitters[seed]->emit_code({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(reg_dst.getIdx()), offset},
-                                pool_aux_vmm_idxs, pool_aux_gpr_idxs);
+    emitters[seed]->emit_code({static_cast<size_t>(vmm_src.getIdx())},
+                              {static_cast<size_t>(reg_dst.getIdx()), offset},
+                              pool_aux_vmm_idxs,
+                              pool_aux_gpr_idxs);
 }
 
 template struct jit_rotary_kernel<cpu_isa_t::avx512_core>;
 template struct jit_rotary_kernel<cpu_isa_t::avx2>;
 
-}   // namespace kernel
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace kernel
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.hpp b/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.hpp
index bdeb937ad29423..8ea184ae94c74e 100644
--- a/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.hpp
+++ b/src/plugins/intel_cpu/src/nodes/kernels/x64/rope_kernel.hpp
@@ -7,7 +7,7 @@
 #include "jit_kernel_base.hpp"
 
 #if defined(OPENVINO_ARCH_X86_64)
-#include "emitters/plugin/x64/jit_load_store_emitters.hpp"
+#    include "emitters/plugin/x64/jit_load_store_emitters.hpp"
 #endif
 
 namespace ov {
@@ -40,14 +40,26 @@ struct jit_rotary_kernel : public JitKernel<jit_rotary_compile_params, jit_rotar
     explicit jit_rotary_kernel(const jit_rotary_compile_params& jcp) : JitKernel(jit_name(), jcp, isa) {}
 
 private:
-    using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,  Xbyak::Xmm,
-        isa == dnnl::impl::cpu::x64::avx2,  Xbyak::Ymm,  Xbyak::Zmm>::type;
+    using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,
+                                                         Xbyak::Xmm,
+                                                         isa == dnnl::impl::cpu::x64::avx2,
+                                                         Xbyak::Ymm,
+                                                         Xbyak::Zmm>::type;
 
     void generate() override;
     void rotary_half(size_t step);
     void rotary_interleave(size_t step);
-    void load(const Vmm& vmm_dst, const Xbyak::Reg64& reg_src, ov::element::Type src_prc, const int& elt_num, bool fill, size_t offset = 0);
-    void store(const Xbyak::Reg64& reg_dst, const Vmm& vmm_src, ov::element::Type dst_prc, const int& elt_num, size_t offset = 0);
+    void load(const Vmm& vmm_dst,
+              const Xbyak::Reg64& reg_src,
+              ov::element::Type src_prc,
+              const int& elt_num,
+              bool fill,
+              size_t offset = 0);
+    void store(const Xbyak::Reg64& reg_dst,
+               const Vmm& vmm_src,
+               ov::element::Type dst_prc,
+               const int& elt_num,
+               size_t offset = 0);
     const Vmm vmm_src0 = Vmm(0);
     const Vmm vmm_src1 = Vmm(1);
     const Vmm vmm_cos = Vmm(2);
@@ -62,12 +74,12 @@ struct jit_rotary_kernel : public JitKernel<jit_rotary_compile_params, jit_rotar
     const Xbyak::Reg64 reg_tmp = rdx;
 
     std::unordered_map<size_t, std::unique_ptr<jit_emitter>> emitters;
-    const std::vector<size_t> pool_aux_gpr_idxs = { static_cast<size_t>(rax.getIdx()), static_cast<size_t>(r9.getIdx()) };
-    const std::vector<size_t> pool_aux_vmm_idxs = { 6 };
+    const std::vector<size_t> pool_aux_gpr_idxs = {static_cast<size_t>(rax.getIdx()), static_cast<size_t>(r9.getIdx())};
+    const std::vector<size_t> pool_aux_vmm_idxs = {6};
 };
 
 #endif
 
-}   // namespace kernel
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace kernel
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/llm_mlp.cpp b/src/plugins/intel_cpu/src/nodes/llm_mlp.cpp
index 8c598c0641493c..b475a602c3cd1a 100644
--- a/src/plugins/intel_cpu/src/nodes/llm_mlp.cpp
+++ b/src/plugins/intel_cpu/src/nodes/llm_mlp.cpp
@@ -11,14 +11,13 @@
 #include "common/cpu_memcpy.h"
 #include "cpu/x64/cpu_isa_traits.hpp"
 #include "cpu/x64/jit_generator.hpp"
+#include "openvino/core/parallel.hpp"
 #include "shape_inference/shape_inference_internal_dyn.hpp"
 #include "utils/plain_tensor.hpp"
 
-#include "openvino/core/parallel.hpp"
-
 #if defined(OPENVINO_ARCH_X86_64)
-#include "kernels/x64/mlp_kernel.hpp"
-#include "kernels/x64/mlp_utils.hpp"
+#    include "kernels/x64/mlp_kernel.hpp"
+#    include "kernels/x64/mlp_utils.hpp"
 #endif
 
 namespace ov {
@@ -27,7 +26,7 @@ namespace node {
 
 #if defined(OPENVINO_ARCH_X86_64)
 
-template<typename T>
+template <typename T>
 class LinearKsplit2 {
 public:
     std::vector<Work> works;
@@ -38,7 +37,7 @@ class LinearKsplit2 {
 
     LinearKsplit2() {}
 
-    ReduceAdd2bh * p_jit_reduce2bh;
+    ReduceAdd2bh* p_jit_reduce2bh;
 
     // weight [N, K]
     // Gate & Up are interleaved in N dimension: 16-gate / 16-up
@@ -86,7 +85,7 @@ class LinearKsplit2 {
                     work.sync_flag = shared_atomic;
                     work.blk_K_size = cache_blk_k_size;
 
-                    work.n0 = (start_blkN) * REG_BLK_N_SIZE;
+                    work.n0 = (start_blkN)*REG_BLK_N_SIZE;
                     work.n1 = (start_blkN + blkN) * REG_BLK_N_SIZE;
                     work.BN = blkN * REG_BLK_N_SIZE;
                     work.k0 = start_blkK * reg_blk_K_size;
@@ -119,10 +118,14 @@ class LinearKsplit2 {
         DEBUG_LOG("   setup is done. weight @ ", static_cast<void*>(p_weight));
     }
 
-    void run(uint8_t* pA, int strideA, int M, T* dstC, int strideC,
+    void run(uint8_t* pA,
+             int strideA,
+             int M,
+             T* dstC,
+             int strideC,
              const LLMMLPNode::Config& config,
              MatrixDynQuantPerRow& src_dq,
-             float * w_scale) {
+             float* w_scale) {
         static ReduceAdd2bh jit_reduce2cvt(true, std::is_same<T, ov::float16>::value);
 
         ov::parallel_nt_static(m_threads_num, [&](const size_t ithr, const size_t nthr) {
@@ -136,18 +139,17 @@ class LinearKsplit2 {
                     auto* ptr_c = work.m_C.template ptr<float>();
                     auto* ptr_wsum = work.w_sum_per_oc.template ptr<float>();
                     auto stride_c = work.m_C.stride(0);
-                    ov::Extensions::Cpu::XARCH::llm_mlp_dequantize_i32_f32(
-                        M,
-                        work.BN,
-                        reinterpret_cast<int32_t*>(ptr_c),
-                        stride_c,
-                        ptr_c,
-                        stride_c,
-                        src_dq.scale,
-                        src_dq.zp,
-                        ptr_wsum,
-                        w_scale + work.n0,
-                        src_dq.asym);
+                    ov::Extensions::Cpu::XARCH::llm_mlp_dequantize_i32_f32(M,
+                                                                           work.BN,
+                                                                           reinterpret_cast<int32_t*>(ptr_c),
+                                                                           stride_c,
+                                                                           ptr_c,
+                                                                           stride_c,
+                                                                           src_dq.scale,
+                                                                           src_dq.zp,
+                                                                           ptr_wsum,
+                                                                           w_scale + work.n0,
+                                                                           src_dq.asym);
                 }
 
                 auto sync_id = work.sync_flag->fetch_add(1);
@@ -157,10 +159,8 @@ class LinearKsplit2 {
                     auto* p_peerC = works[peer_ithr].m_C.template ptr<float>();
                     // the other one has finished, we can do the reduce sum
                     auto* p_curC = workC.template ptr<float>();
-                    jit_reduce2cvt.call(p_curC, p_peerC,
-                                        workC.stride(0),
-                                        dstC + work.n0, strideC / sizeof(*dstC),
-                                        M, work.BN);
+                    jit_reduce2cvt
+                        .call(p_curC, p_peerC, workC.stride(0), dstC + work.n0, strideC / sizeof(*dstC), M, work.BN);
                 }
             }
         });
@@ -170,7 +170,7 @@ class LinearKsplit2 {
     int m_threads_num = 0;
 };
 
-template<typename T>
+template <typename T>
 class LinearGateUp {
 public:
     std::vector<Work> works;
@@ -219,7 +219,7 @@ class LinearGateUp {
         auto start_blkN = 0;
         used_nthr = 0;
 
-        for (int ithr = 0; ithr < m_threads_num; ithr ++) {
+        for (int ithr = 0; ithr < m_threads_num; ithr++) {
             auto blkN = std::min(num_blk_N - start_blkN, blkN_per_thread);
             if (blkN_leftover > 0) {
                 blkN_leftover--;
@@ -231,7 +231,7 @@ class LinearGateUp {
                 work.sync_flag = shared_atomic;
                 work.blk_K_size = cache_blk_k_size;
 
-                work.n0 = (start_blkN) * REG_BLK_N_SIZE;
+                work.n0 = (start_blkN)*REG_BLK_N_SIZE;
                 work.n1 = (start_blkN + blkN) * REG_BLK_N_SIZE;
                 work.BN = blkN * REG_BLK_N_SIZE;
                 work.k0 = 0;
@@ -253,7 +253,8 @@ class LinearGateUp {
                     work.setup(wbuffer.get<int8_t>(ithr),
                                reinterpret_cast<int8_t*>(p_weight_gate),
                                reinterpret_cast<int8_t*>(p_weight_up),
-                               stride, true);
+                               stride,
+                               true);
                 else
                     work.setup(wbuffer.get<T>(ithr),
                                reinterpret_cast<ov::float16*>(p_weight_gate),
@@ -265,11 +266,14 @@ class LinearGateUp {
     }
 
     // gate & up are interleaved: 16 gates + 16 up
-    void runGateUp(uint8_t* pA, int strideA_in_bytes, int M,
-                   T* dstC, int strideC,
+    void runGateUp(uint8_t* pA,
+                   int strideA_in_bytes,
+                   int M,
+                   T* dstC,
+                   int strideC,
                    const LLMMLPNode::Config& config,
                    MatrixDynQuantPerRow& src_dq,
-                   float * w_scale) {
+                   float* w_scale) {
         ov::parallel_nt_static(m_threads_num, [&](const size_t ithr, const size_t nthr) {
             auto& work = works[ithr];
             if (work) {
@@ -277,32 +281,29 @@ class LinearGateUp {
 
                 // K reduce is done, results of [M, BN] sub-block is ready in L2.
                 // combine Gate & Up
-                float * ptr_c;
+                float* ptr_c;
                 size_t stride_c;
                 if (config.gate_up_quantized) {
                     // dequantize m_C in-place
                     ptr_c = work.m_C.template ptr<float>();
                     stride_c = work.m_C.stride(0);
                     auto* p_wsum = work.w_sum_per_oc.template ptr<float>();
-                    ov::Extensions::Cpu::XARCH::llm_mlp_dequantize_i32_f32(
-                        M,
-                        work.BN,
-                        reinterpret_cast<int32_t*>(ptr_c),
-                        stride_c,
-                        ptr_c,
-                        stride_c,
-                        src_dq.scale,
-                        src_dq.zp,
-                        p_wsum,
-                        w_scale + work.n0,
-                        src_dq.asym);
+                    ov::Extensions::Cpu::XARCH::llm_mlp_dequantize_i32_f32(M,
+                                                                           work.BN,
+                                                                           reinterpret_cast<int32_t*>(ptr_c),
+                                                                           stride_c,
+                                                                           ptr_c,
+                                                                           stride_c,
+                                                                           src_dq.scale,
+                                                                           src_dq.zp,
+                                                                           p_wsum,
+                                                                           w_scale + work.n0,
+                                                                           src_dq.asym);
                 } else {
                     ptr_c = work.m_C.template ptr<float>();
                     stride_c = work.m_C.stride(0);
                 }
-                jit_gateup->call(ptr_c, stride_c,
-                                 dstC + (work.n0 / 2), strideC / sizeof(*dstC),
-                                 M, work.BN);
+                jit_gateup->call(ptr_c, stride_c, dstC + (work.n0 / 2), strideC / sizeof(*dstC), M, work.BN);
             }
         });
     }
@@ -311,7 +312,7 @@ class LinearGateUp {
     int m_threads_num = 0;
 };
 
-template<typename T>
+template <typename T>
 struct LLMMLP::Executor : public LLMMLP::ExecutorBase {
     LLMMLP* m_pnode;
     const LLMMLPNode::Config m_config;
@@ -339,7 +340,9 @@ struct LLMMLP::Executor : public LLMMLP::ExecutorBase {
     // w_gate/w_up : [N, K]
     //     w_down  : [K, N]
     Executor(LLMMLP* pnode, const LLMMLPNode::Config& config, DnnlScratchPadPtr scrachPad)
-         : m_pnode(pnode), m_config(config), m_scrachPad(scrachPad) {
+        : m_pnode(pnode),
+          m_config(config),
+          m_scrachPad(scrachPad) {
         PlainTensor w_gate(pnode->getSrcMemoryAtPort(1));
         PlainTensor w_up(pnode->getSrcMemoryAtPort(2));
         PlainTensor w_down(pnode->getSrcMemoryAtPort(3));
@@ -386,8 +389,7 @@ struct LLMMLP::Executor : public LLMMLP::ExecutorBase {
             ScratchBuffAllocator allocator;
 
             allocator.register_allocation(M * m_N * sizeof(T), [&](void* ptr) {
-                m_actUp.resize<T>({static_cast<size_t>(M), static_cast<size_t>(m_N)},
-                                             reinterpret_cast<T*>(ptr));
+                m_actUp.resize<T>({static_cast<size_t>(M), static_cast<size_t>(m_N)}, reinterpret_cast<T*>(ptr));
             });
 
             m_threads_num = parallel_get_max_threads();
@@ -405,7 +407,7 @@ struct LLMMLP::Executor : public LLMMLP::ExecutorBase {
             if (m_config.gate_up_quantized) {
                 m_quant_act.M = M;
                 m_quant_act.K = m_config.hidden_size;
-                allocator.register_allocation(m_quant_act.size(), [&](void* ptr){
+                allocator.register_allocation(m_quant_act.size(), [&](void* ptr) {
                     m_quant_act.setup(ptr);
                 });
             }
@@ -413,7 +415,7 @@ struct LLMMLP::Executor : public LLMMLP::ExecutorBase {
             if (m_config.down_quantized) {
                 m_quant_up_act.M = M;
                 m_quant_up_act.K = m_config.up_size;
-                allocator.register_allocation(m_quant_up_act.size(), [&](void* ptr){
+                allocator.register_allocation(m_quant_up_act.size(), [&](void* ptr) {
                     m_quant_up_act.setup(ptr);
                 });
             }
@@ -470,7 +472,7 @@ struct LLMMLP::Executor : public LLMMLP::ExecutorBase {
                               m_quant_act,
                               m_w_scale_gateup.ptr<float>());
 
-            uint8_t * p_up_act = reinterpret_cast<uint8_t*>(m_actUp.ptr<T>());
+            uint8_t* p_up_act = reinterpret_cast<uint8_t*>(m_actUp.ptr<T>());
             size_t stride_up_act = m_actUp.stride_bytes(0);
             if (m_config.down_quantized) {
                 m_quant_up_act.quantize(BM, m_actUp.ptr<T>(), m_actUp.stride(0));
@@ -478,10 +480,7 @@ struct LLMMLP::Executor : public LLMMLP::ExecutorBase {
                 stride_up_act = m_quant_up_act.stride();
             }
 
-            down.run(p_up_act, stride_up_act, BM, dstC, strideC,
-                    m_config,
-                    m_quant_up_act,
-                    p_w_scale_down);
+            down.run(p_up_act, stride_up_act, BM, dstC, strideC, m_config, m_quant_up_act, p_w_scale_down);
 
             m += BM;
             pA += BM * strideA_in_bytes;
@@ -493,7 +492,7 @@ struct LLMMLP::Executor : public LLMMLP::ExecutorBase {
     size_t m_threads_num = 0lu;
 };
 #else
-template<typename T>
+template <typename T>
 struct LLMMLP::Executor : public LLMMLP::ExecutorBase {
     Executor(LLMMLP* pnode, const LLMMLPNode::Config& config, DnnlScratchPadPtr scrachPad) {}
     void execute() {}
@@ -503,7 +502,7 @@ struct LLMMLP::Executor : public LLMMLP::ExecutorBase {
 LLMMLP::LLMMLP(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
     : Node(op, context, NgraphShapeInferFactory(op)) {
     std::string errorMessage;
-    const auto & config = context->getConfig();
+    const auto& config = context->getConfig();
     if (!isSupportedOperation(op, errorMessage, config.fcDynamicQuantizationGroupSize)) {
         OPENVINO_THROW("CPU: " + errorMessage);
     }
@@ -529,7 +528,9 @@ void LLMMLP::initSupportedPrimitiveDescriptors() {
         }
     }
 
-    OPENVINO_ASSERT(rtPrecision == ov::element::bf16 || rtPrecision == ov::element::f16, "Unexpected rtPrecision:", rtPrecision);
+    OPENVINO_ASSERT(rtPrecision == ov::element::bf16 || rtPrecision == ov::element::f16,
+                    "Unexpected rtPrecision:",
+                    rtPrecision);
 
     if (m_mlp_config.gate_up_quantized) {
         auto weightPrecision = ov::element::i8;
@@ -538,12 +539,27 @@ void LLMMLP::initSupportedPrimitiveDescriptors() {
         inPortConfigs.emplace_back(LayoutType::ncsp, rtPrecision, getInputShapeAtPort(0), false, -1);      // input
         inPortConfigs.emplace_back(LayoutType::ncsp, weightPrecision, getInputShapeAtPort(1), false, -1);  // gate
         inPortConfigs.emplace_back(LayoutType::ncsp, weightPrecision, getInputShapeAtPort(2), false, -1);  // up
-        inPortConfigs.emplace_back(LayoutType::ncsp, m_mlp_config.down_quantized ? ov::element::i8 : ov::element::f16,
-                                   getInputShapeAtPort(3), false, -1);  // down
-        inPortConfigs.emplace_back(LayoutType::ncsp, ov::element::f32, getInputShapeAtPort(4), false, -1);  // gate_weight scales per OC
-        inPortConfigs.emplace_back(LayoutType::ncsp, ov::element::f32, getInputShapeAtPort(5), false, -1);  // up_weight scales per OC
+        inPortConfigs.emplace_back(LayoutType::ncsp,
+                                   m_mlp_config.down_quantized ? ov::element::i8 : ov::element::f16,
+                                   getInputShapeAtPort(3),
+                                   false,
+                                   -1);  // down
+        inPortConfigs.emplace_back(LayoutType::ncsp,
+                                   ov::element::f32,
+                                   getInputShapeAtPort(4),
+                                   false,
+                                   -1);  // gate_weight scales per OC
+        inPortConfigs.emplace_back(LayoutType::ncsp,
+                                   ov::element::f32,
+                                   getInputShapeAtPort(5),
+                                   false,
+                                   -1);  // up_weight scales per OC
         if (m_mlp_config.down_quantized)
-            inPortConfigs.emplace_back(LayoutType::ncsp, ov::element::f32, getInputShapeAtPort(6), false, -1);  // down_weight scales per OC
+            inPortConfigs.emplace_back(LayoutType::ncsp,
+                                       ov::element::f32,
+                                       getInputShapeAtPort(6),
+                                       false,
+                                       -1);  // down_weight scales per OC
 
         // initialize output port
         outPortConfigs.emplace_back(LayoutType::ncsp, rtPrecision, getOutputShapeAtPort(0), false, -1);
@@ -581,7 +597,9 @@ void LLMMLP::execute(dnnl::stream strm) {
     m_executor->execute();
 }
 
-bool LLMMLP::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage, uint64_t fcDynamicQuantizationGroupSize) noexcept {
+bool LLMMLP::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                  std::string& errorMessage,
+                                  uint64_t fcDynamicQuantizationGroupSize) noexcept {
 #if defined(OPENVINO_ARCH_X86_64)
     try {
         const auto node_mlp = std::dynamic_pointer_cast<const LLMMLPNode>(op);
@@ -596,7 +614,8 @@ bool LLMMLP::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std
             auto up_size = down_proj_w_pshape[1].get_length();
 
             auto& config = node_mlp->get_config();
-            if (config.gate_up_quantized && (fcDynamicQuantizationGroupSize < static_cast<uint64_t>(config.hidden_size))) {
+            if (config.gate_up_quantized &&
+                (fcDynamicQuantizationGroupSize < static_cast<uint64_t>(config.hidden_size))) {
                 errorMessage = "LLMMLPNode gate-up-proj only support per-token dynamic quantization";
                 return false;
             }
diff --git a/src/plugins/intel_cpu/src/nodes/llm_mlp.h b/src/plugins/intel_cpu/src/nodes/llm_mlp.h
index 47f9faf70c5cc3..f0e89632ccf97d 100644
--- a/src/plugins/intel_cpu/src/nodes/llm_mlp.h
+++ b/src/plugins/intel_cpu/src/nodes/llm_mlp.h
@@ -39,7 +39,8 @@ class LLMMLP : public Node {
         virtual ~ExecutorBase() = default;
     };
     std::shared_ptr<ExecutorBase> m_executor;
-    template <typename T> struct Executor;
+    template <typename T>
+    struct Executor;
     LLMMLPNode::Config m_mlp_config;
 };
 
diff --git a/src/plugins/intel_cpu/src/nodes/log_softmax.cpp b/src/plugins/intel_cpu/src/nodes/log_softmax.cpp
index 8cc1c2bfb8d921..fc93daa2715812 100644
--- a/src/plugins/intel_cpu/src/nodes/log_softmax.cpp
+++ b/src/plugins/intel_cpu/src/nodes/log_softmax.cpp
@@ -2,11 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <cmath>
+#include "log_softmax.h"
 
+#include <cmath>
 #include <openvino/opsets/opset5.hpp>
+
 #include "openvino/core/parallel.hpp"
-#include "log_softmax.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -63,16 +64,18 @@ void LogSoftmax::initSupportedPrimitiveDescriptors() {
 }
 
 void LogSoftmax::prepareParams() {
-    const auto &dims = getParentEdgeAt(0)->getMemory().getStaticDims();
+    const auto& dims = getParentEdgeAt(0)->getMemory().getStaticDims();
     reducedAxisStride = 1;
     axisStep = 1;
     isLastDim = false;
 
     int j = static_cast<int>(dims.size()) - 1;
     for (; j >= 0; j--) {
-        if (dims[j] != 1) break;
+        if (dims[j] != 1)
+            break;
     }
-    if (j == axis) isLastDim = true;
+    if (j == axis)
+        isLastDim = true;
 
     for (int i = 0; i < axis; i++)
         axisStep *= dims[i];
@@ -86,13 +89,13 @@ void LogSoftmax::executeDynamicImpl(dnnl::stream strm) {
 }
 
 void LogSoftmax::execute(dnnl::stream strm) {
-    const float *srcData = getSrcDataAtPortAs<const float>(0);
+    const float* srcData = getSrcDataAtPortAs<const float>(0);
     float* dstData = getDstDataAtPortAs<float>(0);
 
     if (isLastDim) {
         parallel_for(axisStep, [&](size_t i) {
-            const float *srcDataPtr = &srcData[i * reducedAxisSize];
-            float *dstDataPtr = &dstData[i * reducedAxisSize];
+            const float* srcDataPtr = &srcData[i * reducedAxisSize];
+            float* dstDataPtr = &dstData[i * reducedAxisSize];
 
             float reduceProd = 0.0f;
             const float max = *std::max_element(srcDataPtr, srcDataPtr + reducedAxisSize);
@@ -105,8 +108,8 @@ void LogSoftmax::execute(dnnl::stream strm) {
         });
     } else {
         parallel_for2d(axisStep, reducedAxisStride, [&](size_t k, size_t i) {
-            const float *srcDataPtr = &srcData[k * reducedAxisStride * reducedAxisSize + i];
-            float *dstDataPtr = &dstData[k * reducedAxisStride * reducedAxisSize + i];
+            const float* srcDataPtr = &srcData[k * reducedAxisStride * reducedAxisSize + i];
+            float* dstDataPtr = &dstData[k * reducedAxisStride * reducedAxisSize + i];
 
             float reduceProd = 0.0f;
             float max = std::numeric_limits<float>::min();
@@ -129,6 +132,6 @@ bool LogSoftmax::created() const {
     return getType() == Type::LogSoftmax;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/log_softmax.h b/src/plugins/intel_cpu/src/nodes/log_softmax.h
index 1c8eb7926b01aa..35f1ee9bc95af4 100644
--- a/src/plugins/intel_cpu/src/nodes/log_softmax.h
+++ b/src/plugins/intel_cpu/src/nodes/log_softmax.h
@@ -14,7 +14,7 @@ class LogSoftmax : public Node {
 public:
     LogSoftmax(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -34,6 +34,6 @@ class LogSoftmax : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/lora.cpp b/src/plugins/intel_cpu/src/nodes/lora.cpp
index 52509cdfc44a13..0dcb2e9ef2b9e5 100644
--- a/src/plugins/intel_cpu/src/nodes/lora.cpp
+++ b/src/plugins/intel_cpu/src/nodes/lora.cpp
@@ -4,11 +4,11 @@
 
 #include "lora.h"
 
-#include "nodes/input.h"
 #include "cpu_memory.h"
+#include "nodes/input.h"
 #include "ov_ops/lora_subgraph.hpp"
-#include "utils/debug_capabilities.h"
 #include "shape_inference/shape_inference_pass_through.hpp"
+#include "utils/debug_capabilities.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -48,7 +48,7 @@ void LoRA::selectOptimalPrimitiveDescriptor() {
     std::vector<Input::InputConfig> graphInputConfig;
 
     auto mainInputDesc = getParentOutputMemDesc(getParentEdgeAt(0));
-    auto mainInputPrc = mainInputDesc->getPrecision(); // we have to align precision across all the inputs
+    auto mainInputPrc = mainInputDesc->getPrecision();  // we have to align precision across all the inputs
 
     inConfs.emplace_back(mainInputDesc);
     graphInputConfig.emplace_back(node::Input::InputConfig{mainInputDesc, true});
@@ -76,7 +76,7 @@ void LoRA::selectOptimalPrimitiveDescriptor() {
 
     std::vector<PortConfig> outConfs;
 
-    outConfs.emplace_back(desc, BlockedMemoryDesc::FULL_MASK, 0); // use the memory from the first input inPlace
+    outConfs.emplace_back(desc, BlockedMemoryDesc::FULL_MASK, 0);  // use the memory from the first input inPlace
 
     const NodeConfig config(inConfs, outConfs);
 
diff --git a/src/plugins/intel_cpu/src/nodes/lora.h b/src/plugins/intel_cpu/src/nodes/lora.h
index 27701daf9034f2..b2b5757db4acb8 100644
--- a/src/plugins/intel_cpu/src/nodes/lora.h
+++ b/src/plugins/intel_cpu/src/nodes/lora.h
@@ -34,6 +34,6 @@ class LoRA : public Node {
     Graph m_graph;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/lrn.cpp b/src/plugins/intel_cpu/src/nodes/lrn.cpp
index a26b58798b0dbd..405dfb593857ad 100644
--- a/src/plugins/intel_cpu/src/nodes/lrn.cpp
+++ b/src/plugins/intel_cpu/src/nodes/lrn.cpp
@@ -4,16 +4,17 @@
 
 #include "lrn.h"
 
-#include "dnnl_extension_utils.h"
-#include "openvino/opsets/opset1.hpp"
 #include <memory_desc/cpu_memory_desc_utils.h>
-#include "memory_desc/dnnl_blocked_memory_desc.h"
-#include "common/primitive_hashing_utils.hpp"
-#include <shape_inference/shape_inference_pass_through.hpp>
 
 #include <memory>
+#include <shape_inference/shape_inference_pass_through.hpp>
 #include <string>
 
+#include "common/primitive_hashing_utils.hpp"
+#include "dnnl_extension_utils.h"
+#include "memory_desc/dnnl_blocked_memory_desc.h"
+#include "openvino/opsets/opset1.hpp"
+
 namespace ov {
 namespace intel_cpu {
 namespace node {
@@ -50,7 +51,7 @@ size_t LrnKey::hash() const {
     return seed;
 }
 
-bool LrnKey::operator==(const LrnKey &rhs) const {
+bool LrnKey::operator==(const LrnKey& rhs) const {
     bool retVal = true;
     if (inp0 != rhs.inp0) {
         retVal = retVal && inp0 && rhs.inp0 && inp0->getDnnlDesc() == rhs.inp0->getDnnlDesc();
@@ -60,7 +61,7 @@ bool LrnKey::operator==(const LrnKey &rhs) const {
              alpha == rhs.alpha && beta == rhs.beta;
     return retVal;
 }
-} // namespace
+}  // namespace
 
 bool Lrn::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
@@ -87,7 +88,7 @@ bool Lrn::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::s
             return true;
         } else {
             std::vector<bool> norm(dataRank, false);
-            for (auto &axis : axes) {
+            for (auto& axis : axes) {
                 if (axis < 0 || axis >= static_cast<int64_t>(dataRank)) {
                     errorMessage = "Has incorrect reduction axis: " + std::to_string(axis);
                     return false;
@@ -108,14 +109,15 @@ bool Lrn::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::s
     return true;
 }
 
-Lrn::Lrn(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) :
-        Node(op, context, PassThroughShapeInferFactory()) {
+Lrn::Lrn(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, PassThroughShapeInferFactory()) {
     std::string errorMessage;
     if (isSupportedOperation(op, errorMessage)) {
         errorPrefix = "LRN node with name '" + getName() + "'";
 
         auto lrn = ov::as_type_ptr<const ov::opset1::LRN>(op);
-        auto axes = ov::as_type_ptr<const ov::opset1::Constant>(lrn->get_input_node_shared_ptr(1))->cast_vector<int64_t>();
+        auto axes =
+            ov::as_type_ptr<const ov::opset1::Constant>(lrn->get_input_node_shared_ptr(1))->cast_vector<int64_t>();
         bool isAcrossMaps = (axes.size() == 1 && axes[0] == 1);
         alg = isAcrossMaps ? dnnl::algorithm::lrn_across_channels : dnnl::algorithm::lrn_within_channel;
         alpha = static_cast<float>(lrn->get_alpha());
@@ -141,7 +143,7 @@ void Lrn::getSupportedDescriptors() {
         precision = ov::element::f32;
     auto inputDataType = DnnlExtensionUtils::ElementTypeToDataType(precision);
 
-    const auto &parentShape = getInputShapeAtPort(0);
+    const auto& parentShape = getInputShapeAtPort(0);
 
     for (auto format : getAvailableFormatsForDims(parentShape)) {
         auto in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(parentShape, inputDataType, format);
@@ -149,7 +151,7 @@ void Lrn::getSupportedDescriptors() {
     }
 }
 
-std::shared_ptr<MemoryDesc> Lrn::getSrcMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const {
+std::shared_ptr<MemoryDesc> Lrn::getSrcMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const {
     if (idx > 0) {
         return std::make_shared<CpuBlockedMemoryDesc>(getOriginalInputPrecisionAtPort(idx), getInputShapeAtPort(idx));
     } else {
@@ -181,17 +183,16 @@ void Lrn::prepareParams() {
     auto engine = getEngine();
 
     auto builder = [&engine](const LrnKey& key) -> executorPtr {
-        auto prim_desc = dnnl::lrn_forward::primitive_desc(
-            engine,
-            dnnl::prop_kind::forward_inference,
-            key.alg,
-            key.inp0->getDnnlDesc(),
-            key.inp0->getDnnlDesc(),
-            key.size,
-            key.alpha,
-            key.beta,
-            key.k,
-            key.attr);
+        auto prim_desc = dnnl::lrn_forward::primitive_desc(engine,
+                                                           dnnl::prop_kind::forward_inference,
+                                                           key.alg,
+                                                           key.inp0->getDnnlDesc(),
+                                                           key.inp0->getDnnlDesc(),
+                                                           key.size,
+                                                           key.alpha,
+                                                           key.beta,
+                                                           key.k,
+                                                           key.attr);
 
         const bool found = DnnlExtensionUtils::find_implementation(prim_desc, key.implType);
 
@@ -223,22 +224,20 @@ bool Lrn::created() const {
     return getType() == Type::Lrn;
 }
 
-void Lrn::createDescriptor(const std::vector<MemoryDescPtr> &inputDesc,
-                           const std::vector<MemoryDescPtr> &outputDesc) {
+void Lrn::createDescriptor(const std::vector<MemoryDescPtr>& inputDesc, const std::vector<MemoryDescPtr>& outputDesc) {
     auto inpDesc = inputDesc[0]->isDefined() ? inputDesc[0] : MemoryDescUtils::makeDummyDesc(*inputDesc[0]);
     DnnlMemoryDescPtr definedInpMemDesc = MemoryDescUtils::convertToDnnlMemoryDesc(inpDesc);
     const auto& in_candidate = definedInpMemDesc->getDnnlDesc();
 
-    auto desc = dnnl::lrn_forward::primitive_desc(
-        getEngine(),
-        dnnl::prop_kind::forward_inference,
-        alg,
-        in_candidate,
-        in_candidate,
-        size,
-        alpha,
-        beta,
-        k);
+    auto desc = dnnl::lrn_forward::primitive_desc(getEngine(),
+                                                  dnnl::prop_kind::forward_inference,
+                                                  alg,
+                                                  in_candidate,
+                                                  in_candidate,
+                                                  size,
+                                                  alpha,
+                                                  beta,
+                                                  k);
 
     descs.push_back(desc);
 }
@@ -255,6 +254,6 @@ void Lrn::executeDynamicImpl(dnnl::stream strm) {
     execute(strm);
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/lrn.h b/src/plugins/intel_cpu/src/nodes/lrn.h
index 33bee67a4eeec6..967d841431772e 100644
--- a/src/plugins/intel_cpu/src/nodes/lrn.h
+++ b/src/plugins/intel_cpu/src/nodes/lrn.h
@@ -21,7 +21,7 @@ class Lrn : public Node {
     size_t descInputNumbers() override {
         return static_cast<size_t>(getOriginalInputsNumber());
     }
-    std::shared_ptr<MemoryDesc> getSrcMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const override;
+    std::shared_ptr<MemoryDesc> getSrcMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const override;
     bool created() const override;
     bool canBeInPlace() const override {
         return false;
@@ -45,6 +45,6 @@ class Lrn : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/mathematics.cpp b/src/plugins/intel_cpu/src/nodes/mathematics.cpp
index 2091939a5807fc..79fcb95e39a653 100644
--- a/src/plugins/intel_cpu/src/nodes/mathematics.cpp
+++ b/src/plugins/intel_cpu/src/nodes/mathematics.cpp
@@ -2,14 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "mathematics.h"
+
 #include <cmath>
-#include <vector>
+#include <shape_inference/shape_inference_pass_through.hpp>
 #include <string>
+#include <vector>
 
 #include "openvino/core/parallel.hpp"
 #include "openvino/opsets/opset1.hpp"
-#include "mathematics.h"
-#include <shape_inference/shape_inference_pass_through.hpp>
 
 namespace ov {
 namespace intel_cpu {
@@ -22,7 +23,9 @@ bool Math::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::
             return false;
         }
 
-        if (one_of(op->get_type_info(), ov::op::v0::HardSigmoid::get_type_info_static(), ov::op::v0::Selu::get_type_info_static())) {
+        if (one_of(op->get_type_info(),
+                   ov::op::v0::HardSigmoid::get_type_info_static(),
+                   ov::op::v0::Selu::get_type_info_static())) {
             auto firstConst = ov::as_type_ptr<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
             auto secondConst = ov::as_type_ptr<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2));
             if (!firstConst || !secondConst) {
@@ -58,9 +61,7 @@ void Math::initSupportedPrimitiveDescriptors() {
     for (size_t i = 0; i < inputShapes.size(); ++i)
         inDataConf.emplace_back(LayoutType::ncsp, ov::element::f32);
 
-    addSupportedPrimDesc(inDataConf,
-                         {{LayoutType::ncsp, ov::element::f32}},
-                         impl_desc_type::ref_any);
+    addSupportedPrimDesc(inDataConf, {{LayoutType::ncsp, ov::element::f32}}, impl_desc_type::ref_any);
 }
 
 void Math::executeDynamicImpl(dnnl::stream strm) {
@@ -69,130 +70,130 @@ void Math::executeDynamicImpl(dnnl::stream strm) {
 
 void Math::execute(dnnl::stream strm) {
     size_t dataSize = getChildEdgeAt(0)->getMemory().getShape().getElementsCount();
-    const float *src_data = getSrcDataAtPortAs<const float>(0);
+    const float* src_data = getSrcDataAtPortAs<const float>(0);
     float* dst_data = getDstDataAtPortAs<float>(0);
 
     switch (getAlgorithm()) {
-        case Algorithm::MathAbs:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = (std::abs)(src_data[i]);
-            });
-            break;
-        case Algorithm::MathAcos:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = acosf(src_data[i]);
-            });
-            break;
-        case Algorithm::MathAcosh:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = acoshf(src_data[i]);
-            });
-            break;
-        case Algorithm::MathAsin:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = asinf(src_data[i]);
-            });
-            break;
-        case Algorithm::MathAsinh:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = asinhf(src_data[i]);
-            });
-            break;
-        case Algorithm::MathAtan:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = atanf(src_data[i]);
-            });
-            break;
-        case Algorithm::MathAtanh:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = atanhf(src_data[i]);
-            });
-            break;
-        case Algorithm::MathCeiling:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = ceilf(src_data[i]);
-            });
-            break;
-        case Algorithm::MathCos:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = cosf(src_data[i]);
-            });
-            break;
-        case Algorithm::MathCosh:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = coshf(src_data[i]);
-            });
-            break;
-        case Algorithm::MathFloor:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = floorf(src_data[i]);
-            });
-            break;
-        case Algorithm::MathHardSigmoid:
-            alpha = (alpha == 0.0f) ? 0.2f : alpha;
-            beta = (beta == 0.0f) ? 0.5f : beta;
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = (std::max)(0.f, (std::min)(1.f, alpha * src_data[i] + beta));
-            });
-            break;
-        case Algorithm::MathNegative:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = -src_data[i];
-            });
-            break;
-        case Algorithm::MathReciprocal:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = 1.0f / src_data[i];
-            });
-            break;
-        case Algorithm::MathSelu:
-            alpha = (alpha == 0.0f) ? 1.67326f : alpha;
-            gamma = (gamma == 0.0f) ? 1.0507f : gamma;
-            parallel_for(dataSize, [&](size_t i) {
-                float x = src_data[i];
-                dst_data[i] = (x > 0.0f) ? (gamma * x) : (gamma * alpha * (exp(x) - 1.0f));
-            });
-            break;
-        case Algorithm::MathSign:
-            parallel_for(dataSize, [&](size_t i) {
-                if (src_data[i] > 0.0f)
-                    dst_data[i] = 1.0f;
-                else if (src_data[i] < 0.0f)
-                    dst_data[i] = -1.0f;
-                else if (std::isnan(src_data[i]))
-                    dst_data[i] = src_data[i];
-                else
-                    dst_data[i] = 0.0f;
-            });
-            break;
-        case Algorithm::MathSin:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = sinf(src_data[i]);
-            });
-            break;
-        case Algorithm::MathSinh:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = sinhf(src_data[i]);
-            });
-            break;
-        case Algorithm::MathSoftPlus:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = logf(expf(src_data[i]) + 1);
-            });
-            break;
-        case Algorithm::MathSoftsign:
-            parallel_for(dataSize, [&](size_t i) {
-                float x = src_data[i];
-                dst_data[i] = x / (1.f + (std::abs)(x));
-            });
-            break;
-        case Algorithm::MathTan:
-            parallel_for(dataSize, [&](size_t i) {
-                dst_data[i] = tanf(src_data[i]);
-            });
-            break;
-        default:
-            OPENVINO_THROW("Incorrect Reduce layer type");
+    case Algorithm::MathAbs:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = (std::abs)(src_data[i]);
+        });
+        break;
+    case Algorithm::MathAcos:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = acosf(src_data[i]);
+        });
+        break;
+    case Algorithm::MathAcosh:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = acoshf(src_data[i]);
+        });
+        break;
+    case Algorithm::MathAsin:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = asinf(src_data[i]);
+        });
+        break;
+    case Algorithm::MathAsinh:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = asinhf(src_data[i]);
+        });
+        break;
+    case Algorithm::MathAtan:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = atanf(src_data[i]);
+        });
+        break;
+    case Algorithm::MathAtanh:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = atanhf(src_data[i]);
+        });
+        break;
+    case Algorithm::MathCeiling:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = ceilf(src_data[i]);
+        });
+        break;
+    case Algorithm::MathCos:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = cosf(src_data[i]);
+        });
+        break;
+    case Algorithm::MathCosh:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = coshf(src_data[i]);
+        });
+        break;
+    case Algorithm::MathFloor:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = floorf(src_data[i]);
+        });
+        break;
+    case Algorithm::MathHardSigmoid:
+        alpha = (alpha == 0.0f) ? 0.2f : alpha;
+        beta = (beta == 0.0f) ? 0.5f : beta;
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = (std::max)(0.f, (std::min)(1.f, alpha * src_data[i] + beta));
+        });
+        break;
+    case Algorithm::MathNegative:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = -src_data[i];
+        });
+        break;
+    case Algorithm::MathReciprocal:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = 1.0f / src_data[i];
+        });
+        break;
+    case Algorithm::MathSelu:
+        alpha = (alpha == 0.0f) ? 1.67326f : alpha;
+        gamma = (gamma == 0.0f) ? 1.0507f : gamma;
+        parallel_for(dataSize, [&](size_t i) {
+            float x = src_data[i];
+            dst_data[i] = (x > 0.0f) ? (gamma * x) : (gamma * alpha * (exp(x) - 1.0f));
+        });
+        break;
+    case Algorithm::MathSign:
+        parallel_for(dataSize, [&](size_t i) {
+            if (src_data[i] > 0.0f)
+                dst_data[i] = 1.0f;
+            else if (src_data[i] < 0.0f)
+                dst_data[i] = -1.0f;
+            else if (std::isnan(src_data[i]))
+                dst_data[i] = src_data[i];
+            else
+                dst_data[i] = 0.0f;
+        });
+        break;
+    case Algorithm::MathSin:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = sinf(src_data[i]);
+        });
+        break;
+    case Algorithm::MathSinh:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = sinhf(src_data[i]);
+        });
+        break;
+    case Algorithm::MathSoftPlus:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = logf(expf(src_data[i]) + 1);
+        });
+        break;
+    case Algorithm::MathSoftsign:
+        parallel_for(dataSize, [&](size_t i) {
+            float x = src_data[i];
+            dst_data[i] = x / (1.f + (std::abs)(x));
+        });
+        break;
+    case Algorithm::MathTan:
+        parallel_for(dataSize, [&](size_t i) {
+            dst_data[i] = tanf(src_data[i]);
+        });
+        break;
+    default:
+        OPENVINO_THROW("Incorrect Reduce layer type");
     }
 }
 
@@ -200,73 +201,96 @@ bool Math::created() const {
     return getType() == Type::Math;
 }
 
-std::map<const ov::DiscreteTypeInfo, std::function<void(const std::shared_ptr<ov::Node>&, Math& node)>>& Math::getInitializers() {
-    static std::map<const ov::DiscreteTypeInfo, std::function<void(const std::shared_ptr<ov::Node>&, Math& node)>> initializers {
-            {ov::op::v0::Abs::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathAbs;
-            }},
-            {ov::op::v0::Acos::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathAcos;
-            }},
-            {ov::op::v3::Acosh::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathAcosh;
-            }},
-            {ov::op::v0::Asin::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathAsin;
-            }},
-            {ov::op::v3::Asinh::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathAsinh;
-            }},
-            {ov::op::v0::Atan::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathAtan;
-            }},
-            {ov::op::v0::Ceiling::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathCeiling;
-            }},
-            {ov::op::v0::Cos::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathCos;
-            }},
-            {ov::op::v0::Cosh::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathCosh;
-            }},
-            {ov::op::v0::Floor::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathFloor;
-            }},
-            {ov::op::v0::HardSigmoid::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathHardSigmoid;
-                node.alpha = ov::as_type_ptr<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1))->cast_vector<float>()[0];
-                node.beta = ov::as_type_ptr<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2))->cast_vector<float>()[0];
-            }},
-            {ov::op::v0::Negative::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathNegative;
-            }},
-            {ov::op::v0::Selu::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathSelu;
-                node.alpha = ov::as_type_ptr<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1))->cast_vector<float>()[0];
-                node.gamma = ov::as_type_ptr<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2))->cast_vector<float>()[0];
-            }},
-            {ov::op::v0::Sign::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathSign;
-            }},
-            {ov::op::v0::Sin::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathSin;
-            }},
-            {ov::op::v0::Sinh::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathSinh;
-            }},
-            {ov::op::v4::SoftPlus::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathSoftPlus;
-            }},
-            {ov::op::v0::Tan::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathTan;
-            }},
+std::map<const ov::DiscreteTypeInfo, std::function<void(const std::shared_ptr<ov::Node>&, Math& node)>>&
+Math::getInitializers() {
+    static std::map<const ov::DiscreteTypeInfo, std::function<void(const std::shared_ptr<ov::Node>&, Math& node)>>
+        initializers{
+            {ov::op::v0::Abs::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathAbs;
+             }},
+            {ov::op::v0::Acos::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathAcos;
+             }},
+            {ov::op::v3::Acosh::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathAcosh;
+             }},
+            {ov::op::v0::Asin::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathAsin;
+             }},
+            {ov::op::v3::Asinh::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathAsinh;
+             }},
+            {ov::op::v0::Atan::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathAtan;
+             }},
+            {ov::op::v0::Ceiling::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathCeiling;
+             }},
+            {ov::op::v0::Cos::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathCos;
+             }},
+            {ov::op::v0::Cosh::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathCosh;
+             }},
+            {ov::op::v0::Floor::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathFloor;
+             }},
+            {ov::op::v0::HardSigmoid::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathHardSigmoid;
+                 node.alpha =
+                     ov::as_type_ptr<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1))->cast_vector<float>()[0];
+                 node.beta =
+                     ov::as_type_ptr<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2))->cast_vector<float>()[0];
+             }},
+            {ov::op::v0::Negative::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathNegative;
+             }},
+            {ov::op::v0::Selu::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathSelu;
+                 node.alpha =
+                     ov::as_type_ptr<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1))->cast_vector<float>()[0];
+                 node.gamma =
+                     ov::as_type_ptr<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2))->cast_vector<float>()[0];
+             }},
+            {ov::op::v0::Sign::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathSign;
+             }},
+            {ov::op::v0::Sin::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathSin;
+             }},
+            {ov::op::v0::Sinh::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathSinh;
+             }},
+            {ov::op::v4::SoftPlus::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathSoftPlus;
+             }},
+            {ov::op::v0::Tan::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Math& node) {
+                 node.algorithm = Algorithm::MathTan;
+             }},
             {ov::op::v3::Atanh::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Math& node) {
-                node.algorithm = Algorithm::MathAtanh;
-            }}
-    };
+                 node.algorithm = Algorithm::MathAtanh;
+             }}};
     return initializers;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/mathematics.h b/src/plugins/intel_cpu/src/nodes/mathematics.h
index aad778910d557e..510189bba387f9 100644
--- a/src/plugins/intel_cpu/src/nodes/mathematics.h
+++ b/src/plugins/intel_cpu/src/nodes/mathematics.h
@@ -14,18 +14,21 @@ class Math : public Node {
 public:
     Math(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
 
-    bool needPrepareParams() const override { return false; };
+    bool needPrepareParams() const override {
+        return false;
+    };
     void executeDynamicImpl(dnnl::stream strm) override;
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
 private:
-    static std::map<const ov::DiscreteTypeInfo, std::function<void(const std::shared_ptr<ov::Node>&, Math& node)>>& getInitializers();
+    static std::map<const ov::DiscreteTypeInfo, std::function<void(const std::shared_ptr<ov::Node>&, Math& node)>>&
+    getInitializers();
 
     float alpha = 0.0f;
     float beta = 0.0f;
@@ -34,6 +37,6 @@ class Math : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/matmul.cpp b/src/plugins/intel_cpu/src/nodes/matmul.cpp
index 92d8f356728ed9..fa7abd7685df09 100644
--- a/src/plugins/intel_cpu/src/nodes/matmul.cpp
+++ b/src/plugins/intel_cpu/src/nodes/matmul.cpp
@@ -4,27 +4,26 @@
 
 #include "matmul.h"
 
-#include "memory_desc/cpu_blocked_memory_desc.h"
-#include "cpu_types.h"
-#include "eltwise.h"
-
+#include <memory>
 #include <numeric>
 #include <string>
 #include <vector>
-#include <memory>
+
 #include "common/cpu_memcpy.h"
-#include "openvino/opsets/opset1.hpp"
-#include "memory_desc/dnnl_blocked_memory_desc.h"
-#include "fake_quantize.h"
-#include "utils/general_utils.h"
-#include "memory_desc/cpu_memory_desc_utils.h"
-#include "dnnl_extension_utils.h"
 #include "common/primitive_hashing_utils.hpp"
 #include "cpu/x64/cpu_isa_traits.hpp"
+#include "cpu_types.h"
+#include "dnnl_extension_utils.h"
+#include "eltwise.h"
+#include "fake_quantize.h"
+#include "memory_desc/cpu_blocked_memory_desc.h"
+#include "memory_desc/cpu_memory_desc_utils.h"
+#include "memory_desc/dnnl_blocked_memory_desc.h"
+#include "openvino/opsets/opset1.hpp"
 #include "shape_inference/custom/matmul.hpp"
+#include "utils/general_utils.h"
 using namespace dnnl;
 
-
 namespace ov {
 namespace intel_cpu {
 namespace node {
@@ -59,7 +58,7 @@ size_t MatMulKey::hash() const {
     return seed;
 }
 
-bool MatMulKey::operator==(const MatMulKey &rhs) const {
+bool MatMulKey::operator==(const MatMulKey& rhs) const {
     bool retVal = true;
     if (inp0 != rhs.inp0) {
         retVal = retVal && inp0 && rhs.inp0 && inp0->getDnnlDesc() == rhs.inp0->getDnnlDesc();
@@ -73,11 +72,10 @@ bool MatMulKey::operator==(const MatMulKey &rhs) const {
     if (out != rhs.out) {
         retVal = retVal && out && rhs.out && out->getDnnlDesc() == rhs.out->getDnnlDesc();
     }
-    retVal = retVal && *attr.get() == *rhs.attr.get() &&
-             implType == rhs.implType;
+    retVal = retVal && *attr.get() == *rhs.attr.get() && implType == rhs.implType;
     return retVal;
 }
-} // namespace
+}  // namespace
 
 bool MatMul::canBeExecutedInInt8() const {
     auto firstInputPrecision = getOriginalInputPrecisionAtPort(0);
@@ -97,7 +95,8 @@ bool MatMul::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std
         for (size_t i = 0; i < matMul->get_input_size(); i++) {
             const auto inShapeRank = matMul->get_input_partial_shape(i).rank().get_length();
             if (inShapeRank < 2) {
-                errorMessage = "Unsupported rank: " + std::to_string(inShapeRank) + " on " + std::to_string(i) + " input";
+                errorMessage =
+                    "Unsupported rank: " + std::to_string(inShapeRank) + " on " + std::to_string(i) + " input";
                 return false;
             }
         }
@@ -113,8 +112,9 @@ bool MatMul::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std
     return true;
 }
 
-MatMul::MatMul(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) :
-    Node(op, context, MMShapeInferFactory(op)), withBiases(false) {
+MatMul::MatMul(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, MMShapeInferFactory(op)),
+      withBiases(false) {
     std::string errorMessage;
     errorPrefix = "MatMul node with name '" + getName() + "'";
 
@@ -142,7 +142,10 @@ bool MatMul::canFuse(const NodePtr& node) const {
             if (eltwiseNode->getBroadcastingPolicy() == Eltwise::BroadcastingPolicy::PerChannel) {
                 auto rank = getInputShapeAtPort(0).getRank();
                 if (rank > 4) {
-                    DEBUG_LOG("skip fusing non-perTensor Eltwise:", eltwiseNode->getName(), " into 6D MatMul:", getName());
+                    DEBUG_LOG("skip fusing non-perTensor Eltwise:",
+                              eltwiseNode->getName(),
+                              " into 6D MatMul:",
+                              getName());
                     return false;
                 }
             }
@@ -150,12 +153,12 @@ bool MatMul::canFuse(const NodePtr& node) const {
     }
 
     //  Consider the case when Matmul doesn't support execution in int8, but is getting fused with FQ with int8 output.
-    //  Then the Matmul will change its output precision to fp32. If fusing FQ into matmul, there would be reorder inserted
-    //  after matmul. In some bert model, this reorder causes great perf degradation.
-    //  Todo: Remove this if onednn primitive support U8 output with floating input.
-    if (node->getType() == Type::FakeQuantize && one_of(node->getOriginalOutputPrecisionAtPort(0), ov::element::i8, ov::element::u8) &&
-        !canBeExecutedInInt8() &&
-        getOriginalInputPrecisionAtPort(0) == ov::element::f32 )
+    //  Then the Matmul will change its output precision to fp32. If fusing FQ into matmul, there would be reorder
+    //  inserted after matmul. In some bert model, this reorder causes great perf degradation. Todo: Remove this if
+    //  onednn primitive support U8 output with floating input.
+    if (node->getType() == Type::FakeQuantize &&
+        one_of(node->getOriginalOutputPrecisionAtPort(0), ov::element::i8, ov::element::u8) && !canBeExecutedInInt8() &&
+        getOriginalInputPrecisionAtPort(0) == ov::element::f32)
         return false;
     return canFuseSimpleOperation(node);
 }
@@ -170,7 +173,16 @@ void MatMul::setPostOps(dnnl::primitive_attr& attr, const VectorDims& dims, bool
 
     bool isINT8 = canBeExecutedInInt8();
 
-    DnnlPostOpsComposerLegacy dnnlpoc(getEngine(), attr, ops, postOpsArgs, dims, dims.size() - 1, isINT8, 1 << (dims.size() - 1), getDQScales(), withBiases);
+    DnnlPostOpsComposerLegacy dnnlpoc(getEngine(),
+                                      attr,
+                                      ops,
+                                      postOpsArgs,
+                                      dims,
+                                      dims.size() - 1,
+                                      isINT8,
+                                      1 << (dims.size() - 1),
+                                      getDQScales(),
+                                      withBiases);
 
     for (size_t i = 0; i < fusedWith.size(); ++i) {
         auto& node = fusedWith[i];
@@ -196,7 +208,7 @@ void MatMul::setPostOps(dnnl::primitive_attr& attr, const VectorDims& dims, bool
     attr.set_post_ops(ops);
 }
 
-Node::AttrPtr MatMul::initPrimitiveAttr(const VectorDims &dims) {
+Node::AttrPtr MatMul::initPrimitiveAttr(const VectorDims& dims) {
     auto attr = std::make_shared<dnnl::primitive_attr>(dnnl::primitive_attr());
 
     setPostOps(*attr, dims, true);
@@ -228,7 +240,7 @@ static VectorDims getStridesAndModifyShape(Shape& shape, const bool transpose) {
     VectorDims strides(getRank, 1);
     const auto& staticDims = shape.getStaticDims();
     for (size_t i = 1; i < getRank; i++) {
-        strides[getRank - i - 1 ] = strides[getRank - i] * staticDims[getRank - i];
+        strides[getRank - i - 1] = strides[getRank - i] * staticDims[getRank - i];
     }
 
     if (transpose && getRank > 1) {
@@ -271,8 +283,13 @@ void MatMul::getSupportedDescriptors() {
         firstInPortPrec = secondInPortPrec = getMaxPrecision(getOriginalInputPrecisions());
 
     // fallback to fp32 for any precision that cannot be handled natively
-    if ((!one_of(firstInPortPrec , ov::element::u8, ov::element::i8, ov::element::bf16, ov::element::f16, ov::element::f32) ||
-         !one_of(secondInPortPrec , ov::element::i8, ov::element::bf16, ov::element::f16, ov::element::f32))) {
+    if ((!one_of(firstInPortPrec,
+                 ov::element::u8,
+                 ov::element::i8,
+                 ov::element::bf16,
+                 ov::element::f16,
+                 ov::element::f32) ||
+         !one_of(secondInPortPrec, ov::element::i8, ov::element::bf16, ov::element::f16, ov::element::f32))) {
         outPortPrec = firstInPortPrec = secondInPortPrec = ov::element::f32;
     }
 
@@ -315,16 +332,13 @@ void MatMul::getSupportedDescriptors() {
     const auto& outDims = getOutputShapeAtPort(0).getDims();
 
     // coverity[copy_paste_error]
-    if (!dimsEqualWeak(inDims0[xAxis0], inDims1[yAxis1]) ||
-        !dimsEqualWeak(inDims0[yAxis0], outDims[yAxis]) ||
+    if (!dimsEqualWeak(inDims0[xAxis0], inDims1[yAxis1]) || !dimsEqualWeak(inDims0[yAxis0], outDims[yAxis]) ||
         !dimsEqualWeak(inDims1[xAxis1], outDims[xAxis]))
         OPENVINO_THROW(errorPrefix, " has incorrect spatial input and output dimensions");
 
     for (int dim_idx = nDims - 3; dim_idx >= 0; dim_idx--) {
-        if ((!dimsEqualWeak(inDims0[dim_idx], outDims[dim_idx]) &&
-             !dimsEqualWeak(inDims0[dim_idx], 1)) ||
-            (!dimsEqualWeak(inDims1[dim_idx], outDims[dim_idx]) &&
-             !dimsEqualWeak(inDims1[dim_idx], 1))) {
+        if ((!dimsEqualWeak(inDims0[dim_idx], outDims[dim_idx]) && !dimsEqualWeak(inDims0[dim_idx], 1)) ||
+            (!dimsEqualWeak(inDims1[dim_idx], outDims[dim_idx]) && !dimsEqualWeak(inDims1[dim_idx], 1))) {
             OPENVINO_THROW(errorPrefix, " has incorrect input batch dimensions");
         }
     }
@@ -346,7 +360,7 @@ void MatMul::getSupportedDescriptors() {
 
     inDataDesc[0] = std::make_shared<DnnlBlockedMemoryDesc>(firstInPortPrec, staticInputShapes[0], inStrides0);
     inDataDesc[1] = std::make_shared<DnnlBlockedMemoryDesc>(secondInPortPrec, staticInputShapes[1], inStrides1);
-    outDataDesc   = std::make_shared<DnnlBlockedMemoryDesc>(outPortPrec, staticOutputShape);
+    outDataDesc = std::make_shared<DnnlBlockedMemoryDesc>(outPortPrec, staticOutputShape);
 
     createDescriptor({inDataDesc[0], inDataDesc[1]}, {outDataDesc});
 }
@@ -357,7 +371,7 @@ std::pair<Shape, Shape> MatMul::makeDummyInputShapes(const Shape& in0, const Sha
     }
 
     OPENVINO_ASSERT((in0.getRank() == in1.getRank()) && (in1.getRank() == out.getRank()),
-        "Can't create dummy inputs if argument shapes ranks are not equal");
+                    "Can't create dummy inputs if argument shapes ranks are not equal");
 
     auto swapTranspDims = [&](VectorDims& in0, VectorDims& in1) {
         if (transposeIn[0]) {
@@ -384,7 +398,8 @@ std::pair<Shape, Shape> MatMul::makeDummyInputShapes(const Shape& in0, const Sha
     auto fillDummy = [&](size_t idx0, size_t idx1) {
         if (inDims0[idx0] == Shape::UNDEFINED_DIM && inDims1[idx1] == Shape::UNDEFINED_DIM) {
             inDims0[idx0] = inDims1[idx1] = std::min(std::min(maxDims0[idx0], maxDims1[idx1]),
-                                            std::max(std::max(minDims0[idx0], minDims1[idx1]), static_cast<Dim>(MemoryDescUtils::DEFAULT_DUMMY_VAL)));
+                                                     std::max(std::max(minDims0[idx0], minDims1[idx1]),
+                                                              static_cast<Dim>(MemoryDescUtils::DEFAULT_DUMMY_VAL)));
         } else {
             if (inDims0[idx0] == Shape::UNDEFINED_DIM && inDims1[idx1] != Shape::UNDEFINED_DIM) {
                 if (inDims1[idx1] == 1 && minDims0[idx0] != Shape::UNDEFINED_DIM) {
@@ -409,15 +424,17 @@ std::pair<Shape, Shape> MatMul::makeDummyInputShapes(const Shape& in0, const Sha
     if (outDims[outDims.size() - 2] != Shape::UNDEFINED_DIM) {
         inDims0[inDims0.size() - 2] = outDims[outDims.size() - 2];
     } else if (inDims0[inDims0.size() - 2] == Shape::UNDEFINED_DIM) {
-        inDims0[inDims0.size() - 2] = std::min(maxDims0[inDims0.size() - 2],
-                                               std::max(minDims0[inDims0.size() - 2], static_cast<Dim>(MemoryDescUtils::DEFAULT_DUMMY_VAL)));
+        inDims0[inDims0.size() - 2] =
+            std::min(maxDims0[inDims0.size() - 2],
+                     std::max(minDims0[inDims0.size() - 2], static_cast<Dim>(MemoryDescUtils::DEFAULT_DUMMY_VAL)));
     }
 
     if (outDims[outDims.size() - 1] != Shape::UNDEFINED_DIM) {
         inDims1[inDims1.size() - 1] = outDims[outDims.size() - 1];
     } else if (inDims1[inDims1.size() - 1] == Shape::UNDEFINED_DIM) {
-        inDims1[inDims1.size() - 1] = std::min(maxDims1[inDims1.size() - 1],
-                                               std::max(minDims1[inDims1.size() - 1], static_cast<Dim>(MemoryDescUtils::DEFAULT_DUMMY_VAL)));
+        inDims1[inDims1.size() - 1] =
+            std::min(maxDims1[inDims1.size() - 1],
+                     std::max(minDims1[inDims1.size() - 1], static_cast<Dim>(MemoryDescUtils::DEFAULT_DUMMY_VAL)));
     }
 
     // fill batches
@@ -440,20 +457,18 @@ void MatMul::createDescriptor(const std::vector<MemoryDescPtr>& inputDesc,
     const auto attr = initPrimitiveAttr();
     dnnl::matmul::primitive_desc matmul_desc;
     if (withBiases) {
-        matmul_desc = matmul::primitive_desc(
-            getEngine(),
-            inDataDesc[0]->getDnnlDesc(),
-            inDataDesc[1]->getDnnlDesc(),
-            getBiasDescFrom(outDataDesc),
-            outDataDesc->getDnnlDesc(),
-            *attr);
+        matmul_desc = matmul::primitive_desc(getEngine(),
+                                             inDataDesc[0]->getDnnlDesc(),
+                                             inDataDesc[1]->getDnnlDesc(),
+                                             getBiasDescFrom(outDataDesc),
+                                             outDataDesc->getDnnlDesc(),
+                                             *attr);
     } else {
-        matmul_desc = matmul::primitive_desc(
-            getEngine(),
-            inDataDesc[0]->getDnnlDesc(),
-            inDataDesc[1]->getDnnlDesc(),
-            outDataDesc->getDnnlDesc(),
-            *attr);
+        matmul_desc = matmul::primitive_desc(getEngine(),
+                                             inDataDesc[0]->getDnnlDesc(),
+                                             inDataDesc[1]->getDnnlDesc(),
+                                             outDataDesc->getDnnlDesc(),
+                                             *attr);
     }
 
     descs.emplace_back(matmul_desc);
@@ -486,43 +501,54 @@ void MatMul::initSupportedPrimitiveDescriptors() {
     };
 #ifdef CPU_DEBUG_CAPS
     {
-       if (!customImplPriorities.empty()) {
-            DEBUG_LOG("#", getName(), " customImplPriorities [", 0 , "/", customImplPriorities.size(),
-                        "]: ", impl_type_to_string(customImplPriorities[0]));
-       }
+        if (!customImplPriorities.empty()) {
+            DEBUG_LOG("#",
+                      getName(),
+                      " customImplPriorities [",
+                      0,
+                      "/",
+                      customImplPriorities.size(),
+                      "]: ",
+                      impl_type_to_string(customImplPriorities[0]));
+        }
     }
 #endif
     for (auto& desc : descs) {
         auto first_desc = dnnl::primitive_desc(DnnlExtensionUtils::clone_primitive_desc(desc.get()));
         const bool first_match = customImplPriorities.empty();
-        DEBUG_LOG("#", getName(),
-                ", itpd.impl_info_str(): ", desc.impl_info_str(),
-            ", parsed imp_type: ", impl_type_to_string(parse_impl_name(desc.impl_info_str())),
-            ", first_match: ", first_match ? "true" : "false");
-        DnnlExtensionUtils::for_each_implementation(desc,
-                                                    first_match,
-                                                    [&](impl_desc_type implType) {
-                                                        return contains(getImplPriority(), implType);
-                                                    },
-                                                    [&](dnnl::primitive_desc& desc) {
-                                                        addSupportedPrimitiveDescriptor(desc);
-                                                    });
+        DEBUG_LOG("#",
+                  getName(),
+                  ", itpd.impl_info_str(): ",
+                  desc.impl_info_str(),
+                  ", parsed imp_type: ",
+                  impl_type_to_string(parse_impl_name(desc.impl_info_str())),
+                  ", first_match: ",
+                  first_match ? "true" : "false");
+        DnnlExtensionUtils::for_each_implementation(
+            desc,
+            first_match,
+            [&](impl_desc_type implType) {
+                return contains(getImplPriority(), implType);
+            },
+            [&](dnnl::primitive_desc& desc) {
+                addSupportedPrimitiveDescriptor(desc);
+            });
 
         // fallback. if none of the primitive types is present in the priority list just add first implementation
         // @todo this fallback is not necessary if primitive priority list is filled correctly
         if (supportedPrimitiveDescriptors.empty())
             addSupportedPrimitiveDescriptor(first_desc);
-   }
+    }
 }
 
-MemoryDescPtr MatMul::getSrcMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const {
-    auto desc = idx > 0 ? prim_desc.weights_desc(idx - 1): prim_desc.src_desc(idx);
+MemoryDescPtr MatMul::getSrcMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const {
+    auto desc = idx > 0 ? prim_desc.weights_desc(idx - 1) : prim_desc.src_desc(idx);
 
-    if (idx < 2) // inputs
+    if (idx < 2)  // inputs
         return std::make_shared<CpuBlockedMemoryDesc>(
             DnnlExtensionUtils::DataTypeToElementType(desc.get_data_type()),
             getInputShapeAtPort(idx)); /* provide initial shapes, so hide transpose effect */
-    else // bias
+    else                               // bias
         return DnnlExtensionUtils::makeDescriptor(desc);
 }
 
@@ -552,7 +578,7 @@ void MatMul::prepareParams() {
         // todo: obviously we need a special executor that would process fused ops providing a correct result
         OPENVINO_ASSERT(!withBiases && fusedWith.empty(),
                         "Matmul doesn't support a degenerate case when other ops are fused");
-        //reset executor
+        // reset executor
         execPtr.reset();
         return;
     }
@@ -595,8 +621,12 @@ void MatMul::prepareParams() {
         dnnlBiasMemDesc = biasMemory->getDescWithType<DnnlMemoryDesc>();
     }
 
-    MatMulKey key = {src0TransposedDesc, src1TransposedDesc, dnnlBiasMemDesc,
-                     dstDnnlDesc, *attr, selected_pd->getImplementationType()};
+    MatMulKey key = {src0TransposedDesc,
+                     src1TransposedDesc,
+                     dnnlBiasMemDesc,
+                     dstDnnlDesc,
+                     *attr,
+                     selected_pd->getImplementationType()};
 
     auto engine = getEngine();
 
@@ -604,20 +634,18 @@ void MatMul::prepareParams() {
         dnnl::matmul::primitive_desc prim_desc;
 
         if (key.bias) {
-            prim_desc = matmul::primitive_desc(
-                engine,
-                key.inp0->getDnnlDesc(),
-                key.inp1->getDnnlDesc(),
-                key.bias->getDnnlDesc(),
-                key.out->getDnnlDesc(),
-                key.attr);
+            prim_desc = matmul::primitive_desc(engine,
+                                               key.inp0->getDnnlDesc(),
+                                               key.inp1->getDnnlDesc(),
+                                               key.bias->getDnnlDesc(),
+                                               key.out->getDnnlDesc(),
+                                               key.attr);
         } else {
-            prim_desc = matmul::primitive_desc(
-                engine,
-                key.inp0->getDnnlDesc(),
-                key.inp1->getDnnlDesc(),
-                key.out->getDnnlDesc(),
-                key.attr);
+            prim_desc = matmul::primitive_desc(engine,
+                                               key.inp0->getDnnlDesc(),
+                                               key.inp1->getDnnlDesc(),
+                                               key.out->getDnnlDesc(),
+                                               key.attr);
         }
 
         auto first_desc = dnnl::matmul::primitive_desc(prim_desc.get());
@@ -674,34 +702,20 @@ void MatMul::executeDynamicImpl(dnnl::stream strm) {
 
 const std::vector<impl_desc_type>& MatMul::getDefaultImplPriority() {
     static const std::vector<impl_desc_type> priorities = {
-        impl_desc_type::unknown,
-        impl_desc_type::brgemm_avx512_amx,
-        impl_desc_type::brgemm_avx512,
-        impl_desc_type::brgemm_avx2,
-        impl_desc_type::gemm_acl,
-        impl_desc_type::gemm_blas,
-        impl_desc_type::gemm_avx512,
-        impl_desc_type::gemm_avx2,
-        impl_desc_type::gemm_avx,
-        impl_desc_type::gemm_sse42,
-        impl_desc_type::gemm_any,
-        impl_desc_type::gemm,
-        impl_desc_type::jit_gemm,
-        impl_desc_type::jit_uni_dw,
-        impl_desc_type::jit_uni_1x1,
-        impl_desc_type::jit_uni,
-        impl_desc_type::jit_avx512_dw,
-        impl_desc_type::jit_avx512_1x1,
-        impl_desc_type::jit_avx512,
-        impl_desc_type::jit_avx2_dw,
-        impl_desc_type::jit_avx2_1x1,
-        impl_desc_type::jit_avx2,
-        impl_desc_type::jit_avx_dw,
-        impl_desc_type::jit_avx_1x1,
-        impl_desc_type::jit_avx,
-        impl_desc_type::jit_sse42_dw,
-        impl_desc_type::jit_sse42_1x1,
-        impl_desc_type::jit_sse42,
+        impl_desc_type::unknown,       impl_desc_type::brgemm_avx512_amx,
+        impl_desc_type::brgemm_avx512, impl_desc_type::brgemm_avx2,
+        impl_desc_type::gemm_acl,      impl_desc_type::gemm_blas,
+        impl_desc_type::gemm_avx512,   impl_desc_type::gemm_avx2,
+        impl_desc_type::gemm_avx,      impl_desc_type::gemm_sse42,
+        impl_desc_type::gemm_any,      impl_desc_type::gemm,
+        impl_desc_type::jit_gemm,      impl_desc_type::jit_uni_dw,
+        impl_desc_type::jit_uni_1x1,   impl_desc_type::jit_uni,
+        impl_desc_type::jit_avx512_dw, impl_desc_type::jit_avx512_1x1,
+        impl_desc_type::jit_avx512,    impl_desc_type::jit_avx2_dw,
+        impl_desc_type::jit_avx2_1x1,  impl_desc_type::jit_avx2,
+        impl_desc_type::jit_avx_dw,    impl_desc_type::jit_avx_1x1,
+        impl_desc_type::jit_avx,       impl_desc_type::jit_sse42_dw,
+        impl_desc_type::jit_sse42_1x1, impl_desc_type::jit_sse42,
         impl_desc_type::ref,
     };
 
@@ -712,6 +726,6 @@ bool MatMul::isExecutable() const {
     return !hasEmptyOutputTensors();
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/matmul.h b/src/plugins/intel_cpu/src/nodes/matmul.h
index 2e487148d0ec0c..74dc7cb3701f04 100644
--- a/src/plugins/intel_cpu/src/nodes/matmul.h
+++ b/src/plugins/intel_cpu/src/nodes/matmul.h
@@ -4,12 +4,12 @@
 
 #pragma once
 
+#include <array>
+
 #include "common/dnnl_executor.h"
 #include "memory_desc/dnnl_blocked_memory_desc.h"
 #include "node.h"
 
-#include <array>
-
 namespace ov {
 namespace intel_cpu {
 namespace node {
@@ -22,7 +22,7 @@ class MatMul : public Node {
     void createDescriptor(const std::vector<MemoryDescPtr>& inputDesc,
                           const std::vector<MemoryDescPtr>& outputDesc) override;
     void initSupportedPrimitiveDescriptors() override;
-    MemoryDescPtr getSrcMemDesc(const dnnl::primitive_desc &prim_desc, size_t idx) const override;
+    MemoryDescPtr getSrcMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const override;
     bool canFuse(const NodePtr& node) const override;
     bool created() const override;
 
@@ -53,12 +53,11 @@ class MatMul : public Node {
     using executorPtr = std::shared_ptr<DnnlExecutor>;
     executorPtr execPtr = nullptr;
     dnnl::memory::desc getBiasDescFrom(const DnnlMemoryDescCPtr outMemDesc);
-    std::pair<Shape, Shape>
-    makeDummyInputShapes(const Shape& in0, const Shape& in1, const Shape& out) const;
+    std::pair<Shape, Shape> makeDummyInputShapes(const Shape& in0, const Shape& in1, const Shape& out) const;
 
     bool withBiases;
 
-    void setPostOps(dnnl::primitive_attr &attr, const VectorDims& dims, bool initWeights);
+    void setPostOps(dnnl::primitive_attr& attr, const VectorDims& dims, bool initWeights);
 
     std::string errorPrefix;
 
@@ -69,6 +68,6 @@ class MatMul : public Node {
     DnnlBlockedMemoryDescPtr outDataDesc;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/matrix_nms.cpp b/src/plugins/intel_cpu/src/nodes/matrix_nms.cpp
index 354ac92f9272cb..1af712dde906a0 100644
--- a/src/plugins/intel_cpu/src/nodes/matrix_nms.cpp
+++ b/src/plugins/intel_cpu/src/nodes/matrix_nms.cpp
@@ -3,7 +3,6 @@
 //
 
 #include "matrix_nms.h"
-#include "ov_ops/nms_static_shape_ie.hpp"
 
 #include <algorithm>
 #include <chrono>
@@ -13,8 +12,9 @@
 
 #include "openvino/core/parallel.hpp"
 #include "openvino/opsets/opset8.hpp"
-#include "utils/general_utils.h"
+#include "ov_ops/nms_static_shape_ie.hpp"
 #include "shape_inference/shape_inference_internal_dyn.hpp"
+#include "utils/general_utils.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -119,12 +119,20 @@ void MatrixNms::initSupportedPrimitiveDescriptors() {
     checkPrecision(getOriginalInputPrecisionAtPort(NMS_BOXES), supportedFloatPrecision, "boxes", m_inType);
     checkPrecision(getOriginalInputPrecisionAtPort(NMS_SCORES), supportedFloatPrecision, "scores", m_inType);
 
-    checkPrecision(getOriginalOutputPrecisionAtPort(NMS_SELECTED_INDICES), supportedIntOutputPrecision, "selected_indices", m_outType);
-    checkPrecision(getOriginalOutputPrecisionAtPort(NMS_SELECTED_OUTPUTS), supportedFloatPrecision, "selected_outputs", m_outType);
-    checkPrecision(getOriginalOutputPrecisionAtPort(NMS_VALID_OUTPUTS), supportedIntOutputPrecision, "valid_outputs", m_outType);
-
-    addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32},
-                          {LayoutType::ncsp, ov::element::f32}},
+    checkPrecision(getOriginalOutputPrecisionAtPort(NMS_SELECTED_INDICES),
+                   supportedIntOutputPrecision,
+                   "selected_indices",
+                   m_outType);
+    checkPrecision(getOriginalOutputPrecisionAtPort(NMS_SELECTED_OUTPUTS),
+                   supportedFloatPrecision,
+                   "selected_outputs",
+                   m_outType);
+    checkPrecision(getOriginalOutputPrecisionAtPort(NMS_VALID_OUTPUTS),
+                   supportedIntOutputPrecision,
+                   "valid_outputs",
+                   m_outType);
+
+    addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32}, {LayoutType::ncsp, ov::element::f32}},
                          {{LayoutType::ncsp, ov::element::f32},
                           {LayoutType::ncsp, ov::element::i32},
                           {LayoutType::ncsp, ov::element::i32}},
@@ -170,7 +178,11 @@ static inline float intersectionOverUnion(const float* bbox1, const float* bbox2
 }
 }  // namespace
 
-size_t MatrixNms::nmsMatrix(const float* boxesData, const float* scoresData, BoxInfo* filterBoxes, const int64_t batchIdx, const int64_t classIdx) {
+size_t MatrixNms::nmsMatrix(const float* boxesData,
+                            const float* scoresData,
+                            BoxInfo* filterBoxes,
+                            const int64_t batchIdx,
+                            const int64_t classIdx) {
     std::vector<int32_t> candidateIndex(m_numBoxes);
     std::iota(candidateIndex.begin(), candidateIndex.end(), 0);
     auto end = std::remove_if(candidateIndex.begin(), candidateIndex.end(), [&scoresData, this](int32_t idx) {
@@ -185,9 +197,12 @@ size_t MatrixNms::nmsMatrix(const float* boxesData, const float* scoresData, Box
         originalSize = m_nmsTopk;
     }
 
-    std::partial_sort(candidateIndex.begin(), candidateIndex.begin() + originalSize, end, [&scoresData](int32_t a, int32_t b) {
-        return scoresData[a] > scoresData[b];
-    });
+    std::partial_sort(candidateIndex.begin(),
+                      candidateIndex.begin() + originalSize,
+                      end,
+                      [&scoresData](int32_t a, int32_t b) {
+                          return scoresData[a] > scoresData[b];
+                      });
 
     std::vector<float> iouMatrix((originalSize * (originalSize - 1)) >> 1);
     std::vector<float> iouMax(originalSize);
@@ -259,8 +274,9 @@ void MatrixNms::prepareParams() {
     m_numClasses = scores_dims[1];
 
     int64_t max_output_boxes_per_class = 0;
-    size_t real_num_classes = m_backgroundClass == -1 ? m_numClasses :
-        static_cast<size_t>(m_backgroundClass) < m_numClasses ? m_numClasses - 1 : m_numClasses;
+    size_t real_num_classes = m_backgroundClass == -1                                 ? m_numClasses
+                              : static_cast<size_t>(m_backgroundClass) < m_numClasses ? m_numClasses - 1
+                                                                                      : m_numClasses;
     if (m_nmsTopk >= 0)
         max_output_boxes_per_class = std::min(m_numBoxes, static_cast<size_t>(m_nmsTopk));
     else
@@ -275,7 +291,7 @@ void MatrixNms::prepareParams() {
     m_numPerBatch.resize(m_numBatches);
     m_filteredBoxes.resize(m_numBatches * m_realNumClasses * m_realNumBoxes);
     m_numPerBatchClass.resize(m_numBatches);
-    for (auto &numPerBatch : m_numPerBatchClass) {
+    for (auto& numPerBatch : m_numPerBatchClass) {
         numPerBatch.resize(m_numClasses, 0);
     }
     m_classOffset.resize(m_numClasses, 0);
@@ -312,7 +328,11 @@ void MatrixNms::execute(dnnl::stream strm) {
         const float* scoresPtr = scores + batchIdx * (m_numClasses * m_numBoxes) + classIdx * m_numBoxes;
         size_t classNumDet = 0;
         size_t batchOffset = batchIdx * m_realNumClasses * m_realNumBoxes;
-        classNumDet = nmsMatrix(boxesPtr, scoresPtr, m_filteredBoxes.data() + batchOffset + m_classOffset[classIdx], batchIdx, classIdx);
+        classNumDet = nmsMatrix(boxesPtr,
+                                scoresPtr,
+                                m_filteredBoxes.data() + batchOffset + m_classOffset[classIdx],
+                                batchIdx,
+                                classIdx);
         m_numPerBatchClass[batchIdx][classIdx] = classNumDet;
     });
 
@@ -336,10 +356,14 @@ void MatrixNms::execute(dnnl::stream strm) {
                 keepNum = m_keepTopk;
         }
 
-        std::partial_sort(batchFilteredBox, batchFilteredBox + keepNum, batchFilteredBox + numDet, [](const BoxInfo& lhs, const BoxInfo rhs) {
-            return lhs.score > rhs.score || (lhs.score == rhs.score && lhs.classIndex < rhs.classIndex) ||
-                   (lhs.score == rhs.score && lhs.classIndex == rhs.classIndex && lhs.index < rhs.index);
-        });
+        std::partial_sort(
+            batchFilteredBox,
+            batchFilteredBox + keepNum,
+            batchFilteredBox + numDet,
+            [](const BoxInfo& lhs, const BoxInfo rhs) {
+                return lhs.score > rhs.score || (lhs.score == rhs.score && lhs.classIndex < rhs.classIndex) ||
+                       (lhs.score == rhs.score && lhs.classIndex == rhs.classIndex && lhs.index < rhs.index);
+            });
         m_numPerBatch[batchIdx] = keepNum;
     });
 
@@ -354,17 +378,26 @@ void MatrixNms::execute(dnnl::stream strm) {
 
     if (m_sortResultAcrossBatch) { /* sort across batch */
         if (m_sortResultType == MatrixNmsSortResultType::SCORE) {
-            parallel_sort(m_filteredBoxes.begin(), m_filteredBoxes.begin() + startOffset, [](const BoxInfo& l, const BoxInfo& r) {
-                return (l.score > r.score) || (l.score == r.score && l.batchIndex < r.batchIndex) ||
-                       (l.score == r.score && l.batchIndex == r.batchIndex && l.classIndex < r.classIndex) ||
-                       (l.score == r.score && l.batchIndex == r.batchIndex && l.classIndex == r.classIndex && l.index < r.index);
-            });
+            parallel_sort(
+                m_filteredBoxes.begin(),
+                m_filteredBoxes.begin() + startOffset,
+                [](const BoxInfo& l, const BoxInfo& r) {
+                    return (l.score > r.score) || (l.score == r.score && l.batchIndex < r.batchIndex) ||
+                           (l.score == r.score && l.batchIndex == r.batchIndex && l.classIndex < r.classIndex) ||
+                           (l.score == r.score && l.batchIndex == r.batchIndex && l.classIndex == r.classIndex &&
+                            l.index < r.index);
+                });
         } else if (m_sortResultType == MatrixNmsSortResultType::CLASSID) {
-            parallel_sort(m_filteredBoxes.begin(), m_filteredBoxes.begin() + startOffset, [](const BoxInfo& l, const BoxInfo& r) {
-                return (l.classIndex < r.classIndex) || (l.classIndex == r.classIndex && l.batchIndex < r.batchIndex) ||
-                       (l.classIndex == r.classIndex && l.batchIndex == r.batchIndex && l.score > r.score) ||
-                       (l.classIndex == r.classIndex && l.batchIndex == r.batchIndex && l.score == r.score && l.index < r.index);
-            });
+            parallel_sort(
+                m_filteredBoxes.begin(),
+                m_filteredBoxes.begin() + startOffset,
+                [](const BoxInfo& l, const BoxInfo& r) {
+                    return (l.classIndex < r.classIndex) ||
+                           (l.classIndex == r.classIndex && l.batchIndex < r.batchIndex) ||
+                           (l.classIndex == r.classIndex && l.batchIndex == r.batchIndex && l.score > r.score) ||
+                           (l.classIndex == r.classIndex && l.batchIndex == r.batchIndex && l.score == r.score &&
+                            l.index < r.index);
+                });
         }
     }
 
@@ -412,11 +445,14 @@ void MatrixNms::execute(dnnl::stream strm) {
     }
 }
 
-void MatrixNms::checkPrecision(const ov::element::Type prec, const std::vector<ov::element::Type> precList, const std::string name, const std::string type) {
+void MatrixNms::checkPrecision(const ov::element::Type prec,
+                               const std::vector<ov::element::Type> precList,
+                               const std::string name,
+                               const std::string type) {
     if (std::find(precList.begin(), precList.end(), prec) == precList.end())
         OPENVINO_THROW(m_errorPrefix, "has unsupported '", name, "' ", type, " precision: ", prec);
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/matrix_nms.h b/src/plugins/intel_cpu/src/nodes/matrix_nms.h
index 6afa9c09c751c1..0acc85078644d4 100644
--- a/src/plugins/intel_cpu/src/nodes/matrix_nms.h
+++ b/src/plugins/intel_cpu/src/nodes/matrix_nms.h
@@ -22,7 +22,7 @@ class MatrixNms : public Node {
 public:
     MatrixNms(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -32,7 +32,9 @@ class MatrixNms : public Node {
     bool isExecutable() const override;
     void executeDynamicImpl(dnnl::stream strm) override;
 
-    bool needShapeInfer() const override { return false; }
+    bool needShapeInfer() const override {
+        return false;
+    }
     void prepareParams() override;
 
 private:
@@ -64,7 +66,11 @@ class MatrixNms : public Node {
     bool m_outStaticShape = false;
 
     struct Rectangle {
-        Rectangle(float x_left, float y_left, float x_right, float y_right) : x1 {x_left}, y1 {y_left}, x2 {x_right}, y2 {y_right} {}
+        Rectangle(float x_left, float y_left, float x_right, float y_right)
+            : x1{x_left},
+              y1{y_left},
+              x2{x_right},
+              y2{y_right} {}
 
         Rectangle() = default;
 
@@ -76,7 +82,11 @@ class MatrixNms : public Node {
 
     struct BoxInfo {
         BoxInfo(const Rectangle& r, int64_t idx, float sc, int64_t batch_idx, int64_t class_idx)
-            : box {r}, index {idx}, batchIndex {batch_idx}, classIndex {class_idx}, score {sc} {}
+            : box{r},
+              index{idx},
+              batchIndex{batch_idx},
+              classIndex{class_idx},
+              score{sc} {}
 
         BoxInfo() = default;
 
@@ -95,12 +105,18 @@ class MatrixNms : public Node {
     size_t m_realNumClasses = 0;
     size_t m_realNumBoxes = 0;
     float (*m_decay_fn)(float, float, float) = nullptr;
-    void checkPrecision(const ov::element::Type prec, const std::vector<ov::element::Type> precList, const std::string name,
+    void checkPrecision(const ov::element::Type prec,
+                        const std::vector<ov::element::Type> precList,
+                        const std::string name,
                         const std::string type);
 
-    size_t nmsMatrix(const float* boxesData, const float* scoresData, BoxInfo* filterBoxes, const int64_t batchIdx, const int64_t classIdx);
+    size_t nmsMatrix(const float* boxesData,
+                     const float* scoresData,
+                     BoxInfo* filterBoxes,
+                     const int64_t batchIdx,
+                     const int64_t classIdx);
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/memory.cpp b/src/plugins/intel_cpu/src/nodes/memory.cpp
index b43085f3e62f96..5a0bd7a1e3dff1 100644
--- a/src/plugins/intel_cpu/src/nodes/memory.cpp
+++ b/src/plugins/intel_cpu/src/nodes/memory.cpp
@@ -2,15 +2,17 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "memory.hpp"
+
 #include <string>
-#include "dnnl_types.h"
+
+#include "common/arbitrary_order_desc_creator.h"
 #include "dnnl_extension_utils.h"
-#include "memory.hpp"
-#include "scaled_attn.h"
-#include "utils/general_utils.h"
+#include "dnnl_types.h"
 #include "memory_desc/cpu_memory_desc_utils.h"
+#include "scaled_attn.h"
 #include "shape_inference/shape_inference_pass_through.hpp"
-#include "common/arbitrary_order_desc_creator.h"
+#include "utils/general_utils.h"
 
 using namespace dnnl;
 
@@ -99,13 +101,14 @@ class MemoryStub : public IMemory {
     MemoryDescPtr m_pMemDesc;
     std::shared_ptr<MemoryBlockStub> m_pMemoryBlock;
 };
-} // namespace
+}  // namespace
 
-bool MemoryOutputBase::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool MemoryOutputBase::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                            std::string& errorMessage) noexcept {
     try {
         if (!one_of(op->get_type_info(),
-                ov::op::v3::Assign::get_type_info_static(),
-                ov::op::v6::Assign::get_type_info_static())) {
+                    ov::op::v3::Assign::get_type_info_static(),
+                    ov::op::v6::Assign::get_type_info_static())) {
             errorMessage = "Node is not an instance of Assign from the operation set v3 or v6.";
             return false;
         }
@@ -116,7 +119,8 @@ bool MemoryOutputBase::isSupportedOperation(const std::shared_ptr<const ov::Node
 }
 
 MemoryOutputBase::MemoryOutputBase(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
-    : Node(op, context, NgraphShapeInferFactory(op)), MemoryNode(op) {
+    : Node(op, context, NgraphShapeInferFactory(op)),
+      MemoryNode(op) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
@@ -131,8 +135,9 @@ MemoryOutputBase::MemoryOutputBase(const std::string id,
                                    const std::string& type,
                                    const Shape& input_shape,
                                    const ov::element::Type& input_prc,
-                                   const GraphContext::CPtr context) :
-    Node(type, {input_shape}, {}, {input_prc}, {}, name, context), MemoryNode(id) {
+                                   const GraphContext::CPtr context)
+    : Node(type, {input_shape}, {}, {input_prc}, {}, name, context),
+      MemoryNode(id) {
     isDynamic = input_shape.isDynamic();
     if (isDynamic) {
         shapeInference = PassThroughShapeInferFactory().makeShapeInfer();
@@ -143,7 +148,9 @@ MemoryOutputBase::MemoryOutputBase(const std::string id,
 }
 
 MemoryOutputBase::~MemoryOutputBase() {
-    if (inputNode) { inputNode->deregisterSibling(this); }
+    if (inputNode) {
+        inputNode->deregisterSibling(this);
+    }
     context->getMemoryStatesRegister()->remove(this);
 }
 
@@ -180,27 +187,30 @@ void MemoryOutputBase::initOptimalPrimitiveDescriptor() {
     auto parent = parentEdge->getParent();
     auto parentPd = parent->getSelectedPrimitiveDescriptor();
     OPENVINO_ASSERT(parentPd,
-        parent->getTypeStr(), " ",
-        parent->getName(),
-        "failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
+                    parent->getTypeStr(),
+                    " ",
+                    parent->getName(),
+                    "failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
 
     const auto& parentConfig = parentPd->getConfig();
     auto mem_desc = parentConfig.outConfs[parentEdge->getInputNum()].getMemDesc();
 
     auto selected_pd = getSelectedPrimitiveDescriptor();
     OPENVINO_ASSERT(selected_pd,
-        "MemoryOutput ",
-        getName(),
-        " failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
+                    "MemoryOutput ",
+                    getName(),
+                    " failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
 
     auto config = selected_pd->getConfig();
 
     const bool parentInplaceConflict = parent->inPlaceOutPort(parentEdge->getInputNum()) >= 0;
 
-    //disable inPlace to avoid inPlace conflict and handle memory copy internally (to get room for optimizations)
-    if (parentInplaceConflict) { config.inConfs.front().inPlace(-1); }
+    // disable inPlace to avoid inPlace conflict and handle memory copy internally (to get room for optimizations)
+    if (parentInplaceConflict) {
+        config.inConfs.front().inPlace(-1);
+    }
     config.inConfs.front().setMemDesc(mem_desc);
-    //bypass any checks, we enforce the parent descriptor
+    // bypass any checks, we enforce the parent descriptor
     selected_pd->setConfig(config);
 }
 
@@ -225,14 +235,20 @@ bool MemoryOutputBase::isExecutable() const {
 }
 
 void MemoryOutputBase::registerInputNode(MemoryInputBase* node) {
-    if (inputNode == node) { return; }
-    if (inputNode) { inputNode->deregisterSibling(this); }
+    if (inputNode == node) {
+        return;
+    }
+    if (inputNode) {
+        inputNode->deregisterSibling(this);
+    }
     inputNode = node;
     inputNode->registerOutputNode(this);
 }
 
 void MemoryOutputBase::deregisterSibling(MemoryInputBase* node) {
-    if (node == inputNode) { inputNode = nullptr; }
+    if (node == inputNode) {
+        inputNode = nullptr;
+    }
 }
 
 bool MemoryOutput::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
@@ -247,14 +263,15 @@ void MemoryOutput::resolveInPlaceEdges(Edge::LOOK look) {
 
     auto selected_pd = getSelectedPrimitiveDescriptor();
     OPENVINO_ASSERT(selected_pd,
-        "MemoryOutput ",
-        getName(),
-        " failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
+                    "MemoryOutput ",
+                    getName(),
+                    " failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
 
-    auto parentEdge = getParentEdgeAt(0); // always only one parent edge
+    auto parentEdge = getParentEdgeAt(0);  // always only one parent edge
 
     OPENVINO_ASSERT(one_of(parentEdge->getStatus(), Edge::Status::Uninitialized, Edge::Status::NotAllocated),
-        " Unexpected inplace resolve call to an allocated edge: ", *parentEdge);
+                    " Unexpected inplace resolve call to an allocated edge: ",
+                    *parentEdge);
 
     auto memDesc = selected_pd->getConfig().inConfs.front().getMemDesc();
     memBlock = std::make_shared<ProxyMemoryBlock>();
@@ -264,18 +281,14 @@ void MemoryOutput::resolveInPlaceEdges(Edge::LOOK look) {
 
 void MemoryOutput::assignExtMemory(const MemoryPtr& mem, const MemoryDescPtr& memDesc) {
     assignedMem = mem;
-    OPENVINO_ASSERT(assignedMem,
-        "MemoryOutput ",
-        getName(),
-        " assigned state has null memory ptr");
+    OPENVINO_ASSERT(assignedMem, "MemoryOutput ", getName(), " assigned state has null memory ptr");
 
     extMemDesc = memDesc;
-    OPENVINO_ASSERT(extMemDesc,
-        "MemoryOutput ",
-        getName(),
-        " assigned state has null base mem desc ptr");
+    OPENVINO_ASSERT(extMemDesc, "MemoryOutput ", getName(), " assigned state has null base mem desc ptr");
 
-    if (!memBlock) { return; } //nothing to do, edge memory isn't under control
+    if (!memBlock) {
+        return;
+    }  // nothing to do, edge memory isn't under control
     auto inpDesc = getBaseMemDescAtInputPort(0);
 
     if (inpDesc->isCompatible(*extMemDesc)) {
@@ -285,12 +298,9 @@ void MemoryOutput::assignExtMemory(const MemoryPtr& mem, const MemoryDescPtr& me
     }
 }
 
-void MemoryOutput::runStatic(dnnl::stream strm)  {
+void MemoryOutput::runStatic(dnnl::stream strm) {
     auto inputMem = getSrcMemoryAtPort(0);
-    OPENVINO_ASSERT(assignedMem,
-        "MemoryOutput ",
-        getName(),
-        " uninitialized assigned memory");
+    OPENVINO_ASSERT(assignedMem, "MemoryOutput ", getName(), " uninitialized assigned memory");
 
     if (inputMem->getData() != assignedMem->getData()) {
         assignedMem->load(*inputMem);
@@ -298,41 +308,36 @@ void MemoryOutput::runStatic(dnnl::stream strm)  {
 }
 
 void MemoryOutput::runDynamic(dnnl::stream strm) {
-    //first we have to resize the output memory
+    // first we have to resize the output memory
     auto inputMem = getSrcMemoryAtPort(0);
 
-    OPENVINO_ASSERT(assignedMem,
-        "MemoryOutput ",
-        getName(),
-        " uninitialized assigned memory");
+    OPENVINO_ASSERT(assignedMem, "MemoryOutput ", getName(), " uninitialized assigned memory");
 
     const auto& newShape = inputMem->getShape();
     const auto& stateShape = assignedMem->getShape();
 
     if (stateShape.isDynamic() || stateShape.getStaticDims() != newShape.getStaticDims()) {
-        OPENVINO_ASSERT(extMemDesc,
-            "MemoryOutput ",
-            getName(),
-            " uninitialized assigned memory");
+        OPENVINO_ASSERT(extMemDesc, "MemoryOutput ", getName(), " uninitialized assigned memory");
         auto newExternDesc = extMemDesc->cloneWithNewDims(newShape.getStaticDims());
         assignedMem->redefineDesc(newExternDesc);
     }
 
-    if (!newShape.hasZeroDims()) { // no need to copy data for empty tensor
+    if (!newShape.hasZeroDims()) {  // no need to copy data for empty tensor
         runStatic(strm);
     }
 }
 
-bool MemoryOutputStub::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool MemoryOutputStub::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                            std::string& errorMessage) noexcept {
     return MemoryOutputBase::isSupportedOperation(op, errorMessage);
 }
 
 void MemoryOutputStub::runStatic(dnnl::stream strm) {
-    //nothing to do
+    // nothing to do
 }
 
 void MemoryOutputStub::runDynamic(dnnl::stream strm) {
-    //nothing to do
+    // nothing to do
 }
 
 void MemoryOutputStub::resolveInPlaceEdges(Edge::LOOK look) {
@@ -343,14 +348,15 @@ void MemoryOutputStub::resolveInPlaceEdges(Edge::LOOK look) {
 
     auto selected_pd = getSelectedPrimitiveDescriptor();
     OPENVINO_ASSERT(selected_pd,
-        "MemoryOutput ",
-        getName(),
-        " failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
+                    "MemoryOutput ",
+                    getName(),
+                    " failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
 
-    auto parentEdge = getParentEdgeAt(0); // always only one parent edge
+    auto parentEdge = getParentEdgeAt(0);  // always only one parent edge
 
     OPENVINO_ASSERT(one_of(parentEdge->getStatus(), Edge::Status::Uninitialized, Edge::Status::NotAllocated),
-        " Unexpected inplace resolve call to an allocated edge: ", *parentEdge);
+                    " Unexpected inplace resolve call to an allocated edge: ",
+                    *parentEdge);
 
     auto memDesc = selected_pd->getConfig().inConfs.front().getMemDesc();
     // make a fake memory
@@ -359,14 +365,15 @@ void MemoryOutputStub::resolveInPlaceEdges(Edge::LOOK look) {
 }
 
 void MemoryOutputStub::assignExtMemory(const MemoryPtr& mem, const MemoryDescPtr& memDesc) {
-    //nothing to do
+    // nothing to do
 }
 
-bool MemoryInputBase::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool MemoryInputBase::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                           std::string& errorMessage) noexcept {
     try {
         if (!one_of(op->get_type_info(),
-                ov::op::v3::ReadValue::get_type_info_static(),
-                ov::op::v6::ReadValue::get_type_info_static())) {
+                    ov::op::v3::ReadValue::get_type_info_static(),
+                    ov::op::v6::ReadValue::get_type_info_static())) {
             errorMessage = "Node is not an instance of ReadValue from the operation set v3 or v6.";
             return false;
         }
@@ -429,7 +436,9 @@ MemoryInputBase::MemoryInputBase(const std::string id,
 }
 
 MemoryInputBase::~MemoryInputBase() {
-    if (outputNode) { outputNode->deregisterSibling(this); }
+    if (outputNode) {
+        outputNode->deregisterSibling(this);
+    }
     context->getMemoryStatesRegister()->remove(this);
 }
 
@@ -452,23 +461,28 @@ void MemoryInputBase::initSupportedPrimitiveDescriptors() {
     }
 
     const auto& outputShape = getOutputShapeAtPort(0);
-    config.outConfs.emplace_back(
-        descCreators.at(LayoutType::ncsp)->createSharedDesc(precision, outputShape),
-        BlockedMemoryDesc::FULL_MASK,
-        0);
+    config.outConfs.emplace_back(descCreators.at(LayoutType::ncsp)->createSharedDesc(precision, outputShape),
+                                 BlockedMemoryDesc::FULL_MASK,
+                                 0);
 
     supportedPrimitiveDescriptors.emplace_back(config, impl_desc_type::unknown);
 }
 
 void MemoryInputBase::registerOutputNode(MemoryOutputBase* node) {
-    if (outputNode == node) { return; }
-    if (outputNode) { outputNode->deregisterSibling(this); }
+    if (outputNode == node) {
+        return;
+    }
+    if (outputNode) {
+        outputNode->deregisterSibling(this);
+    }
     outputNode = node;
     outputNode->registerInputNode(this);
 }
 
 void MemoryInputBase::deregisterSibling(MemoryOutputBase* node) {
-    if (node == outputNode) { outputNode = nullptr; }
+    if (node == outputNode) {
+        outputNode = nullptr;
+    }
 }
 
 bool MemoryInputBase::isExecutable() const {
@@ -485,7 +499,7 @@ void MemoryStatesRegister::registerInput(MemoryInputBase* node) {
     memory_inputs[node->getId()] = node;
 }
 
-void MemoryStatesRegister::registerOutput(MemoryOutputBase * node) {
+void MemoryStatesRegister::registerOutput(MemoryOutputBase* node) {
     OPENVINO_ASSERT(node, "Unexpected null MemoryOutput pointer");
     auto sibling = getMemoryInputByName(node->getId());
     if (sibling != nullptr) {
@@ -554,19 +568,15 @@ bool MemoryInput::needInitGraphProcessing() const {
 
 void MemoryInput::initOptimalPrimitiveDescriptor() {
     // Mimic the child node memory desc to avoid extra reorder
-    static const Type preferredTypes[] = {
-        Type::ScaledDotProductAttention,
-        Type::MatMul,
-        Type::FullyConnected,
-        Type::Convolution,
-        Type::RNNCell,
-        Type::RNNSeq,
-        Type::Subgraph
-    };
+    static const Type preferredTypes[] = {Type::ScaledDotProductAttention,
+                                          Type::MatMul,
+                                          Type::FullyConnected,
+                                          Type::Convolution,
+                                          Type::RNNCell,
+                                          Type::RNNSeq,
+                                          Type::Subgraph};
 
-    static const Type skipTypes[] = {
-        Type::ShapeOf
-    };
+    static const Type skipTypes[] = {Type::ShapeOf};
 
     auto&& childEdges = getChildEdgesAtPort(0);
     EdgePtr childEdge = childEdges.front();
@@ -575,11 +585,14 @@ void MemoryInput::initOptimalPrimitiveDescriptor() {
         // try to prioritize memory desc
         for (auto&& item : childEdges) {
             auto itemType = item->getChild()->getType();
-            if (std::any_of(std::begin(skipTypes), std::end(skipTypes), [=](Type type){ return type == itemType; })) {
+            if (std::any_of(std::begin(skipTypes), std::end(skipTypes), [=](Type type) {
+                    return type == itemType;
+                })) {
                 continue;
             }
-            if (std::any_of(std::begin(preferredTypes),
-                    std::end(preferredTypes), [=](Type type){ return type == itemType; })) {
+            if (std::any_of(std::begin(preferredTypes), std::end(preferredTypes), [=](Type type) {
+                    return type == itemType;
+                })) {
                 childEdge = item;
                 break;
             }
@@ -589,37 +602,32 @@ void MemoryInput::initOptimalPrimitiveDescriptor() {
     auto child = childEdge->getChild();
     auto childPd = child->getSelectedPrimitiveDescriptor();
     OPENVINO_ASSERT(childPd,
-        child->getTypeStr(), " ",
-        child->getName(),
-        "failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
+                    child->getTypeStr(),
+                    " ",
+                    child->getName(),
+                    "failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
 
     const auto& childConfig = childPd->getConfig();
     auto mem_desc = childConfig.inConfs[childEdge->getOutputNum()].getMemDesc();
 
     auto selectedPd = getSelectedPrimitiveDescriptor();
     OPENVINO_ASSERT(selectedPd,
-        "MemoryInput ",
-        getName(),
-        " failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
+                    "MemoryInput ",
+                    getName(),
+                    " failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
 
     auto config = selectedPd->getConfig();
     config.outConfs.front().setMemDesc(mem_desc);
-    //bypass any checks, we enforce the child descriptor
+    // bypass any checks, we enforce the child descriptor
     selectedPd->setConfig(config);
 }
 
 void MemoryInput::runDynamic(dnnl::stream strm) {
     auto assignedMem = getAssignedState()->input_mem();
 
-    OPENVINO_ASSERT(assignedMem,
-        "MemoryInput ",
-        getName(),
-        " assigned state has null memory ptr");
+    OPENVINO_ASSERT(assignedMem, "MemoryInput ", getName(), " assigned state has null memory ptr");
 
-    OPENVINO_ASSERT(memBlock,
-        "MemoryInput ",
-        getName(),
-        " has uninitialized memory block.");
+    OPENVINO_ASSERT(memBlock, "MemoryInput ", getName(), " has uninitialized memory block.");
 
     // check whether we can share memory block
     const auto& shape = assignedMem->getShape();
@@ -647,12 +655,12 @@ void MemoryInput::runDynamic(dnnl::stream strm) {
         memBlock->reset();
     }
 
-    //reshape output
+    // reshape output
     const auto& newDims = processInitGraph ? getSrcMemoryAtPort(0)->getStaticDims() : stateDims;
 
     redefineOutputMemory(0, newDims);
 
-    //copy data when necessary
+    // copy data when necessary
     auto src = processInitGraph ? getSrcMemoryAtPort(0) : assignedMem;
     if (src->getData() != dst->getData()) {
         dst->load(*src);
@@ -662,27 +670,21 @@ void MemoryInput::runDynamic(dnnl::stream strm) {
 void MemoryInput::runStatic(dnnl::stream strm) {
     auto assignedMem = getAssignedState()->input_mem();
 
-    OPENVINO_ASSERT(assignedMem,
-        "MemoryInput ",
-        getName(),
-        " assigned state has null memory ptr");
+    OPENVINO_ASSERT(assignedMem, "MemoryInput ", getName(), " assigned state has null memory ptr");
 
     const auto& stateDims = assignedMem->getStaticDims();
     const auto& expectedDims = getBaseMemDescAtOutputPort(0)->getShape().getStaticDims();
     OPENVINO_ASSERT(expectedDims == stateDims,
-            "MemoryInput ",
-            getName(),
-            " unexpected state shape: ",
-            vec2str(stateDims),
-            ", while the expected shape: ",
-            vec2str(expectedDims));
+                    "MemoryInput ",
+                    getName(),
+                    " unexpected state shape: ",
+                    vec2str(stateDims),
+                    ", while the expected shape: ",
+                    vec2str(expectedDims));
 
     auto internDesc = getBaseMemDescAtOutputPort(0);
 
-    OPENVINO_ASSERT(memBlock,
-        "MemoryInput ",
-        getName(),
-        " has uninitialized memory block.");
+    OPENVINO_ASSERT(memBlock, "MemoryInput ", getName(), " has uninitialized memory block.");
 
     if (internDesc->isCompatible(assignedMem->getDesc())) {
         memBlock->setMemBlock(assignedMem->getMemoryBlock());
@@ -692,7 +694,7 @@ void MemoryInput::runStatic(dnnl::stream strm) {
 
     const auto processInitGraph = needInitGraphProcessing();
 
-    //copy data when necessary
+    // copy data when necessary
     auto src = processInitGraph ? getSrcMemoryAtPort(0) : assignedMem;
     auto dst = getDstMemoryAtPort(0);
     if (src->getData() != dst->getData()) {
@@ -708,16 +710,17 @@ void MemoryInput::resolveInPlaceEdges(Edge::LOOK look) {
 
     auto selected_pd = getSelectedPrimitiveDescriptor();
     OPENVINO_ASSERT(selected_pd,
-        "MemoryInput ",
-        getName(),
-        " failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
+                    "MemoryInput ",
+                    getName(),
+                    " failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
 
     auto memDesc = selected_pd->getConfig().outConfs.front().getMemDesc();
     memBlock = std::make_shared<ProxyMemoryBlock>();
 
-    for (auto&& edge : getChildEdgesAtPort(0)) { // always only one child port
+    for (auto&& edge : getChildEdgesAtPort(0)) {  // always only one child port
         OPENVINO_ASSERT(one_of(edge->getStatus(), Edge::Status::Uninitialized, Edge::Status::NotAllocated),
-            " Unexpected inplace resolve call to an allocated edge: ", *edge);
+                        " Unexpected inplace resolve call to an allocated edge: ",
+                        *edge);
 
         auto edgeMem = std::make_shared<Memory>(getEngine(), memDesc, memBlock);
         edge->reuse(edgeMem);
@@ -741,9 +744,9 @@ MemStatePtr MemoryInput::makeState() const {
     }
 
     return std::make_shared<VariableStateDoubleBuffer>(state_name,
-        std::make_shared<Memory>(eng, mem_desc),
-        std::make_shared<Memory>(eng, mem_desc),
-        original_desc);
+                                                       std::make_shared<Memory>(eng, mem_desc),
+                                                       std::make_shared<Memory>(eng, mem_desc),
+                                                       original_desc);
 }
 
 bool MemoryInput::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
@@ -758,15 +761,16 @@ MemoryInputSDPA::MemoryInputSDPA(const std::string id,
                                  const GraphContext::CPtr context,
                                  const ov::optional<Shape>& input_shape,
                                  const ov::optional<ov::element::Type>& input_prc,
-                                 const std::shared_ptr<ScaledDotProductAttention>& sdpaNode) :
-    MemoryInputBase(id, name, type, output_shape, output_prc, context, input_shape, input_prc), m_sdpaNode(sdpaNode) {}
+                                 const std::shared_ptr<ScaledDotProductAttention>& sdpaNode)
+    : MemoryInputBase(id, name, type, output_shape, output_prc, context, input_shape, input_prc),
+      m_sdpaNode(sdpaNode) {}
 
 void MemoryInputSDPA::createPrimitive() {
     MemoryInputBase::createPrimitive();
     // determine the output node idx
     auto memDesc = getBaseMemDescAtOutputPort(0);
     auto sdpaNode = m_sdpaNode.lock();
-    for (auto&& edge : getChildEdgesAtPort(0)) { // always only one child port
+    for (auto&& edge : getChildEdgesAtPort(0)) {  // always only one child port
         auto node = edge->getChild();
         if (node == sdpaNode) {
             m_child_port_idx = edge->getOutputNum();
@@ -814,7 +818,7 @@ MemStatePtr MemoryInputSDPA::makeState() const {
 }
 
 void MemoryInputSDPA::runStatic(dnnl::stream strm) {
-    //nothing to do
+    // nothing to do
 }
 
 void MemoryInputSDPA::runDynamic(dnnl::stream strm) {
@@ -830,10 +834,10 @@ void MemoryInputSDPA::runDynamic(dnnl::stream strm) {
     } else {
         auto stateMem = currentState->input_mem();
         OPENVINO_ASSERT(stateMem,
-            "Internal state mem id: ",
-            currentState->get_name(),
-            " is empty, node name: ",
-            getName());
+                        "Internal state mem id: ",
+                        currentState->get_name(),
+                        " is empty, node name: ",
+                        getName());
 
         redefineOutputMemory({stateMem->getStaticDims()});
     }
@@ -844,9 +848,10 @@ void MemoryInputSDPA::resolveInPlaceEdges(Edge::LOOK look) {
         Node::resolveInPlaceEdges(look);
     } else {
         auto memDesc = getBaseMemDescAtOutputPort(0);
-        for (auto&& edge : getChildEdgesAtPort(0)) { // always only one child port
+        for (auto&& edge : getChildEdgesAtPort(0)) {  // always only one child port
             OPENVINO_ASSERT(one_of(edge->getStatus(), Edge::Status::Uninitialized, Edge::Status::NotAllocated),
-                " Unexpected inplace resolve call to an allocated edge: ", *edge);
+                            " Unexpected inplace resolve call to an allocated edge: ",
+                            *edge);
 
             auto edgeMem = std::make_shared<MemoryStub>(getEngine(), memDesc);
             edge->reuse(edgeMem);
@@ -897,21 +902,21 @@ void MemoryInputSingle::runStatic(dnnl::stream strm) {
     MemoryInput::runStatic(strm);
     if (needInitGraphProcessing()) {
         // since there is no corresponding MemoryOutput node, we need to update the state here
-        auto result = getDstMemoryAtPort(0); // only one output port
+        auto result = getDstMemoryAtPort(0);  // only one output port
         auto stateMem = getAssignedState()->output_mem();
         CPU_NODE_ASSERT(stateMem, " state memory has nullptr");
         if (result->getData() != stateMem->getData()) {
             stateMem->load(*result);
         }
     }
-    getAssignedState()->commit(); // since we don't use MemoryOutput, commit must be called to change the reset state
+    getAssignedState()->commit();  // since we don't use MemoryOutput, commit must be called to change the reset state
 }
 
 void MemoryInputSingle::runDynamic(dnnl::stream strm) {
     MemoryInput::runDynamic(strm);
     if (needInitGraphProcessing()) {
         // since there is no corresponding MemoryOutput node, we need to update the state here
-        auto result = getDstMemoryAtPort(0); // only one output port
+        auto result = getDstMemoryAtPort(0);  // only one output port
         auto state = getAssignedState();
         auto stateMem = state->output_mem();
         CPU_NODE_ASSERT(stateMem, " state memory has nullptr");
@@ -929,7 +934,7 @@ void MemoryInputSingle::runDynamic(dnnl::stream strm) {
             stateMem->load(*result);
         }
     }
-    getAssignedState()->commit(); // since we don't use MemoryOutput, commit must be called to change the reset state
+    getAssignedState()->commit();  // since we don't use MemoryOutput, commit must be called to change the reset state
 }
 
 bool MemoryInputSingle::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
@@ -938,5 +943,5 @@ bool MemoryInputSingle::isSupportedOperation(const std::shared_ptr<const ov::Nod
 }
 
 }  // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/memory.hpp b/src/plugins/intel_cpu/src/nodes/memory.hpp
index f503a8d58386a5..1571e8fffa2231 100644
--- a/src/plugins/intel_cpu/src/nodes/memory.hpp
+++ b/src/plugins/intel_cpu/src/nodes/memory.hpp
@@ -4,13 +4,13 @@
 
 #pragma once
 
+#include <map>
+
 #include "input.h"
 #include "memory_state_base.h"
 #include "ov_optional.hpp"
 #include "proxy_mem_blk.h"
 
-#include <map>
-
 namespace ov {
 namespace intel_cpu {
 namespace node {
@@ -25,8 +25,8 @@ class MemoryStatesRegister {
     using OutputNodesMap = std::unordered_map<std::string, MemoryNode*>;
 
 public:
-    void registerOutput(MemoryOutputBase * node);
-    void registerInput(MemoryInputBase * node);
+    void registerOutput(MemoryOutputBase* node);
+    void registerInput(MemoryInputBase* node);
     void remove(MemoryNode* node);
 
     const InputNodesMap& getMemoryStates() const {
@@ -62,15 +62,19 @@ class MemoryOutputBase : public Node, public MemoryNode {
         return getType() == Type::MemoryOutput;
     }
 
-    void execute(dnnl::stream strm) override final; // NOLINT
-    void executeDynamicImpl(dnnl::stream strm) override final; // NOLINT
-    bool isExecutable() const override final; // NOLINT
+    void execute(dnnl::stream strm) override final;             // NOLINT
+    void executeDynamicImpl(dnnl::stream strm) override final;  // NOLINT
+    bool isExecutable() const override final;                   // NOLINT
 
     void registerInputNode(MemoryInputBase* node);
     void deregisterSibling(MemoryInputBase* node);
 
-    bool needShapeInfer() const override { return false; }
-    bool needPrepareParams() const override { return false; }
+    bool needShapeInfer() const override {
+        return false;
+    }
+    bool needPrepareParams() const override {
+        return false;
+    }
 
     void assignState(MemStatePtr newState);
 
@@ -85,7 +89,7 @@ class MemoryOutputBase : public Node, public MemoryNode {
      * @brief keeps reference to input sibling node
      */
     MemoryInputBase* inputNode = nullptr;
-    MemStatePtr state = nullptr; //keep reference to call commit()
+    MemStatePtr state = nullptr;  // keep reference to call commit()
 };
 
 class MemoryOutput : public MemoryOutputBase {
@@ -102,7 +106,7 @@ class MemoryOutput : public MemoryOutputBase {
 
 private:
     MemoryPtr assignedMem = nullptr;
-    MemoryDescPtr extMemDesc = nullptr; // used for resize
+    MemoryDescPtr extMemDesc = nullptr;  // used for resize
     ProxyMemoryBlockPtr memBlock = nullptr;
 };
 
@@ -121,10 +125,7 @@ class MemoryOutputStub : public MemoryOutputBase {
 
 class MemoryInputBase : public Input, public MemoryStateNode {
 public:
-    enum class mode {
-        read_value_assign,
-        single_read_value
-    };
+    enum class mode { read_value_assign, single_read_value };
 
 public:
     MemoryInputBase(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
@@ -138,17 +139,21 @@ class MemoryInputBase : public Input, public MemoryStateNode {
 
     void initSupportedPrimitiveDescriptors() override;
 
-    void execute(dnnl::stream strm) override final; // NOLINT
-    void executeDynamicImpl(dnnl::stream strm) override final; // NOLINT
-    bool needShapeInfer() const override { return false; }
-    bool needPrepareParams() const override { return false; }
-    bool isExecutable() const override final; // NOLINT
+    void execute(dnnl::stream strm) override final;             // NOLINT
+    void executeDynamicImpl(dnnl::stream strm) override final;  // NOLINT
+    bool needShapeInfer() const override {
+        return false;
+    }
+    bool needPrepareParams() const override {
+        return false;
+    }
+    bool isExecutable() const override final;  // NOLINT
 
     void registerOutputNode(MemoryOutputBase* node);
     void deregisterSibling(MemoryOutputBase* node);
 
     MemoryOutputBase& getOutputNode();
-    void assignState(MemStatePtr newState) override final; // NOLINT
+    void assignState(MemStatePtr newState) override final;  // NOLINT
 
 protected:
     MemoryInputBase(const std::string id,
@@ -202,7 +207,8 @@ class MemoryInput : public MemoryInputBase {
     void runDynamic(dnnl::stream strm) override;
 
 private:
-    void assignStateHook() override {/*pass*/}
+    void assignStateHook() override { /*pass*/
+    }
 
 private:
     ProxyMemoryBlockPtr memBlock = nullptr;
@@ -256,6 +262,6 @@ class MemoryInputSDPA : public MemoryInputBase {
     std::weak_ptr<ScaledDotProductAttention> m_sdpaNode;
     int m_child_port_idx = -1;
 };
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/memory_state_base.cpp b/src/plugins/intel_cpu/src/nodes/memory_state_base.cpp
index 00e88394ab3e5d..58d855a091d716 100644
--- a/src/plugins/intel_cpu/src/nodes/memory_state_base.cpp
+++ b/src/plugins/intel_cpu/src/nodes/memory_state_base.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "memory_state_base.h"
+
 #include <openvino/core/type.hpp>
 #include <openvino/op/util/assign_base.hpp>
 #include <openvino/op/util/read_value_base.hpp>
diff --git a/src/plugins/intel_cpu/src/nodes/memory_state_base.h b/src/plugins/intel_cpu/src/nodes/memory_state_base.h
index 90fbd65051b17d..c7843c6923367b 100644
--- a/src/plugins/intel_cpu/src/nodes/memory_state_base.h
+++ b/src/plugins/intel_cpu/src/nodes/memory_state_base.h
@@ -11,7 +11,7 @@ namespace intel_cpu {
 namespace node {
 
 class MemoryNode {
- public:
+public:
     explicit MemoryNode(std::string id) : m_id(id) {}
     explicit MemoryNode(const std::shared_ptr<ov::Node>& op);
     virtual ~MemoryNode() = default;
@@ -33,6 +33,6 @@ class MemoryStateNode : public MemoryNode {
 using MmemoryStateNodePtr = std::shared_ptr<MemoryStateNode>;
 using MemoryStateNodeCPtr = std::shared_ptr<const MemoryStateNode>;
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/mha.cpp b/src/plugins/intel_cpu/src/nodes/mha.cpp
index 97c2d9be4d4ea8..bb6e014be16157 100644
--- a/src/plugins/intel_cpu/src/nodes/mha.cpp
+++ b/src/plugins/intel_cpu/src/nodes/mha.cpp
@@ -3,6 +3,10 @@
 //
 
 #include "mha.h"
+
+#include <string>
+#include <vector>
+
 #include "common/cpu_convert.h"
 #include "common/cpu_memcpy.h"
 #include "cpu/x64/jit_generator.hpp"
@@ -16,9 +20,6 @@
 #include "utils/general_utils.h"
 #include "utils/ngraph_utils.hpp"
 
-#include <string>
-#include <vector>
-
 using namespace dnnl::impl;
 using namespace dnnl::impl::cpu::x64;
 using namespace dnnl::impl::cpu::x64::matmul;
@@ -36,7 +37,9 @@ template <cpu_isa_t isa>
 struct jit_mul_add_softmax_kernel : public jit_uni_mul_add_softmax_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_mul_add_softmax_kernel)
 
-    explicit jit_mul_add_softmax_kernel(const jit_mul_add_softmax_compile_params& jcp) : jit_uni_mul_add_softmax_kernel(jcp), jit_generator(jit_name()) {
+    explicit jit_mul_add_softmax_kernel(const jit_mul_add_softmax_compile_params& jcp)
+        : jit_uni_mul_add_softmax_kernel(jcp),
+          jit_generator(jit_name()) {
         exp_emitter = std::make_shared<jit_dnnl_aux_emitter>(this, isa, dnnl_eltwise_exp, 0.f, 0.f);
 
         vec_size = dnnl::impl::cpu::x64::cpu_isa_traits<isa>::vlen / sizeof(float);
@@ -49,12 +52,13 @@ struct jit_mul_add_softmax_kernel : public jit_uni_mul_add_softmax_kernel, publi
     }
 
 private:
-    using Vmm = typename dnnl::impl::utils::conditional3<isa == cpu_isa_t::sse41, Xmm, isa == cpu_isa_t::avx2, Ymm, Zmm>::type;
+    using Vmm =
+        typename dnnl::impl::utils::conditional3<isa == cpu_isa_t::sse41, Xmm, isa == cpu_isa_t::avx2, Ymm, Zmm>::type;
 
     void generate() override {
         this->preamble();
 
-#define GET_OFF(field) offsetof(jit_mul_add_softmax_call_args, field)
+#    define GET_OFF(field) offsetof(jit_mul_add_softmax_call_args, field)
         mov(reg_in0, ptr[reg_params + GET_OFF(p_in0)]);
         mov(reg_add_in1, ptr[reg_params + GET_OFF(p_add_in1)]);
         mov(reg_out, ptr[reg_params + GET_OFF(p_out)]);
@@ -208,7 +212,7 @@ struct jit_mul_add_softmax_kernel : public jit_uni_mul_add_softmax_kernel, publi
         if (jcp_.with_scales0) {
             if (!jcp_.broadcast_scales0) {
                 load(vmm_scales, reg_scales, ov::element::f32, step, is_tail);
-                add(reg_scales,  sizeof(float) * step);
+                add(reg_scales, sizeof(float) * step);
             }
             uni_vmulps(get_vmm_in(0), get_vmm_in(0), vmm_scales);
             uni_vmaxps(get_vmm_in(0), get_vmm_in(0), vmm_crop_low);
@@ -268,7 +272,7 @@ struct jit_mul_add_softmax_kernel : public jit_uni_mul_add_softmax_kernel, publi
             if (jcp_.with_scales1) {
                 if (!jcp_.broadcast_scales1) {
                     load(vmm_scales, reg_scales, ov::element::f32, step, is_tail);
-                    add(reg_scales,  sizeof(float) * step);
+                    add(reg_scales, sizeof(float) * step);
                 }
                 uni_vmulps(get_vmm_in(0), get_vmm_in(0), vmm_scales);
             }
@@ -280,17 +284,30 @@ struct jit_mul_add_softmax_kernel : public jit_uni_mul_add_softmax_kernel, publi
             add(reg_buffer, sizeof(float) * step);
             add(reg_out, jcp_.dst_prc.size() * step);
         }
-#undef GET_OFF
+#    undef GET_OFF
     }
 
-    inline void load(const Vmm& vmm_dst, const Xbyak::Reg64& reg_src, ov::element::Type src_prc, const int& elt_num, bool fill) {
+    inline void load(const Vmm& vmm_dst,
+                     const Xbyak::Reg64& reg_src,
+                     ov::element::Type src_prc,
+                     const int& elt_num,
+                     bool fill) {
         const auto seed = load_emitter_params(src_prc, ov::element::f32, elt_num, fill, "float_min").hash();
         if (!emitters[seed]) {
-            emitters[seed].reset(new jit_load_emitter(this, isa, src_prc, ov::element::f32, elt_num, ov::element::f32, fill, "float_min"));
-        }
-
-        emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), 0}, {static_cast<size_t>(vmm_dst.getIdx())},
-                                  pool_aux_vmm_idxs, pool_aux_gpr_idxs);
+            emitters[seed].reset(new jit_load_emitter(this,
+                                                      isa,
+                                                      src_prc,
+                                                      ov::element::f32,
+                                                      elt_num,
+                                                      ov::element::f32,
+                                                      fill,
+                                                      "float_min"));
+        }
+
+        emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), 0},
+                                  {static_cast<size_t>(vmm_dst.getIdx())},
+                                  pool_aux_vmm_idxs,
+                                  pool_aux_gpr_idxs);
     }
     inline void store(const Xbyak::Reg64& reg_dst, const Vmm& vmm_src, ov::element::Type dst_prc, const int& elt_num) {
         const auto seed = store_emitter_params(ov::element::f32, dst_prc, elt_num).hash();
@@ -298,8 +315,10 @@ struct jit_mul_add_softmax_kernel : public jit_uni_mul_add_softmax_kernel, publi
             emitters[seed].reset(new jit_store_emitter(this, isa, ov::element::f32, dst_prc, elt_num));
         }
 
-        emitters[seed]->emit_code({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(reg_dst.getIdx())},
-                                  pool_aux_vmm_idxs, pool_aux_gpr_idxs);
+        emitters[seed]->emit_code({static_cast<size_t>(vmm_src.getIdx())},
+                                  {static_cast<size_t>(reg_dst.getIdx())},
+                                  pool_aux_vmm_idxs,
+                                  pool_aux_gpr_idxs);
     }
 
     size_t unroll_factor = 3;
@@ -323,7 +342,6 @@ struct jit_mul_add_softmax_kernel : public jit_uni_mul_add_softmax_kernel, publi
         return Xmm(1 + 2 * unroll_factor + idx);
     }
 
-
     Vmm get_vmm_denom(int idx) {
         return Vmm(1 + 3 * unroll_factor + idx);
     }
@@ -349,8 +367,9 @@ struct jit_mul_add_softmax_kernel : public jit_uni_mul_add_softmax_kernel, publi
     Reg32 reg_max_32 = Reg32(rdx.getIdx());
     Reg64 reg_params = abi_param1;
 
-    const std::vector<size_t> pool_aux_gpr_idxs = { static_cast<size_t>(rsi.getIdx()), static_cast<size_t>(rbp.getIdx()) };
-    const std::vector<size_t> pool_aux_vmm_idxs = { 12, 13, 14, 15 };
+    const std::vector<size_t> pool_aux_gpr_idxs = {static_cast<size_t>(rsi.getIdx()),
+                                                   static_cast<size_t>(rbp.getIdx())};
+    const std::vector<size_t> pool_aux_vmm_idxs = {12, 13, 14, 15};
 
     std::unordered_map<size_t, std::unique_ptr<jit_emitter>> emitters;
 
@@ -363,7 +382,9 @@ template <cpu_isa_t isa>
 struct jit_convert_reorder_kernel : public jit_uni_convert_reorder_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_convert_reorder_kernel)
 
-    explicit jit_convert_reorder_kernel(const jit_convert_reorder_compile_params& jcp) : jit_uni_convert_reorder_kernel(jcp), jit_generator(jit_name()) {
+    explicit jit_convert_reorder_kernel(const jit_convert_reorder_compile_params& jcp)
+        : jit_uni_convert_reorder_kernel(jcp),
+          jit_generator(jit_name()) {
         vec_size = dnnl::impl::cpu::x64::cpu_isa_traits<isa>::vlen / sizeof(float);
     }
     virtual ~jit_convert_reorder_kernel() {}
@@ -374,12 +395,13 @@ struct jit_convert_reorder_kernel : public jit_uni_convert_reorder_kernel, publi
     }
 
 private:
-    using Vmm = typename dnnl::impl::utils::conditional3<isa == cpu_isa_t::sse41, Xmm, isa == cpu_isa_t::avx2, Ymm, Zmm>::type;
+    using Vmm =
+        typename dnnl::impl::utils::conditional3<isa == cpu_isa_t::sse41, Xmm, isa == cpu_isa_t::avx2, Ymm, Zmm>::type;
 
     void generate() override {
         this->preamble();
 
-#define GET_OFF(field) offsetof(jit_convert_reorder_call_args, field)
+#    define GET_OFF(field) offsetof(jit_convert_reorder_call_args, field)
         mov(reg_in, ptr[reg_params + GET_OFF(p_in)]);
         mov(reg_out, ptr[reg_params + GET_OFF(p_out)]);
         mov(reg_outter_work_amount, ptr[reg_params + GET_OFF(outter_work_amount)]);
@@ -451,7 +473,7 @@ struct jit_convert_reorder_kernel : public jit_uni_convert_reorder_kernel, publi
         if (jcp_.with_scales) {
             if (!jcp_.broadcast_scales) {
                 load(vmm_scales, reg_scales, ov::element::f32, step, is_tail);
-                add(reg_scales,  sizeof(float) * step);
+                add(reg_scales, sizeof(float) * step);
             }
             uni_vmulps(vmm_in, vmm_in, vmm_scales);
         }
@@ -463,16 +485,29 @@ struct jit_convert_reorder_kernel : public jit_uni_convert_reorder_kernel, publi
             add(reg_out_aux, jcp_.dst_prc.size() * step);
         }
     }
-#undef GET_OFF
+#    undef GET_OFF
 
-    inline void load(const Vmm& vmm_dst, const Xbyak::Reg64& reg_src, ov::element::Type src_prc, const int& elt_num, bool fill) {
+    inline void load(const Vmm& vmm_dst,
+                     const Xbyak::Reg64& reg_src,
+                     ov::element::Type src_prc,
+                     const int& elt_num,
+                     bool fill) {
         const auto seed = load_emitter_params(src_prc, ov::element::f32, elt_num, fill, "float_min").hash();
         if (!emitters[seed]) {
-            emitters[seed].reset(new jit_load_emitter(this, isa, src_prc, ov::element::f32, elt_num, ov::element::f32, fill, "float_min"));
-        }
-
-        emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), 0}, {static_cast<size_t>(vmm_dst.getIdx())},
-                                  pool_aux_vmm_idxs, pool_aux_gpr_idxs);
+            emitters[seed].reset(new jit_load_emitter(this,
+                                                      isa,
+                                                      src_prc,
+                                                      ov::element::f32,
+                                                      elt_num,
+                                                      ov::element::f32,
+                                                      fill,
+                                                      "float_min"));
+        }
+
+        emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), 0},
+                                  {static_cast<size_t>(vmm_dst.getIdx())},
+                                  pool_aux_vmm_idxs,
+                                  pool_aux_gpr_idxs);
     }
     inline void store(const Xbyak::Reg64& reg_dst, const Vmm& vmm_src, ov::element::Type dst_prc, const int& elt_num) {
         const auto seed = store_emitter_params(ov::element::f32, dst_prc, elt_num).hash();
@@ -480,8 +515,10 @@ struct jit_convert_reorder_kernel : public jit_uni_convert_reorder_kernel, publi
             emitters[seed].reset(new jit_store_emitter(this, isa, ov::element::f32, dst_prc, elt_num));
         }
 
-        emitters[seed]->emit_code({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(reg_dst.getIdx())},
-                                  pool_aux_vmm_idxs, pool_aux_gpr_idxs);
+        emitters[seed]->emit_code({static_cast<size_t>(vmm_src.getIdx())},
+                                  {static_cast<size_t>(reg_dst.getIdx())},
+                                  pool_aux_vmm_idxs,
+                                  pool_aux_gpr_idxs);
     }
 
     size_t vec_size;
@@ -499,8 +536,9 @@ struct jit_convert_reorder_kernel : public jit_uni_convert_reorder_kernel, publi
     Reg64 reg_outter_work_amount = r15;
     Reg64 reg_params = abi_param1;
 
-    const std::vector<size_t> pool_aux_gpr_idxs = { static_cast<size_t>(rsi.getIdx()), static_cast<size_t>(rbp.getIdx()) };
-    const std::vector<size_t> pool_aux_vmm_idxs = { static_cast<size_t>(xmm_tmp.getIdx()) };
+    const std::vector<size_t> pool_aux_gpr_idxs = {static_cast<size_t>(rsi.getIdx()),
+                                                   static_cast<size_t>(rbp.getIdx())};
+    const std::vector<size_t> pool_aux_vmm_idxs = {static_cast<size_t>(xmm_tmp.getIdx())};
 
     std::unordered_map<size_t, std::unique_ptr<jit_emitter>> emitters;
 };
@@ -509,7 +547,9 @@ template <cpu_isa_t isa>
 struct jit_convert_transpose_kernel : public jit_uni_convert_transpose_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_convert_transpose_kernel)
 
-    explicit jit_convert_transpose_kernel(const jit_convert_transpose_compile_params& jcp) : jit_uni_convert_transpose_kernel(jcp), jit_generator(jit_name()) {
+    explicit jit_convert_transpose_kernel(const jit_convert_transpose_compile_params& jcp)
+        : jit_uni_convert_transpose_kernel(jcp),
+          jit_generator(jit_name()) {
         interm_prc = jcp_.with_scales ? ov::element::f32 : jcp_.src_prc;
         vec_size = dnnl::impl::cpu::x64::cpu_isa_traits<isa>::vlen / interm_prc.size();
     }
@@ -521,12 +561,13 @@ struct jit_convert_transpose_kernel : public jit_uni_convert_transpose_kernel, p
     }
 
 private:
-    using Vmm = typename dnnl::impl::utils::conditional3<isa == cpu_isa_t::sse41, Xmm, isa == cpu_isa_t::avx2, Ymm, Zmm>::type;
+    using Vmm =
+        typename dnnl::impl::utils::conditional3<isa == cpu_isa_t::sse41, Xmm, isa == cpu_isa_t::avx2, Ymm, Zmm>::type;
 
     void generate() override {
         this->preamble();
 
-#define GET_OFF(field) offsetof(jit_convert_transpose_call_args, field)
+#    define GET_OFF(field) offsetof(jit_convert_transpose_call_args, field)
         mov(reg_in, ptr[reg_params + GET_OFF(p_in)]);
         mov(reg_out, ptr[reg_params + GET_OFF(p_out)]);
         if (jcp_.with_scales) {
@@ -623,24 +664,38 @@ struct jit_convert_transpose_kernel : public jit_uni_convert_transpose_kernel, p
             add(reg_out_aux, jcp_.dst_prc.size() * step);
         }
     }
-#undef GET_OFF
-    inline void load(const Vmm& vmm_dst, const Xbyak::Reg64& reg_src, ov::element::Type src_prc, ov::element::Type dst_prc, const int& elt_num, bool fill) {
+#    undef GET_OFF
+    inline void load(const Vmm& vmm_dst,
+                     const Xbyak::Reg64& reg_src,
+                     ov::element::Type src_prc,
+                     ov::element::Type dst_prc,
+                     const int& elt_num,
+                     bool fill) {
         const auto seed = load_emitter_params(src_prc, dst_prc, elt_num, fill, "float_min").hash();
         if (!emitters[seed]) {
-            emitters[seed].reset(new jit_load_emitter(this, isa, src_prc, dst_prc, elt_num, ov::element::f32, fill, "float_min"));
+            emitters[seed].reset(
+                new jit_load_emitter(this, isa, src_prc, dst_prc, elt_num, ov::element::f32, fill, "float_min"));
         }
 
-        emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), 0}, {static_cast<size_t>(vmm_dst.getIdx())},
-                                  pool_aux_vmm_idxs, pool_aux_gpr_idxs);
+        emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), 0},
+                                  {static_cast<size_t>(vmm_dst.getIdx())},
+                                  pool_aux_vmm_idxs,
+                                  pool_aux_gpr_idxs);
     }
-    inline void store(const Xbyak::Reg64& reg_dst, const Vmm& vmm_src, ov::element::Type src_prc, ov::element::Type dst_prc, const int& elt_num) {
+    inline void store(const Xbyak::Reg64& reg_dst,
+                      const Vmm& vmm_src,
+                      ov::element::Type src_prc,
+                      ov::element::Type dst_prc,
+                      const int& elt_num) {
         const auto seed = store_emitter_params(src_prc, dst_prc, elt_num).hash();
         if (!emitters[seed]) {
             emitters[seed].reset(new jit_store_emitter(this, isa, src_prc, dst_prc, elt_num));
         }
 
-        emitters[seed]->emit_code({static_cast<size_t>(vmm_src.getIdx())}, {static_cast<size_t>(reg_dst.getIdx())},
-                                  pool_aux_vmm_idxs, pool_aux_gpr_idxs);
+        emitters[seed]->emit_code({static_cast<size_t>(vmm_src.getIdx())},
+                                  {static_cast<size_t>(reg_dst.getIdx())},
+                                  pool_aux_vmm_idxs,
+                                  pool_aux_gpr_idxs);
     }
 
     size_t vec_size;
@@ -662,13 +717,14 @@ struct jit_convert_transpose_kernel : public jit_uni_convert_transpose_kernel, p
     Reg64 reg_outter_work_amount = r15;
     Reg64 reg_params = abi_param1;
 
-    const std::vector<size_t> pool_aux_gpr_idxs = { static_cast<size_t>(rsi.getIdx()), static_cast<size_t>(rbp.getIdx()) };
-    const std::vector<size_t> pool_aux_vmm_idxs = { static_cast<size_t>(xmm_tmp.getIdx()) };
+    const std::vector<size_t> pool_aux_gpr_idxs = {static_cast<size_t>(rsi.getIdx()),
+                                                   static_cast<size_t>(rbp.getIdx())};
+    const std::vector<size_t> pool_aux_vmm_idxs = {static_cast<size_t>(xmm_tmp.getIdx())};
 
     std::unordered_map<size_t, std::unique_ptr<jit_emitter>> emitters;
 };
 
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
 bool MHA::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
@@ -684,20 +740,19 @@ bool MHA::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::s
         }
 
         bool supportedPrecisions = true;
-        if (!(mha->get_input_element_type(0) == element::i8 &&
-              mha->get_input_element_type(1) == element::f32 &&
+        if (!(mha->get_input_element_type(0) == element::i8 && mha->get_input_element_type(1) == element::f32 &&
               mha->get_input_element_type(3) == element::f32)) {
             if (!one_of(mha->get_input_element_type(0), element::f32, element::bf16, element::i8)) {
                 supportedPrecisions = false;
             }
 
             if (mha->get_input_element_type(0) != mha->get_input_element_type(1) ||
-                    mha->get_input_element_type(0) != mha->get_input_element_type(3)) {
+                mha->get_input_element_type(0) != mha->get_input_element_type(3)) {
                 supportedPrecisions = false;
             }
         } else {
             if (mha->get_fq0_output_type() != mha->get_input_element_type(0))
-               supportedPrecisions = false;
+                supportedPrecisions = false;
         }
 
         if (!mha->get_fq_scales1().empty() && mha->get_fq1_output_type() != element::i8) {
@@ -777,8 +832,8 @@ void MHA::initSupportedPrimitiveDescriptors() {
 
     if ((inputPrecisions[0] != inputPrecisions[1]) &&
         !(inputPrecisions[0] == ov::element::i8 && inputPrecisions[1] == ov::element::f32 && !fqScales0.empty())) {
-            inputPrecisions[0] = inputPrecisions[1] = ov::element::f32;
-        }
+        inputPrecisions[0] = inputPrecisions[1] = ov::element::f32;
+    }
 
     inputPrecisions[2] = ov::element::f32;
 
@@ -802,13 +857,30 @@ void MHA::initSupportedPrimitiveDescriptors() {
 void MHA::init_brgemm(brgemmCtx& ctx, std::unique_ptr<brgemm_kernel_t>& brgKernel, bool use_amx) {
 #ifdef OPENVINO_ARCH_X86_64
     brgemm_desc_t brgDesc;
-    brgemm_strides_t strides {static_cast<dnnl_dim_t>(ctx.M * ctx.K), static_cast<dnnl_dim_t>(ctx.K * ctx.N)};
-
-    const bool is_int8 = one_of(ctx.dt_in0, data_type::u8, data_type::s8) && one_of(ctx.dt_in1, data_type::u8, data_type::s8);
-    auto isa = use_amx ? isa_undef
-        : ctx.dt_in0 == dnnl_data_type_t::dnnl_bf16 ? avx512_core_bf16 : (is_int8 ? avx512_core_vnni : avx512_core);
-    auto status = brgemm_desc_init(&brgDesc, isa, brgemm_strd, ctx.dt_in0, ctx.dt_in1,
-            false, false, brgemm_row_major, 1.f, ctx.beta, ctx.LDA, ctx.LDB, ctx.LDC, ctx.M, ctx.N, ctx.K, &strides);
+    brgemm_strides_t strides{static_cast<dnnl_dim_t>(ctx.M * ctx.K), static_cast<dnnl_dim_t>(ctx.K * ctx.N)};
+
+    const bool is_int8 =
+        one_of(ctx.dt_in0, data_type::u8, data_type::s8) && one_of(ctx.dt_in1, data_type::u8, data_type::s8);
+    auto isa = use_amx                                     ? isa_undef
+               : ctx.dt_in0 == dnnl_data_type_t::dnnl_bf16 ? avx512_core_bf16
+                                                           : (is_int8 ? avx512_core_vnni : avx512_core);
+    auto status = brgemm_desc_init(&brgDesc,
+                                   isa,
+                                   brgemm_strd,
+                                   ctx.dt_in0,
+                                   ctx.dt_in1,
+                                   false,
+                                   false,
+                                   brgemm_row_major,
+                                   1.f,
+                                   ctx.beta,
+                                   ctx.LDA,
+                                   ctx.LDB,
+                                   ctx.LDC,
+                                   ctx.M,
+                                   ctx.N,
+                                   ctx.K,
+                                   &strides);
     if (status != dnnl_success) {
         THROW_ERROR("cannot be executed due to invalid brgconv params");
     }
@@ -829,11 +901,15 @@ void MHA::init_brgemm(brgemmCtx& ctx, std::unique_ptr<brgemm_kernel_t>& brgKerne
     brgKernel.reset(brgKernel_);
 #else
     THROW_ERROR("is not supported on non-x86_64");
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 }
 
-void MHA::init_brgemm_copy_a(std::unique_ptr<jit_brgemm_matmul_copy_a_t>& brgCopyKernel, size_t K, size_t K_blk, size_t K_tail,
-        size_t LDA, dnnl_data_type_t dt_in0) {
+void MHA::init_brgemm_copy_a(std::unique_ptr<jit_brgemm_matmul_copy_a_t>& brgCopyKernel,
+                             size_t K,
+                             size_t K_blk,
+                             size_t K_tail,
+                             size_t LDA,
+                             dnnl_data_type_t dt_in0) {
     brgemm_matmul_conf_t brgCopyKernelConf;
     brgCopyKernelConf.src_tag = dnnl_abcd;
     brgCopyKernelConf.K = K;
@@ -851,11 +927,18 @@ void MHA::init_brgemm_copy_a(std::unique_ptr<jit_brgemm_matmul_copy_a_t>& brgCop
 
 #if defined(OPENVINO_ARCH_X86_64)
     create_brgemm_matmul_copy_a(brgCopyKernel, &brgCopyKernelConf);
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 }
 
-void MHA::init_brgemm_copy_b(std::unique_ptr<jit_brgemm_matmul_copy_b_t>& brgCopyKernel, size_t N, size_t N_blk, size_t N_tail, size_t LDB, size_t K,
-        bool is_with_amx, dnnl_data_type_t dt_in0, dnnl_data_type_t dt_in1) {
+void MHA::init_brgemm_copy_b(std::unique_ptr<jit_brgemm_matmul_copy_b_t>& brgCopyKernel,
+                             size_t N,
+                             size_t N_blk,
+                             size_t N_tail,
+                             size_t LDB,
+                             size_t K,
+                             bool is_with_amx,
+                             dnnl_data_type_t dt_in0,
+                             dnnl_data_type_t dt_in1) {
     brgemm_matmul_conf_t brgCopyKernelConf;
     brgCopyKernelConf.src_dt = dt_in0;
     brgCopyKernelConf.wei_dt = dt_in1;
@@ -870,8 +953,10 @@ void MHA::init_brgemm_copy_b(std::unique_ptr<jit_brgemm_matmul_copy_b_t>& brgCop
     brgCopyKernelConf.K = K;
     brgCopyKernelConf.K_blk = K;
     brgCopyKernelConf.N_chunk_elems = brgCopyKernelConf.N_blk;
-    brgCopyKernelConf.b_dt_sz = DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(brgCopyKernelConf.src_dt));
-    brgCopyKernelConf.tr_b_dt_sz = DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(brgCopyKernelConf.src_dt));
+    brgCopyKernelConf.b_dt_sz =
+        DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(brgCopyKernelConf.src_dt));
+    brgCopyKernelConf.tr_b_dt_sz =
+        DnnlExtensionUtils::sizeOfDataType(static_cast<dnnl::memory::data_type>(brgCopyKernelConf.src_dt));
     brgCopyKernelConf.req_wei_vnni_downconvert = false;
     brgCopyKernelConf.copy_B_wei_stride = brgCopyKernelConf.N * brgCopyKernelConf.b_dt_sz;
 
@@ -889,9 +974,9 @@ void MHA::init_brgemm_copy_b(std::unique_ptr<jit_brgemm_matmul_copy_b_t>& brgCop
 
 #if defined(OPENVINO_ARCH_X86_64)
     auto ret = create_brgemm_matmul_copy_b(brgCopyKernel, &brgCopyKernelConf);
-    if ( ret != dnnl::impl::status_t::dnnl_success )
+    if (ret != dnnl::impl::status_t::dnnl_success)
         THROW_ERROR("cannot create_brgemm_matmul_copy_b kernel, dnnl_status: ", ret);
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 }
 
 void MHA::prepareParams() {
@@ -950,13 +1035,12 @@ void MHA::prepareParams() {
 
     auto brg0Prc = inputPrecisions[0];
     brg0VnniFactor = 4 / brg0Prc.size();
-    bool brg0WithAMX = isAMXSupported && brg0Prc != ov::element::f32 && (K0 % brg0VnniFactor == 0) && (N0 % brg0VnniFactor == 0);
+    bool brg0WithAMX =
+        isAMXSupported && brg0Prc != ov::element::f32 && (K0 % brg0VnniFactor == 0) && (N0 % brg0VnniFactor == 0);
 
-    N0_blk = brg0Prc == ov::element::f32 ? N0 :
-             brg0Prc == ov::element::bf16 ? 32 : 64;
+    N0_blk = brg0Prc == ov::element::f32 ? N0 : brg0Prc == ov::element::bf16 ? 32 : 64;
     N0_tail = N0 % N0_blk;
-    K0_blk = brg0WithAMX ? brg0Prc == ov::element::bf16 ? 32 : 64
-                         : K0;
+    K0_blk = brg0WithAMX ? brg0Prc == ov::element::bf16 ? 32 : 64 : K0;
     K0_tail = K0 % K0_blk;
 
     accPrecision0 = brg0Prc == ov::element::i8 ? ov::element::i32 : ov::element::f32;
@@ -967,8 +1051,7 @@ void MHA::prepareParams() {
             for (size_t n = 0; n < 2; n++) {
                 auto& brgemmCtx = brgCtxs0[getBrgIdx(m, k, n)];
 
-                auto M_ = m ? M_tail
-                            : M < M_blk ? 0 : M_blk;
+                auto M_ = m ? M_tail : M < M_blk ? 0 : M_blk;
                 auto N_ = n ? N0_tail : N0 - N0_tail;
                 auto K_ = k ? K0_tail : K0 - K0_tail;
                 auto beta = k && brgCtxs0[getBrgIdx(m, 0, n)].K != 0 ? 1.0f : 0.0f;
@@ -1001,8 +1084,15 @@ void MHA::prepareParams() {
     // }
 
     if (brgemmCtx0.is_with_amx || brg0Prc == ov::element::i8 || brg0Prc == ov::element::bf16) {
-        init_brgemm_copy_b(brgCopyBKernel0, N0, N0_blk, N0_tail, brgemmCtx0.LDB, brgemmCtx0.K,
-            brgemmCtx0.is_with_amx, brgemmCtx0.dt_in0, brgemmCtx0.dt_in1);
+        init_brgemm_copy_b(brgCopyBKernel0,
+                           N0,
+                           N0_blk,
+                           N0_tail,
+                           brgemmCtx0.LDB,
+                           brgemmCtx0.K,
+                           brgemmCtx0.is_with_amx,
+                           brgemmCtx0.dt_in0,
+                           brgemmCtx0.dt_in1);
     }
 
     dimsMatMul1Out = {dimsMatMul0Out[0], dimsMatMul0Out[1], dimsMatMul0Out[2], dimsMatMul1In1[3]};
@@ -1013,13 +1103,12 @@ void MHA::prepareParams() {
     auto brg1PrcIn0 = !fqScales2.empty() ? fqPrc2 : inputPrecisions[3];
     auto brg1PrcIn1 = inputPrecisions[3];
     brg1VnniFactor = 4 / brg1PrcIn0.size();
-    bool brg1WithAMX = isAMXSupported && brg1PrcIn0 != ov::element::f32 && (K1 % brg1VnniFactor == 0) && (N1 % brg1VnniFactor == 0);
+    bool brg1WithAMX =
+        isAMXSupported && brg1PrcIn0 != ov::element::f32 && (K1 % brg1VnniFactor == 0) && (N1 % brg1VnniFactor == 0);
 
-    N1_blk = brg1PrcIn1 == ov::element::f32 ? N1 :
-             brg1PrcIn1 == ov::element::bf16 ? 32 : 64;
+    N1_blk = brg1PrcIn1 == ov::element::f32 ? N1 : brg1PrcIn1 == ov::element::bf16 ? 32 : 64;
     N1_tail = N1 % N1_blk;
-    K1_blk = brg1WithAMX ? brg1PrcIn0 == ov::element::bf16 ? 32 : 64
-                         : K1;
+    K1_blk = brg1WithAMX ? brg1PrcIn0 == ov::element::bf16 ? 32 : 64 : K1;
     K1_tail = K1 % K1_blk;
 
     accPrecision1 = one_of(brg1PrcIn0, ov::element::u8, ov::element::i8) ? ov::element::i32 : ov::element::f32;
@@ -1030,8 +1119,7 @@ void MHA::prepareParams() {
             for (size_t n = 0; n < 2; n++) {
                 auto& brgemmCtx = brgCtxs1[getBrgIdx(m, k, n)];
 
-                auto M_ = m ? M_tail
-                            : M < M_blk ? 0 : M_blk;
+                auto M_ = m ? M_tail : M < M_blk ? 0 : M_blk;
                 auto N_ = n ? N1_tail : N1 - N1_tail;
                 auto K_ = k ? K1_tail : K1 - K1_tail;
 
@@ -1059,34 +1147,42 @@ void MHA::prepareParams() {
 
     auto& brgemmCtx1 = brgCtxs1[brg1BaseIdx];
     if (brgemmCtx1.is_with_amx || brg1PrcIn1 == ov::element::i8 || brg1PrcIn1 == ov::element::bf16) {
-        init_brgemm_copy_b(brgCopyBKernel1, batch1 * N1, N1_blk, N1_tail, brgemmCtx1.LDB, brgemmCtx1.K,
-            brgemmCtx1.is_with_amx, brgemmCtx1.dt_in0, brgemmCtx1.dt_in1);
+        init_brgemm_copy_b(brgCopyBKernel1,
+                           batch1 * N1,
+                           N1_blk,
+                           N1_tail,
+                           brgemmCtx1.LDB,
+                           brgemmCtx1.K,
+                           brgemmCtx1.is_with_amx,
+                           brgemmCtx1.dt_in0,
+                           brgemmCtx1.dt_in1);
     }
 
     bufferMatMul0In0Size = M_blk * rnd_up(K0, K0_blk) * brg0Prc.size();
     bufferMatMul0In1Size = rnd_up(K0, brg0VnniFactor) * rnd_up(N0, N0_blk) * brg0Prc.size();
     bufferMatMul0OutSize = brgemmCtx0.M * N0 * accPrecision0.size();
-    bufferMatMul1In1Size = rnd_up(K1, brg1VnniFactor) * rnd_up(N1, N1_blk) * std::max(brg0Prc.size(), brg1PrcIn1.size());
+    bufferMatMul1In1Size =
+        rnd_up(K1, brg1VnniFactor) * rnd_up(N1, N1_blk) * std::max(brg0Prc.size(), brg1PrcIn1.size());
     bufferMatMul1OutSize = brgemmCtx1.M * N1 * accPrecision1.size();
     bufferCompensation0Size = rnd_up(N0, N0_blk);
     bufferCompensation1Size = rnd_up(N1, N1_blk);
 
     if (brgCopyAKernel0) {
-        bufferMatMul0In0.resize(m_threads_num  * bufferMatMul0In0Size);
+        bufferMatMul0In0.resize(m_threads_num * bufferMatMul0In0Size);
     }
-    bufferMatMul0In1.resize(m_threads_num  * bufferMatMul0In1Size);
-    bufferMatMul0Out.resize(m_threads_num  * bufferMatMul0OutSize);
-    bufferMatMul1In1.resize(m_threads_num  * bufferMatMul1In1Size);
-    bufferMatMul1Out.resize(m_threads_num  * bufferMatMul1OutSize);
+    bufferMatMul0In1.resize(m_threads_num * bufferMatMul0In1Size);
+    bufferMatMul0Out.resize(m_threads_num * bufferMatMul0OutSize);
+    bufferMatMul1In1.resize(m_threads_num * bufferMatMul1In1Size);
+    bufferMatMul1Out.resize(m_threads_num * bufferMatMul1OutSize);
     if (brgemmCtx0.is_with_comp) {
-        bufferCompensation0.resize(m_threads_num  * bufferCompensation0Size);
+        bufferCompensation0.resize(m_threads_num * bufferCompensation0Size);
     }
     if (brgemmCtx1.is_with_comp) {
-        bufferCompensation1.resize(m_threads_num  * bufferCompensation1Size);
+        bufferCompensation1.resize(m_threads_num * bufferCompensation1Size);
     }
 
     if (brgemmCtx0.is_with_amx || brgemmCtx1.is_with_amx) {
-        wsp.resize(m_threads_num  * wsp_size_per_thread);
+        wsp.resize(m_threads_num * wsp_size_per_thread);
     }
 
     {
@@ -1109,7 +1205,7 @@ void MHA::prepareParams() {
         } else if (mayiuse(cpu_isa_t::sse41)) {
             mulAddSoftmaxKernel.reset(new jit_mul_add_softmax_kernel<cpu_isa_t::sse41>(jcp));
         }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
         if (!mulAddSoftmaxKernel) {
             THROW_ERROR("cannot create jit eltwise kernel");
         }
@@ -1133,7 +1229,7 @@ void MHA::prepareParams() {
         } else if (mayiuse(cpu_isa_t::sse41)) {
             convertReorderKernel.reset(new jit_convert_reorder_kernel<cpu_isa_t::sse41>(jcp));
         }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
         if (!convertReorderKernel) {
             THROW_ERROR("cannot create jit eltwise kernel");
         }
@@ -1159,7 +1255,7 @@ void MHA::prepareParams() {
         } else if (mayiuse(cpu_isa_t::sse41)) {
             convertTransposeKernel.reset(new jit_convert_transpose_kernel<cpu_isa_t::sse41>(jcp));
         }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
         if (!convertTransposeKernel) {
             THROW_ERROR("cannot create jit eltwise kernel");
@@ -1189,17 +1285,26 @@ void MHA::prepareParams() {
     }
 }
 
-template<typename srcT, typename dstT>
-static void reorder2D(const srcT* pin, dstT* pout, const std::vector<size_t>& dimsOut,
-               const std::vector<size_t>& stridesOut, const std::vector<size_t>& stridesIn) {
+template <typename srcT, typename dstT>
+static void reorder2D(const srcT* pin,
+                      dstT* pout,
+                      const std::vector<size_t>& dimsOut,
+                      const std::vector<size_t>& stridesOut,
+                      const std::vector<size_t>& stridesIn) {
     for (size_t i0 = 0; i0 < dimsOut[0]; i0++) {
         for (size_t i1 = 0; i1 < dimsOut[1]; i1++) {
-            pout[i0 * stridesOut[0] + i1 * stridesOut[1]] = static_cast<dstT>(pin[i0 * stridesIn[0] + i1 * stridesIn[1]]);
+            pout[i0 * stridesOut[0] + i1 * stridesOut[1]] =
+                static_cast<dstT>(pin[i0 * stridesIn[0] + i1 * stridesIn[1]]);
         }
     }
 }
 
-void MHA::callBrgemm(brgemmCtx& ctx, std::unique_ptr<brgemm_kernel_t>& brgKernel, const void* pin0, const void* pin1, void* pout, void* wsp) {
+void MHA::callBrgemm(brgemmCtx& ctx,
+                     std::unique_ptr<brgemm_kernel_t>& brgKernel,
+                     const void* pin0,
+                     const void* pin1,
+                     void* pout,
+                     void* wsp) {
 #if defined(OPENVINO_ARCH_X86_64)
     if (ctx.is_with_amx)
         amx_tile_configure(ctx.palette);
@@ -1211,7 +1316,7 @@ void MHA::callBrgemm(brgemmCtx& ctx, std::unique_ptr<brgemm_kernel_t>& brgKernel
     }
 #else
     THROW_ERROR("is not supported on non-x64 platforms");
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 }
 
 template <typename in1_type>
@@ -1227,19 +1332,25 @@ void MHA::mhaImpl() {
     auto spatial_loop = [&](size_t i0, size_t i1) {
         size_t threadNum = parallel_get_thread_num();
 
-        auto pTranspose0In0_aux = pTranspose0In0 + (i0 * strTranspose0In0[0] + i1 * strTranspose0In0[2]) * inputPrecisions[0].size(); // order 0213
-        auto pTranspose1In0_aux = pTranspose1In0 + (i0 * strTranspose1In0[0] + i1 * strTranspose1In0[2]) * inputPrecisions[1].size(); // order 0231
+        auto pTranspose0In0_aux = pTranspose0In0 + (i0 * strTranspose0In0[0] + i1 * strTranspose0In0[2]) *
+                                                       inputPrecisions[0].size();  // order 0213
+        auto pTranspose1In0_aux = pTranspose1In0 + (i0 * strTranspose1In0[0] + i1 * strTranspose1In0[2]) *
+                                                       inputPrecisions[1].size();  // order 0231
 
-        auto pAddIn1_aux = pAddIn1 + i0 * strAddIn1[0]; // order 0231
+        auto pAddIn1_aux = pAddIn1 + i0 * strAddIn1[0];  // order 0231
 
-        auto bufferMatMul0In1_local = reinterpret_cast<uint8_t*>(bufferMatMul0In1.data() + threadNum * bufferMatMul0In1Size);
-        auto bufferMatMul0Out_local = reinterpret_cast<uint8_t*>(bufferMatMul0Out.data() + threadNum * bufferMatMul0OutSize);
-        auto bufferMatMul1In1_local = reinterpret_cast<uint8_t*>(bufferMatMul1In1.data() + threadNum * bufferMatMul1In1Size);
-        auto bufferMatMul1Out_local = reinterpret_cast<uint8_t*>(bufferMatMul1Out.data() + threadNum * bufferMatMul1OutSize);
+        auto bufferMatMul0In1_local =
+            reinterpret_cast<uint8_t*>(bufferMatMul0In1.data() + threadNum * bufferMatMul0In1Size);
+        auto bufferMatMul0Out_local =
+            reinterpret_cast<uint8_t*>(bufferMatMul0Out.data() + threadNum * bufferMatMul0OutSize);
+        auto bufferMatMul1In1_local =
+            reinterpret_cast<uint8_t*>(bufferMatMul1In1.data() + threadNum * bufferMatMul1In1Size);
+        auto bufferMatMul1Out_local =
+            reinterpret_cast<uint8_t*>(bufferMatMul1Out.data() + threadNum * bufferMatMul1OutSize);
 
-        auto pTranspose1Out_aux = brgCopyBKernel0 ? bufferMatMul1In1_local
-                                                  : bufferMatMul0In1_local;
-        auto pTranspose2In0_aux = pTranspose2In0 + (i0 * strTranspose2In0[0] + i1 * strTranspose2In0[2]) * inputPrecisions[3].size(); // order 0213
+        auto pTranspose1Out_aux = brgCopyBKernel0 ? bufferMatMul1In1_local : bufferMatMul0In1_local;
+        auto pTranspose2In0_aux = pTranspose2In0 + (i0 * strTranspose2In0[0] + i1 * strTranspose2In0[2]) *
+                                                       inputPrecisions[3].size();  // order 0213
 
         if (convertTransposeKernel) {
             jit_convert_transpose_call_args call_args;
@@ -1249,16 +1360,17 @@ void MHA::mhaImpl() {
 
             (*convertTransposeKernel)(&call_args);
         } else {
-            reorder2D(reinterpret_cast<const in1_type*>(pTranspose1In0_aux), reinterpret_cast<in1_type*>(pTranspose1Out_aux), {K0, N0}, {N0, 1},
+            reorder2D(reinterpret_cast<const in1_type*>(pTranspose1In0_aux),
+                      reinterpret_cast<in1_type*>(pTranspose1Out_aux),
+                      {K0, N0},
+                      {N0, 1},
                       {strTranspose1In0[3], strTranspose1In0[1]});
         }
 
-        auto bufferCompensation0_aux = !bufferCompensation0.empty()
-            ? bufferCompensation0.data() + threadNum * bufferCompensation0Size
-            : nullptr;
-        auto bufferCompensation1_aux = !bufferCompensation1.empty()
-            ? bufferCompensation1.data() + threadNum * bufferCompensation1Size
-            : nullptr;
+        auto bufferCompensation0_aux =
+            !bufferCompensation0.empty() ? bufferCompensation0.data() + threadNum * bufferCompensation0Size : nullptr;
+        auto bufferCompensation1_aux =
+            !bufferCompensation1.empty() ? bufferCompensation1.data() + threadNum * bufferCompensation1Size : nullptr;
 
         auto wsp_local = !wsp.empty() ? wsp.data() + threadNum * wsp_size_per_thread : nullptr;
 
@@ -1266,7 +1378,8 @@ void MHA::mhaImpl() {
         if (brgCopyBKernel0) {
             for (size_t nb = 0; nb < div_up(N0, N0_blk); nb++) {
                 auto pCopyKernel0In = pMatMul0In1 + nb * N0_blk * inputPrecisions[0].size();
-                auto pCopyKernel0Out = bufferMatMul0In1_local + nb * N0_blk * brg0VnniFactor * inputPrecisions[0].size();
+                auto pCopyKernel0Out =
+                    bufferMatMul0In1_local + nb * N0_blk * brg0VnniFactor * inputPrecisions[0].size();
 
                 auto ctx = jit_brgemm_matmul_copy_b_t::ctx_t();
 
@@ -1290,7 +1403,8 @@ void MHA::mhaImpl() {
         if (brgCopyBKernel1) {
             for (size_t nb = 0; nb < div_up(N1, N1_blk); nb++) {
                 auto pCopyKernel1In = pMatMul1In1 + nb * N1_blk * inputPrecisions[3].size();
-                auto pCopyKernel1Out = reinterpret_cast<uint8_t*>(bufferMatMul1In1_local) + nb * N1_blk * brg1VnniFactor * inputPrecisions[3].size();
+                auto pCopyKernel1Out = reinterpret_cast<uint8_t*>(bufferMatMul1In1_local) +
+                                       nb * N1_blk * brg1VnniFactor * inputPrecisions[3].size();
 
                 auto ctx = jit_brgemm_matmul_copy_b_t::ctx_t();
 
@@ -1318,7 +1432,8 @@ void MHA::mhaImpl() {
 
             // TODO: matrix A copy should be performed to enable AMX matmuls for arbitrary shapes
             // if (brgCopyAKernel0) {
-            //     auto bufferMatMul0In0_local = reinterpret_cast<void*>(bufferMatMul0In0.data() + threadNum * bufferMatMul0In0Size);
+            //     auto bufferMatMul0In0_local = reinterpret_cast<void*>(bufferMatMul0In0.data() + threadNum *
+            //     bufferMatMul0In0Size);
 
             //     auto pCopyKernel0In = pMatMul0In0;
             //     auto pCopyKernel0Out = reinterpret_cast<data_type*>(bufferMatMul0In0_local);
@@ -1352,14 +1467,16 @@ void MHA::mhaImpl() {
                     size_t mIdx = is_M_tail ? 1 : 0;
                     auto& brgemmCtx = brgCtxs0[getBrgIdx(mIdx, k, n)];
 
-                    auto wsp = brgemmCtx.is_with_comp
-                        ? reinterpret_cast<void*>(bufferCompensation0_aux + n * N0_step1)
-                        : reinterpret_cast<void*>(wsp_local);
+                    auto wsp = brgemmCtx.is_with_comp ? reinterpret_cast<void*>(bufferCompensation0_aux + n * N0_step1)
+                                                      : reinterpret_cast<void*>(wsp_local);
 
                     if (brgemmCtx.K != 0 && brgemmCtx.N != 0) {
-                        callBrgemm(brgemmCtx, brgKernels0[getBrgIdx(mIdx, k, n)],
-                            pMatMul0In0 + (k * K0_step0) * inputPrecisions[0].size(), pMatMul0In1 + (k * K0_step1 + n * N0_step0) * inputPrecisions[0].size(),
-                            pMatMul0Out + (n * N0_step1) * accPrecision0.size(), wsp);
+                        callBrgemm(brgemmCtx,
+                                   brgKernels0[getBrgIdx(mIdx, k, n)],
+                                   pMatMul0In0 + (k * K0_step0) * inputPrecisions[0].size(),
+                                   pMatMul0In1 + (k * K0_step1 + n * N0_step0) * inputPrecisions[0].size(),
+                                   pMatMul0Out + (n * N0_step1) * accPrecision0.size(),
+                                   wsp);
                     }
                 }
             }
@@ -1381,9 +1498,8 @@ void MHA::mhaImpl() {
             auto pMatMul1In0 = bufferMatMul0Out_local;
             auto pOut_aux = pout + (i0 * strOut[0] + i1 * strOut[2]) * outPrcSize;
 
-            auto pMatMul1Out = outputPrecision == ov::element::f32
-                ? pOut_aux + (mb * M_blk * batch1 * N1) * outPrcSize
-                : bufferMatMul1Out_local;
+            auto pMatMul1Out = outputPrecision == ov::element::f32 ? pOut_aux + (mb * M_blk * batch1 * N1) * outPrcSize
+                                                                   : bufferMatMul1Out_local;
 
             size_t brgIdx1 = getBrgIdx(0, 0, 0);
             size_t K1_step0 = brgCtxs1[brgIdx1].K;
@@ -1395,14 +1511,16 @@ void MHA::mhaImpl() {
                     size_t mIdx = is_M_tail ? 1 : 0;
                     auto& brgemmCtx = brgCtxs1[getBrgIdx(mIdx, k, n)];
 
-                    auto wsp = brgemmCtx.is_with_comp
-                        ? reinterpret_cast<void*>(bufferCompensation1_aux + n * N1_step1)
-                        : reinterpret_cast<void*>(wsp_local);
+                    auto wsp = brgemmCtx.is_with_comp ? reinterpret_cast<void*>(bufferCompensation1_aux + n * N1_step1)
+                                                      : reinterpret_cast<void*>(wsp_local);
 
                     if (brgemmCtx.K != 0 && brgemmCtx.N != 0) {
-                        callBrgemm(brgemmCtx, brgKernels1[getBrgIdx(mIdx, k, n)],
-                            pMatMul1In0 + (k * K1_step0) * inputPrecisions[3].size(), pMatMul1In1 + (k * K1_step1 + n * N1_step0) * inputPrecisions[3].size(),
-                            pMatMul1Out + (n * N1_step1) * accPrecision1.size(), wsp);
+                        callBrgemm(brgemmCtx,
+                                   brgKernels1[getBrgIdx(mIdx, k, n)],
+                                   pMatMul1In0 + (k * K1_step0) * inputPrecisions[3].size(),
+                                   pMatMul1In1 + (k * K1_step1 + n * N1_step0) * inputPrecisions[3].size(),
+                                   pMatMul1Out + (n * N1_step1) * accPrecision1.size(),
+                                   wsp);
                     }
                 }
             }
@@ -1444,6 +1562,6 @@ bool MHA::created() const {
     return getType() == Type::MHA;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/mha.h b/src/plugins/intel_cpu/src/nodes/mha.h
index 36afe20224299a..a3af1e7c0b53f4 100644
--- a/src/plugins/intel_cpu/src/nodes/mha.h
+++ b/src/plugins/intel_cpu/src/nodes/mha.h
@@ -6,13 +6,13 @@
 
 #include <node.h>
 
-#include <memory>
-#include <string>
-#include <vector>
+#include <cpu/x64/amx_tile_configure.hpp>
 #include <cpu/x64/brgemm/brgemm.hpp>
 #include <cpu/x64/matmul/brgemm_matmul_copy_utils.hpp>
 #include <cpu/x64/matmul/brgemm_matmul_utils.hpp>
-#include <cpu/x64/amx_tile_configure.hpp>
+#include <memory>
+#include <string>
+#include <vector>
 
 namespace ov {
 namespace intel_cpu {
@@ -31,13 +31,13 @@ struct jit_mul_add_softmax_compile_params {
 };
 
 struct jit_mul_add_softmax_call_args {
-    const void *p_in0;
-    const void *p_mul_in1;
-    const void *p_add_in1;
-    void *p_out;
-    void *p_buffer;
-    const void *p_scales0;
-    const void *p_scales1;
+    const void* p_in0;
+    const void* p_mul_in1;
+    const void* p_add_in1;
+    void* p_out;
+    void* p_buffer;
+    const void* p_scales0;
+    const void* p_scales1;
 };
 
 struct jit_uni_mul_add_softmax_kernel {
@@ -67,9 +67,9 @@ struct jit_convert_reorder_compile_params {
 };
 
 struct jit_convert_reorder_call_args {
-    const void *p_in;
-    void *p_out;
-    const void *p_scales;
+    const void* p_in;
+    void* p_out;
+    const void* p_scales;
     size_t outter_work_amount;
 };
 
@@ -102,9 +102,9 @@ struct jit_convert_transpose_compile_params {
 };
 
 struct jit_convert_transpose_call_args {
-    const void *p_in;
-    void *p_out;
-    const void *p_scales;
+    const void* p_in;
+    void* p_out;
+    const void* p_scales;
 };
 
 struct jit_uni_convert_transpose_kernel {
@@ -115,7 +115,9 @@ struct jit_uni_convert_transpose_kernel {
         ker_(call_args);
     }
 
-    explicit jit_uni_convert_transpose_kernel(const jit_convert_transpose_compile_params& jcp) : ker_(nullptr), jcp_(jcp) {}
+    explicit jit_uni_convert_transpose_kernel(const jit_convert_transpose_compile_params& jcp)
+        : ker_(nullptr),
+          jcp_(jcp) {}
     virtual ~jit_uni_convert_transpose_kernel() {}
 
     virtual void create_ker() = 0;
@@ -129,7 +131,7 @@ class MHA : public Node {
 public:
     MHA(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -156,12 +158,27 @@ class MHA : public Node {
 
     void init_brgemm(brgemmCtx& ctx, std::unique_ptr<dnnl::impl::cpu::x64::brgemm_kernel_t>& brgKernel, bool use_amx);
     void init_brgemm_copy_a(std::unique_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_a_t>& brgCopyKernel,
-        size_t K, size_t K_blk, size_t K_tail, size_t LDA, dnnl_data_type_t dt_in0);
+                            size_t K,
+                            size_t K_blk,
+                            size_t K_tail,
+                            size_t LDA,
+                            dnnl_data_type_t dt_in0);
     void init_brgemm_copy_b(std::unique_ptr<dnnl::impl::cpu::x64::matmul::jit_brgemm_matmul_copy_b_t>& brgCopyKernel,
-        size_t N, size_t N_blk, size_t N_tail, size_t LDB, size_t K, bool is_with_amx, dnnl_data_type_t dt_in0, dnnl_data_type_t dt_in1);
-
-    void callBrgemm(brgemmCtx& ctx, std::unique_ptr<dnnl::impl::cpu::x64::brgemm_kernel_t>& brgKernel,
-                    const void* pin0, const void* pin1, void* pout, void* wsp);
+                            size_t N,
+                            size_t N_blk,
+                            size_t N_tail,
+                            size_t LDB,
+                            size_t K,
+                            bool is_with_amx,
+                            dnnl_data_type_t dt_in0,
+                            dnnl_data_type_t dt_in1);
+
+    void callBrgemm(brgemmCtx& ctx,
+                    std::unique_ptr<dnnl::impl::cpu::x64::brgemm_kernel_t>& brgKernel,
+                    const void* pin0,
+                    const void* pin1,
+                    void* pout,
+                    void* wsp);
 
     size_t getBrgIdx(size_t mIdx, size_t kIdx, size_t nIdx) {
         return mIdx * 4 + kIdx * 2 + nIdx;
@@ -242,6 +259,6 @@ class MHA : public Node {
     size_t m_threads_num = 0lu;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/multiclass_nms.cpp b/src/plugins/intel_cpu/src/nodes/multiclass_nms.cpp
index e87fd69fd9c004..b16b37089186b7 100644
--- a/src/plugins/intel_cpu/src/nodes/multiclass_nms.cpp
+++ b/src/plugins/intel_cpu/src/nodes/multiclass_nms.cpp
@@ -3,7 +3,6 @@
 //
 
 #include "multiclass_nms.hpp"
-#include "ov_ops/multiclass_nms_ie_internal.hpp"
 
 #include <algorithm>
 #include <cassert>
@@ -15,8 +14,9 @@
 #include <vector>
 
 #include "openvino/core/parallel.hpp"
-#include "utils/general_utils.h"
+#include "ov_ops/multiclass_nms_ie_internal.hpp"
 #include "shape_inference/shape_inference_internal_dyn.hpp"
+#include "utils/general_utils.h"
 
 using namespace ov;
 
@@ -26,12 +26,13 @@ namespace node {
 
 using ngNmsSortResultType = ov::op::util::MulticlassNmsBase::SortResultType;
 
-bool MultiClassNms::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool MultiClassNms::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                         std::string& errorMessage) noexcept {
     try {
         if (!one_of(op->get_type_info(),
-                ov::op::v9::MulticlassNms::get_type_info_static(),
-                ov::op::v8::MulticlassNms::get_type_info_static(),
-                ov::op::internal::MulticlassNmsIEInternal::get_type_info_static())) {
+                    ov::op::v9::MulticlassNms::get_type_info_static(),
+                    ov::op::v8::MulticlassNms::get_type_info_static(),
+                    ov::op::internal::MulticlassNmsIEInternal::get_type_info_static())) {
             errorMessage = "Node is not an instance of MulticlassNms from opset v8 or v9.";
             return false;
         }
@@ -117,32 +118,42 @@ void MultiClassNms::initSupportedPrimitiveDescriptors() {
     if (!supportedPrimitiveDescriptors.empty())
         return;
 
-    const std::vector<ov::element::Type> supportedFloatPrecision = {ov::element::f32, ov::element::f16, ov::element::bf16};
+    const std::vector<ov::element::Type> supportedFloatPrecision = {ov::element::f32,
+                                                                    ov::element::f16,
+                                                                    ov::element::bf16};
     const std::vector<ov::element::Type> supportedIntOutputPrecision = {ov::element::i32, ov::element::i64};
 
     checkPrecision(getOriginalInputPrecisionAtPort(NMS_BOXES), supportedFloatPrecision, "boxes", m_inType);
     checkPrecision(getOriginalInputPrecisionAtPort(NMS_SCORES), supportedFloatPrecision, "scores", m_inType);
 
-    checkPrecision(getOriginalOutputPrecisionAtPort(NMS_SELECTEDINDICES), supportedIntOutputPrecision, "selected_indices", m_outType);
-    checkPrecision(getOriginalOutputPrecisionAtPort(NMS_SELECTEDOUTPUTS), supportedFloatPrecision, "selected_outputs", m_outType);
-    checkPrecision(getOriginalOutputPrecisionAtPort(NMS_SELECTEDNUM), supportedIntOutputPrecision, "selected_num", m_outType);
+    checkPrecision(getOriginalOutputPrecisionAtPort(NMS_SELECTEDINDICES),
+                   supportedIntOutputPrecision,
+                   "selected_indices",
+                   m_outType);
+    checkPrecision(getOriginalOutputPrecisionAtPort(NMS_SELECTEDOUTPUTS),
+                   supportedFloatPrecision,
+                   "selected_outputs",
+                   m_outType);
+    checkPrecision(getOriginalOutputPrecisionAtPort(NMS_SELECTEDNUM),
+                   supportedIntOutputPrecision,
+                   "selected_num",
+                   m_outType);
 
     if (getOriginalInputsNumber() == 3) {
         checkPrecision(getOriginalInputPrecisionAtPort(NMS_ROISNUM), supportedIntOutputPrecision, "roisnum", m_inType);
         addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32},
-                            {LayoutType::ncsp, ov::element::f32},
-                            {LayoutType::ncsp, ov::element::i32}},
-                            {{LayoutType::ncsp, ov::element::f32},
-                            {LayoutType::ncsp, ov::element::i32},
-                            {LayoutType::ncsp, ov::element::i32}},
-                            impl_desc_type::ref_any);
+                              {LayoutType::ncsp, ov::element::f32},
+                              {LayoutType::ncsp, ov::element::i32}},
+                             {{LayoutType::ncsp, ov::element::f32},
+                              {LayoutType::ncsp, ov::element::i32},
+                              {LayoutType::ncsp, ov::element::i32}},
+                             impl_desc_type::ref_any);
     } else {
-        addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32},
-                            {LayoutType::ncsp, ov::element::f32}},
-                            {{LayoutType::ncsp, ov::element::f32},
-                            {LayoutType::ncsp, ov::element::i32},
-                            {LayoutType::ncsp, ov::element::i32}},
-                            impl_desc_type::ref_any);
+        addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32}, {LayoutType::ncsp, ov::element::f32}},
+                             {{LayoutType::ncsp, ov::element::f32},
+                              {LayoutType::ncsp, ov::element::i32},
+                              {LayoutType::ncsp, ov::element::i32}},
+                             impl_desc_type::ref_any);
     }
 }
 
@@ -191,11 +202,11 @@ void MultiClassNms::prepareParams() {
     m_numClasses = shared ? scores_dims[1] : scores_dims[0];
 
     int max_output_boxes_per_class = 0;
-    size_t real_num_classes = m_backgroundClass == -1 ? m_numClasses :
-        static_cast<size_t>(m_backgroundClass) < m_numClasses ? m_numClasses - 1 : m_numClasses;
+    size_t real_num_classes = m_backgroundClass == -1                                 ? m_numClasses
+                              : static_cast<size_t>(m_backgroundClass) < m_numClasses ? m_numClasses - 1
+                                                                                      : m_numClasses;
     if (m_nmsTopK) {
-        max_output_boxes_per_class = (m_nmsTopK == -1) ? m_numBoxes :
-            std::min(m_nmsTopK, static_cast<int>(m_numBoxes));
+        max_output_boxes_per_class = (m_nmsTopK == -1) ? m_numBoxes : std::min(m_nmsTopK, static_cast<int>(m_numBoxes));
         m_filtBoxes.resize(max_output_boxes_per_class * m_numBatches * m_numClasses);
     }
     m_nmsRealTopk = max_output_boxes_per_class;
@@ -205,7 +216,7 @@ void MultiClassNms::prepareParams() {
         m_maxBoxesPerBatch = std::min(m_maxBoxesPerBatch, static_cast<size_t>(m_keepTopK));
 
     m_numFiltBox.resize(m_numBatches);  // number of rois after nms for each class in each image
-    for (auto &numPerBatch : m_numFiltBox) {
+    for (auto& numPerBatch : m_numFiltBox) {
         numPerBatch.resize(m_numClasses, 0);
     }
     m_numBoxOffset.resize(m_numBatches);
@@ -274,11 +285,16 @@ void MultiClassNms::execute(dnnl::stream strm) {
             m_numBoxOffset[b] += m_numFiltBox[0][0];
     }
     // sort element before go through keep_top_k
-    parallel_sort(m_filtBoxes.begin(), m_filtBoxes.begin() + startOffset, [](const filteredBoxes& l, const filteredBoxes& r) {
-        return ((l.batch_index < r.batch_index) ||
-                ((l.batch_index == r.batch_index) && ((l.score > r.score) || ((std::fabs(l.score - r.score) < 1e-6) && l.class_index < r.class_index) ||
-                                                      ((std::fabs(l.score - r.score) < 1e-6) && l.class_index == r.class_index && l.box_index < r.box_index))));
-    });
+    parallel_sort(
+        m_filtBoxes.begin(),
+        m_filtBoxes.begin() + startOffset,
+        [](const filteredBoxes& l, const filteredBoxes& r) {
+            return ((l.batch_index < r.batch_index) ||
+                    ((l.batch_index == r.batch_index) &&
+                     ((l.score > r.score) || ((std::fabs(l.score - r.score) < 1e-6) && l.class_index < r.class_index) ||
+                      ((std::fabs(l.score - r.score) < 1e-6) && l.class_index == r.class_index &&
+                       l.box_index < r.box_index))));
+        });
 
     if (m_keepTopK > -1) {
         startOffset = 0;
@@ -312,25 +328,38 @@ void MultiClassNms::execute(dnnl::stream strm) {
 
     if (m_sortResultAcrossBatch) { /* sort across batch */
         if (m_sortResultType == MulticlassNmsSortResultType::SCORE) {
-            parallel_sort(m_filtBoxes.begin(), m_filtBoxes.begin() + startOffset, [](const filteredBoxes& l, const filteredBoxes& r) {
-                return (l.score > r.score) || (l.score == r.score && l.batch_index < r.batch_index) ||
-                       (l.score == r.score && l.batch_index == r.batch_index && l.class_index < r.class_index) ||
-                       (l.score == r.score && l.batch_index == r.batch_index && l.class_index == r.class_index && l.box_index < r.box_index);
-            });
+            parallel_sort(
+                m_filtBoxes.begin(),
+                m_filtBoxes.begin() + startOffset,
+                [](const filteredBoxes& l, const filteredBoxes& r) {
+                    return (l.score > r.score) || (l.score == r.score && l.batch_index < r.batch_index) ||
+                           (l.score == r.score && l.batch_index == r.batch_index && l.class_index < r.class_index) ||
+                           (l.score == r.score && l.batch_index == r.batch_index && l.class_index == r.class_index &&
+                            l.box_index < r.box_index);
+                });
         } else if (m_sortResultType == MulticlassNmsSortResultType::CLASSID) {
-            parallel_sort(m_filtBoxes.begin(), m_filtBoxes.begin() + startOffset, [](const filteredBoxes& l, const filteredBoxes& r) {
-                return (l.class_index < r.class_index) || (l.class_index == r.class_index && l.batch_index < r.batch_index) ||
-                       (l.class_index == r.class_index && l.batch_index == r.batch_index && l.score > r.score) ||
-                       (l.class_index == r.class_index && l.batch_index == r.batch_index && l.score == r.score && l.box_index < r.box_index);
-            });
+            parallel_sort(
+                m_filtBoxes.begin(),
+                m_filtBoxes.begin() + startOffset,
+                [](const filteredBoxes& l, const filteredBoxes& r) {
+                    return (l.class_index < r.class_index) ||
+                           (l.class_index == r.class_index && l.batch_index < r.batch_index) ||
+                           (l.class_index == r.class_index && l.batch_index == r.batch_index && l.score > r.score) ||
+                           (l.class_index == r.class_index && l.batch_index == r.batch_index && l.score == r.score &&
+                            l.box_index < r.box_index);
+                });
         }
     } else if (m_sortResultType == MulticlassNmsSortResultType::CLASSID) {
-        parallel_sort(m_filtBoxes.begin(), m_filtBoxes.begin() + startOffset, [](const filteredBoxes& l, const filteredBoxes& r) {
-            return ((l.batch_index < r.batch_index) ||
-                    ((l.batch_index == r.batch_index) &&
-                     ((l.class_index < r.class_index) || ((l.class_index == r.class_index) && l.score > r.score) ||
-                      ((std::fabs(l.score - r.score) <= 1e-6) && l.class_index == r.class_index && l.box_index < r.box_index))));
-        });
+        parallel_sort(
+            m_filtBoxes.begin(),
+            m_filtBoxes.begin() + startOffset,
+            [](const filteredBoxes& l, const filteredBoxes& r) {
+                return ((l.batch_index < r.batch_index) ||
+                        ((l.batch_index == r.batch_index) &&
+                         ((l.class_index < r.class_index) || ((l.class_index == r.class_index) && l.score > r.score) ||
+                          ((std::fabs(l.score - r.score) <= 1e-6) && l.class_index == r.class_index &&
+                           l.box_index < r.box_index))));
+            });
     }
 
     /* output */
@@ -365,13 +394,13 @@ void MultiClassNms::execute(dnnl::stream strm) {
 
         for (size_t j = 0; j < real_boxes; j++) {
             auto original_index = original_offset + j;
-            const auto &box_info = m_filtBoxes[original_index];
+            const auto& box_info = m_filtBoxes[original_index];
 
             auto selected_base = selected_outputs + (output_offset + j) * 6;
             selected_base[0] = box_info.class_index;
             selected_base[1] = box_info.score;
 
-            auto &selected_index = selected_indices[j + output_offset];
+            auto& selected_index = selected_indices[j + output_offset];
             if (shared) {
                 selected_index = _flattened_index(box_info.batch_index, box_info.box_index, m_numBoxes);
                 selected_base[2] = boxes[selected_index * 4];
@@ -384,10 +413,9 @@ void MultiClassNms::execute(dnnl::stream strm) {
                     offset += roisnum[i];
                 }
                 // selected index from (M, C, 4)
-                selected_index = _flattened_index((offset + box_info.box_index),
-                                                box_info.class_index, m_numClasses);
+                selected_index = _flattened_index((offset + box_info.box_index), box_info.class_index, m_numClasses);
                 int idx = box_info.class_index * boxesStrides[0] + offset * boxesStrides[1];
-                const float* curboxes = boxes + idx; // a slice of boxes of current class current image
+                const float* curboxes = boxes + idx;  // a slice of boxes of current class current image
                 selected_base[2] = curboxes[4 * box_info.box_index];
                 selected_base[3] = curboxes[4 * box_info.box_index + 1];
                 selected_base[4] = curboxes[4 * box_info.box_index + 2];
@@ -396,7 +424,9 @@ void MultiClassNms::execute(dnnl::stream strm) {
         }
 
         if (m_outStaticShape) {
-            std::fill_n(selected_outputs + (output_offset + real_boxes) * 6, (selectedBoxesNum_perBatch - real_boxes) * 6, -1.f);
+            std::fill_n(selected_outputs + (output_offset + real_boxes) * 6,
+                        (selectedBoxesNum_perBatch - real_boxes) * 6,
+                        -1.f);
             std::fill_n(selected_indices + (output_offset + real_boxes), selectedBoxesNum_perBatch - real_boxes, -1);
             output_offset += selectedBoxesNum_perBatch;
             original_offset += real_boxes;
@@ -436,12 +466,12 @@ float MultiClassNms::intersectionOverUnion(const float* boxesI, const float* box
 }
 
 void MultiClassNms::nmsWithEta(const float* boxes,
-                                const float* scores,
-                                const int* roisnum,
-                                const VectorDims& boxesStrides,
-                                const VectorDims& scoresStrides,
-                                const VectorDims& roisnumStrides,
-                                const bool shared) {
+                               const float* scores,
+                               const int* roisnum,
+                               const VectorDims& boxesStrides,
+                               const VectorDims& scoresStrides,
+                               const VectorDims& roisnumStrides,
+                               const bool shared) {
     auto less = [](const boxInfo& l, const boxInfo& r) {
         return l.score < r.score || ((l.score == r.score) && (l.idx > r.idx));
     };
@@ -459,8 +489,10 @@ void MultiClassNms::nmsWithEta(const float* boxes,
         }
         if (class_idx != m_backgroundClass) {
             std::vector<filteredBoxes> fb;
-            const float* boxesPtr = slice_class(batch_idx, class_idx, boxes, boxesStrides, true, roisnum, roisnumStrides, shared);
-            const float* scoresPtr = slice_class(batch_idx, class_idx, scores, scoresStrides, false, roisnum, roisnumStrides, shared);
+            const float* boxesPtr =
+                slice_class(batch_idx, class_idx, boxes, boxesStrides, true, roisnum, roisnumStrides, shared);
+            const float* scoresPtr =
+                slice_class(batch_idx, class_idx, scores, scoresStrides, false, roisnum, roisnumStrides, shared);
 
             std::priority_queue<boxInfo, std::vector<boxInfo>, decltype(less)> sorted_boxes(less);
             int cur_numBoxes = shared ? m_numBoxes : roisnum[batch_idx];
@@ -481,7 +513,9 @@ void MultiClassNms::nmsWithEta(const float* boxes,
 
                     bool box_is_selected = true;
                     for (int idx = static_cast<int>(fb.size()) - 1; idx >= currBox.suppress_begin_index; idx--) {
-                        float iou = intersectionOverUnion(&boxesPtr[currBox.idx * 4], &boxesPtr[fb[idx].box_index * 4], m_normalized);
+                        float iou = intersectionOverUnion(&boxesPtr[currBox.idx * 4],
+                                                          &boxesPtr[fb[idx].box_index * 4],
+                                                          m_normalized);
                         currBox.score *= func(iou, adaptive_threshold);
                         if (iou >= adaptive_threshold) {
                             box_is_selected = false;
@@ -548,12 +582,12 @@ const float* MultiClassNms::slice_class(const int batch_idx,
 }
 
 void MultiClassNms::nmsWithoutEta(const float* boxes,
-                                const float* scores,
-                                const int* roisnum,
-                                const VectorDims& boxesStrides,
-                                const VectorDims& scoresStrides,
-                                const VectorDims& roisnumStrides,
-                                const bool shared) {
+                                  const float* scores,
+                                  const int* roisnum,
+                                  const VectorDims& boxesStrides,
+                                  const VectorDims& scoresStrides,
+                                  const VectorDims& roisnumStrides,
+                                  const bool shared) {
     parallel_for2d(m_numBatches, m_numClasses, [&](int batch_idx, int class_idx) {
         /*
         // nms over a class over an image
@@ -567,8 +601,10 @@ void MultiClassNms::nmsWithoutEta(const float* boxes,
             }
         }
         if (class_idx != m_backgroundClass) {
-            const float* boxesPtr = slice_class(batch_idx, class_idx, boxes, boxesStrides, true, roisnum, roisnumStrides, shared);
-            const float* scoresPtr = slice_class(batch_idx, class_idx, scores, scoresStrides, false, roisnum, roisnumStrides, shared);
+            const float* boxesPtr =
+                slice_class(batch_idx, class_idx, boxes, boxesStrides, true, roisnum, roisnumStrides, shared);
+            const float* scoresPtr =
+                slice_class(batch_idx, class_idx, scores, scoresStrides, false, roisnum, roisnumStrides, shared);
 
             std::vector<std::pair<float, int>> sorted_boxes;
             int cur_numBoxes = shared ? m_numBoxes : roisnum[batch_idx];
@@ -579,11 +615,14 @@ void MultiClassNms::nmsWithoutEta(const float* boxes,
 
             int io_selection_size = 0;
             if (sorted_boxes.size() > 0) {
-                parallel_sort(sorted_boxes.begin(), sorted_boxes.end(), [](const std::pair<float, int>& l, const std::pair<float, int>& r) {
-                    return (l.first > r.first || ((l.first == r.first) && (l.second < r.second)));
-                });
+                parallel_sort(sorted_boxes.begin(),
+                              sorted_boxes.end(),
+                              [](const std::pair<float, int>& l, const std::pair<float, int>& r) {
+                                  return (l.first > r.first || ((l.first == r.first) && (l.second < r.second)));
+                              });
                 int offset = batch_idx * m_numClasses * m_nmsRealTopk + class_idx * m_nmsRealTopk;
-                m_filtBoxes[offset + 0] = filteredBoxes(sorted_boxes[0].first, batch_idx, class_idx, sorted_boxes[0].second);
+                m_filtBoxes[offset + 0] =
+                    filteredBoxes(sorted_boxes[0].first, batch_idx, class_idx, sorted_boxes[0].second);
                 io_selection_size++;
                 int max_out_box =
                     (static_cast<size_t>(m_nmsRealTopk) > sorted_boxes.size()) ? sorted_boxes.size() : m_nmsRealTopk;
@@ -591,7 +630,8 @@ void MultiClassNms::nmsWithoutEta(const float* boxes,
                     bool box_is_selected = true;
                     for (int idx = io_selection_size - 1; idx >= 0; idx--) {
                         float iou = intersectionOverUnion(&boxesPtr[sorted_boxes[box_idx].second * 4],
-                            &boxesPtr[m_filtBoxes[offset + idx].box_index * 4], m_normalized);
+                                                          &boxesPtr[m_filtBoxes[offset + idx].box_index * 4],
+                                                          m_normalized);
                         if (iou >= m_iouThreshold) {
                             box_is_selected = false;
                             break;
@@ -599,8 +639,10 @@ void MultiClassNms::nmsWithoutEta(const float* boxes,
                     }
 
                     if (box_is_selected) {
-                        m_filtBoxes[offset + io_selection_size] = filteredBoxes(sorted_boxes[box_idx].first, batch_idx, class_idx,
-                            sorted_boxes[box_idx].second);
+                        m_filtBoxes[offset + io_selection_size] = filteredBoxes(sorted_boxes[box_idx].first,
+                                                                                batch_idx,
+                                                                                class_idx,
+                                                                                sorted_boxes[box_idx].second);
                         io_selection_size++;
                     }
                 }
@@ -618,6 +660,6 @@ void MultiClassNms::checkPrecision(const ov::element::Type prec,
         OPENVINO_THROW(m_errorPrefix, "has unsupported '", name, "' ", type, " precision: ", prec);
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/multiclass_nms.hpp b/src/plugins/intel_cpu/src/nodes/multiclass_nms.hpp
index ea5d166351efb6..ea79ee323b66df 100644
--- a/src/plugins/intel_cpu/src/nodes/multiclass_nms.hpp
+++ b/src/plugins/intel_cpu/src/nodes/multiclass_nms.hpp
@@ -20,7 +20,7 @@ class MultiClassNms : public Node {
 public:
     MultiClassNms(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -30,7 +30,9 @@ class MultiClassNms : public Node {
     bool isExecutable() const override;
     void executeDynamicImpl(dnnl::stream strm) override;
 
-    bool needShapeInfer() const override { return false; }
+    bool needShapeInfer() const override {
+        return false;
+    }
     void prepareParams() override;
 
 private:
@@ -66,7 +68,7 @@ class MultiClassNms : public Node {
 
     std::string m_errorPrefix;
 
-    std::vector<std::vector<size_t>> m_numFiltBox; // number of rois after nms for each class in each image
+    std::vector<std::vector<size_t>> m_numFiltBox;  // number of rois after nms for each class in each image
     std::vector<size_t> m_numBoxOffset;
     const std::string m_inType = "input", m_outType = "output";
 
@@ -77,7 +79,10 @@ class MultiClassNms : public Node {
         int box_index;
         filteredBoxes() = default;
         filteredBoxes(float _score, int _batch_index, int _class_index, int _box_index)
-            : score(_score), batch_index(_batch_index), class_index(_class_index), box_index(_box_index) {}
+            : score(_score),
+              batch_index(_batch_index),
+              class_index(_class_index),
+              box_index(_box_index) {}
     };
 
     struct boxInfo {
@@ -86,29 +91,41 @@ class MultiClassNms : public Node {
         int suppress_begin_index;
     };
 
-    std::vector<filteredBoxes> m_filtBoxes; // rois after nms for each class in each image
+    std::vector<filteredBoxes> m_filtBoxes;  // rois after nms for each class in each image
 
-    void checkPrecision(const ov::element::Type prec, const std::vector<ov::element::Type> precList, const std::string name,
+    void checkPrecision(const ov::element::Type prec,
+                        const std::vector<ov::element::Type> precList,
+                        const std::string name,
                         const std::string type);
 
     float intersectionOverUnion(const float* boxesI, const float* boxesJ, const bool normalized);
 
-    void nmsWithEta(const float* boxes, const float* scores, const int* roisnum, const VectorDims& boxesStrides,
-                    const VectorDims& scoresStrides, const VectorDims& roisnumStrides, const bool shared);
-
-    void nmsWithoutEta(const float* boxes, const float* scores, const int* roisnum, const VectorDims& boxesStrides,
-                       const VectorDims& scoresStrides, const VectorDims& roisnumStrides, const bool shared);
+    void nmsWithEta(const float* boxes,
+                    const float* scores,
+                    const int* roisnum,
+                    const VectorDims& boxesStrides,
+                    const VectorDims& scoresStrides,
+                    const VectorDims& roisnumStrides,
+                    const bool shared);
+
+    void nmsWithoutEta(const float* boxes,
+                       const float* scores,
+                       const int* roisnum,
+                       const VectorDims& boxesStrides,
+                       const VectorDims& scoresStrides,
+                       const VectorDims& roisnumStrides,
+                       const bool shared);
 
     const float* slice_class(const int batch_idx,
-                            const int class_idx,
-                            const float* dataPtr,
-                            const VectorDims& dataStrides,
-                            const bool is_boxes,
-                            const int* roisnum,
-                            const VectorDims& roisnumStrides,
-                            const bool shared);
+                             const int class_idx,
+                             const float* dataPtr,
+                             const VectorDims& dataStrides,
+                             const bool is_boxes,
+                             const int* roisnum,
+                             const VectorDims& roisnumStrides,
+                             const bool shared);
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/multinomial.cpp b/src/plugins/intel_cpu/src/nodes/multinomial.cpp
index 4ea11b2b44ffac..2e0b0e74926610 100644
--- a/src/plugins/intel_cpu/src/nodes/multinomial.cpp
+++ b/src/plugins/intel_cpu/src/nodes/multinomial.cpp
@@ -4,9 +4,10 @@
 
 #include "multinomial.hpp"
 
-#include "openvino/op/multinomial.hpp"
-#include <openvino/op/constant.hpp>
 #include <openvino/core/type.hpp>
+#include <openvino/op/constant.hpp>
+
+#include "openvino/op/multinomial.hpp"
 #include "utils/bfloat16.hpp"
 
 namespace ov {
@@ -80,7 +81,7 @@ bool Multinomial::needPrepareParams() const {
 void Multinomial::createPrimitive() {
     if (!m_const_inputs[NUM_SAMPLES_PORT]) {
         CPU_NODE_ASSERT(isDynamicNode(), "is static while the samples input is a variable");
-        return; // avoid reading non initialized data from the NUM_SAMPLES_PORT input
+        return;  // avoid reading non initialized data from the NUM_SAMPLES_PORT input
     }
     Node::createPrimitive();
 }
@@ -102,11 +103,9 @@ void Multinomial::prepareParams() {
     }
 
     if (m_num_samples_precision == ov::element::i32) {
-        m_samples_count =
-            getSrcDataAtPortAs<const int32_t>(NUM_SAMPLES_PORT)[0];
+        m_samples_count = getSrcDataAtPortAs<const int32_t>(NUM_SAMPLES_PORT)[0];
     } else {
-        m_samples_count =
-            getSrcDataAtPortAs<const int64_t>(NUM_SAMPLES_PORT)[0];
+        m_samples_count = getSrcDataAtPortAs<const int64_t>(NUM_SAMPLES_PORT)[0];
     }
 
     m_batches_count = probs_shape[0];
diff --git a/src/plugins/intel_cpu/src/nodes/multinomial.hpp b/src/plugins/intel_cpu/src/nodes/multinomial.hpp
index 611b70503f5dba..cf18ee9b030446 100644
--- a/src/plugins/intel_cpu/src/nodes/multinomial.hpp
+++ b/src/plugins/intel_cpu/src/nodes/multinomial.hpp
@@ -7,8 +7,8 @@
 #include <random>
 #include <string>
 
-#include "openvino/core/parallel.hpp"
 #include "node.h"
+#include "openvino/core/parallel.hpp"
 
 namespace ov {
 namespace intel_cpu {
diff --git a/src/plugins/intel_cpu/src/nodes/mvn.cpp b/src/plugins/intel_cpu/src/nodes/mvn.cpp
index 6405a3f1511286..6c11feee2534b9 100644
--- a/src/plugins/intel_cpu/src/nodes/mvn.cpp
+++ b/src/plugins/intel_cpu/src/nodes/mvn.cpp
@@ -5,26 +5,24 @@
 #include "mvn.h"
 
 #include <algorithm>
+#include <memory>
+#include <openvino/opsets/opset6.hpp>
 #include <string>
 #include <vector>
-#include <memory>
-
-#include "fake_quantize.h"
-#include "eltwise.h"
-#include "dnnl_extension_utils.h"
-#include "utils/bfloat16.hpp"
-#include "openvino/core/parallel.hpp"
-#include "emitters/plugin/x64/jit_load_store_emitters.hpp"
-#include "emitters/plugin/x64/jit_bf16_emitters.hpp"
 
-#include "cpu/x64/jit_generator.hpp"
-#include "cpu/x64/jit_uni_eltwise.hpp"
 #include "cpu/x64/injectors/jit_uni_depthwise_injector.hpp"
-#include "cpu/x64/injectors/jit_uni_quantization_injector.hpp"
 #include "cpu/x64/injectors/jit_uni_eltwise_injector.hpp"
-
-#include <openvino/opsets/opset6.hpp>
+#include "cpu/x64/injectors/jit_uni_quantization_injector.hpp"
+#include "cpu/x64/jit_generator.hpp"
+#include "cpu/x64/jit_uni_eltwise.hpp"
+#include "dnnl_extension_utils.h"
+#include "eltwise.h"
+#include "emitters/plugin/x64/jit_bf16_emitters.hpp"
+#include "emitters/plugin/x64/jit_load_store_emitters.hpp"
+#include "fake_quantize.h"
 #include "memory_desc/dnnl_blocked_memory_desc.h"
+#include "openvino/core/parallel.hpp"
+#include "utils/bfloat16.hpp"
 #include "utils/cpu_utils.hpp"
 
 using namespace dnnl;
@@ -68,19 +66,16 @@ size_t MVNKey::hash() const {
 
 bool MVNKey::operator==(const MVNKey& rhs) const {
     bool retVal = true;
-    retVal = retVal &&
-             mvnAttrs.initAcrossChannels_ == rhs.mvnAttrs.initAcrossChannels_ &&
+    retVal = retVal && mvnAttrs.initAcrossChannels_ == rhs.mvnAttrs.initAcrossChannels_ &&
              mvnAttrs.execAcrossChannels_ == rhs.mvnAttrs.execAcrossChannels_ &&
              mvnAttrs.normalizeVariance_ == rhs.mvnAttrs.normalizeVariance_ &&
-             mvnAttrs.epsValue_ == rhs.mvnAttrs.epsValue_ &&
-             mvnAttrs.epsMode_ == rhs.mvnAttrs.epsMode_ &&
-             mvnAttrs.src_prc == rhs.mvnAttrs.src_prc &&
-             mvnAttrs.dst_prc == rhs.mvnAttrs.dst_prc &&
+             mvnAttrs.epsValue_ == rhs.mvnAttrs.epsValue_ && mvnAttrs.epsMode_ == rhs.mvnAttrs.epsMode_ &&
+             mvnAttrs.src_prc == rhs.mvnAttrs.src_prc && mvnAttrs.dst_prc == rhs.mvnAttrs.dst_prc &&
              mvnAttrs.layout == rhs.mvnAttrs.layout;
     retVal = retVal && *attr.get() == *rhs.attr.get();
     return retVal;
 }
-} // namespace
+}  // namespace
 
 #if defined(OPENVINO_ARCH_X86_64)
 
@@ -111,7 +106,9 @@ template <cpu_isa_t isa>
 struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_mvn_mean_kernel_f32)
 
-    explicit jit_uni_mvn_mean_variance_kernel_f32(jit_mvn_config_params jcp) : jit_uni_mvn_mean_variance_kernel(jcp), jit_generator(jit_name()) {}
+    explicit jit_uni_mvn_mean_variance_kernel_f32(jit_mvn_config_params jcp)
+        : jit_uni_mvn_mean_variance_kernel(jcp),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -120,15 +117,24 @@ struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_k
 
     void generate() override {
         ov::element::Type dst_prc = isFloatCompatible(jcp_.src_prc) ? ov::element::f32 : ov::element::i32;
-        load_emitter[VECTOR] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, vector_step));
-        load_emitter[TAIL8] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 8));
-        load_emitter[TAIL4] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 4));
-        load_emitter[TAIL2] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 2));
-        load_emitter[TAIL1] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 1));
-        load_emitter[TAIL8_FILL] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 8, ov::element::f32, true, "zero"));
-        load_emitter[TAIL4_FILL] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 4, ov::element::f32, true, "zero"));
-        load_emitter[TAIL2_FILL] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 2, ov::element::f32, true, "zero"));
-        load_emitter[TAIL1_FILL] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 1, ov::element::f32, true, "zero"));
+        load_emitter[VECTOR] =
+            std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, vector_step));
+        load_emitter[TAIL8] =
+            std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 8));
+        load_emitter[TAIL4] =
+            std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 4));
+        load_emitter[TAIL2] =
+            std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 2));
+        load_emitter[TAIL1] =
+            std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 1));
+        load_emitter[TAIL8_FILL] = std::unique_ptr<jit_load_emitter>(
+            new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 8, ov::element::f32, true, "zero"));
+        load_emitter[TAIL4_FILL] = std::unique_ptr<jit_load_emitter>(
+            new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 4, ov::element::f32, true, "zero"));
+        load_emitter[TAIL2_FILL] = std::unique_ptr<jit_load_emitter>(
+            new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 2, ov::element::f32, true, "zero"));
+        load_emitter[TAIL1_FILL] = std::unique_ptr<jit_load_emitter>(
+            new jit_load_emitter(this, isa, jcp_.src_prc, dst_prc, 1, ov::element::f32, true, "zero"));
 
         this->preamble();
         mov(reg_table, l_table);
@@ -152,10 +158,12 @@ struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_k
             }
         }
 
-        size_t data_step = (isa == cpu::x64::sse41 && jcp_.layout == MVNLayoutType::mvn_block) ? vector_step * 2 : vector_step;
+        size_t data_step =
+            (isa == cpu::x64::sse41 && jcp_.layout == MVNLayoutType::mvn_block) ? vector_step * 2 : vector_step;
         src_stride = data_step * jcp_.src_data_size;
 
-        load_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx()), static_cast<size_t>(reg_load_table.getIdx())};
+        load_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx()),
+                              static_cast<size_t>(reg_load_table.getIdx())};
 
         if (jcp_.layout == MVNLayoutType::mvn_planar) {
             worker_vector_unroll();
@@ -188,8 +196,8 @@ struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_k
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
 
     const int vlen = cpu_isa_traits<isa>::vlen;
     const int vector_step = vlen / sizeof(float);
@@ -273,7 +281,7 @@ struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_k
         mov(rax, reg_rt_shape);
         mov(reg_vector_num, vector_step);
         xor_(rdx, rdx);
-        div(reg_vector_num);    // reg_rt_shape / vector_step, rax is result, rdx is tails(remainder)
+        div(reg_vector_num);  // reg_rt_shape / vector_step, rax is result, rdx is tails(remainder)
         mov(reg_vector_num, rax);
         mov(reg_tail_num, rdx);
 
@@ -304,9 +312,7 @@ struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_k
         mov(last_unroll_size, rdx);
         jmp(label_reset_last_unroll_size_end);
         L(label_reset_last_unroll_size);
-        {
-            mov(last_unroll_size, reg_unroll_size);
-        }
+        { mov(last_unroll_size, reg_unroll_size); }
         L(label_reset_last_unroll_size_end);
 
         // size_t unroll_number = div_up(vec_num, unroll_size); --> (vec_num + unroll_size - 1) / unroll_size;
@@ -325,7 +331,10 @@ struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_k
                 uni_vmovups(Vmm(ur_base + 8 + vmm_id), ptr[reg_mean + vmm_id * vlen]);
         };
         auto load_src = [&](int vmm_id) {
-            load_emitter[VECTOR]->emit_code({static_cast<size_t>(reg_src_aux.getIdx())}, {static_cast<size_t>(ur_base + vmm_id)}, {}, {load_pool_gpr_idxs});
+            load_emitter[VECTOR]->emit_code({static_cast<size_t>(reg_src_aux.getIdx())},
+                                            {static_cast<size_t>(ur_base + vmm_id)},
+                                            {},
+                                            {load_pool_gpr_idxs});
             add(reg_src_aux, vector_step * jcp_.src_data_size);
         };
         auto mv = [&](int vmm_id) {
@@ -461,8 +470,10 @@ struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_k
             } else if (step == 2) {
                 emitter_id = 3;
             }
-            load_emitter[emitter_id]->emit_code({static_cast<size_t>(reg_src_aux.getIdx())}, {static_cast<size_t>(ur_base + vmm_id)},
-                                                {}, {load_pool_gpr_idxs});
+            load_emitter[emitter_id]->emit_code({static_cast<size_t>(reg_src_aux.getIdx())},
+                                                {static_cast<size_t>(ur_base + vmm_id)},
+                                                {},
+                                                {load_pool_gpr_idxs});
             add(reg_src_aux, step * jcp_.src_data_size);
         };
         auto mv_tails = [&](int step) {
@@ -534,7 +545,8 @@ struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_k
         Xbyak::Reg64 reg_work_amount_bk = rdi;
         mov(reg_src_bk, reg_src);
         mov(reg_work_amount_bk, reg_work_amount);
-        int repeats = (isa == cpu::x64::sse41) ? 2 : 1; // block size is also 8 on cpu::x64::sse41 with two step process
+        int repeats =
+            (isa == cpu::x64::sse41) ? 2 : 1;  // block size is also 8 on cpu::x64::sse41 with two step process
 
         auto reset_with_offset = [&](int offset) {
             add(reg_src_bk, offset * jcp_.src_data_size);
@@ -566,7 +578,8 @@ struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_k
                 }
                 uni_vmovups(ptr[reg_variance], vmm_variance);
             } else {
-                if (!isFloatCompatible(jcp_.src_prc))  // add with int for int-family data type, other compute go with float
+                if (!isFloatCompatible(
+                        jcp_.src_prc))  // add with int for int-family data type, other compute go with float
                     uni_vcvtdq2ps(vmm_sum, vmm_sum);
 
                 if (!jcp_.across_channels) {
@@ -715,8 +728,10 @@ struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_k
     }
 
     inline void worker_full_size() {
-        load_emitter[VECTOR]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-                                       {}, {load_pool_gpr_idxs});
+        load_emitter[VECTOR]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                        {static_cast<size_t>(vmm_val.getIdx())},
+                                        {},
+                                        {load_pool_gpr_idxs});
 
         if (jcp_.normalize_variance) {
             // all with float
@@ -752,20 +767,28 @@ struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_k
         if (is_zero_pad) {
             switch (block_num) {
             case 8:
-                load_emitter[TAIL8_FILL]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-                                           {}, {load_pool_gpr_idxs});
+                load_emitter[TAIL8_FILL]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                                    {static_cast<size_t>(vmm_val.getIdx())},
+                                                    {},
+                                                    {load_pool_gpr_idxs});
                 break;
             case 4:
-                load_emitter[TAIL4_FILL]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-                                           {}, {load_pool_gpr_idxs});
+                load_emitter[TAIL4_FILL]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                                    {static_cast<size_t>(vmm_val.getIdx())},
+                                                    {},
+                                                    {load_pool_gpr_idxs});
                 break;
             case 2:
-                load_emitter[TAIL2_FILL]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-                                           {}, {load_pool_gpr_idxs});
+                load_emitter[TAIL2_FILL]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                                    {static_cast<size_t>(vmm_val.getIdx())},
+                                                    {},
+                                                    {load_pool_gpr_idxs});
                 break;
             case 1:
-                load_emitter[TAIL1_FILL]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-                                           {}, {load_pool_gpr_idxs});
+                load_emitter[TAIL1_FILL]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                                    {static_cast<size_t>(vmm_val.getIdx())},
+                                                    {},
+                                                    {load_pool_gpr_idxs});
                 break;
             default:
                 assert(!"MVN layer tails is processed only with 8/4/2/1 blocks.");
@@ -774,20 +797,28 @@ struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_k
         } else {
             switch (block_num) {
             case 8:
-                load_emitter[TAIL8]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-                                           {}, {load_pool_gpr_idxs});
+                load_emitter[TAIL8]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                               {static_cast<size_t>(vmm_val.getIdx())},
+                                               {},
+                                               {load_pool_gpr_idxs});
                 break;
             case 4:
-                load_emitter[TAIL4]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-                                           {}, {load_pool_gpr_idxs});
+                load_emitter[TAIL4]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                               {static_cast<size_t>(vmm_val.getIdx())},
+                                               {},
+                                               {load_pool_gpr_idxs});
                 break;
             case 2:
-                load_emitter[TAIL2]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-                                           {}, {load_pool_gpr_idxs});
+                load_emitter[TAIL2]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                               {static_cast<size_t>(vmm_val.getIdx())},
+                                               {},
+                                               {load_pool_gpr_idxs});
                 break;
             case 1:
-                load_emitter[TAIL1]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-                                           {}, {load_pool_gpr_idxs});
+                load_emitter[TAIL1]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                               {static_cast<size_t>(vmm_val.getIdx())},
+                                               {},
+                                               {load_pool_gpr_idxs});
                 break;
             default:
                 assert(!"MVN layer tails is processed only with 8/4/2/1 blocks.");
@@ -826,10 +857,10 @@ struct jit_uni_mvn_mean_variance_kernel_f32 : public jit_uni_mvn_mean_variance_k
     }
 
     inline void reduce_sum_store_xmm(Xbyak::Xmm xmm_sum) {
-        uni_vmovshdup(xmm_aux3, xmm_sum);            //  sum:1,2,3,4; aux3:2,2,4,4
-        uni_vaddps(xmm_sum, xmm_sum, xmm_aux3);      //  sum:1+2,2+2,3+4,4+4
-        uni_vmovhlps(xmm_aux3, xmm_aux3, xmm_sum);   //  aux3:3+4,4+4,4,4
-        uni_vaddps(xmm_sum, xmm_sum,  xmm_aux3);     //  sum:1+2+3+4,...
+        uni_vmovshdup(xmm_aux3, xmm_sum);           //  sum:1,2,3,4; aux3:2,2,4,4
+        uni_vaddps(xmm_sum, xmm_sum, xmm_aux3);     //  sum:1+2,2+2,3+4,4+4
+        uni_vmovhlps(xmm_aux3, xmm_aux3, xmm_sum);  //  aux3:3+4,4+4,4,4
+        uni_vaddps(xmm_sum, xmm_sum, xmm_aux3);     //  sum:1+2+3+4,...
         if (jcp_.normalize_variance) {
             uni_vmovss(ptr[reg_variance], xmm_sum);
         } else {
@@ -887,16 +918,20 @@ template <cpu_isa_t isa>
 struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_mvn_kernel_f32)
 
-    explicit jit_uni_mvn_kernel_f32(jit_mvn_config_params jcp, const dnnl_primitive_attr &attr) : jit_uni_mvn_kernel(jcp, attr), jit_generator(jit_name()) {
-        const auto &p = attr_.post_ops_;
-        bool opt_scaleshift_applicable = jcp_.layout == MVNLayoutType::mvn_by_channel && isa == cpu::x64::avx512_core && !jcp_.across_channels;
+    explicit jit_uni_mvn_kernel_f32(jit_mvn_config_params jcp, const dnnl_primitive_attr& attr)
+        : jit_uni_mvn_kernel(jcp, attr),
+          jit_generator(jit_name()) {
+        const auto& p = attr_.post_ops_;
+        bool opt_scaleshift_applicable =
+            jcp_.layout == MVNLayoutType::mvn_by_channel && isa == cpu::x64::avx512_core && !jcp_.across_channels;
         if (opt_scaleshift_applicable) {
             for (int i = 0; i < p.len(); i++) {
-                auto &post_op = p.entry_[i];
+                auto& post_op = p.entry_[i];
                 if (post_op.is_depthwise()) {
                     if (0 == i && post_op.depthwise.alg == alg_kind::depthwise_scale_shift) {
                         optimized_scaleshift_num = 1;
-                    } else if (1 == i && optimized_scaleshift_num == 1 && post_op.depthwise.alg == alg_kind::depthwise_scale_shift) {
+                    } else if (1 == i && optimized_scaleshift_num == 1 &&
+                               post_op.depthwise.alg == alg_kind::depthwise_scale_shift) {
                         optimized_scaleshift_num = 2;
                     }
                 }
@@ -910,31 +945,47 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
     }
 
     void generate() override {
-        const auto &p = attr_.post_ops_;
+        const auto& p = attr_.post_ops_;
         for (int i = 0; i < p.len(); i++) {
-            auto &post_op = p.entry_[i];
+            auto& post_op = p.entry_[i];
             if (post_op.is_eltwise()) {
-                eltwise_injectors.push_back(std::make_shared<jit_uni_eltwise_injector_f32<isa>>(
-                        this, post_op.eltwise.alg, post_op.eltwise.alpha, post_op.eltwise.beta, post_op.eltwise.scale));
+                eltwise_injectors.push_back(std::make_shared<jit_uni_eltwise_injector_f32<isa>>(this,
+                                                                                                post_op.eltwise.alg,
+                                                                                                post_op.eltwise.alpha,
+                                                                                                post_op.eltwise.beta,
+                                                                                                post_op.eltwise.scale));
             } else if (post_op.is_depthwise()) {
-                depthwise_injectors.push_back(std::make_shared<jit_uni_depthwise_injector_f32<isa>>(
-                        this, post_op));
+                depthwise_injectors.push_back(std::make_shared<jit_uni_depthwise_injector_f32<isa>>(this, post_op));
             } else if (post_op.is_quantization()) {
-                quantization_injectors.push_back(std::make_shared<jit_uni_quantization_injector_f32<isa>>(
-                        this, post_op, vmm_d_weights, vmm_d_bias, reg_d_weights, reg_d_bias));
+                quantization_injectors.push_back(std::make_shared<jit_uni_quantization_injector_f32<isa>>(this,
+                                                                                                          post_op,
+                                                                                                          vmm_d_weights,
+                                                                                                          vmm_d_bias,
+                                                                                                          reg_d_weights,
+                                                                                                          reg_d_bias));
             }
         }
 
-        load_emitter[VECTOR] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, ov::element::f32, vector_step));
-        load_emitter[TAIL8] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, ov::element::f32, 8));
-        load_emitter[TAIL4] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, ov::element::f32, 4));
-        load_emitter[TAIL2] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, ov::element::f32, 2));
-        load_emitter[TAIL1] = std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, ov::element::f32, 1));
-        store_emitter[VECTOR] = std::unique_ptr<jit_store_emitter>(new jit_store_emitter(this, isa, ov::element::f32, jcp_.dst_prc, vector_step));
-        store_emitter[TAIL8] = std::unique_ptr<jit_store_emitter>(new jit_store_emitter(this, isa, ov::element::f32, jcp_.dst_prc, 8));
-        store_emitter[TAIL4] = std::unique_ptr<jit_store_emitter>(new jit_store_emitter(this, isa, ov::element::f32, jcp_.dst_prc, 4));
-        store_emitter[TAIL2] = std::unique_ptr<jit_store_emitter>(new jit_store_emitter(this, isa, ov::element::f32, jcp_.dst_prc, 2));
-        store_emitter[TAIL1] = std::unique_ptr<jit_store_emitter>(new jit_store_emitter(this, isa, ov::element::f32, jcp_.dst_prc, 1));
+        load_emitter[VECTOR] = std::unique_ptr<jit_load_emitter>(
+            new jit_load_emitter(this, isa, jcp_.src_prc, ov::element::f32, vector_step));
+        load_emitter[TAIL8] =
+            std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, ov::element::f32, 8));
+        load_emitter[TAIL4] =
+            std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, ov::element::f32, 4));
+        load_emitter[TAIL2] =
+            std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, ov::element::f32, 2));
+        load_emitter[TAIL1] =
+            std::unique_ptr<jit_load_emitter>(new jit_load_emitter(this, isa, jcp_.src_prc, ov::element::f32, 1));
+        store_emitter[VECTOR] = std::unique_ptr<jit_store_emitter>(
+            new jit_store_emitter(this, isa, ov::element::f32, jcp_.dst_prc, vector_step));
+        store_emitter[TAIL8] =
+            std::unique_ptr<jit_store_emitter>(new jit_store_emitter(this, isa, ov::element::f32, jcp_.dst_prc, 8));
+        store_emitter[TAIL4] =
+            std::unique_ptr<jit_store_emitter>(new jit_store_emitter(this, isa, ov::element::f32, jcp_.dst_prc, 4));
+        store_emitter[TAIL2] =
+            std::unique_ptr<jit_store_emitter>(new jit_store_emitter(this, isa, ov::element::f32, jcp_.dst_prc, 2));
+        store_emitter[TAIL1] =
+            std::unique_ptr<jit_store_emitter>(new jit_store_emitter(this, isa, ov::element::f32, jcp_.dst_prc, 1));
 
         this->preamble();
 
@@ -948,7 +999,8 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
         mov(reg_rt_shape, ptr[reg_params + GET_OFF(rt_shape_size)]);
         mov(reg_oc_off, ptr[reg_params + GET_OFF(oc_off)]);
 
-        size_t data_step = (isa == cpu::x64::sse41 && jcp_.layout == MVNLayoutType::mvn_block) ? vector_step * 2 : vector_step;
+        size_t data_step =
+            (isa == cpu::x64::sse41 && jcp_.layout == MVNLayoutType::mvn_block) ? vector_step * 2 : vector_step;
         src_stride = data_step * jcp_.src_data_size;
         dst_stride = data_step * jcp_.dst_data_size;
 
@@ -964,7 +1016,8 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
 
         uni_vpxor(vmm_zero, vmm_zero, vmm_zero);
 
-        load_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx()), static_cast<size_t>(reg_load_table.getIdx())};
+        load_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx()),
+                              static_cast<size_t>(reg_load_table.getIdx())};
         store_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx())};
         store_pool_vec_idxs = {static_cast<size_t>(vmm_zero.getIdx()), static_cast<size_t>(vmm_val.getIdx())};
 
@@ -998,8 +1051,8 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
 
     const int vlen = cpu_isa_traits<isa>::vlen;
     const int vector_step = vlen / sizeof(float);
@@ -1017,7 +1070,7 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
     Xbyak::Reg64 reg_post_ops_data = rsi;
 
     Xbyak::Reg64 reg_rt_shape = r15;
-    Xbyak::Reg64 reg_load_table = r15; // fill not needed, dummy
+    Xbyak::Reg64 reg_load_table = r15;  // fill not needed, dummy
     Xbyak::Reg64 reg_load_store_mask = rbp;
 
     size_t src_stride = 0;
@@ -1157,7 +1210,7 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
         mov(rax, reg_rt_shape);
         mov(addr_vector_num, vector_step);
         xor_(rdx, rdx);
-        div(addr_vector_num);    // reg_rt_shape / vector_step, rax is result, rdx is tails
+        div(addr_vector_num);  // reg_rt_shape / vector_step, rax is result, rdx is tails
         mov(addr_vector_num, rax);
         mov(addr_tail_num, rdx);
 
@@ -1227,7 +1280,9 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
 
         auto load_src = [&](int vmm_id, int step) {
             load_emitter[VECTOR]->emit_code({static_cast<size_t>(reg_src_aux.getIdx())},
-                                           {static_cast<size_t>(ur_base + vmm_id)}, {}, {load_pool_gpr_idxs});
+                                            {static_cast<size_t>(ur_base + vmm_id)},
+                                            {},
+                                            {load_pool_gpr_idxs});
             add(reg_src_aux, step * jcp_.src_data_size);
         };
 
@@ -1240,7 +1295,9 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
 
         // optimized scaleshift fusion
         auto optimized_ss = [&](int vmm_id, int step) {
-            uni_vfmadd132ps(Vmm(ur_base + vmm_id), Vmm(24 + ss_repeat_id * 4 + vmm_id), Vmm(16 + ss_repeat_id * 4 + vmm_id));
+            uni_vfmadd132ps(Vmm(ur_base + vmm_id),
+                            Vmm(24 + ss_repeat_id * 4 + vmm_id),
+                            Vmm(16 + ss_repeat_id * 4 + vmm_id));
         };
 
         auto post_ops = [&](int vmm_id, int step) {
@@ -1249,8 +1306,10 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
         };
 
         auto store_dst = [&](int vmm_id, int step) {
-            store_emitter[VECTOR]->emit_code({static_cast<size_t>(ur_base + vmm_id)}, {static_cast<size_t>(reg_dst_aux.getIdx())},
-                {store_pool_vec_idxs}, {store_pool_gpr_idxs});
+            store_emitter[VECTOR]->emit_code({static_cast<size_t>(ur_base + vmm_id)},
+                                             {static_cast<size_t>(reg_dst_aux.getIdx())},
+                                             {store_pool_vec_idxs},
+                                             {store_pool_gpr_idxs});
             add(reg_dst_aux, step * jcp_.dst_data_size);
         };
 
@@ -1424,14 +1483,18 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
             int vmm_id = get_tile_vr_id(step);
             int emitter_id = get_tile_emitter_id(step);
             load_emitter[emitter_id]->emit_code({static_cast<size_t>(reg_src_aux.getIdx())},
-                                                {static_cast<size_t>(ur_base + vmm_id)}, {}, {load_pool_gpr_idxs});
+                                                {static_cast<size_t>(ur_base + vmm_id)},
+                                                {},
+                                                {load_pool_gpr_idxs});
             add(reg_src_aux, step * jcp_.src_data_size);
         };
         auto store_tails = [&](int step) {
             int vmm_id = get_tile_vr_id(step);
             int emitter_id = get_tile_emitter_id(step);
-            store_emitter[emitter_id]->emit_code({static_cast<size_t>(ur_base + vmm_id)}, {static_cast<size_t>(reg_dst_aux.getIdx())},
-                                       {store_pool_vec_idxs}, {store_pool_gpr_idxs});
+            store_emitter[emitter_id]->emit_code({static_cast<size_t>(ur_base + vmm_id)},
+                                                 {static_cast<size_t>(reg_dst_aux.getIdx())},
+                                                 {store_pool_vec_idxs},
+                                                 {store_pool_gpr_idxs});
             add(reg_dst_aux, step * jcp_.dst_data_size);
         };
 
@@ -1578,8 +1641,10 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
     }
 
     inline void worker_mvn_vector() {
-        load_emitter[VECTOR]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-            {}, {load_pool_gpr_idxs});
+        load_emitter[VECTOR]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                        {static_cast<size_t>(vmm_val.getIdx())},
+                                        {},
+                                        {load_pool_gpr_idxs});
 
         uni_vsubps(vmm_val, vmm_val, vmm_mean);
         if (jcp_.normalize_variance)
@@ -1587,8 +1652,10 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
 
         apply_post_ops(jcp_.dst_prc, vmm_val.getIdx(), jcp_.layout == MVNLayoutType::mvn_planar);
 
-        store_emitter[VECTOR]->emit_code({static_cast<size_t>(vmm_val.getIdx())}, {static_cast<size_t>(reg_dst.getIdx())},
-            {store_pool_vec_idxs}, {store_pool_gpr_idxs});
+        store_emitter[VECTOR]->emit_code({static_cast<size_t>(vmm_val.getIdx())},
+                                         {static_cast<size_t>(reg_dst.getIdx())},
+                                         {store_pool_vec_idxs},
+                                         {store_pool_gpr_idxs});
     }
 
     inline void worker_mvn_tails(Xbyak::Reg64& reg_tail_num, std::function<void(int)> func) {
@@ -1608,20 +1675,28 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
     inline void worker_mvn_block(int block_num) {
         switch (block_num) {
         case 8:
-            load_emitter[TAIL8]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-                {}, {load_pool_gpr_idxs});
+            load_emitter[TAIL8]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                           {static_cast<size_t>(vmm_val.getIdx())},
+                                           {},
+                                           {load_pool_gpr_idxs});
             break;
         case 4:
-            load_emitter[TAIL4]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-                {}, {load_pool_gpr_idxs});
+            load_emitter[TAIL4]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                           {static_cast<size_t>(vmm_val.getIdx())},
+                                           {},
+                                           {load_pool_gpr_idxs});
             break;
         case 2:
-            load_emitter[TAIL2]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-                {}, {load_pool_gpr_idxs});
+            load_emitter[TAIL2]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                           {static_cast<size_t>(vmm_val.getIdx())},
+                                           {},
+                                           {load_pool_gpr_idxs});
             break;
         case 1:
-            load_emitter[TAIL1]->emit_code({static_cast<size_t>(reg_src.getIdx())}, {static_cast<size_t>(vmm_val.getIdx())},
-                {}, {load_pool_gpr_idxs});
+            load_emitter[TAIL1]->emit_code({static_cast<size_t>(reg_src.getIdx())},
+                                           {static_cast<size_t>(vmm_val.getIdx())},
+                                           {},
+                                           {load_pool_gpr_idxs});
             break;
         default:
             assert(!"MVN layer tails is processed only with 8/4/2/1 blocks.");
@@ -1636,20 +1711,28 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
 
         switch (block_num) {
         case 8:
-            store_emitter[TAIL8]->emit_code({static_cast<size_t>(vmm_val.getIdx())}, {static_cast<size_t>(reg_dst.getIdx())},
-                {store_pool_vec_idxs}, {store_pool_gpr_idxs});
+            store_emitter[TAIL8]->emit_code({static_cast<size_t>(vmm_val.getIdx())},
+                                            {static_cast<size_t>(reg_dst.getIdx())},
+                                            {store_pool_vec_idxs},
+                                            {store_pool_gpr_idxs});
             break;
         case 4:
-            store_emitter[TAIL4]->emit_code({static_cast<size_t>(vmm_val.getIdx())}, {static_cast<size_t>(reg_dst.getIdx())},
-                {store_pool_vec_idxs}, {store_pool_gpr_idxs});
+            store_emitter[TAIL4]->emit_code({static_cast<size_t>(vmm_val.getIdx())},
+                                            {static_cast<size_t>(reg_dst.getIdx())},
+                                            {store_pool_vec_idxs},
+                                            {store_pool_gpr_idxs});
             break;
         case 2:
-            store_emitter[TAIL2]->emit_code({static_cast<size_t>(vmm_val.getIdx())}, {static_cast<size_t>(reg_dst.getIdx())},
-                {store_pool_vec_idxs}, {store_pool_gpr_idxs});
+            store_emitter[TAIL2]->emit_code({static_cast<size_t>(vmm_val.getIdx())},
+                                            {static_cast<size_t>(reg_dst.getIdx())},
+                                            {store_pool_vec_idxs},
+                                            {store_pool_gpr_idxs});
             break;
         case 1:
-            store_emitter[TAIL1]->emit_code({static_cast<size_t>(vmm_val.getIdx())}, {static_cast<size_t>(reg_dst.getIdx())},
-                {store_pool_vec_idxs}, {store_pool_gpr_idxs});
+            store_emitter[TAIL1]->emit_code({static_cast<size_t>(vmm_val.getIdx())},
+                                            {static_cast<size_t>(reg_dst.getIdx())},
+                                            {store_pool_vec_idxs},
+                                            {store_pool_gpr_idxs});
             break;
         default:
             assert(!"MVN layer tails is processed only with 8/4/2/1 blocks.");
@@ -1658,7 +1741,7 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
     }
 
     void apply_post_ops(ov::element::Type dst_prc, size_t vmm_idx, bool is_broadcast) {
-        const auto &p = attr_.post_ops_;
+        const auto& p = attr_.post_ops_;
         int eltwise_inj_idx = 0;
         int depthwise_inj_idx = 0;
         int quantization_inj_idx = 0;
@@ -1677,8 +1760,11 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
                 mov(reg_d_weights, ptr[reg_post_ops_data + post_ops_data_offset]);
                 add(reg_d_weights, reg_oc_off);
 
-                depthwise_injectors[depthwise_inj_idx]->compute_vector_range(
-                        vmm_idx, vmm_idx + 1, reg_d_weights, reg_d_weights, is_broadcast);
+                depthwise_injectors[depthwise_inj_idx]->compute_vector_range(vmm_idx,
+                                                                             vmm_idx + 1,
+                                                                             reg_d_weights,
+                                                                             reg_d_weights,
+                                                                             is_broadcast);
 
                 post_ops_data_offset += depthwise_injectors[depthwise_inj_idx]->memoryStep();
                 depthwise_inj_idx++;
@@ -1686,14 +1772,24 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
                 bool do_dequantization = post_op.quantization.alg == alg_kind::quantization_quantize_dequantize;
                 bool do_rounding = do_dequantization || isFloatCompatible(dst_prc) || i != p.len() - 1;
 
-                quantization_injectors[quantization_inj_idx]->init_crop_ptrs(reg_post_ops_data + post_ops_data_offset, reg_oc_off);
+                quantization_injectors[quantization_inj_idx]->init_crop_ptrs(reg_post_ops_data + post_ops_data_offset,
+                                                                             reg_oc_off);
                 quantization_injectors[quantization_inj_idx]->compute_crop(vmm_idx, vmm_idx + 1, 0, 0, is_broadcast);
 
-                quantization_injectors[quantization_inj_idx]->init_input_scale_shift_ptrs(reg_post_ops_data + post_ops_data_offset, reg_oc_off);
-                quantization_injectors[quantization_inj_idx]->compute_input_scale_shift(vmm_idx, vmm_idx + 1, 0, do_rounding, 0, is_broadcast);
-
-                quantization_injectors[quantization_inj_idx]->init_output_scale_shift_ptrs(reg_post_ops_data + post_ops_data_offset, reg_oc_off);
-                quantization_injectors[quantization_inj_idx]->compute_output_scale_shift(vmm_idx, vmm_idx + 1, 0, 0, is_broadcast);
+                quantization_injectors[quantization_inj_idx]->init_input_scale_shift_ptrs(
+                    reg_post_ops_data + post_ops_data_offset,
+                    reg_oc_off);
+                quantization_injectors[quantization_inj_idx]
+                    ->compute_input_scale_shift(vmm_idx, vmm_idx + 1, 0, do_rounding, 0, is_broadcast);
+
+                quantization_injectors[quantization_inj_idx]->init_output_scale_shift_ptrs(
+                    reg_post_ops_data + post_ops_data_offset,
+                    reg_oc_off);
+                quantization_injectors[quantization_inj_idx]->compute_output_scale_shift(vmm_idx,
+                                                                                         vmm_idx + 1,
+                                                                                         0,
+                                                                                         0,
+                                                                                         is_broadcast);
 
                 post_ops_data_offset += quantization_injectors[quantization_inj_idx]->memoryStep();
                 quantization_inj_idx++;
@@ -1702,7 +1798,7 @@ struct jit_uni_mvn_kernel_f32 : public jit_uni_mvn_kernel, public jit_generator
     }
 };
 
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
 //////////////////////////////////////////////////////////////////////////////////
 
@@ -1726,10 +1822,9 @@ bool MVN::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::s
             }
 
             auto epsMode = mvnOp->get_eps_mode();
-            if (epsMode != ov::op::MVNEpsMode::INSIDE_SQRT &&
-                    epsMode != ov::op::MVNEpsMode::OUTSIDE_SQRT) {
+            if (epsMode != ov::op::MVNEpsMode::INSIDE_SQRT && epsMode != ov::op::MVNEpsMode::OUTSIDE_SQRT) {
                 errorMessage = std::string("Just INSIDE_SQRT and OUTSIDE_SQRT epsilon mods are supported. Actual: ") +
-                        std::to_string(static_cast<int>(epsMode));
+                               std::to_string(static_cast<int>(epsMode));
                 return false;
             }
             // Validates MVN node axes to check whether it can be executed on the current CPU implementation.
@@ -1805,22 +1900,23 @@ MVN::MVN(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
 void MVN::getSupportedDescriptors() {}
 
 static inline bool isUnaryEltwise(const NodePtr& node) {
-    return one_of(node->getAlgorithm(), Algorithm::EltwiseRelu,
-                                        Algorithm::EltwiseGeluErf,
-                                        Algorithm::EltwiseGeluTanh,
-                                        Algorithm::EltwiseElu,
-                                        Algorithm::EltwiseSigmoid,
-                                        Algorithm::EltwiseClamp,
-                                        Algorithm::EltwiseTanh,
-                                        Algorithm::EltwiseSwish,
-                                        Algorithm::EltwiseHswish,
-                                        Algorithm::EltwiseMish,
-                                        Algorithm::EltwiseHsigmoid,
-                                        Algorithm::EltwiseRoundHalfToEven,
-                                        Algorithm::EltwiseRoundHalfAwayFromZero,
-                                        Algorithm::EltwiseAbs,
-                                        Algorithm::EltwiseSqrt,
-                                        Algorithm::EltwiseSoftRelu);
+    return one_of(node->getAlgorithm(),
+                  Algorithm::EltwiseRelu,
+                  Algorithm::EltwiseGeluErf,
+                  Algorithm::EltwiseGeluTanh,
+                  Algorithm::EltwiseElu,
+                  Algorithm::EltwiseSigmoid,
+                  Algorithm::EltwiseClamp,
+                  Algorithm::EltwiseTanh,
+                  Algorithm::EltwiseSwish,
+                  Algorithm::EltwiseHswish,
+                  Algorithm::EltwiseMish,
+                  Algorithm::EltwiseHsigmoid,
+                  Algorithm::EltwiseRoundHalfToEven,
+                  Algorithm::EltwiseRoundHalfAwayFromZero,
+                  Algorithm::EltwiseAbs,
+                  Algorithm::EltwiseSqrt,
+                  Algorithm::EltwiseSoftRelu);
 }
 
 void MVN::initSupportedPrimitiveDescriptors() {
@@ -1835,7 +1931,7 @@ void MVN::initSupportedPrimitiveDescriptors() {
     if (!fusedWith.empty()) {
         outputPrecision = fusedWith[fusedWith.size() - 1]->getOriginalOutputPrecisionAtPort(0);
         onlyUnaryPostOps = true;
-        for (auto &node : fusedWith) {
+        for (auto& node : fusedWith) {
             if (isUnaryEltwise(node)) {
                 continue;
             } else {
@@ -1850,7 +1946,7 @@ void MVN::initSupportedPrimitiveDescriptors() {
         inputPrecision = outputPrecision = ov::element::f32;
     }
 #endif
-//Output precision has to be equal to input precision in ACL MVN
+// Output precision has to be equal to input precision in ACL MVN
 #if defined(OV_CPU_WITH_ACL)
     outputPrecision = inputPrecision;
 #endif
@@ -1875,7 +1971,8 @@ void MVN::initSupportedPrimitiveDescriptors() {
     auto& creatorsMap = BlockedDescCreator::getCommonCreators();
     auto pushDesc = [&](LayoutType format, impl_desc_type impl_type, bool useAclExecutor = false) {
         config.inConfs[0].setMemDesc(creatorsMap.at(format)->createSharedDesc(inputPrecision, getInputShapeAtPort(0)));
-        config.outConfs[0].setMemDesc(creatorsMap.at(format)->createSharedDesc(outputPrecision, getOutputShapeAtPort(0)));
+        config.outConfs[0].setMemDesc(
+            creatorsMap.at(format)->createSharedDesc(outputPrecision, getOutputShapeAtPort(0)));
 
         if (useAclExecutor) {
             std::vector<MemoryDescPtr> srcMemoryDescs;
@@ -1887,8 +1984,11 @@ void MVN::initSupportedPrimitiveDescriptors() {
                 dstMemoryDescs.push_back(config.outConfs[i].getMemDesc());
             }
 
-            auto factory = std::make_shared<MVNExecutorFactory>(mvnAttrs, srcMemoryDescs, dstMemoryDescs,
-                                                                        std::make_shared<ExecutorContext>(context, getImplPriority()));
+            auto factory =
+                std::make_shared<MVNExecutorFactory>(mvnAttrs,
+                                                     srcMemoryDescs,
+                                                     dstMemoryDescs,
+                                                     std::make_shared<ExecutorContext>(context, getImplPriority()));
             if (!factory->isEmpty()) {
                 supportedPrimitiveDescriptors.push_back({config, impl_type, factory});
             }
@@ -1898,15 +1998,15 @@ void MVN::initSupportedPrimitiveDescriptors() {
     };
 
 #if defined(OV_CPU_WITH_ACL)
-        pushDesc(LayoutType::nspc, undef, true);
-        pushDesc(LayoutType::ncsp, undef, true);
-        canUseAclExecutor = !supportedPrimitiveDescriptors.empty();
-        if (canUseAclExecutor)
-            return;
-        else
-            // Reference MVN implementation does not support fp16, so set fp32 explicitly
-            inputPrecision = outputPrecision = ov::element::f32;
-#endif // OV_CPU_WITH_ACL
+    pushDesc(LayoutType::nspc, undef, true);
+    pushDesc(LayoutType::ncsp, undef, true);
+    canUseAclExecutor = !supportedPrimitiveDescriptors.empty();
+    if (canUseAclExecutor)
+        return;
+    else
+        // Reference MVN implementation does not support fp16, so set fp32 explicitly
+        inputPrecision = outputPrecision = ov::element::f32;
+#endif  // OV_CPU_WITH_ACL
 
     impl_desc_type impl_type;
     if (mayiuse(cpu::x64::avx512_core)) {
@@ -1929,7 +2029,7 @@ void MVN::initSupportedPrimitiveDescriptors() {
             if (getInputShapeAtPort(0).getRank() == 4 || getInputShapeAtPort(0).getRank() == 5) {
                 pushDesc(LayoutType::nCsp16c, impl_type);
             }
-        } else if (impl_desc_type::jit_avx2 ==  impl_type || impl_desc_type::jit_sse42 == impl_type) {
+        } else if (impl_desc_type::jit_avx2 == impl_type || impl_desc_type::jit_sse42 == impl_type) {
             if (getInputShapeAtPort(0).getRank() == 4 || getInputShapeAtPort(0).getRank() == 5) {
                 pushDesc(LayoutType::nCsp8c, impl_type);
             }
@@ -1947,9 +2047,8 @@ MVN::MVNExecutorBase::MVNExecutorBase(const MVNAttrs& mvnAttrs)
       src_data_size(mvnAttrs.src_prc.size()),
       dst_data_size(mvnAttrs.dst_prc.size()) {}
 
-MVN::MVNJitExecutor::MVNJitExecutor(const MVNAttrs& mvnAttrs,
-                                              const dnnl::primitive_attr& attr):
-                                              MVNExecutorBase(mvnAttrs) {
+MVN::MVNJitExecutor::MVNJitExecutor(const MVNAttrs& mvnAttrs, const dnnl::primitive_attr& attr)
+    : MVNExecutorBase(mvnAttrs) {
     auto jcp = jit_mvn_config_params();
     jcp.src_prc = mvnAttrs.src_prc;
     jcp.dst_prc = mvnAttrs.dst_prc;
@@ -1986,7 +2085,7 @@ MVN::MVNJitExecutor::MVNJitExecutor(const MVNAttrs& mvnAttrs,
     } else {
         OPENVINO_THROW("Can't create jit MVN kernel");
     }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
     if (mvn_kernel)
         mvn_kernel->create_ker();
     if (mvn_mean_kernel)
@@ -1995,7 +2094,10 @@ MVN::MVNJitExecutor::MVNJitExecutor(const MVNAttrs& mvnAttrs,
         mvn_variance_kernel->create_ker();
 }
 
-void MVN::MVNJitExecutor::exec(const uint8_t *src_data, uint8_t *dst_data, const void *post_ops_data_, const VectorDims& shape5d) {
+void MVN::MVNJitExecutor::exec(const uint8_t* src_data,
+                               uint8_t* dst_data,
+                               const void* post_ops_data_,
+                               const VectorDims& shape5d) {
     if (!mvn_mean_kernel || (mvnAttrs.normalizeVariance_ && !mvn_variance_kernel) || !mvn_kernel) {
         OPENVINO_THROW("MVN layer doesn't create kernel to execute on sse41 above platform.");
     }
@@ -2008,9 +2110,12 @@ void MVN::MVNJitExecutor::exec(const uint8_t *src_data, uint8_t *dst_data, const
     }
 }
 
-MVN::MVNRefExecutor::MVNRefExecutor(const MVNAttrs& mvnAttrs):MVNExecutorBase(mvnAttrs) {}
+MVN::MVNRefExecutor::MVNRefExecutor(const MVNAttrs& mvnAttrs) : MVNExecutorBase(mvnAttrs) {}
 
-void MVN::MVNRefExecutor::exec(const uint8_t *src_data, uint8_t *dst_data, const void *post_ops_data_, const VectorDims& shape5d) {
+void MVN::MVNRefExecutor::exec(const uint8_t* src_data,
+                               uint8_t* dst_data,
+                               const void* post_ops_data_,
+                               const VectorDims& shape5d) {
     mvn_ref(src_data, dst_data, shape5d);
 }
 
@@ -2029,10 +2134,11 @@ void MVN::prepareParams() {
 
 #if defined(OPENVINO_ARCH_X86_64)
     // New shape5D always need prepare via transformTo5DCase(), which is need in exec().
-    // MVN itself and unary post ops is totally shape agnostic, execPtr can be reused directly w/o recompilation and setPostOps when shape is changed.
-    // As key have not shape, if shape changes and new post ops attr is also the same, execPtr can still hit.
-    // If new shape(channel changes) impact post ops attr, such as entry.quantization.offset, entry.depthwise.offset, entry.quantization.per_channel,
-    // which is participate in compilation, even postOpsData is passed in runtime, still need recompilation.
+    // MVN itself and unary post ops is totally shape agnostic, execPtr can be reused directly w/o recompilation and
+    // setPostOps when shape is changed. As key have not shape, if shape changes and new post ops attr is also the same,
+    // execPtr can still hit. If new shape(channel changes) impact post ops attr, such as entry.quantization.offset,
+    // entry.depthwise.offset, entry.quantization.per_channel, which is participate in compilation, even postOpsData is
+    // passed in runtime, still need recompilation.
     if (execPtr != nullptr && (fusedWith.empty() || onlyUnaryPostOps)) {
         return;
     }
@@ -2058,7 +2164,10 @@ void MVN::prepareParams() {
         dstMemoryDescs.push_back(getDstMemoryAtPort(0)->getDescPtr());
 
         auto selectedPD = getSelectedPrimitiveDescriptor();
-        aclExecPtr = selectedPD->getExecutorFactoryAs<MVNExecutorFactory>()->makeExecutor(mvnAttrs, srcMemoryDescs, dstMemoryDescs, {});
+        aclExecPtr = selectedPD->getExecutorFactoryAs<MVNExecutorFactory>()->makeExecutor(mvnAttrs,
+                                                                                          srcMemoryDescs,
+                                                                                          dstMemoryDescs,
+                                                                                          {});
         selectedPD->setImplementationType(aclExecPtr->getImplType());
 
         return;
@@ -2087,47 +2196,53 @@ void MVN::transformTo5DCase(const VectorDims& shape) {
     // for 1 and 2 rank, if initAcrossChannels_ is true, adjust shape to fully vectorize under unified 5d procedure.
     // otherwise there are not enough data in spatial dimension to process in one kernel.
     switch (rank) {
-        case 1 :  // C
-            if (mvnAttrs.initAcrossChannels_) {
-                shape5D = {1, 1, 1, 1, shape[0]};
-                mvnAttrs.execAcrossChannels_ = false;
-                break;
-            } else {
-                shape5D = {1, shape[0], 1, 1, 1};
-                break;
-            }
-        case 2 :  // NC
-            if (mvnAttrs.initAcrossChannels_) {
-                shape5D = {1, shape[0], 1, shape[1], 1};
-                mvnAttrs.execAcrossChannels_ = false;
-                break;
-            } else {
-                shape5D = {shape[0], shape[1], 1, 1, 1};
-                break;
-            }
-        case 3 : { shape5D = {shape[0], shape[1], 1, shape[2], 1}; break; }
-        case 4 : { shape5D = {shape[0], shape[1], 1, shape[2], shape[3]}; break; }
-        case 5 : { shape5D = {shape[0], shape[1], shape[2], shape[3], shape[4]}; break; }
-        default: {
-            OPENVINO_THROW("MVN layer with name '",
-                           getName(),
-                           "' doesn't support planar layout with rank: ",
-                           shape.size());
+    case 1:  // C
+        if (mvnAttrs.initAcrossChannels_) {
+            shape5D = {1, 1, 1, 1, shape[0]};
+            mvnAttrs.execAcrossChannels_ = false;
+            break;
+        } else {
+            shape5D = {1, shape[0], 1, 1, 1};
+            break;
         }
+    case 2:  // NC
+        if (mvnAttrs.initAcrossChannels_) {
+            shape5D = {1, shape[0], 1, shape[1], 1};
+            mvnAttrs.execAcrossChannels_ = false;
+            break;
+        } else {
+            shape5D = {shape[0], shape[1], 1, 1, 1};
+            break;
+        }
+    case 3: {
+        shape5D = {shape[0], shape[1], 1, shape[2], 1};
+        break;
+    }
+    case 4: {
+        shape5D = {shape[0], shape[1], 1, shape[2], shape[3]};
+        break;
+    }
+    case 5: {
+        shape5D = {shape[0], shape[1], shape[2], shape[3], shape[4]};
+        break;
+    }
+    default: {
+        OPENVINO_THROW("MVN layer with name '", getName(), "' doesn't support planar layout with rank: ", shape.size());
+    }
     }
 }
 
-void MVN::setPostOps(dnnl::primitive_attr &attr, bool initWeights) {
+void MVN::setPostOps(dnnl::primitive_attr& attr, bool initWeights) {
     dnnl::post_ops ops;
     postOpsDataPtrs.clear();
-    for (auto &node : fusedWith) {
-        auto* fakeQuantizeNode = dynamic_cast<FakeQuantize *>(node.get());
+    for (auto& node : fusedWith) {
+        auto* fakeQuantizeNode = dynamic_cast<FakeQuantize*>(node.get());
         if (fakeQuantizeNode) {
             fakeQuantizeNode->appendPostOps(ops, {}, postOpsDataPtrs);
             continue;
         }
 
-        auto* eltwiseNode = dynamic_cast<Eltwise *>(node.get());
+        auto* eltwiseNode = dynamic_cast<Eltwise*>(node.get());
         if (eltwiseNode) {
             eltwiseNode->appendPostOps(ops, shape5D, postOpsDataPtrs);
             continue;
@@ -2150,8 +2265,8 @@ void MVN::execute(dnnl::stream strm) {
     auto srcMemPtr = getSrcMemoryAtPort(0);
 
     if (execPtr) {
-        uint8_t *dst_data = dstMemPtr->getDataAs<uint8_t>();
-        uint8_t *src_data = srcMemPtr->getDataAs<uint8_t>();
+        uint8_t* dst_data = dstMemPtr->getDataAs<uint8_t>();
+        uint8_t* src_data = srcMemPtr->getDataAs<uint8_t>();
         execPtr->exec(src_data, dst_data, postOpsDataPtrs.data(), shape5D);
     } else if (aclExecPtr) {
         aclExecPtr->exec({srcMemPtr}, {dstMemPtr}, postOpsDataPtrs.data());
@@ -2160,7 +2275,10 @@ void MVN::execute(dnnl::stream strm) {
     }
 }
 
-void MVN::MVNJitExecutor::mvn_pln(const uint8_t* src_data, uint8_t* dst_data, const void *post_ops_data_, const VectorDims& shape5d) {
+void MVN::MVNJitExecutor::mvn_pln(const uint8_t* src_data,
+                                  uint8_t* dst_data,
+                                  const void* post_ops_data_,
+                                  const VectorDims& shape5d) {
     size_t blk_size = 1;  // blk size in vmm
     if (mayiuse(cpu::x64::avx512_core)) {
         blk_size = 16;
@@ -2187,13 +2305,13 @@ void MVN::MVNJitExecutor::mvn_pln(const uint8_t* src_data, uint8_t* dst_data, co
             // Parallel sum for each channel
             float C3inv = 1.f / static_cast<float>(C3);
             float mean_temp = 0.0f;
-            mean_temp = parallel_sum(C, mean_temp, [&](size_t c)->float {
+            mean_temp = parallel_sum(C, mean_temp, [&](size_t c) -> float {
                 float mean_internal = 0.0f;
                 size_t cc = cb + c * C2;
                 auto arg = jit_mvn_call_args();
                 arg.src = src_data + cc * src_data_size;
                 arg.sum = static_cast<float*>(&mean_internal);
-                arg.work_amount = static_cast<size_t>(C2 / blk_size); // for vector part
+                arg.work_amount = static_cast<size_t>(C2 / blk_size);  // for vector part
                 arg.rt_shape_size = static_cast<size_t>(C2 % blk_size);
                 arg.post_op_data = post_ops_data_;
                 (*mvn_mean_kernel)(&arg);
@@ -2206,14 +2324,14 @@ void MVN::MVNJitExecutor::mvn_pln(const uint8_t* src_data, uint8_t* dst_data, co
             // parallel sum for each channel
             if (mvnAttrs.normalizeVariance_) {
                 float variance_temp = 0.0f;
-                variance_temp = parallel_sum(C, variance_temp, [&](size_t c)->float {
+                variance_temp = parallel_sum(C, variance_temp, [&](size_t c) -> float {
                     float variance_internal = 0.0f;
                     size_t cc = cb + c * C2;
                     auto arg = jit_mvn_call_args();
                     arg.src = src_data + cc * src_data_size;
                     arg.mean = static_cast<float*>(&mean);
                     arg.variance = static_cast<float*>(&variance_internal);
-                    arg.work_amount = static_cast<size_t>(C2 / blk_size);  // vector part
+                    arg.work_amount = static_cast<size_t>(C2 / blk_size);    // vector part
                     arg.rt_shape_size = static_cast<size_t>(C2 % blk_size);  // for tails
                     arg.post_op_data = post_ops_data_;
                     (*mvn_variance_kernel)(&arg);
@@ -2234,7 +2352,7 @@ void MVN::MVNJitExecutor::mvn_pln(const uint8_t* src_data, uint8_t* dst_data, co
                     arg.dst = dst_data + cc * dst_data_size;
                     arg.mean = static_cast<float*>(&mean);
                     arg.variance = static_cast<float*>(&variance);
-                    arg.work_amount = static_cast<size_t>(C2 / blk_size);  // work amount for vector part
+                    arg.work_amount = static_cast<size_t>(C2 / blk_size);    // work amount for vector part
                     arg.rt_shape_size = static_cast<size_t>(C2 % blk_size);  // for tails
                     arg.oc_off = sizeof(float) * c;
                     arg.post_op_data = post_ops_data_;
@@ -2301,8 +2419,8 @@ void MVN::MVNJitExecutor::mvn_pln(const uint8_t* src_data, uint8_t* dst_data, co
 }
 
 void MVN::MVNRefExecutor::mvn_ref(const uint8_t* src_data, uint8_t* dst_data, const VectorDims& shape5d) {
-    const float *src_data_ptr = reinterpret_cast<const float *>(src_data);
-    float *dst_data_ptr = reinterpret_cast<float *>(dst_data);
+    const float* src_data_ptr = reinterpret_cast<const float*>(src_data);
+    float* dst_data_ptr = reinterpret_cast<float*>(dst_data);
     const size_t N = shape5d[0];
     const size_t C = shape5d[1];
     const size_t D = shape5d[2];
@@ -2320,7 +2438,7 @@ void MVN::MVNRefExecutor::mvn_ref(const uint8_t* src_data, uint8_t* dst_data, co
             float C3inv = 1.f / static_cast<float>(C3);
             float mean_temp = 0.0f;
 
-            mean_temp = parallel_sum(C, mean_temp, [&](size_t c)->float {
+            mean_temp = parallel_sum(C, mean_temp, [&](size_t c) -> float {
                 float mean_internal = 0.0f;
                 size_t cc = cb + c * C2;
                 for (size_t sp = 0lu; sp < C2; sp++) {
@@ -2334,7 +2452,7 @@ void MVN::MVNRefExecutor::mvn_ref(const uint8_t* src_data, uint8_t* dst_data, co
             if (mvnAttrs.normalizeVariance_) {
                 // parallel sum for each channel for variance
                 float variance_temp = 0.0f;
-                variance_temp = parallel_sum(C, variance_temp, [&](size_t c)->float {
+                variance_temp = parallel_sum(C, variance_temp, [&](size_t c) -> float {
                     float variance_internal = 0.0f;
                     size_t cc = cb + c * C2;
                     for (size_t sp = 0lu; sp < C2; sp++) {
@@ -2401,7 +2519,10 @@ void MVN::MVNRefExecutor::mvn_ref(const uint8_t* src_data, uint8_t* dst_data, co
     });
 }
 
-void MVN::MVNJitExecutor::mvn_nspc(const uint8_t* src_data, uint8_t* dst_data, const void *post_ops_data_, const VectorDims& shape5d) {
+void MVN::MVNJitExecutor::mvn_nspc(const uint8_t* src_data,
+                                   uint8_t* dst_data,
+                                   const void* post_ops_data_,
+                                   const VectorDims& shape5d) {
     size_t blk_size = 1;  // channel blk for memory layout
     if (mayiuse(cpu::x64::avx512_core)) {
         blk_size = 16;
@@ -2519,7 +2640,10 @@ void MVN::MVNJitExecutor::mvn_nspc(const uint8_t* src_data, uint8_t* dst_data, c
     });
 }
 
-void MVN::MVNJitExecutor::mvn_blk(const uint8_t* src_data, uint8_t* dst_data, const void *post_ops_data_, const VectorDims& shape5d) {
+void MVN::MVNJitExecutor::mvn_blk(const uint8_t* src_data,
+                                  uint8_t* dst_data,
+                                  const void* post_ops_data_,
+                                  const VectorDims& shape5d) {
     size_t blk_size = 1;  // channel blk for memory layout
     if (mayiuse(cpu::x64::avx512_core)) {
         blk_size = 16;
@@ -2553,7 +2677,7 @@ void MVN::MVNJitExecutor::mvn_blk(const uint8_t* src_data, uint8_t* dst_data, co
             // mean for this instance in batch
             float C5inv = 1.f / static_cast<float>(C5);
             float mean_temp = 0.0f;
-            mean_temp = parallel_sum3d(CB, D, H, mean_temp, [&](size_t cb, size_t d, size_t h)->float {
+            mean_temp = parallel_sum3d(CB, D, H, mean_temp, [&](size_t cb, size_t d, size_t h) -> float {
                 size_t src_offset = b_offset + cb * C2 + d * C1 + h * C0;
 
                 float mean_internal = 0.0f;
@@ -2561,7 +2685,7 @@ void MVN::MVNJitExecutor::mvn_blk(const uint8_t* src_data, uint8_t* dst_data, co
                 //          W           //  |
                 //                      //  |
                 //                      //  |
-                //blk +  +  +  +  +  +  //  |  +
+                // blk +  +  +  +  +  +  //  |  +
                 //                      //  |
                 //                      //  |
                 //                      // \|/
@@ -2581,7 +2705,7 @@ void MVN::MVNJitExecutor::mvn_blk(const uint8_t* src_data, uint8_t* dst_data, co
                 // real tail number or tail is 0(for full vector block).
                 arg.rt_shape_size = (C - cb * blk_size) < blk_size ? static_cast<size_t>(C % blk_size) : 0;
                 arg.oc_off = static_cast<size_t>(cb * blk_size * sizeof(float));  // for tail process
-                (*mvn_mean_kernel)(&arg); // for W * blk
+                (*mvn_mean_kernel)(&arg);                                         // for W * blk
 
                 size_t min_cb = (std::min)(blk_size, C - cb * blk_size);
                 for (size_t i = 0; i < min_cb; i++)
@@ -2593,11 +2717,12 @@ void MVN::MVNJitExecutor::mvn_blk(const uint8_t* src_data, uint8_t* dst_data, co
             if (mvnAttrs.normalizeVariance_) {
                 // variance: sum((x-mean)*(x-mean)) for one instance in batch
                 float variance_temp = 0.0f;
-                variance_temp = parallel_sum3d(CB, D, H, variance_temp, [&](size_t cb, size_t d, size_t h)->float {
+                variance_temp = parallel_sum3d(CB, D, H, variance_temp, [&](size_t cb, size_t d, size_t h) -> float {
                     size_t src_offset = b_offset + cb * C2 + d * C1 + h * C0;
 
                     float variance_internal = 0.0f;
-                    auto variance_buffer_ptr = &variance_buffer[aux_buffer_size * static_cast<size_t>(parallel_get_thread_num())];
+                    auto variance_buffer_ptr =
+                        &variance_buffer[aux_buffer_size * static_cast<size_t>(parallel_get_thread_num())];
                     for (size_t i = 0; i < blk_size; i++)
                         variance_buffer_ptr[i] = 0.f;
 
@@ -2772,8 +2897,7 @@ bool MVN::canFuse(const NodePtr& node) const {
     // 1D only fused with unary
     int inputRank = getInputShapeAtPort(0).getRank();
     bool unaryEltwise = isUnaryEltwise(node);
-    if ((inputRank == 1 && !unaryEltwise) ||
-        (inputRank == 2 && !unaryEltwise && mvnAttrs.initAcrossChannels_)) {
+    if ((inputRank == 1 && !unaryEltwise) || (inputRank == 2 && !unaryEltwise && mvnAttrs.initAcrossChannels_)) {
         return false;
     }
 
@@ -2784,6 +2908,6 @@ bool MVN::created() const {
     return getType() == Type::MVN;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/mvn.h b/src/plugins/intel_cpu/src/nodes/mvn.h
index 8d55cac0f7df63..2b244d81c25586 100644
--- a/src/plugins/intel_cpu/src/nodes/mvn.h
+++ b/src/plugins/intel_cpu/src/nodes/mvn.h
@@ -5,10 +5,12 @@
 #pragma once
 
 #include <node.h>
-#include <string>
+
 #include <memory>
-#include <vector>
+#include <string>
 #include <tuple>
+#include <vector>
+
 #include "executors/mvn_list.hpp"
 
 namespace ov {
@@ -26,11 +28,11 @@ struct jit_mvn_config_params {
 };
 
 struct jit_mvn_call_args {
-    const void *src;
-    void *dst;
-    float *sum;
-    float *mean;
-    float *variance;
+    const void* src;
+    void* dst;
+    float* sum;
+    float* mean;
+    float* variance;
     size_t work_amount;
     size_t oc_off;
     // shape need for shape agnostic kernel passed with each infer.
@@ -40,9 +42,9 @@ struct jit_mvn_call_args {
 };
 
 struct jit_uni_mvn_mean_variance_kernel {
-    void (*ker_)(const jit_mvn_call_args *);
+    void (*ker_)(const jit_mvn_call_args*);
 
-    void operator()(const jit_mvn_call_args *args) {
+    void operator()(const jit_mvn_call_args* args) {
         assert(ker_);
         ker_(args);
     }
@@ -56,20 +58,23 @@ struct jit_uni_mvn_mean_variance_kernel {
 };
 
 struct jit_uni_mvn_kernel {
-    void (*ker_)(const jit_mvn_call_args *);
+    void (*ker_)(const jit_mvn_call_args*);
 
-    void operator()(const jit_mvn_call_args *args) {
+    void operator()(const jit_mvn_call_args* args) {
         assert(ker_);
         ker_(args);
     }
 
-    explicit jit_uni_mvn_kernel(jit_mvn_config_params jcp, const dnnl_primitive_attr &attr) : ker_(nullptr), jcp_(jcp), attr_(attr) {}
+    explicit jit_uni_mvn_kernel(jit_mvn_config_params jcp, const dnnl_primitive_attr& attr)
+        : ker_(nullptr),
+          jcp_(jcp),
+          attr_(attr) {}
     virtual ~jit_uni_mvn_kernel() {}
 
     virtual void create_ker() = 0;
 
     jit_mvn_config_params jcp_;
-    const dnnl_primitive_attr &attr_;
+    const dnnl_primitive_attr& attr_;
     int optimized_scaleshift_num = 0;
 };
 
@@ -99,7 +104,7 @@ class MVN : public Node {
     void prepareParams() override;
 
 private:
-    void setPostOps(dnnl::primitive_attr &attr, bool initWeights = false);
+    void setPostOps(dnnl::primitive_attr& attr, bool initWeights = false);
 
     void transformTo5DCase(const VectorDims& shape);
 
@@ -112,7 +117,10 @@ class MVN : public Node {
     class MVNExecutorBase {
     public:
         MVNExecutorBase(const MVNAttrs& mvnAttrs);
-        virtual void exec(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_, const VectorDims& shape5d) = 0;
+        virtual void exec(const uint8_t* in_ptr_,
+                          uint8_t* out_ptr_,
+                          const void* post_ops_data_,
+                          const VectorDims& shape5d) = 0;
         virtual ~MVNExecutorBase() = default;
 
     protected:
@@ -126,33 +134,38 @@ class MVN : public Node {
     std::shared_ptr<MVNExecutor> aclExecPtr = nullptr;
 
     class MVNJitExecutor : public MVNExecutorBase {
-        public:
-            MVNJitExecutor(const MVNAttrs& mvnAttrs,
-                           const dnnl::primitive_attr &attr);
+    public:
+        MVNJitExecutor(const MVNAttrs& mvnAttrs, const dnnl::primitive_attr& attr);
 
-            void exec(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_, const VectorDims& shape5d) override;
+        void exec(const uint8_t* in_ptr_,
+                  uint8_t* out_ptr_,
+                  const void* post_ops_data_,
+                  const VectorDims& shape5d) override;
 
-        private:
-            void mvn_pln(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_, const VectorDims& shape5d);
-            void mvn_blk(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_, const VectorDims& shape5d);
-            void mvn_nspc(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_, const VectorDims& shape5d);
+    private:
+        void mvn_pln(const uint8_t* in_ptr_, uint8_t* out_ptr_, const void* post_ops_data_, const VectorDims& shape5d);
+        void mvn_blk(const uint8_t* in_ptr_, uint8_t* out_ptr_, const void* post_ops_data_, const VectorDims& shape5d);
+        void mvn_nspc(const uint8_t* in_ptr_, uint8_t* out_ptr_, const void* post_ops_data_, const VectorDims& shape5d);
 
-            std::shared_ptr<jit_uni_mvn_mean_variance_kernel> mvn_mean_kernel;
-            std::shared_ptr<jit_uni_mvn_mean_variance_kernel> mvn_variance_kernel;
-            std::shared_ptr<jit_uni_mvn_kernel> mvn_kernel;
+        std::shared_ptr<jit_uni_mvn_mean_variance_kernel> mvn_mean_kernel;
+        std::shared_ptr<jit_uni_mvn_mean_variance_kernel> mvn_variance_kernel;
+        std::shared_ptr<jit_uni_mvn_kernel> mvn_kernel;
     };
 
     class MVNRefExecutor : public MVNExecutorBase {
-        public:
-            MVNRefExecutor(const MVNAttrs& mvnAttrs);
+    public:
+        MVNRefExecutor(const MVNAttrs& mvnAttrs);
 
-            void exec(const uint8_t *in_ptr_, uint8_t *out_ptr_, const void *post_ops_data_, const VectorDims& shape5d) override;
+        void exec(const uint8_t* in_ptr_,
+                  uint8_t* out_ptr_,
+                  const void* post_ops_data_,
+                  const VectorDims& shape5d) override;
 
-        private:
-            void mvn_ref(const uint8_t *in_ptr_, uint8_t *out_ptr_, const VectorDims& shape5d);
+    private:
+        void mvn_ref(const uint8_t* in_ptr_, uint8_t* out_ptr_, const VectorDims& shape5d);
     };
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/ngram.cpp b/src/plugins/intel_cpu/src/nodes/ngram.cpp
index 02c2493fc0f682..3ae38bd7a60906 100644
--- a/src/plugins/intel_cpu/src/nodes/ngram.cpp
+++ b/src/plugins/intel_cpu/src/nodes/ngram.cpp
@@ -2,14 +2,15 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "ngram.h"
+
 #include <string>
 #include <vector>
 
-#include "ngram.h"
-#include "openvino/core/parallel.hpp"
 #include "common/cpu_memcpy.h"
-#include "transformations/cpu_opset/common/op/ngram.hpp"
+#include "openvino/core/parallel.hpp"
 #include "shape_inference/custom/ngram.hpp"
+#include "transformations/cpu_opset/common/op/ngram.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -59,8 +60,7 @@ void Ngram::initSupportedPrimitiveDescriptors() {
         idcesPrecision = ov::element::i32;
     }
 
-    addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32},
-                          {LayoutType::ncsp, idcesPrecision}},
+    addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32}, {LayoutType::ncsp, idcesPrecision}},
                          {{LayoutType::ncsp, ov::element::f32}},
                          ref_any);
 }
@@ -68,7 +68,8 @@ void Ngram::initSupportedPrimitiveDescriptors() {
 void Ngram::prepareParams() {
     const auto& srcDataDims = getSrcMemoryAtPort(0)->getStaticDims();
     const auto& srcIndicesDims = getSrcMemoryAtPort(1)->getStaticDims();
-    const auto& outDims = getDstMemoryAtPort(0)->getStaticDims();;
+    const auto& outDims = getDstMemoryAtPort(0)->getStaticDims();
+    ;
 
     idcesShapeSize = std::accumulate(srcIndicesDims.begin(), srcIndicesDims.end(), 1, std::multiplies<size_t>());
     numOutElems = std::accumulate(outDims.begin(), outDims.end(), 1, std::multiplies<size_t>());
@@ -124,11 +125,14 @@ void Ngram::execute(dnnl::stream strm) {
         const size_t dstBatchBias = batchLenghts[batchIdx] * windowStride * k;
         for (size_t i = 0; i < niter; ++i) {
             const size_t curLeftPad = leftPad >= i ? leftPaddingSize - i * windowStride : 0;
-            const size_t curRightPad = rightPad >= niter - 1 - i ? rightPaddingSize - (niter - 1 - i) * windowStride : 0;
+            const size_t curRightPad =
+                rightPad >= niter - 1 - i ? rightPaddingSize - (niter - 1 - i) * windowStride : 0;
             const size_t dataSize = windowSize - curLeftPad - curRightPad;
 
             dstWindowBias += curLeftPad;
-            cpu_memcpy(dstData + dstBatchBias + dstWindowBias, srcData + srcBatchBias + srcWindowBias, dataSize * sizeof(float));
+            cpu_memcpy(dstData + dstBatchBias + dstWindowBias,
+                       srcData + srcBatchBias + srcWindowBias,
+                       dataSize * sizeof(float));
             dstWindowBias += dataSize + curRightPad;
             if (curLeftPad == 0)
                 srcWindowBias += windowStride;
@@ -144,6 +148,6 @@ bool Ngram::created() const {
     return getType() == Type::Ngram;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/ngram.h b/src/plugins/intel_cpu/src/nodes/ngram.h
index 91a5aded67ba52..9ed8e2bf3af400 100644
--- a/src/plugins/intel_cpu/src/nodes/ngram.h
+++ b/src/plugins/intel_cpu/src/nodes/ngram.h
@@ -18,7 +18,7 @@ class Ngram : public Node {
 public:
     Ngram(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr& context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -50,6 +50,6 @@ class Ngram : public Node {
     ov::element::Type idcesPrecision;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/node_config.h b/src/plugins/intel_cpu/src/nodes/node_config.h
index d814f0ee65df37..253fc02f139be0 100644
--- a/src/plugins/intel_cpu/src/nodes/node_config.h
+++ b/src/plugins/intel_cpu/src/nodes/node_config.h
@@ -5,8 +5,9 @@
 #pragma once
 
 #include <memory>
-#include "memory_desc/cpu_memory_desc.h"
+
 #include "memory_desc/blocked_memory_desc.h"
+#include "memory_desc/cpu_memory_desc.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -26,6 +27,7 @@ class PortDescBase {
         return typeid(*this) == typeid(rhs) && this->compareImpl(rhs);
     }
     virtual MemoryDescPtr getMemDesc() const = 0;
+
 protected:
     virtual bool compareImpl(const PortDescBase& rhs) const = 0;
 };
@@ -33,7 +35,7 @@ class PortDescBase {
 using PortDescBasePtr = std::shared_ptr<PortDescBase>;
 using PortDescBaseCPtr = std::shared_ptr<const PortDescBase>;
 
-template<class T>
+template <class T>
 class PortDescBase_ : public PortDescBase {
 protected:
     PortDescBase_() = default;
@@ -63,6 +65,7 @@ class PortDescGeneric : public PortDescBase_<PortDescGeneric> {
 class PortDescBlocked : public PortDescBase_<PortDescBlocked> {
 public:
     using CmpMask = BlockedMemoryDesc::CmpMask;
+
 public:
     PortDescBlocked(BlockedMemoryDescPtr memDesc, CmpMask cmpMask) : _memDesc(memDesc), _cmpMask(cmpMask) {
         if (nullptr == _memDesc) {
@@ -94,10 +97,7 @@ class PortConfig {
           _constant(isConstant) {}
 
     // prevent implicit convertion of cmpMask
-    PortConfig(MemoryDescPtr desc,
-               int cmpMask,
-               int inPlacePort = -1,
-               bool isConstant = false) = delete;
+    PortConfig(MemoryDescPtr desc, int cmpMask, int inPlacePort = -1, bool isConstant = false) = delete;
 
     PortConfig(const PortConfig& rhs) = default;
 
@@ -159,12 +159,12 @@ struct NodeConfig {
     NodeConfig() = default;
 
     NodeConfig(std::vector<PortConfig> inConfs, std::vector<PortConfig> outConfs)
-        : inConfs(std::move(inConfs)), outConfs(std::move(outConfs))
-    {}
+        : inConfs(std::move(inConfs)),
+          outConfs(std::move(outConfs)) {}
 
     std::vector<PortConfig> inConfs;
     std::vector<PortConfig> outConfs;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/non_max_suppression.cpp b/src/plugins/intel_cpu/src/nodes/non_max_suppression.cpp
index 944318a3c24ed6..2d8bb582f9ca83 100644
--- a/src/plugins/intel_cpu/src/nodes/non_max_suppression.cpp
+++ b/src/plugins/intel_cpu/src/nodes/non_max_suppression.cpp
@@ -6,35 +6,39 @@
 // https://github.com/facebookresearch/detectron2/blob/v0.6/detectron2/layers/csrc/box_iou_rotated/box_iou_rotated_utils.h
 //
 
-
 #include "non_max_suppression.h"
 
+#include <queue>
+
 #include "cpu_types.h"
 #include "openvino/core/parallel.hpp"
-#include "utils/general_utils.h"
-#include "shape_inference/shape_inference_internal_dyn.hpp"
 #include "openvino/op/nms_rotated.hpp"
 #include "openvino/op/non_max_suppression.hpp"
 #include "ov_ops/nms_ie_internal.hpp"
-
-#include <queue>
+#include "shape_inference/shape_inference_internal_dyn.hpp"
+#include "utils/general_utils.h"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-bool NonMaxSuppression::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool NonMaxSuppression::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                             std::string& errorMessage) noexcept {
     try {
-        if (!one_of(op->get_type_info(), op::v9::NonMaxSuppression::get_type_info_static(),
-                                         op::internal::NonMaxSuppressionIEInternal::get_type_info_static(),
-                                         op::v13::NMSRotated::get_type_info_static())) {
-            errorMessage = "Only NonMaxSuppression from opset9, NonMaxSuppressionIEInternal and NMSRotated from opset13 are supported.";
+        if (!one_of(op->get_type_info(),
+                    op::v9::NonMaxSuppression::get_type_info_static(),
+                    op::internal::NonMaxSuppressionIEInternal::get_type_info_static(),
+                    op::v13::NMSRotated::get_type_info_static())) {
+            errorMessage = "Only NonMaxSuppression from opset9, NonMaxSuppressionIEInternal and NMSRotated from "
+                           "opset13 are supported.";
             return false;
         }
 
         if (auto nms9 = as_type<const op::v9::NonMaxSuppression>(op.get())) {
             const auto boxEncoding = nms9->get_box_encoding();
-            if (!one_of(boxEncoding, op::v9::NonMaxSuppression::BoxEncodingType::CENTER, op::v9::NonMaxSuppression::BoxEncodingType::CORNER)) {
+            if (!one_of(boxEncoding,
+                        op::v9::NonMaxSuppression::BoxEncodingType::CENTER,
+                        op::v9::NonMaxSuppression::BoxEncodingType::CORNER)) {
                 errorMessage = "Supports only CENTER and CORNER box encoding type";
                 return false;
             }
@@ -46,8 +50,8 @@ bool NonMaxSuppression::isSupportedOperation(const std::shared_ptr<const ov::Nod
 }
 
 NonMaxSuppression::NonMaxSuppression(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr& context)
-        : Node(op, context, InternalDynShapeInferFactory()),
-          m_is_soft_suppressed_by_iou(false) {
+    : Node(op, context, InternalDynShapeInferFactory()),
+      m_is_soft_suppressed_by_iou(false) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
         OPENVINO_THROW(errorMessage);
@@ -78,11 +82,11 @@ NonMaxSuppression::NonMaxSuppression(const std::shared_ptr<ov::Node>& op, const
         m_rotated_boxes = true;
         m_coord_num = 5lu;
     } else {
-        const auto &typeInfo = op->get_type_info();
+        const auto& typeInfo = op->get_type_info();
         THROW_CPU_NODE_ERR("doesn't support NMS: ", typeInfo.name, " v", typeInfo.version_id);
     }
 
-    const auto &boxes_dims = getInputShapeAtPort(NMS_BOXES).getDims();
+    const auto& boxes_dims = getInputShapeAtPort(NMS_BOXES).getDims();
     if (boxes_dims.size() != 3) {
         THROW_CPU_NODE_ERR("has unsupported 'boxes' input rank: ", boxes_dims.size());
     }
@@ -90,7 +94,7 @@ NonMaxSuppression::NonMaxSuppression(const std::shared_ptr<ov::Node>& op, const
         THROW_CPU_NODE_ERR("has unsupported 'boxes' input 3rd dimension size: ", boxes_dims[2]);
     }
 
-    const auto &scores_dims = getInputShapeAtPort(NMS_SCORES).getDims();
+    const auto& scores_dims = getInputShapeAtPort(NMS_SCORES).getDims();
     if (scores_dims.size() != 3) {
         THROW_CPU_NODE_ERR("has unsupported 'scores' input rank: ", scores_dims.size());
     }
@@ -100,7 +104,8 @@ NonMaxSuppression::NonMaxSuppression(const std::shared_ptr<ov::Node>& op, const
         THROW_CPU_NODE_ERR("has unsupported 'valid_outputs' output rank: ", valid_outputs_shape.getRank());
     }
     if (valid_outputs_shape.getDims()[0] != 1) {
-        THROW_CPU_NODE_ERR("has unsupported 'valid_outputs' output 1st dimension size: ", valid_outputs_shape.getDims()[1]);
+        THROW_CPU_NODE_ERR("has unsupported 'valid_outputs' output 1st dimension size: ",
+                           valid_outputs_shape.getDims()[1]);
     }
 
     for (size_t i = 0lu; i < op->get_output_size(); i++) {
@@ -114,7 +119,9 @@ void NonMaxSuppression::initSupportedPrimitiveDescriptors() {
 
     const auto inputs_num = inputShapes.size();
     if (inputs_num > NMS_MAX_OUTPUT_BOXES_PER_CLASS) {
-        check1DInput(getInputShapeAtPort(NMS_MAX_OUTPUT_BOXES_PER_CLASS), "max_output_boxes_per_class", NMS_MAX_OUTPUT_BOXES_PER_CLASS);
+        check1DInput(getInputShapeAtPort(NMS_MAX_OUTPUT_BOXES_PER_CLASS),
+                     "max_output_boxes_per_class",
+                     NMS_MAX_OUTPUT_BOXES_PER_CLASS);
     }
     if (inputs_num > NMS_IOU_THRESHOLD) {
         check1DInput(getInputShapeAtPort(NMS_IOU_THRESHOLD), "iou_threshold", NMS_IOU_THRESHOLD);
@@ -148,7 +155,8 @@ void NonMaxSuppression::initSupportedPrimitiveDescriptors() {
 #if defined(OPENVINO_ARCH_X86_64)
     using namespace dnnl::impl::cpu;
 
-    // As only FP32 and ncsp is supported, and kernel is shape agnostic, we can create here. There is no need to recompilation.
+    // As only FP32 and ncsp is supported, and kernel is shape agnostic, we can create here. There is no need to
+    // recompilation.
     createJitKernel();
 
     x64::cpu_isa_t actual_isa = x64::isa_undef;
@@ -156,21 +164,28 @@ void NonMaxSuppression::initSupportedPrimitiveDescriptors() {
         actual_isa = m_jit_kernel->getIsa();
     }
     switch (actual_isa) {
-        case x64::avx512_core: impl_type = impl_desc_type::jit_avx512; break;
-        case x64::avx2:        impl_type = impl_desc_type::jit_avx2;   break;
-        case x64::sse41:       impl_type = impl_desc_type::jit_sse42;  break;
-        default:               impl_type = impl_desc_type::ref;
-    }
-#endif // OPENVINO_ARCH_X86_64
+    case x64::avx512_core:
+        impl_type = impl_desc_type::jit_avx512;
+        break;
+    case x64::avx2:
+        impl_type = impl_desc_type::jit_avx2;
+        break;
+    case x64::sse41:
+        impl_type = impl_desc_type::jit_sse42;
+        break;
+    default:
+        impl_type = impl_desc_type::ref;
+    }
+#endif  // OPENVINO_ARCH_X86_64
 
     addSupportedPrimDesc(inDataConf, outDataConf, impl_type);
 }
 
 void NonMaxSuppression::prepareParams() {
-    const auto& boxesDims = isDynamicNode() ? getParentEdgeAt(NMS_BOXES)->getMemory().getStaticDims() :
-                                               getInputShapeAtPort(NMS_BOXES).getStaticDims();
-    const auto& scoresDims = isDynamicNode() ? getParentEdgeAt(NMS_SCORES)->getMemory().getStaticDims() :
-                                                getInputShapeAtPort(NMS_SCORES).getStaticDims();
+    const auto& boxesDims = isDynamicNode() ? getParentEdgeAt(NMS_BOXES)->getMemory().getStaticDims()
+                                            : getInputShapeAtPort(NMS_BOXES).getStaticDims();
+    const auto& scoresDims = isDynamicNode() ? getParentEdgeAt(NMS_SCORES)->getMemory().getStaticDims()
+                                             : getInputShapeAtPort(NMS_SCORES).getStaticDims();
 
     m_batches_num = boxesDims[0];
     m_boxes_num = boxesDims[1];
@@ -187,7 +202,7 @@ void NonMaxSuppression::prepareParams() {
     m_filtered_boxes.resize(max_number_of_boxes);
 
     m_num_filtered_boxes.resize(m_batches_num);
-    for (auto & i : m_num_filtered_boxes) {
+    for (auto& i : m_num_filtered_boxes) {
         i.resize(m_classes_num);
     }
 }
@@ -199,14 +214,16 @@ void NonMaxSuppression::createJitKernel() {
         jcp.box_encode_type = boxEncodingType;
         jcp.is_soft_suppressed_by_iou = m_is_soft_suppressed_by_iou;
 
-        m_jit_kernel = kernel::JitKernel<kernel::NmsCompileParams, kernel::NmsCallArgs>::createInstance<kernel::NonMaxSuppression>(jcp);
+        m_jit_kernel =
+            kernel::JitKernel<kernel::NmsCompileParams, kernel::NmsCallArgs>::createInstance<kernel::NonMaxSuppression>(
+                jcp);
     }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 }
 
 void NonMaxSuppression::executeDynamicImpl(dnnl::stream strm) {
     if (hasEmptyInputTensors() || (inputShapes.size() > NMS_MAX_OUTPUT_BOXES_PER_CLASS &&
-            getSrcDataAtPortAs<int>(NMS_MAX_OUTPUT_BOXES_PER_CLASS)[0] == 0)) {
+                                   getSrcDataAtPortAs<int>(NMS_MAX_OUTPUT_BOXES_PER_CLASS)[0] == 0)) {
         redefineOutputMemory({{0, 3}, {0, 3}, {1}});
         *getDstDataAtPortAs<int>(NMS_VALID_OUTPUTS) = 0;
         return;
@@ -273,13 +290,12 @@ void NonMaxSuppression::execute(dnnl::stream strm) {
     // need more particular comparator to get deterministic behaviour
     // escape situation when filtred boxes with same score have different position from launch to launch
     if (m_sort_result_descending) {
-        parallel_sort(boxes_ptr, boxes_ptr + start_offset,
-                      [](const FilteredBox& l, const FilteredBox& r) {
-                          return (l.score > r.score) ||
-                                 (l.score == r.score && l.batch_index < r.batch_index) ||
-                                 (l.score == r.score && l.batch_index == r.batch_index && l.class_index < r.class_index) ||
-                                 (l.score == r.score && l.batch_index == r.batch_index && l.class_index == r.class_index && l.box_index < r.box_index);
-                      });
+        parallel_sort(boxes_ptr, boxes_ptr + start_offset, [](const FilteredBox& l, const FilteredBox& r) {
+            return (l.score > r.score) || (l.score == r.score && l.batch_index < r.batch_index) ||
+                   (l.score == r.score && l.batch_index == r.batch_index && l.class_index < r.class_index) ||
+                   (l.score == r.score && l.batch_index == r.batch_index && l.class_index == r.class_index &&
+                    l.box_index < r.box_index);
+        });
     }
 
     const size_t valid_outputs = std::min(start_offset, max_number_of_boxes);
@@ -328,15 +344,18 @@ void NonMaxSuppression::execute(dnnl::stream strm) {
     }
 }
 
-void NonMaxSuppression::nmsWithSoftSigma(const float *boxes, const float *scores, const VectorDims &boxesStrides,
-                                                             const VectorDims &scoresStrides, std::vector<FilteredBox> &filtBoxes) {
+void NonMaxSuppression::nmsWithSoftSigma(const float* boxes,
+                                         const float* scores,
+                                         const VectorDims& boxesStrides,
+                                         const VectorDims& scoresStrides,
+                                         std::vector<FilteredBox>& filtBoxes) {
     auto less = [](const boxInfo& l, const boxInfo& r) {
         return l.score < r.score || ((l.score == r.score) && (l.idx > r.idx));
     };
 
     // update score, if iou is 0, weight is 1, score does not change
-    // if is_soft_suppressed_by_iou is false, apply for all iou, including iou>iou_threshold, soft suppressed when score < score_threshold
-    // if is_soft_suppressed_by_iou is true, hard suppressed by iou_threshold, then soft suppress
+    // if is_soft_suppressed_by_iou is false, apply for all iou, including iou>iou_threshold, soft suppressed when score
+    // < score_threshold if is_soft_suppressed_by_iou is true, hard suppressed by iou_threshold, then soft suppress
     auto coeff = [&](float iou) {
         if (m_is_soft_suppressed_by_iou && iou > m_iou_threshold)
             return 0.0f;
@@ -345,10 +364,11 @@ void NonMaxSuppression::nmsWithSoftSigma(const float *boxes, const float *scores
 
     parallel_for2d(m_batches_num, m_classes_num, [&](int batch_idx, int class_idx) {
         std::vector<FilteredBox> selectedBoxes;
-        const float *boxesPtr = boxes + batch_idx * boxesStrides[0];
-        const float *scoresPtr = scores + batch_idx * scoresStrides[0] + class_idx * scoresStrides[1];
+        const float* boxesPtr = boxes + batch_idx * boxesStrides[0];
+        const float* scoresPtr = scores + batch_idx * scoresStrides[0] + class_idx * scoresStrides[1];
 
-        std::priority_queue<boxInfo, std::vector<boxInfo>, decltype(less)> sorted_boxes(less);  // score, box_id, suppress_begin_index
+        std::priority_queue<boxInfo, std::vector<boxInfo>, decltype(less)> sorted_boxes(
+            less);  // score, box_id, suppress_begin_index
         for (int box_idx = 0; box_idx < static_cast<int>(m_boxes_num); box_idx++) {
             if (scoresPtr[box_idx] > m_score_threshold)
                 sorted_boxes.emplace(boxInfo({scoresPtr[box_idx], box_idx, 0}));
@@ -360,7 +380,7 @@ void NonMaxSuppression::nmsWithSoftSigma(const float *boxes, const float *scores
             // include first directly
             boxInfo candidateBox = sorted_boxes.top();
             sorted_boxes.pop();
-            selectedBoxes.push_back({ candidateBox.score, batch_idx, class_idx, candidateBox.idx });
+            selectedBoxes.push_back({candidateBox.score, batch_idx, class_idx, candidateBox.idx});
             if (maxSeletedBoxNum > 1) {
                 if (m_jit_kernel) {
 #if defined(OPENVINO_ARCH_X86_64)
@@ -383,13 +403,18 @@ void NonMaxSuppression::nmsWithSoftSigma(const float *boxes, const float *scores
                         float origScore = candidateBox.score;
                         sorted_boxes.pop();
 
-                        int candidateStatus = NMSCandidateStatus::SELECTED; // 0 for suppressed, 1 for selected, 2 for updated
+                        int candidateStatus =
+                            NMSCandidateStatus::SELECTED;  // 0 for suppressed, 1 for selected, 2 for updated
                         arg.score = static_cast<float*>(&candidateBox.score);
                         arg.selected_boxes_num = selectedBoxes.size() - candidateBox.suppress_begin_index;
-                        arg.selected_boxes_coord[0] = static_cast<float*>(&boxCoord0[candidateBox.suppress_begin_index]);
-                        arg.selected_boxes_coord[1] = static_cast<float*>(&boxCoord1[candidateBox.suppress_begin_index]);
-                        arg.selected_boxes_coord[2] = static_cast<float*>(&boxCoord2[candidateBox.suppress_begin_index]);
-                        arg.selected_boxes_coord[3] = static_cast<float*>(&boxCoord3[candidateBox.suppress_begin_index]);
+                        arg.selected_boxes_coord[0] =
+                            static_cast<float*>(&boxCoord0[candidateBox.suppress_begin_index]);
+                        arg.selected_boxes_coord[1] =
+                            static_cast<float*>(&boxCoord1[candidateBox.suppress_begin_index]);
+                        arg.selected_boxes_coord[2] =
+                            static_cast<float*>(&boxCoord2[candidateBox.suppress_begin_index]);
+                        arg.selected_boxes_coord[3] =
+                            static_cast<float*>(&boxCoord3[candidateBox.suppress_begin_index]);
                         arg.candidate_box = static_cast<const float*>(&boxesPtr[candidateBox.idx * m_coord_num]);
                         arg.candidate_status = static_cast<int*>(&candidateStatus);
                         (*m_jit_kernel)(&arg);
@@ -398,7 +423,7 @@ void NonMaxSuppression::nmsWithSoftSigma(const float *boxes, const float *scores
                             continue;
                         } else {
                             if (candidateBox.score == origScore) {
-                                selectedBoxes.push_back({ candidateBox.score, batch_idx, class_idx, candidateBox.idx });
+                                selectedBoxes.push_back({candidateBox.score, batch_idx, class_idx, candidateBox.idx});
                                 int selectedSize = selectedBoxes.size();
                                 boxCoord0[selectedSize - 1] = boxesPtr[candidateBox.idx * m_coord_num];
                                 boxCoord1[selectedSize - 1] = boxesPtr[candidateBox.idx * m_coord_num + 1];
@@ -410,19 +435,24 @@ void NonMaxSuppression::nmsWithSoftSigma(const float *boxes, const float *scores
                             }
                         }
                     }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
                 } else {
                     while (selectedBoxes.size() < m_output_boxes_per_class && !sorted_boxes.empty()) {
                         boxInfo candidateBox = sorted_boxes.top();
                         float origScore = candidateBox.score;
                         sorted_boxes.pop();
 
-                        int candidateStatus = NMSCandidateStatus::SELECTED; // 0 for suppressed, 1 for selected, 2 for updated
-                        for (int selected_idx = static_cast<int>(selectedBoxes.size()) - 1; selected_idx >= candidateBox.suppress_begin_index; selected_idx--) {
-                            float iou = intersectionOverUnion(&boxesPtr[candidateBox.idx * m_coord_num],
-                                                              &boxesPtr[selectedBoxes[selected_idx].box_index * m_coord_num]);
-
-                            // when is_soft_suppressed_by_iou is true, score is decayed to zero and implicitely suppressed if iou > iou_threshold.
+                        int candidateStatus =
+                            NMSCandidateStatus::SELECTED;  // 0 for suppressed, 1 for selected, 2 for updated
+                        for (int selected_idx = static_cast<int>(selectedBoxes.size()) - 1;
+                             selected_idx >= candidateBox.suppress_begin_index;
+                             selected_idx--) {
+                            float iou =
+                                intersectionOverUnion(&boxesPtr[candidateBox.idx * m_coord_num],
+                                                      &boxesPtr[selectedBoxes[selected_idx].box_index * m_coord_num]);
+
+                            // when is_soft_suppressed_by_iou is true, score is decayed to zero and implicitely
+                            // suppressed if iou > iou_threshold.
                             candidateBox.score *= coeff(iou);
                             // soft suppressed
                             if (candidateBox.score <= m_score_threshold) {
@@ -435,7 +465,7 @@ void NonMaxSuppression::nmsWithSoftSigma(const float *boxes, const float *scores
                             continue;
                         } else {
                             if (candidateBox.score == origScore) {
-                                selectedBoxes.push_back({ candidateBox.score, batch_idx, class_idx, candidateBox.idx });
+                                selectedBoxes.push_back({candidateBox.score, batch_idx, class_idx, candidateBox.idx});
                             } else {
                                 candidateBox.suppress_begin_index = selectedBoxes.size();
                                 sorted_boxes.push(candidateBox);
@@ -453,12 +483,15 @@ void NonMaxSuppression::nmsWithSoftSigma(const float *boxes, const float *scores
     });
 }
 
-void NonMaxSuppression::nmsWithoutSoftSigma(const float *boxes, const float *scores, const VectorDims &boxesStrides,
-                                                                const VectorDims &scoresStrides, std::vector<FilteredBox> &filtBoxes) {
+void NonMaxSuppression::nmsWithoutSoftSigma(const float* boxes,
+                                            const float* scores,
+                                            const VectorDims& boxesStrides,
+                                            const VectorDims& scoresStrides,
+                                            std::vector<FilteredBox>& filtBoxes) {
     int max_out_box = static_cast<int>(m_output_boxes_per_class);
     parallel_for2d(m_batches_num, m_classes_num, [&](int batch_idx, int class_idx) {
-        const float *boxesPtr = boxes + batch_idx * boxesStrides[0];
-        const float *scoresPtr = scores + batch_idx * scoresStrides[0] + class_idx * scoresStrides[1];
+        const float* boxesPtr = boxes + batch_idx * boxesStrides[0];
+        const float* scoresPtr = scores + batch_idx * scoresStrides[0] + class_idx * scoresStrides[1];
 
         std::vector<std::pair<float, int>> sorted_boxes;  // score, box_idx
         sorted_boxes.reserve(m_boxes_num);
@@ -471,7 +504,8 @@ void NonMaxSuppression::nmsWithoutSoftSigma(const float *boxes, const float *sco
         int io_selection_size = 0;
         const size_t sortedBoxSize = sorted_boxes.size();
         if (sortedBoxSize > 0lu) {
-            parallel_sort(sorted_boxes.begin(), sorted_boxes.end(),
+            parallel_sort(sorted_boxes.begin(),
+                          sorted_boxes.end(),
                           [](const std::pair<float, int>& l, const std::pair<float, int>& r) {
                               return (l.first > r.first || ((l.first == r.first) && (l.second < r.second)));
                           });
@@ -501,29 +535,38 @@ void NonMaxSuppression::nmsWithoutSoftSigma(const float *boxes, const float *sco
                     arg.selected_boxes_coord[2] = static_cast<float*>(&boxCoord2[0]);
                     arg.selected_boxes_coord[3] = static_cast<float*>(&boxCoord3[0]);
 
-                    for (size_t candidate_idx = 1; (candidate_idx < sortedBoxSize) && (io_selection_size < max_out_box); candidate_idx++) {
-                        int candidateStatus = NMSCandidateStatus::SELECTED; // 0 for suppressed, 1 for selected
+                    for (size_t candidate_idx = 1; (candidate_idx < sortedBoxSize) && (io_selection_size < max_out_box);
+                         candidate_idx++) {
+                        int candidateStatus = NMSCandidateStatus::SELECTED;  // 0 for suppressed, 1 for selected
                         arg.selected_boxes_num = io_selection_size;
-                        arg.candidate_box = static_cast<const float*>(&boxesPtr[sorted_boxes[candidate_idx].second * m_coord_num]);
+                        arg.candidate_box =
+                            static_cast<const float*>(&boxesPtr[sorted_boxes[candidate_idx].second * m_coord_num]);
                         arg.candidate_status = static_cast<int*>(&candidateStatus);
                         (*m_jit_kernel)(&arg);
                         if (candidateStatus == NMSCandidateStatus::SELECTED) {
                             boxCoord0[io_selection_size] = boxesPtr[sorted_boxes[candidate_idx].second * m_coord_num];
-                            boxCoord1[io_selection_size] = boxesPtr[sorted_boxes[candidate_idx].second * m_coord_num + 1];
-                            boxCoord2[io_selection_size] = boxesPtr[sorted_boxes[candidate_idx].second * m_coord_num + 2];
-                            boxCoord3[io_selection_size] = boxesPtr[sorted_boxes[candidate_idx].second * m_coord_num + 3];
-                            filtBoxes[offset + io_selection_size] =
-                                FilteredBox(sorted_boxes[candidate_idx].first, batch_idx, class_idx, sorted_boxes[candidate_idx].second);
+                            boxCoord1[io_selection_size] =
+                                boxesPtr[sorted_boxes[candidate_idx].second * m_coord_num + 1];
+                            boxCoord2[io_selection_size] =
+                                boxesPtr[sorted_boxes[candidate_idx].second * m_coord_num + 2];
+                            boxCoord3[io_selection_size] =
+                                boxesPtr[sorted_boxes[candidate_idx].second * m_coord_num + 3];
+                            filtBoxes[offset + io_selection_size] = FilteredBox(sorted_boxes[candidate_idx].first,
+                                                                                batch_idx,
+                                                                                class_idx,
+                                                                                sorted_boxes[candidate_idx].second);
                             io_selection_size++;
                         }
                     }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
                 } else {
-                    for (size_t candidate_idx = 1; (candidate_idx < sortedBoxSize) && (io_selection_size < max_out_box); candidate_idx++) {
-                        int candidateStatus = NMSCandidateStatus::SELECTED; // 0 for suppressed, 1 for selected
+                    for (size_t candidate_idx = 1; (candidate_idx < sortedBoxSize) && (io_selection_size < max_out_box);
+                         candidate_idx++) {
+                        int candidateStatus = NMSCandidateStatus::SELECTED;  // 0 for suppressed, 1 for selected
                         for (int selected_idx = io_selection_size - 1; selected_idx >= 0; selected_idx--) {
-                            float iou = intersectionOverUnion(&boxesPtr[sorted_boxes[candidate_idx].second * m_coord_num],
-                                    &boxesPtr[filtBoxes[offset + selected_idx].box_index * m_coord_num]);
+                            float iou = intersectionOverUnion(
+                                &boxesPtr[sorted_boxes[candidate_idx].second * m_coord_num],
+                                &boxesPtr[filtBoxes[offset + selected_idx].box_index * m_coord_num]);
                             if (iou >= m_iou_threshold) {
                                 candidateStatus = NMSCandidateStatus::SUPPRESSED;
                                 break;
@@ -531,8 +574,10 @@ void NonMaxSuppression::nmsWithoutSoftSigma(const float *boxes, const float *sco
                         }
 
                         if (candidateStatus == NMSCandidateStatus::SELECTED) {
-                            filtBoxes[offset + io_selection_size] =
-                                FilteredBox(sorted_boxes[candidate_idx].first, batch_idx, class_idx, sorted_boxes[candidate_idx].second);
+                            filtBoxes[offset + io_selection_size] = FilteredBox(sorted_boxes[candidate_idx].first,
+                                                                                batch_idx,
+                                                                                class_idx,
+                                                                                sorted_boxes[candidate_idx].second);
                             io_selection_size++;
                         }
                     }
@@ -751,7 +796,9 @@ inline size_t getIntersectionPoints(const NonMaxSuppression::Point2D (&pts1)[4],
     return num;
 }
 
-inline float rotatedBoxesIntersection(const NonMaxSuppression::Point2D (&vertices_0)[4], const float* box_1, const bool clockwise) {
+inline float rotatedBoxesIntersection(const NonMaxSuppression::Point2D (&vertices_0)[4],
+                                      const float* box_1,
+                                      const bool clockwise) {
     // There are up to 4 x 4 + 4 + 4 = 24 intersections (including duplicates) returned
     NonMaxSuppression::Point2D intersect_pts[24], ordered_pts[24];
 
@@ -768,8 +815,10 @@ inline float rotatedBoxesIntersection(const NonMaxSuppression::Point2D (&vertice
     return polygonArea(ordered_pts, num_convex);
 }
 
-inline float NonMaxSuppression::rotatedIntersectionOverUnion(const NonMaxSuppression::Point2D (&vertices_0)[4], const float area_0, const float* box_1) {
-    const auto area_1 = box_1[2] * box_1[3]; // W x H
+inline float NonMaxSuppression::rotatedIntersectionOverUnion(const NonMaxSuppression::Point2D (&vertices_0)[4],
+                                                             const float area_0,
+                                                             const float* box_1) {
+    const auto area_1 = box_1[2] * box_1[3];  // W x H
     if (area_1 <= 0.f) {
         return 0.f;
     }
@@ -779,14 +828,17 @@ inline float NonMaxSuppression::rotatedIntersectionOverUnion(const NonMaxSuppres
     return intersection / (area_0 + area_1 - intersection);
 }
 
-void NonMaxSuppression::nmsRotated(const float* boxes, const float* scores, const VectorDims& boxes_strides,
-                                   const VectorDims& scores_strides, std::vector<FilteredBox>& filtered_boxes) {
+void NonMaxSuppression::nmsRotated(const float* boxes,
+                                   const float* scores,
+                                   const VectorDims& boxes_strides,
+                                   const VectorDims& scores_strides,
+                                   std::vector<FilteredBox>& filtered_boxes) {
     if (m_jit_kernel) {
         THROW_CPU_NODE_ERR("does not have implementation of the JIT kernel for Rotated boxes.");
     } else {
         parallel_for2d(m_batches_num, m_classes_num, [&](int64_t batch_idx, int64_t class_idx) {
-            const float *boxes_ptr = boxes + batch_idx * boxes_strides[0];
-            const float *scores_ptr = scores + batch_idx * scores_strides[0] + class_idx * scores_strides[1];
+            const float* boxes_ptr = boxes + batch_idx * boxes_strides[0];
+            const float* scores_ptr = scores + batch_idx * scores_strides[0] + class_idx * scores_strides[1];
 
             std::vector<std::pair<float, size_t>> sorted_indices;  // score, box_idx
             sorted_indices.reserve(m_boxes_num);
@@ -800,31 +852,37 @@ void NonMaxSuppression::nmsRotated(const float* boxes, const float* scores, cons
             const size_t sorted_boxes_size = sorted_indices.size();
 
             if (sorted_boxes_size > 0lu) {
-                parallel_sort(sorted_indices.begin(), sorted_indices.end(),
-                            [](const std::pair<float, size_t>& l, const std::pair<float, size_t>& r) {
-                                return (l.first > r.first || ((l.first == r.first) && (l.second < r.second)));
-                            });
+                parallel_sort(sorted_indices.begin(),
+                              sorted_indices.end(),
+                              [](const std::pair<float, size_t>& l, const std::pair<float, size_t>& r) {
+                                  return (l.first > r.first || ((l.first == r.first) && (l.second < r.second)));
+                              });
                 auto sorted_indices_ptr = sorted_indices.data();
-                auto filtered_boxes_ptr = filtered_boxes.data()
-                        + batch_idx * m_classes_num * m_output_boxes_per_class + class_idx * m_output_boxes_per_class;
-                *filtered_boxes_ptr = FilteredBox(sorted_indices[0].first, batch_idx, class_idx, sorted_indices[0].second);
+                auto filtered_boxes_ptr = filtered_boxes.data() + batch_idx * m_classes_num * m_output_boxes_per_class +
+                                          class_idx * m_output_boxes_per_class;
+                *filtered_boxes_ptr =
+                    FilteredBox(sorted_indices[0].first, batch_idx, class_idx, sorted_indices[0].second);
                 io_selection_size++;
                 if (sorted_boxes_size > 1lu) {
                     sorted_indices_ptr++;
                     NMSCandidateStatus candidate_status;
 
-                    for (size_t candidate_idx = 1lu; (candidate_idx < sorted_boxes_size) && (io_selection_size < m_output_boxes_per_class);
-                            candidate_idx++, sorted_indices_ptr++) {
+                    for (size_t candidate_idx = 1lu;
+                         (candidate_idx < sorted_boxes_size) && (io_selection_size < m_output_boxes_per_class);
+                         candidate_idx++, sorted_indices_ptr++) {
                         candidate_status = NMSCandidateStatus::SELECTED;
                         auto box_0 = boxes_ptr + (*sorted_indices_ptr).second * m_coord_num;
-                        const auto area_0 = box_0[2] * box_0[3]; // W x H
+                        const auto area_0 = box_0[2] * box_0[3];  // W x H
 
                         if (area_0 > 0.f) {
                             NonMaxSuppression::Point2D vertices_0[4];
                             getRotatedVertices(box_0, vertices_0, m_clockwise);
-                            auto trg_boxes = reinterpret_cast<int32_t *>(&((*filtered_boxes_ptr).box_index));
-                            for (size_t selected_idx = 0lu; selected_idx < io_selection_size; selected_idx++, trg_boxes -= 4) {
-                                auto iou = rotatedIntersectionOverUnion(vertices_0, area_0, boxes_ptr + m_coord_num * (*trg_boxes));
+                            auto trg_boxes = reinterpret_cast<int32_t*>(&((*filtered_boxes_ptr).box_index));
+                            for (size_t selected_idx = 0lu; selected_idx < io_selection_size;
+                                 selected_idx++, trg_boxes -= 4) {
+                                auto iou = rotatedIntersectionOverUnion(vertices_0,
+                                                                        area_0,
+                                                                        boxes_ptr + m_coord_num * (*trg_boxes));
                                 if (iou > m_iou_threshold) {
                                     candidate_status = NMSCandidateStatus::SUPPRESSED;
                                     break;
@@ -835,8 +893,10 @@ void NonMaxSuppression::nmsRotated(const float* boxes, const float* scores, cons
                         }
 
                         if (candidate_status == NMSCandidateStatus::SELECTED) {
-                            *(++filtered_boxes_ptr) =
-                                FilteredBox((*sorted_indices_ptr).first, batch_idx, class_idx, (*sorted_indices_ptr).second);
+                            *(++filtered_boxes_ptr) = FilteredBox((*sorted_indices_ptr).first,
+                                                                  batch_idx,
+                                                                  class_idx,
+                                                                  (*sorted_indices_ptr).second);
                             io_selection_size++;
                         }
                     }
@@ -850,7 +910,7 @@ void NonMaxSuppression::nmsRotated(const float* boxes, const float* scores, cons
 
 /////////////// End of Rotated boxes ///////////////
 
-float NonMaxSuppression::intersectionOverUnion(const float *boxesI, const float *boxesJ) {
+float NonMaxSuppression::intersectionOverUnion(const float* boxesI, const float* boxesJ) {
     float yminI, xminI, ymaxI, xmaxI, yminJ, xminJ, ymaxJ, xmaxJ;
     if (boxEncodingType == NMSBoxEncodeType::CENTER) {
         //  box format: x_center, y_center, width, height
@@ -879,9 +939,8 @@ float NonMaxSuppression::intersectionOverUnion(const float *boxesI, const float
     if (areaI <= 0.f || areaJ <= 0.f)
         return 0.f;
 
-    float intersection_area =
-            (std::max)((std::min)(ymaxI, ymaxJ) - (std::max)(yminI, yminJ), 0.f) *
-            (std::max)((std::min)(xmaxI, xmaxJ) - (std::max)(xminI, xminJ), 0.f);
+    float intersection_area = (std::max)((std::min)(ymaxI, ymaxJ) - (std::max)(yminI, yminJ), 0.f) *
+                              (std::max)((std::min)(xmaxI, xmaxJ) - (std::max)(xminI, xminJ), 0.f);
     return intersection_area / (areaI + areaJ - intersection_area);
 }
 
@@ -908,6 +967,6 @@ bool NonMaxSuppression::created() const {
     return getType() == Type::NonMaxSuppression;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/non_max_suppression.h b/src/plugins/intel_cpu/src/nodes/non_max_suppression.h
index 025c46f5799a3e..09f91fc1fb223b 100644
--- a/src/plugins/intel_cpu/src/nodes/non_max_suppression.h
+++ b/src/plugins/intel_cpu/src/nodes/non_max_suppression.h
@@ -4,25 +4,20 @@
 
 #pragma once
 
-#include "node.h"
 #include "kernels/x64/non_max_suppression.hpp"
-
+#include "node.h"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-enum NMSCandidateStatus {
-    SUPPRESSED = 0,
-    SELECTED = 1,
-    UPDATED = 2
-};
+enum NMSCandidateStatus { SUPPRESSED = 0, SELECTED = 1, UPDATED = 2 };
 
 class NonMaxSuppression : public Node {
 public:
     NonMaxSuppression(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr& context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
 
     void initSupportedPrimitiveDescriptors() override;
 
@@ -40,8 +35,11 @@ class NonMaxSuppression : public Node {
         int class_index;
         int box_index;
         FilteredBox() = default;
-        FilteredBox(float _score, int _batch_index, int _class_index, int _box_index) :
-                score(_score), batch_index(_batch_index), class_index(_class_index), box_index(_box_index) {}
+        FilteredBox(float _score, int _batch_index, int _class_index, int _box_index)
+            : score(_score),
+              batch_index(_batch_index),
+              class_index(_class_index),
+              box_index(_box_index) {}
     };
 
     struct boxInfo {
@@ -52,7 +50,9 @@ class NonMaxSuppression : public Node {
 
     bool isExecutable() const override;
 
-    bool needShapeInfer() const override { return false; }
+    bool needShapeInfer() const override {
+        return false;
+    }
 
     void prepareParams() override;
 
@@ -87,36 +87,36 @@ class NonMaxSuppression : public Node {
     };
 
     // output
-    enum {
-        NMS_SELECTED_INDICES,
-        NMS_SELECTED_SCORES,
-        NMS_VALID_OUTPUTS
-    };
+    enum { NMS_SELECTED_INDICES, NMS_SELECTED_SCORES, NMS_VALID_OUTPUTS };
 
-    float intersectionOverUnion(const float *boxesI, const float *boxesJ);
+    float intersectionOverUnion(const float* boxesI, const float* boxesJ);
 
     float rotatedIntersectionOverUnion(const Point2D (&vertices_0)[4], const float area_0, const float* box_1);
 
-    void nmsWithSoftSigma(const float *boxes, const float *scores, const VectorDims &boxesStrides,
-                const VectorDims &scoresStrides, std::vector<FilteredBox> &filtBoxes);
+    void nmsWithSoftSigma(const float* boxes,
+                          const float* scores,
+                          const VectorDims& boxesStrides,
+                          const VectorDims& scoresStrides,
+                          std::vector<FilteredBox>& filtBoxes);
 
-    void nmsWithoutSoftSigma(const float *boxes, const float *scores, const VectorDims &boxesStrides,
-                const VectorDims &scoresStrides, std::vector<FilteredBox> &filtBoxes);
+    void nmsWithoutSoftSigma(const float* boxes,
+                             const float* scores,
+                             const VectorDims& boxesStrides,
+                             const VectorDims& scoresStrides,
+                             std::vector<FilteredBox>& filtBoxes);
 
-    void nmsRotated(const float *boxes, const float *scores, const VectorDims &boxesStrides,
-                const VectorDims &scoresStrides, std::vector<FilteredBox> &filtBoxes);
+    void nmsRotated(const float* boxes,
+                    const float* scores,
+                    const VectorDims& boxesStrides,
+                    const VectorDims& scoresStrides,
+                    std::vector<FilteredBox>& filtBoxes);
 
-    void check1DInput(const Shape& shape,
-                      const std::string& name,
-                      const size_t port);
+    void check1DInput(const Shape& shape, const std::string& name, const size_t port);
 
-    void checkOutput(const Shape& shape,
-                     const std::string& name,
-                     const size_t port);
+    void checkOutput(const Shape& shape, const std::string& name, const size_t port);
 
     void createJitKernel();
 
-
     NMSBoxEncodeType boxEncodingType = NMSBoxEncodeType::CORNER;
     bool m_sort_result_descending = true;
     bool m_clockwise = false;
@@ -124,14 +124,14 @@ class NonMaxSuppression : public Node {
     size_t m_coord_num = 1lu;
 
     size_t m_batches_num = 0lu;
-    size_t m_boxes_num   = 0lu;
+    size_t m_boxes_num = 0lu;
     size_t m_classes_num = 0lu;
 
-    size_t m_max_output_boxes_per_class = 0lu; // Original value of input NMS_MAX_OUTPUT_BOXES_PER_CLASS
-    size_t m_output_boxes_per_class     = 0lu; // Actual number of output boxes
-    float m_iou_threshold   = 0.f;
+    size_t m_max_output_boxes_per_class = 0lu;  // Original value of input NMS_MAX_OUTPUT_BOXES_PER_CLASS
+    size_t m_output_boxes_per_class = 0lu;      // Actual number of output boxes
+    float m_iou_threshold = 0.f;
     float m_score_threshold = 0.f;
-    float m_soft_nms_sigma  = 0.f;
+    float m_soft_nms_sigma = 0.f;
     float m_scale = 0.f;
     // control placeholder for NMS in new opset.
     bool m_is_soft_suppressed_by_iou = false;
@@ -141,12 +141,12 @@ class NonMaxSuppression : public Node {
     std::vector<std::vector<size_t>> m_num_filtered_boxes;
     const std::string inType = "input";
     const std::string outType = "output";
-    bool m_defined_outputs[NMS_VALID_OUTPUTS + 1] = { false, false, false };
+    bool m_defined_outputs[NMS_VALID_OUTPUTS + 1] = {false, false, false};
     std::vector<FilteredBox> m_filtered_boxes;
 
     std::shared_ptr<kernel::JitKernelBase> m_jit_kernel;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/non_zero.cpp b/src/plugins/intel_cpu/src/nodes/non_zero.cpp
index f897c6ef7bf939..35ad2e614b0756 100644
--- a/src/plugins/intel_cpu/src/nodes/non_zero.cpp
+++ b/src/plugins/intel_cpu/src/nodes/non_zero.cpp
@@ -6,9 +6,10 @@
 
 #include <nodes/common/cpu_memcpy.h>
 
+#include <utils/bfloat16.hpp>
+
 #include "openvino/core/parallel.hpp"
 #include "openvino/opsets/opset3.hpp"
-#include <utils/bfloat16.hpp>
 #include "shape_inference/shape_inference_internal_dyn.hpp"
 
 namespace ov {
@@ -54,10 +55,16 @@ void NonZero::initSupportedPrimitiveDescriptors() {
     if (!supportedPrimitiveDescriptors.empty())
         return;
 
-    const auto &inPrc = getOriginalInputPrecisionAtPort(0);
-    if (!one_of(inPrc, ov::element::f32, ov::element::f16,
-                       ov::element::bf16, ov::element::f32, ov::element::i32,
-                       ov::element::u32, ov::element::i8,  ov::element::u8)) {
+    const auto& inPrc = getOriginalInputPrecisionAtPort(0);
+    if (!one_of(inPrc,
+                ov::element::f32,
+                ov::element::f16,
+                ov::element::bf16,
+                ov::element::f32,
+                ov::element::i32,
+                ov::element::u32,
+                ov::element::i8,
+                ov::element::u8)) {
         OPENVINO_THROW("Can't create primitive descriptor for NonZero layer with name: ",
                        getName(),
                        " doesn't support ",
@@ -65,9 +72,7 @@ void NonZero::initSupportedPrimitiveDescriptors() {
                        " precision on 0 port");
     }
 
-    addSupportedPrimDesc({{LayoutType::ncsp}},
-                         {{LayoutType::ncsp, ov::element::i32}},
-                         impl_desc_type::ref);
+    addSupportedPrimDesc({{LayoutType::ncsp}}, {{LayoutType::ncsp, ov::element::i32}}, impl_desc_type::ref);
 }
 
 template <typename T>
@@ -106,12 +111,12 @@ std::vector<size_t> NonZero::getNonZeroElementsCount(const T* src, const Shape&
 }
 namespace {
 struct NonZeroContext {
-    NonZero &node;
+    NonZero& node;
 };
-}
-template<typename T>
+}  // namespace
+template <typename T>
 struct NonZero::NonZeroExecute {
-    void operator()(NonZeroContext & ctx) {
+    void operator()(NonZeroContext& ctx) {
         ctx.node.executeSpecified<T>();
     }
 };
@@ -122,8 +127,11 @@ void NonZero::executeDynamicImpl(dnnl::stream strm) {
 
 void NonZero::execute(dnnl::stream strm) {
     auto inputPrec = getParentEdgeAt(0)->getMemory().getDesc().getPrecision();
-    NonZeroContext ctx = {*this };
-    OV_SWITCH(intel_cpu, NonZeroExecute, ctx, inputPrec,
+    NonZeroContext ctx = {*this};
+    OV_SWITCH(intel_cpu,
+              NonZeroExecute,
+              ctx,
+              inputPrec,
               OV_CASE(ov::element::f32, float),
               OV_CASE(ov::element::bf16, bfloat16_t),
               OV_CASE(ov::element::f16, float16),
@@ -135,7 +143,7 @@ void NonZero::execute(dnnl::stream strm) {
 template <typename T>
 void NonZero::executeSpecified() {
     const T zero = 0;
-    const T *src = getSrcDataAtPortAs<T>(0);
+    const T* src = getSrcDataAtPortAs<T>(0);
     auto dstMemPtr = getDstMemoryAtPort(0);
     Shape inShape = getParentEdgeAt(0)->getMemory().getShape();
     size_t inRank = inShape.getRank();
@@ -166,8 +174,8 @@ void NonZero::executeSpecified() {
         dst[0] = 0;
         break;
     case 1: {
-        //if nonZeroCounts.size() > 1, then the 2nd round scan could run in parallel.
-        parallel_nt(threadsCount, [&](int ithr, int nthr){
+        // if nonZeroCounts.size() > 1, then the 2nd round scan could run in parallel.
+        parallel_nt(threadsCount, [&](int ithr, int nthr) {
             size_t outputIndex = std::accumulate(nonZeroCounts.begin(), nonZeroCounts.begin() + ithr, 0);
             for_1d(ithr, nthr, inShape.getElementsCount(), [&](size_t i) {
                 if (src[i] != zero) {
@@ -180,7 +188,7 @@ void NonZero::executeSpecified() {
     }
     case 2: {
         parallel_nt(threadsCount, [&](int ithr, int nthr) {
-#define ELEMENTS_COUNT  64
+#define ELEMENTS_COUNT 64
             constexpr auto elementsCount = elementsStride * 2;  // elementsStride * inRank
             static_assert(elementsCount == ELEMENTS_COUNT, "Recalculate ELEMENTS_COUNT!");
 
@@ -226,28 +234,29 @@ void NonZero::executeSpecified() {
 #undef ELEMENTS_COUNT
 
             size_t& outputIndex = destIndices[ithr];
-            for_3d(ithr,
-                   nthr,
-                   srcDims[0],
-                   srcDims[1],
-                   srcDims[2],
-                   [&](size_t, size_t inputIndex, int i0, int i1, int i2) {
-                       if (src[inputIndex] != zero) {
-                            cache[counter] = i0;
-                            cache[counter + elementsStride] = i1;
-                            cache[counter + elementsStride * 2] = i2;
-                            counter++;
-
-                            if (counter >= elementsStride) {
-                                cpu_memcpy(&dst[outputIndex], cache, blockSize);
-                                cpu_memcpy(&dst[outputIndex + totalNonZeroCount], &cache[elementsStride], blockSize);
-                                cpu_memcpy(&dst[outputIndex + x2totalNonZeroCount], &cache[elementsStride * 2], blockSize);
-
-                                outputIndex += elementsStride;
-                                counter = 0;
-                            }
-                       }
-                   });
+            for_3d(
+                ithr,
+                nthr,
+                srcDims[0],
+                srcDims[1],
+                srcDims[2],
+                [&](size_t, size_t inputIndex, int i0, int i1, int i2) {
+                    if (src[inputIndex] != zero) {
+                        cache[counter] = i0;
+                        cache[counter + elementsStride] = i1;
+                        cache[counter + elementsStride * 2] = i2;
+                        counter++;
+
+                        if (counter >= elementsStride) {
+                            cpu_memcpy(&dst[outputIndex], cache, blockSize);
+                            cpu_memcpy(&dst[outputIndex + totalNonZeroCount], &cache[elementsStride], blockSize);
+                            cpu_memcpy(&dst[outputIndex + x2totalNonZeroCount], &cache[elementsStride * 2], blockSize);
+
+                            outputIndex += elementsStride;
+                            counter = 0;
+                        }
+                    }
+                });
 
             if (counter != 0) {
                 const auto remainingBlockSize = counter * sizeof(int);
@@ -326,34 +335,35 @@ void NonZero::executeSpecified() {
 #undef ELEMENTS_COUNT
 
             size_t& outputIndex = destIndices[ithr];
-            for_5d(ithr,
-                   nthr,
-                   srcDims[0],
-                   srcDims[1],
-                   srcDims[2],
-                   srcDims[3],
-                   srcDims[4],
-                   [&](size_t, size_t inputIndex, int i0, int i1, int i2, int i3, int i4) {
-                        if (src[inputIndex] != zero) {
-                            cache[counter] = i0;
-                            cache[counter + elementsStride] = i1;
-                            cache[counter + elementsStride * 2] = i2;
-                            cache[counter + elementsStride * 3] = i3;
-                            cache[counter + elementsStride * 4] = i4;
-                            counter++;
-
-                            if (counter >= elementsStride) {
-                                cpu_memcpy(&dst[outputIndex], cache, blockSize);
-                                cpu_memcpy(&dst[outputIndex + totalNonZeroCount], &cache[elementsStride], blockSize);
-                                cpu_memcpy(&dst[outputIndex + x2totalNonZeroCount], &cache[elementsStride * 2], blockSize);
-                                cpu_memcpy(&dst[outputIndex + x3totalNonZeroCount], &cache[elementsStride * 3], blockSize);
-                                cpu_memcpy(&dst[outputIndex + x4totalNonZeroCount], &cache[elementsStride * 4], blockSize);
-
-                                outputIndex += elementsStride;
-                                counter = 0;
-                            }
+            for_5d(
+                ithr,
+                nthr,
+                srcDims[0],
+                srcDims[1],
+                srcDims[2],
+                srcDims[3],
+                srcDims[4],
+                [&](size_t, size_t inputIndex, int i0, int i1, int i2, int i3, int i4) {
+                    if (src[inputIndex] != zero) {
+                        cache[counter] = i0;
+                        cache[counter + elementsStride] = i1;
+                        cache[counter + elementsStride * 2] = i2;
+                        cache[counter + elementsStride * 3] = i3;
+                        cache[counter + elementsStride * 4] = i4;
+                        counter++;
+
+                        if (counter >= elementsStride) {
+                            cpu_memcpy(&dst[outputIndex], cache, blockSize);
+                            cpu_memcpy(&dst[outputIndex + totalNonZeroCount], &cache[elementsStride], blockSize);
+                            cpu_memcpy(&dst[outputIndex + x2totalNonZeroCount], &cache[elementsStride * 2], blockSize);
+                            cpu_memcpy(&dst[outputIndex + x3totalNonZeroCount], &cache[elementsStride * 3], blockSize);
+                            cpu_memcpy(&dst[outputIndex + x4totalNonZeroCount], &cache[elementsStride * 4], blockSize);
+
+                            outputIndex += elementsStride;
+                            counter = 0;
                         }
-                   });
+                    }
+                });
 
             if (counter != 0) {
                 const auto remainingBlockSize = counter * sizeof(int);
@@ -395,6 +405,6 @@ bool NonZero::created() const {
     return getType() == Type::NonZero;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/non_zero.h b/src/plugins/intel_cpu/src/nodes/non_zero.h
index 515ff965055bea..ac66d26188d513 100644
--- a/src/plugins/intel_cpu/src/nodes/non_zero.h
+++ b/src/plugins/intel_cpu/src/nodes/non_zero.h
@@ -5,12 +5,13 @@
 #pragma once
 
 #include <node.h>
-#include <string>
+
+#include <cpu/platform.hpp>
 #include <memory>
+#include <string>
 #include <vector>
-#include "dnnl_extension_utils.h"
 
-#include <cpu/platform.hpp>
+#include "dnnl_extension_utils.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -18,30 +19,36 @@ namespace node {
 
 class NonZero : public Node {
 public:
-  NonZero(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
+    NonZero(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
     void getSupportedDescriptors() override;
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
-    bool needShapeInfer() const override {return false;};
-    bool needPrepareParams() const override {return false;};
+    bool needShapeInfer() const override {
+        return false;
+    };
+    bool needPrepareParams() const override {
+        return false;
+    };
     void executeDynamicImpl(dnnl::stream strm) override;
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
-    bool isExecutable() const override { return true; }
+    bool isExecutable() const override {
+        return true;
+    }
 
 private:
     int threadsCount = 1;
     std::string errorPrefix;
     template <typename inputType>
     void executeSpecified();
-    template<typename T>
+    template <typename T>
     struct NonZeroExecute;
     template <typename T>
     std::vector<size_t> getNonZeroElementsCount(const T* arg, const Shape& arg_shape);
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/normalize.cpp b/src/plugins/intel_cpu/src/nodes/normalize.cpp
index ca52e572b73ea8..45e4d12c7e76c6 100644
--- a/src/plugins/intel_cpu/src/nodes/normalize.cpp
+++ b/src/plugins/intel_cpu/src/nodes/normalize.cpp
@@ -4,26 +4,25 @@
 
 #include "normalize.h"
 
-#include "openvino/core/parallel.hpp"
+#include <shape_inference/shape_inference_pass_through.hpp>
 
-#include "fake_quantize.h"
-#include "eltwise.h"
-#include "utils/bfloat16.hpp"
-#include "utils/general_utils.h"
-#include "dnnl_extension_utils.h"
-#include "emitters/plugin/x64/jit_bf16_emitters.hpp"
-#include "cpu/x64/injectors/jit_uni_eltwise_injector.hpp"
+#include "common/cpu_memcpy.h"
+#include "common/primitive_hashing_utils.hpp"
 #include "cpu/x64/injectors/jit_uni_depthwise_injector.hpp"
+#include "cpu/x64/injectors/jit_uni_eltwise_injector.hpp"
 #include "cpu/x64/injectors/jit_uni_quantization_injector.hpp"
-#include "common/cpu_memcpy.h"
+#include "dnnl_extension_utils.h"
+#include "eltwise.h"
+#include "emitters/plugin/x64/jit_bf16_emitters.hpp"
+#include "fake_quantize.h"
+#include "memory_desc/dnnl_blocked_memory_desc.h"
 #include "nodes/common/cpu_convert.h"
-#include "selective_build.h"
-
+#include "openvino/core/parallel.hpp"
 #include "openvino/opsets/opset1.hpp"
-#include "memory_desc/dnnl_blocked_memory_desc.h"
+#include "selective_build.h"
+#include "utils/bfloat16.hpp"
 #include "utils/cpu_utils.hpp"
-#include "common/primitive_hashing_utils.hpp"
-#include <shape_inference/shape_inference_pass_through.hpp>
+#include "utils/general_utils.h"
 
 using namespace dnnl;
 
@@ -33,7 +32,7 @@ using namespace dnnl::impl::utils;
 using namespace Xbyak;
 
 #if defined(OPENVINO_ARCH_X86_64)
-#define GET_OFF(field) offsetof(jit_normalize_call_args, field)
+#    define GET_OFF(field) offsetof(jit_normalize_call_args, field)
 #endif
 #define THROW_ERROR(...) OPENVINO_THROW("NormalizeL2 layer with name '", getName(), "' ", __VA_ARGS__)
 
@@ -89,7 +88,9 @@ template <cpu_isa_t isa>
 struct jit_uni_normalize_modulo_kernel_f32 : public jit_uni_normalize_modulo_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_normalize_modulo_kernel_f32)
 
-    jit_uni_normalize_modulo_kernel_f32(jit_normalize_config_params jcp) : jit_uni_normalize_modulo_kernel(jcp), jit_generator(jit_name()) {}
+    jit_uni_normalize_modulo_kernel_f32(jit_normalize_config_params jcp)
+        : jit_uni_normalize_modulo_kernel(jcp),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -156,8 +157,8 @@ struct jit_uni_normalize_modulo_kernel_f32 : public jit_uni_normalize_modulo_ker
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
     size_t vlen = cpu_isa_traits<isa>::vlen;
 
     Xbyak::Reg64 reg_src = r8;
@@ -173,31 +174,31 @@ struct jit_uni_normalize_modulo_kernel_f32 : public jit_uni_normalize_modulo_ker
     Xbyak::Xmm xmm_aux3 = Xbyak::Xmm(4);
 
     inline void hsum_store(Xbyak::Xmm xmm_sqr_sum) {
-        uni_vmovshdup(xmm_aux3, xmm_sqr_sum);  //  sqrt_sum:1,2,3,4; aux3:2,2,4,4
-        uni_vaddps(xmm_sqr_sum, xmm_sqr_sum, xmm_aux3);     //  sqrt_sum:1+2,2+2,3+4,4+4
+        uni_vmovshdup(xmm_aux3, xmm_sqr_sum);            //  sqrt_sum:1,2,3,4; aux3:2,2,4,4
+        uni_vaddps(xmm_sqr_sum, xmm_sqr_sum, xmm_aux3);  //  sqrt_sum:1+2,2+2,3+4,4+4
         uni_vmovhlps(xmm_aux3, xmm_aux3, xmm_sqr_sum);   //  aux3:3+4,4+4,4,4
-        uni_vaddps(xmm_sqr_sum, xmm_sqr_sum, xmm_aux3);     //  sqrt_sum:1+2+3+4,...
+        uni_vaddps(xmm_sqr_sum, xmm_sqr_sum, xmm_aux3);  //  sqrt_sum:1+2+3+4,...
         uni_vmovss(ptr[reg_modulo], xmm_sqr_sum);
     }
 
-    inline void load_vector(Vmm vmm_src, const Xbyak::Address &op, memory::data_type src_dt) {
+    inline void load_vector(Vmm vmm_src, const Xbyak::Address& op, memory::data_type src_dt) {
         switch (src_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovups(vmm_src, op);
-                break;
-            case memory::data_type::bf16:
-                uni_vpmovzxwd(vmm_src, op);
-                uni_vpslld(vmm_src, vmm_src, 16);
-                break;
-            case memory::data_type::s8:
-                uni_vpmovsxbd(vmm_src, op);
-                break;
-            case memory::data_type::u8:
-                uni_vpmovzxbd(vmm_src, op);
-                break;
-            default:
-                assert(!"unknown dst_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovups(vmm_src, op);
+            break;
+        case memory::data_type::bf16:
+            uni_vpmovzxwd(vmm_src, op);
+            uni_vpslld(vmm_src, vmm_src, 16);
+            break;
+        case memory::data_type::s8:
+            uni_vpmovsxbd(vmm_src, op);
+            break;
+        case memory::data_type::u8:
+            uni_vpmovzxbd(vmm_src, op);
+            break;
+        default:
+            assert(!"unknown dst_dt");
         }
         if (!isFloatCompatible(src_dt))
             uni_vcvtdq2ps(vmm_src, vmm_src);
@@ -209,8 +210,9 @@ template <cpu_isa_t isa>
 struct jit_uni_normalize_kernel_f32 : public jit_uni_normalize_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_normalize_kernel_f32)
 
-    explicit jit_uni_normalize_kernel_f32(jit_normalize_config_params jcp, const dnnl_primitive_attr &attr)
-    : jit_uni_normalize_kernel(jcp, attr), jit_generator(jit_name()) {}
+    explicit jit_uni_normalize_kernel_f32(jit_normalize_config_params jcp, const dnnl_primitive_attr& attr)
+        : jit_uni_normalize_kernel(jcp, attr),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -218,18 +220,24 @@ struct jit_uni_normalize_kernel_f32 : public jit_uni_normalize_kernel, public ji
     }
 
     void generate() override {
-        const auto &p = attr_.post_ops_;
+        const auto& p = attr_.post_ops_;
         for (int i = 0; i < p.len(); i++) {
-            auto &post_op = p.entry_[i];
+            auto& post_op = p.entry_[i];
             if (post_op.is_eltwise()) {
-                eltwise_injectors.push_back(std::make_shared<jit_uni_eltwise_injector_f32<isa>>(
-                        this, post_op.eltwise.alg, post_op.eltwise.alpha, post_op.eltwise.beta, post_op.eltwise.scale));
+                eltwise_injectors.push_back(std::make_shared<jit_uni_eltwise_injector_f32<isa>>(this,
+                                                                                                post_op.eltwise.alg,
+                                                                                                post_op.eltwise.alpha,
+                                                                                                post_op.eltwise.beta,
+                                                                                                post_op.eltwise.scale));
             } else if (post_op.is_depthwise()) {
-                depthwise_injectors.push_back(std::make_shared<jit_uni_depthwise_injector_f32<isa>>(
-                        this, post_op));
+                depthwise_injectors.push_back(std::make_shared<jit_uni_depthwise_injector_f32<isa>>(this, post_op));
             } else if (post_op.is_quantization()) {
-                quantization_injectors.push_back(std::make_shared<jit_uni_quantization_injector_f32<isa>>(
-                        this, post_op, vmm_d_weights, vmm_d_bias, reg_d_weights, reg_d_bias));
+                quantization_injectors.push_back(std::make_shared<jit_uni_quantization_injector_f32<isa>>(this,
+                                                                                                          post_op,
+                                                                                                          vmm_d_weights,
+                                                                                                          vmm_d_bias,
+                                                                                                          reg_d_weights,
+                                                                                                          reg_d_bias));
             }
         }
 
@@ -266,8 +274,8 @@ struct jit_uni_normalize_kernel_f32 : public jit_uni_normalize_kernel, public ji
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
     size_t vlen = cpu_isa_traits<isa>::vlen;
 
     Xbyak::Reg64 reg_src = r8;
@@ -426,7 +434,7 @@ struct jit_uni_normalize_kernel_f32 : public jit_uni_normalize_kernel, public ji
         L(tail_loop_end_label);
     }
 
-// tails with padding as a vector for normalize.
+    // tails with padding as a vector for normalize.
     inline void normalize_blk() {
         size_t blk_size = 0;
         size_t simd_w = 0;
@@ -518,49 +526,49 @@ struct jit_uni_normalize_kernel_f32 : public jit_uni_normalize_kernel, public ji
         }
     }
 
-    inline void load_vector(Vmm vmm_src, const Xbyak::Address &op, memory::data_type src_dt) {
+    inline void load_vector(Vmm vmm_src, const Xbyak::Address& op, memory::data_type src_dt) {
         switch (src_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovups(vmm_src, op);
-                break;
-            case memory::data_type::bf16:
-                uni_vpmovzxwd(vmm_src, op);
-                uni_vpslld(vmm_src, vmm_src, 16);
-                break;
-            case memory::data_type::s8:
-                uni_vpmovsxbd(vmm_src, op);
-                break;
-            case memory::data_type::u8:
-                uni_vpmovzxbd(vmm_src, op);
-                break;
-            default:
-                assert(!"unknown dst_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovups(vmm_src, op);
+            break;
+        case memory::data_type::bf16:
+            uni_vpmovzxwd(vmm_src, op);
+            uni_vpslld(vmm_src, vmm_src, 16);
+            break;
+        case memory::data_type::s8:
+            uni_vpmovsxbd(vmm_src, op);
+            break;
+        case memory::data_type::u8:
+            uni_vpmovzxbd(vmm_src, op);
+            break;
+        default:
+            assert(!"unknown dst_dt");
         }
         if (!isFloatCompatible(src_dt))
             uni_vcvtdq2ps(vmm_src, vmm_src);
     }
 
-    inline void load_scalar(Xmm xmm_src, const Xbyak::Address &op, memory::data_type src_dt) {
+    inline void load_scalar(Xmm xmm_src, const Xbyak::Address& op, memory::data_type src_dt) {
         switch (src_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovss(xmm_src, op);
-                break;
-            case memory::data_type::bf16:
-                uni_vpinsrw(xmm_src, xmm_src, op, 0x0);
-                uni_vpslld(xmm_src, xmm_src, 16);
-                break;
-            case memory::data_type::s8:
-                movsx(reg_tmp_32, op);
-                uni_vmovq(xmm_src, reg_tmp_64);
-                break;
-            case memory::data_type::u8:
-                movzx(reg_tmp_32, op);
-                uni_vmovq(xmm_src, reg_tmp_64);
-                break;
-            default:
-                assert(!"unknown dst_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovss(xmm_src, op);
+            break;
+        case memory::data_type::bf16:
+            uni_vpinsrw(xmm_src, xmm_src, op, 0x0);
+            uni_vpslld(xmm_src, xmm_src, 16);
+            break;
+        case memory::data_type::s8:
+            movsx(reg_tmp_32, op);
+            uni_vmovq(xmm_src, reg_tmp_64);
+            break;
+        case memory::data_type::u8:
+            movzx(reg_tmp_32, op);
+            uni_vmovq(xmm_src, reg_tmp_64);
+            break;
+        default:
+            assert(!"unknown dst_dt");
         }
 
         if (!isFloatCompatible(src_dt)) {
@@ -568,14 +576,15 @@ struct jit_uni_normalize_kernel_f32 : public jit_uni_normalize_kernel, public ji
         }
     }
 
-    inline void store_vector(const Xbyak::Address &op, Vmm vmm_dst, memory::data_type dst_dt) {
+    inline void store_vector(const Xbyak::Address& op, Vmm vmm_dst, memory::data_type dst_dt) {
         Ymm ymm_dst = Ymm(vmm_dst.getIdx());
         Xmm xmm_dst = Xmm(vmm_dst.getIdx());
 
         if (dst_dt == memory::data_type::f32) {
             uni_vmovups(op, vmm_dst);
         } else if (dst_dt == memory::data_type::bf16) {
-            uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())}, {static_cast<size_t>(ymm_dst.getIdx())});
+            uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
+                                         {static_cast<size_t>(ymm_dst.getIdx())});
             vmovdqu16(op, ymm_dst);
         } else if (dst_dt == memory::data_type::u8) {
             uni_vcvtps2dq(vmm_dst, vmm_dst);
@@ -609,41 +618,41 @@ struct jit_uni_normalize_kernel_f32 : public jit_uni_normalize_kernel, public ji
         }
     }
 
-    inline void store_scalar(const Xbyak::Address &op, Xmm xmm_dst, memory::data_type dst_dt) {
+    inline void store_scalar(const Xbyak::Address& op, Xmm xmm_dst, memory::data_type dst_dt) {
         if (!isFloatCompatible(dst_dt)) {
             uni_vcvtps2dq(xmm_dst, xmm_dst);
         }
 
         switch (dst_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovss(op, xmm_dst);
-                break;
-            case memory::data_type::bf16:
-                uni_vpsrld(xmm_dst, xmm_dst, 16);
-                uni_vpextrw(op, xmm_dst, 0x0);
-                break;
-            case memory::data_type::s8:
-                uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
-                movq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_8);
-                break;
-            case memory::data_type::u8:
-                uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
-                movq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_8);
-                break;
-            default:
-                assert(!"unknown dst_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovss(op, xmm_dst);
+            break;
+        case memory::data_type::bf16:
+            uni_vpsrld(xmm_dst, xmm_dst, 16);
+            uni_vpextrw(op, xmm_dst, 0x0);
+            break;
+        case memory::data_type::s8:
+            uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
+            movq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_8);
+            break;
+        case memory::data_type::u8:
+            uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
+            movq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_8);
+            break;
+        default:
+            assert(!"unknown dst_dt");
         }
     }
 
     // scalar: load scalar to xmm, process on xmm with padded param, store xmm to scalar.
     // is_broadcast for broadcasting param for depth_wise and quantize, for fusion with plain layout.
     void apply_post_ops(memory::data_type dst_dt, bool is_broadcast) {
-        const auto &p = attr_.post_ops_;
+        const auto& p = attr_.post_ops_;
         size_t eltwise_inj_idx = 0;
         size_t depthwise_inj_idx = 0;
         size_t quantization_inj_idx = 0;
@@ -651,27 +660,29 @@ struct jit_uni_normalize_kernel_f32 : public jit_uni_normalize_kernel, public ji
         for (int i = 0; i < p.len(); i++) {
             auto& post_op = p.entry_[i];
             if (post_op.is_eltwise()) {
-                if (eltwise_injectors.size() <= eltwise_inj_idx
-                        || eltwise_injectors[eltwise_inj_idx] == nullptr)
+                if (eltwise_injectors.size() <= eltwise_inj_idx || eltwise_injectors[eltwise_inj_idx] == nullptr)
                     assert(!"Invalid eltwise injectors.");
                 eltwise_injectors[eltwise_inj_idx]->compute_vector_range(vmm_val.getIdx(), vmm_val.getIdx() + 1);
                 eltwise_inj_idx++;
             } else if (post_op.is_depthwise()) {
-                if (depthwise_injectors.size() <= depthwise_inj_idx
-                        || depthwise_injectors[depthwise_inj_idx] == nullptr)
+                if (depthwise_injectors.size() <= depthwise_inj_idx ||
+                    depthwise_injectors[depthwise_inj_idx] == nullptr)
                     assert(!"Invalid depthwise injectors.");
                 mov(reg_d_weights, ptr[reg_post_ops_data + post_ops_data_offset]);
                 add(reg_d_weights, reg_oc_off);
 
                 // weight and bias is padding. scalar as vector.
-                depthwise_injectors[depthwise_inj_idx]->compute_vector_range(
-                        vmm_val.getIdx(), vmm_val.getIdx() + 1, reg_d_weights, reg_d_weights, is_broadcast);
+                depthwise_injectors[depthwise_inj_idx]->compute_vector_range(vmm_val.getIdx(),
+                                                                             vmm_val.getIdx() + 1,
+                                                                             reg_d_weights,
+                                                                             reg_d_weights,
+                                                                             is_broadcast);
 
                 post_ops_data_offset += depthwise_injectors[depthwise_inj_idx]->memoryStep();
                 depthwise_inj_idx++;
             } else if (post_op.is_quantization()) {
-                if (quantization_injectors.size() <= quantization_inj_idx
-                        || quantization_injectors[quantization_inj_idx] == nullptr)
+                if (quantization_injectors.size() <= quantization_inj_idx ||
+                    quantization_injectors[quantization_inj_idx] == nullptr)
                     assert(!"Invalid quantization injectors.");
                 bool do_dequantization = post_op.quantization.alg == alg_kind::quantization_quantize_dequantize;
                 bool do_rounding = do_dequantization || isFloatCompatible(dst_dt) || i != p.len() - 1;
@@ -683,11 +694,17 @@ struct jit_uni_normalize_kernel_f32 : public jit_uni_normalize_kernel, public ji
                 quantization_injectors[quantization_inj_idx]->compute_crop(s_idx, s_idx + 1, 0, 0, is_broadcast);
 
                 quantization_injectors[quantization_inj_idx]->init_input_scale_shift_ptrs(quant_arg_base, reg_oc_off);
-                quantization_injectors[quantization_inj_idx]->compute_input_scale_shift(s_idx, s_idx + 1, 0, do_rounding, 0, is_broadcast);
+                quantization_injectors[quantization_inj_idx]
+                    ->compute_input_scale_shift(s_idx, s_idx + 1, 0, do_rounding, 0, is_broadcast);
 
                 if (do_dequantization) {
-                    quantization_injectors[quantization_inj_idx]->init_output_scale_shift_ptrs(quant_arg_base, reg_oc_off);
-                    quantization_injectors[quantization_inj_idx]->compute_output_scale_shift(s_idx, s_idx + 1, 0, 0, is_broadcast);
+                    quantization_injectors[quantization_inj_idx]->init_output_scale_shift_ptrs(quant_arg_base,
+                                                                                               reg_oc_off);
+                    quantization_injectors[quantization_inj_idx]->compute_output_scale_shift(s_idx,
+                                                                                             s_idx + 1,
+                                                                                             0,
+                                                                                             0,
+                                                                                             is_broadcast);
                 }
 
                 post_ops_data_offset += quantization_injectors[quantization_inj_idx]->memoryStep();
@@ -723,7 +740,7 @@ bool NormalizeL2::isSupportedOperation(const std::shared_ptr<const ov::Node>& op
             return false;
         }
 
-        const auto isSupportedAxes = [](const std::vector<size_t> &axes, const size_t inputRank) {
+        const auto isSupportedAxes = [](const std::vector<size_t>& axes, const size_t inputRank) {
             if (axes.size() == 1 && axes[0] == 1) {
                 return true;
             } else if (axes.size() == inputRank - 1) {
@@ -755,8 +772,8 @@ bool NormalizeL2::isSupportedOperation(const std::shared_ptr<const ov::Node>& op
     return true;
 }
 
-NormalizeL2::NormalizeL2(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) :
-        Node(op, context, PassThroughShapeInferFactory()) {
+NormalizeL2::NormalizeL2(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, PassThroughShapeInferFactory()) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
@@ -800,10 +817,20 @@ void NormalizeL2::initSupportedPrimitiveDescriptors() {
         inputPrecision = outputPrecision = ov::element::f32;
     }
 
-    if (!one_of(inputPrecision, ov::element::f32, ov::element::bf16, ov::element::f16, ov::element::i8, ov::element::u8)) {
+    if (!one_of(inputPrecision,
+                ov::element::f32,
+                ov::element::bf16,
+                ov::element::f16,
+                ov::element::i8,
+                ov::element::u8)) {
         THROW_ERROR("has unsupported input precision: ", inputPrecision);
     }
-    if (!one_of(outputPrecision, ov::element::f32, ov::element::bf16, ov::element::f16, ov::element::i8, ov::element::u8)) {
+    if (!one_of(outputPrecision,
+                ov::element::f32,
+                ov::element::bf16,
+                ov::element::f16,
+                ov::element::i8,
+                ov::element::u8)) {
         THROW_ERROR("has unsupported output precision: ", outputPrecision);
     }
 
@@ -858,14 +885,14 @@ void NormalizeL2::setPostOps(dnnl::primitive_attr& kernel_attrs, const VectorDim
     dnnl::post_ops ops;
 
     postOpsDataPtrs.clear();
-    for (auto &node : fusedWith) {
-        auto* fakeQuantizeNode = dynamic_cast<FakeQuantize *>(node.get());
+    for (auto& node : fusedWith) {
+        auto* fakeQuantizeNode = dynamic_cast<FakeQuantize*>(node.get());
         if (fakeQuantizeNode) {
             fakeQuantizeNode->appendPostOps(ops, {}, postOpsDataPtrs);
             continue;
         }
 
-        auto* eltwiseNode = dynamic_cast<Eltwise *>(node.get());
+        auto* eltwiseNode = dynamic_cast<Eltwise*>(node.get());
         if (eltwiseNode) {
             eltwiseNode->appendPostOps(ops, dims, postOpsDataPtrs);
             continue;
@@ -945,8 +972,8 @@ void NormalizeL2::execute(dnnl::stream strm) {
     if (!execPtr)
         THROW_ERROR("doesn't have a compiled executor.");
 
-    const uint8_t *src_ptr = getSrcDataAtPortAs<const uint8_t>(DATA);
-    uint8_t *dst_ptr = getDstDataAtPortAs<uint8_t>(DATA);
+    const uint8_t* src_ptr = getSrcDataAtPortAs<const uint8_t>(DATA);
+    uint8_t* dst_ptr = getDstDataAtPortAs<uint8_t>(DATA);
     execPtr->exec(src_ptr, dst_ptr, postOpsDataPtrs.data());
 }
 
@@ -959,9 +986,10 @@ class NormalizeL2::NormalizeL2CornerCaseExecutor : public NormalizeL2::Normalize
         workAmount = std::accumulate(dims.begin(), dims.end(), 1, std::multiplies<size_t>());
     }
 
-    void exec(const uint8_t *src_ptr, uint8_t *dst_ptr, const void **post_ops_data) override {
+    void exec(const uint8_t* src_ptr, uint8_t* dst_ptr, const void** post_ops_data) override {
         normalize(reinterpret_cast<const in_data_t*>(src_ptr), reinterpret_cast<out_data_t*>(dst_ptr));
     }
+
 private:
     void normalize(const in_data_t* src_data, out_data_t* dst_data) {
         parallel_for(workAmount, [&](size_t i) {
@@ -1007,18 +1035,15 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
         if (mayiuse(cpu::x64::avx512_core)) {
             blk_size = 16;
             normalize_modulo_kernel.reset(new jit_uni_normalize_modulo_kernel_f32<cpu::x64::avx512_core>(jcp));
-            normalize_kernel.reset(
-                    new jit_uni_normalize_kernel_f32<cpu::x64::avx512_core>(jcp, *kernel_attrs.get()));
+            normalize_kernel.reset(new jit_uni_normalize_kernel_f32<cpu::x64::avx512_core>(jcp, *kernel_attrs.get()));
         } else if (mayiuse(cpu::x64::avx2)) {
             blk_size = 8;
             normalize_modulo_kernel.reset(new jit_uni_normalize_modulo_kernel_f32<cpu::x64::avx2>(jcp));
-            normalize_kernel.reset(
-                    new jit_uni_normalize_kernel_f32<cpu::x64::avx2>(jcp, *kernel_attrs.get()));
+            normalize_kernel.reset(new jit_uni_normalize_kernel_f32<cpu::x64::avx2>(jcp, *kernel_attrs.get()));
         } else if (mayiuse(cpu::x64::sse41)) {
             blk_size = jcp.is_blk ? 8 : 4;
             normalize_modulo_kernel.reset(new jit_uni_normalize_modulo_kernel_f32<cpu::x64::sse41>(jcp));
-            normalize_kernel.reset(
-                    new jit_uni_normalize_kernel_f32<cpu::x64::sse41>(jcp, *kernel_attrs.get()));
+            normalize_kernel.reset(new jit_uni_normalize_kernel_f32<cpu::x64::sse41>(jcp, *kernel_attrs.get()));
         } else {
             OPENVINO_THROW("Jit Executor for NormalizeL2 cannot create kernels!");
         }
@@ -1030,28 +1055,34 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
             normalize_modulo_kernel->create_ker();
     }
 
-    void exec(const uint8_t *src_ptr, uint8_t *dst_ptr, const void **post_ops_data) override {
+    void exec(const uint8_t* src_ptr, uint8_t* dst_ptr, const void** post_ops_data) override {
         if (jcp.is_nchw) {
-            normalize_nchw(reinterpret_cast<const in_data_t*>(src_ptr), reinterpret_cast<out_data_t*>(dst_ptr), post_ops_data);
+            normalize_nchw(reinterpret_cast<const in_data_t*>(src_ptr),
+                           reinterpret_cast<out_data_t*>(dst_ptr),
+                           post_ops_data);
         } else if (jcp.is_nhwc) {
-            normalize_nhwc(reinterpret_cast<const in_data_t*>(src_ptr), reinterpret_cast<out_data_t*>(dst_ptr), post_ops_data);
+            normalize_nhwc(reinterpret_cast<const in_data_t*>(src_ptr),
+                           reinterpret_cast<out_data_t*>(dst_ptr),
+                           post_ops_data);
         } else if (jcp.is_blk) {
-            normalize_blk(reinterpret_cast<const in_data_t*>(src_ptr), reinterpret_cast<out_data_t*>(dst_ptr), post_ops_data);
+            normalize_blk(reinterpret_cast<const in_data_t*>(src_ptr),
+                          reinterpret_cast<out_data_t*>(dst_ptr),
+                          post_ops_data);
         }
     }
 
 private:
-    void normalize_nchw(const in_data_t* src_data, out_data_t* dst_data, const void **post_ops_data) {
+    void normalize_nchw(const in_data_t* src_data, out_data_t* dst_data, const void** post_ops_data) {
         const size_t spatial_dims = jcp.h * jcp.w;
         for (size_t b = 0lu; b < jcp.n; b++) {
-            const in_data_t *src_data_b = src_data + b * jcp.c * spatial_dims;
-            out_data_t *dst_data_b = dst_data + b * jcp.c * spatial_dims;
+            const in_data_t* src_data_b = src_data + b * jcp.c * spatial_dims;
+            out_data_t* dst_data_b = dst_data + b * jcp.c * spatial_dims;
             if (attrs.across_spatial) {
                 // modulo
                 float addition_identity = 0.0f;
                 float modulo = 0.0f;
                 modulo = parallel_sum(jcp.c, addition_identity, [&](int ic) -> float {
-                    const in_data_t *src_data_bc = src_data_b + ic * spatial_dims;
+                    const in_data_t* src_data_bc = src_data_b + ic * spatial_dims;
                     float modulo_kernel = 0.0f;
                     float modulo_tail = 0.0f;
                     size_t tail_start = 0;
@@ -1076,8 +1107,8 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
 
                 // normalize
                 parallel_for(jcp.c, [&](size_t ic) {
-                    const in_data_t *src_data_bc = src_data_b + ic * spatial_dims;
-                    out_data_t *dst_data_bc = dst_data_b + ic * spatial_dims;
+                    const in_data_t* src_data_bc = src_data_b + ic * spatial_dims;
+                    out_data_t* dst_data_bc = dst_data_b + ic * spatial_dims;
                     auto arg = jit_normalize_call_args();
                     arg.src = src_data_bc;
                     arg.dst = dst_data_bc;
@@ -1092,7 +1123,7 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
                 std::vector<float> moduloM(spatial_dims, 0.f);
                 size_t blocks_num = div_up(spatial_dims, blk_size);
                 parallel_for(blocks_num, [&](size_t ib) {
-                    const in_data_t *src_data_b_ib = src_data_b + ib * blk_size;
+                    const in_data_t* src_data_b_ib = src_data_b + ib * blk_size;
                     size_t min_cb = (std::min)(blk_size, spatial_dims - (ib * blk_size));
                     if (min_cb == blk_size) {
                         auto arg = jit_normalize_call_args();
@@ -1103,7 +1134,7 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
                         (*normalize_modulo_kernel)(&arg);
                     } else {
                         for (size_t c = 0; c < jcp.c; c++) {
-                            const in_data_t *src_data_b_ib_c = src_data_b_ib + spatial_dims * c;
+                            const in_data_t* src_data_b_ib_c = src_data_b_ib + spatial_dims * c;
                             for (size_t blk = 0; blk < min_cb; blk++) {
                                 moduloM[ib * blk_size + blk] += src_data_b_ib_c[blk] * src_data_b_ib_c[blk];
                             }
@@ -1117,8 +1148,8 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
 
                 // normalize
                 parallel_for(jcp.c, [&](size_t ic) {
-                    const in_data_t *src_data_bc = src_data_b + ic * spatial_dims;
-                    out_data_t *dst_data_bc = dst_data_b + ic * spatial_dims;
+                    const in_data_t* src_data_bc = src_data_b + ic * spatial_dims;
+                    out_data_t* dst_data_bc = dst_data_b + ic * spatial_dims;
                     auto arg = jit_normalize_call_args();
                     arg.src = src_data_bc;
                     arg.dst = dst_data_bc;
@@ -1132,19 +1163,19 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
         }
     }
 
-    void normalize_nhwc(const in_data_t* src_data, out_data_t* dst_data, const void **post_ops_data) {
+    void normalize_nhwc(const in_data_t* src_data, out_data_t* dst_data, const void** post_ops_data) {
         const size_t spatial_dims = jcp.h * jcp.w;
         const size_t c_w_dims = jcp.c * jcp.w;
         for (size_t b = 0lu; b < jcp.n; b++) {
-            const in_data_t *src_data_b = src_data + b * jcp.c * spatial_dims;
-            out_data_t *dst_data_b = dst_data + b * jcp.c * spatial_dims;
+            const in_data_t* src_data_b = src_data + b * jcp.c * spatial_dims;
+            out_data_t* dst_data_b = dst_data + b * jcp.c * spatial_dims;
             if (attrs.across_spatial) {
                 // modulo
                 float addition_identity = 0;
                 float modulo = 0.0f;
                 modulo = parallel_sum(jcp.h, addition_identity, [&](int ih) -> float {
                     size_t tail_start = 0;
-                    const in_data_t *src_data_bh = src_data_b + ih * c_w_dims;
+                    const in_data_t* src_data_bh = src_data_b + ih * c_w_dims;
                     float modulo_kernel = 0.f;
                     float modulo_tail = 0.f;
 
@@ -1168,8 +1199,8 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
 
                 // normalize
                 parallel_for2d(jcp.h, jcp.w, [&](int ih, int iw) {
-                    const in_data_t *src_data_bhw = src_data_b + ih * c_w_dims + iw * jcp.c;
-                    out_data_t *dst_data_bhw = dst_data_b + ih * c_w_dims + iw * jcp.c;
+                    const in_data_t* src_data_bhw = src_data_b + ih * c_w_dims + iw * jcp.c;
+                    out_data_t* dst_data_bhw = dst_data_b + ih * c_w_dims + iw * jcp.c;
                     auto arg = jit_normalize_call_args();
                     arg.src = src_data_bhw;
                     arg.dst = dst_data_bhw;
@@ -1183,8 +1214,8 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
                 parallel_for2d(jcp.h, jcp.w, [&](int ih, int iw) {
                     // modulo
                     float modulo = 0.f;
-                    const in_data_t *src_data_bhw = src_data_b + ih * c_w_dims + iw * jcp.c;
-                    out_data_t *dst_data_bhw = dst_data_b + ih * c_w_dims + iw * jcp.c;
+                    const in_data_t* src_data_bhw = src_data_b + ih * c_w_dims + iw * jcp.c;
+                    out_data_t* dst_data_bhw = dst_data_b + ih * c_w_dims + iw * jcp.c;
                     auto arg = jit_normalize_call_args();
                     arg.src = src_data_bhw;
                     arg.modulo = static_cast<float*>(&modulo);
@@ -1213,20 +1244,20 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
         }
     }
 
-    void normalize_blk(const in_data_t* src_data, out_data_t* dst_data, const void **post_ops_data) {
+    void normalize_blk(const in_data_t* src_data, out_data_t* dst_data, const void** post_ops_data) {
         const size_t CB = div_up(jcp.c, blk_size);
         const size_t spatial_dims = jcp.h * jcp.w;
         const size_t w_blk_dims = jcp.w * blk_size;
         for (size_t b = 0lu; b < jcp.n; b++) {
-            const in_data_t *src_data_b = src_data + b * CB * spatial_dims * blk_size;
-            out_data_t *dst_data_b = dst_data + b * CB * spatial_dims * blk_size;
+            const in_data_t* src_data_b = src_data + b * CB * spatial_dims * blk_size;
+            out_data_t* dst_data_b = dst_data + b * CB * spatial_dims * blk_size;
             if (attrs.across_spatial) {
                 // modulo
                 float modulo = 0.0f;
                 float addition_identity = 0.0f;
                 modulo = parallel_sum2d(CB, jcp.h, addition_identity, [&](size_t cb, size_t h) -> float {
                     // handle W * blk_size data
-                    const in_data_t *src_data_b_cb_h = src_data_b + cb * spatial_dims * blk_size + h * w_blk_dims;
+                    const in_data_t* src_data_b_cb_h = src_data_b + cb * spatial_dims * blk_size + h * w_blk_dims;
                     size_t min_cb = (std::min)(blk_size, jcp.c - cb * blk_size);
                     float modulo_w_blk = 0.0f;
                     if (min_cb == blk_size) {
@@ -1238,7 +1269,7 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
                         (*normalize_modulo_kernel)(&arg);
                     } else {
                         for (size_t w = 0; w < jcp.w; w++) {
-                            const in_data_t *src_data_b_cb_h_w = src_data_b_cb_h + w * blk_size;
+                            const in_data_t* src_data_b_cb_h_w = src_data_b_cb_h + w * blk_size;
                             for (size_t c = 0; c < min_cb; c++) {
                                 modulo_w_blk += src_data_b_cb_h_w[c] * src_data_b_cb_h_w[c];
                             }
@@ -1251,8 +1282,8 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
 
                 // normalize
                 parallel_for2d(CB, jcp.h, [&](size_t cb, size_t h) {
-                    const in_data_t *src_data_b_cb_h = src_data_b + cb * spatial_dims * blk_size + h * w_blk_dims;
-                    out_data_t *dst_data_b_cb_h = dst_data_b + cb * spatial_dims * blk_size + h * w_blk_dims;
+                    const in_data_t* src_data_b_cb_h = src_data_b + cb * spatial_dims * blk_size + h * w_blk_dims;
+                    out_data_t* dst_data_b_cb_h = dst_data_b + cb * spatial_dims * blk_size + h * w_blk_dims;
                     auto arg = jit_normalize_call_args();
                     arg.src = src_data_b_cb_h;
                     arg.dst = dst_data_b_cb_h;
@@ -1266,8 +1297,8 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
                 parallel_for2d(jcp.h, jcp.w, [&](size_t ih, size_t iw) {
                     // modulo
                     float modulo = 0.0f;
-                    const in_data_t *src_data_bhw = src_data_b + ih * w_blk_dims + iw * blk_size;
-                    out_data_t *dst_data_bhw = dst_data_b + ih * w_blk_dims + iw * blk_size;
+                    const in_data_t* src_data_bhw = src_data_b + ih * w_blk_dims + iw * blk_size;
+                    out_data_t* dst_data_bhw = dst_data_b + ih * w_blk_dims + iw * blk_size;
                     auto arg = jit_normalize_call_args();
                     arg.src = src_data_bhw;
                     arg.modulo = static_cast<float*>(&modulo);
@@ -1278,7 +1309,7 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
                     size_t padding = CB * blk_size - jcp.c;
                     if (padding > 0) {
                         size_t tail = blk_size - padding;
-                        const in_data_t *src_data_bhw_lastCB = src_data_bhw + (CB - 1) * blk_size * spatial_dims;
+                        const in_data_t* src_data_bhw_lastCB = src_data_bhw + (CB - 1) * blk_size * spatial_dims;
                         for (size_t c = 0; c < tail; c++) {
                             modulo += src_data_bhw_lastCB[c] * src_data_bhw_lastCB[c];
                         }
@@ -1313,30 +1344,39 @@ class NormalizeL2::NormalizeL2JitExecutor : public NormalizeL2::NormalizeL2Execu
 template <typename in_data_t, typename out_data_t>
 class NormalizeL2::NormalizeL2ReferenceExecutor : public NormalizeL2::NormalizeL2Executor {
 public:
-    NormalizeL2ReferenceExecutor(const NormalizeL2Attrs& attrs, const dnnl::primitive_attr& kernel_attrs, const VectorDims& dims) :
-        dims(dims), kernel_attrs(kernel_attrs), attrs(attrs) {
+    NormalizeL2ReferenceExecutor(const NormalizeL2Attrs& attrs,
+                                 const dnnl::primitive_attr& kernel_attrs,
+                                 const VectorDims& dims)
+        : dims(dims),
+          kernel_attrs(kernel_attrs),
+          attrs(attrs) {
         if (attrs.layout != LayoutType::ncsp) {
             OPENVINO_THROW("Reference Executor of 'NormalizeL2' supports only ncsp layout!");
         }
 
-        const auto &p = (*kernel_attrs.get()).post_ops_;
+        const auto& p = (*kernel_attrs.get()).post_ops_;
         for (int i = 0; i < p.len(); i++) {
-            auto &post_op = p.entry_[i];
+            auto& post_op = p.entry_[i];
             if (post_op.is_eltwise()) {
-                eltwise_injectors_ref.push_back(std::make_shared<cpu::ref_eltwise_scalar_fwd_t>(
-                        post_op.eltwise.alg, post_op.eltwise.alpha, post_op.eltwise.beta, post_op.eltwise.scale));
+                eltwise_injectors_ref.push_back(std::make_shared<cpu::ref_eltwise_scalar_fwd_t>(post_op.eltwise.alg,
+                                                                                                post_op.eltwise.alpha,
+                                                                                                post_op.eltwise.beta,
+                                                                                                post_op.eltwise.scale));
             } else if (post_op.is_depthwise()) {
-                depthwise_injectors_ref.push_back(std::make_shared<cpu::ref_depthwise_scalar_fwd_t>(post_op.depthwise.alg));
+                depthwise_injectors_ref.push_back(
+                    std::make_shared<cpu::ref_depthwise_scalar_fwd_t>(post_op.depthwise.alg));
             }
         }
     }
 
-    void exec(const uint8_t *src_ptr, uint8_t *dst_ptr, const void **post_ops_data) override {
-        normalize_nchw_ref(reinterpret_cast<const in_data_t*>(src_ptr), reinterpret_cast<out_data_t*>(dst_ptr), post_ops_data);
+    void exec(const uint8_t* src_ptr, uint8_t* dst_ptr, const void** post_ops_data) override {
+        normalize_nchw_ref(reinterpret_cast<const in_data_t*>(src_ptr),
+                           reinterpret_cast<out_data_t*>(dst_ptr),
+                           post_ops_data);
     }
 
 private:
-    void normalize_nchw_ref(const in_data_t* src_data, out_data_t* dst_data, const void **post_ops_data) {
+    void normalize_nchw_ref(const in_data_t* src_data, out_data_t* dst_data, const void** post_ops_data) {
         size_t dims_size = dims.size();
         const size_t N = dims[0];
         const size_t C = dims[1];
@@ -1344,14 +1384,14 @@ class NormalizeL2::NormalizeL2ReferenceExecutor : public NormalizeL2::NormalizeL
         const size_t W = (dims_size > 3) ? dims[3] : 1lu;
         const size_t spatial_dims = H * W;
         for (size_t b = 0lu; b < N; b++) {
-            const in_data_t *src_data_b = src_data + b * C * spatial_dims;
-            out_data_t *dst_data_b = dst_data + b * C * spatial_dims;
+            const in_data_t* src_data_b = src_data + b * C * spatial_dims;
+            out_data_t* dst_data_b = dst_data + b * C * spatial_dims;
             if (attrs.across_spatial) {
                 // modulo
                 float addition_identity = 0.0f;
                 float modulo = 0.0f;
                 modulo = parallel_sum(C, addition_identity, [&](int ic) -> float {
-                    const in_data_t *src_data_bc = src_data_b + ic * spatial_dims;
+                    const in_data_t* src_data_bc = src_data_b + ic * spatial_dims;
                     float modulo_c = 0.0f;
                     for (size_t m = 0; m < spatial_dims; m++) {
                         modulo_c += src_data_bc[m] * src_data_bc[m];
@@ -1363,8 +1403,8 @@ class NormalizeL2::NormalizeL2ReferenceExecutor : public NormalizeL2::NormalizeL
 
                 // normalize
                 parallel_for(C, [&](size_t ic) {
-                    const in_data_t *src_data_bc = src_data_b + ic * spatial_dims;
-                    out_data_t *dst_data_bc = dst_data_b + ic * spatial_dims;
+                    const in_data_t* src_data_bc = src_data_b + ic * spatial_dims;
+                    out_data_t* dst_data_bc = dst_data_b + ic * spatial_dims;
                     for (size_t m = 0; m < spatial_dims; m++) {
                         float dst_value = src_data_bc[m] * modulo_inv;
                         apply_post_ops_scalar(dst_value, ic, post_ops_data);
@@ -1380,9 +1420,9 @@ class NormalizeL2::NormalizeL2ReferenceExecutor : public NormalizeL2::NormalizeL
                 std::vector<float> moduloM(spatial_dims, 0.f);
                 parallel_for(H, [&](size_t ih) {
                     size_t offset_h = ih * W;
-                    const in_data_t *src_data_b_ih = src_data_b + offset_h;
+                    const in_data_t* src_data_b_ih = src_data_b + offset_h;
                     for (size_t c = 0; c < C; c++) {
-                        const in_data_t *src_data_b_ih_c = src_data_b_ih + spatial_dims * c;
+                        const in_data_t* src_data_b_ih_c = src_data_b_ih + spatial_dims * c;
                         for (size_t w = 0; w < W; w++) {
                             moduloM[offset_h + w] += src_data_b_ih_c[w] * src_data_b_ih_c[w];
                         }
@@ -1395,8 +1435,8 @@ class NormalizeL2::NormalizeL2ReferenceExecutor : public NormalizeL2::NormalizeL
 
                 // normalize
                 parallel_for(C, [&](size_t ic) {
-                    const in_data_t *src_data_bc = src_data_b + ic * spatial_dims;
-                    out_data_t *dst_data_bc = dst_data_b + ic * spatial_dims;
+                    const in_data_t* src_data_bc = src_data_b + ic * spatial_dims;
+                    out_data_t* dst_data_bc = dst_data_b + ic * spatial_dims;
                     for (size_t m = 0; m < spatial_dims; m++) {
                         float dst_value = src_data_bc[m] * moduloM[m];
                         apply_post_ops_scalar(dst_value, ic, post_ops_data);
@@ -1411,14 +1451,14 @@ class NormalizeL2::NormalizeL2ReferenceExecutor : public NormalizeL2::NormalizeL
         }
     }
 
-    inline void apply_post_ops_scalar(float &dst_value, int index_c, const void **post_ops_data_) {
-        const auto &p = (*kernel_attrs.get()).post_ops_;
+    inline void apply_post_ops_scalar(float& dst_value, int index_c, const void** post_ops_data_) {
+        const auto& p = (*kernel_attrs.get()).post_ops_;
         int eltwise_inj_idx = 0;
         int depthwise_inj_idx = 0;
         // reinterpret cast from (pointer to const void) to (pointer to const pointer to const float)
         const float** post_ops_data = reinterpret_cast<const float**>(post_ops_data_);
         for (int i = 0; i < p.len(); i++) {
-            auto &post_op = p.entry_[i];
+            auto& post_op = p.entry_[i];
             if (post_op.is_eltwise()) {
                 dst_value = eltwise_injectors_ref[eltwise_inj_idx]->compute_scalar(dst_value);
                 eltwise_inj_idx++;
@@ -1427,7 +1467,9 @@ class NormalizeL2::NormalizeL2ReferenceExecutor : public NormalizeL2::NormalizeL
                 auto depthwise_weights = depthwise_base + post_op.depthwise.offset[post_op.depthwise.scales] + index_c;
                 auto depthwise_bias = depthwise_base + post_op.depthwise.offset[post_op.depthwise.shifts] + index_c;
 
-                dst_value = depthwise_injectors_ref[depthwise_inj_idx]->compute_scalar(dst_value, depthwise_weights, depthwise_bias);
+                dst_value = depthwise_injectors_ref[depthwise_inj_idx]->compute_scalar(dst_value,
+                                                                                       depthwise_weights,
+                                                                                       depthwise_bias);
 
                 depthwise_inj_idx++;
                 post_ops_data++;
@@ -1478,10 +1520,15 @@ class NormalizeL2::NormalizeL2ReferenceExecutor : public NormalizeL2::NormalizeL
 // *=================* *======* *=================*
 
 std::shared_ptr<NormalizeL2::NormalizeL2Executor> NormalizeL2::NormalizeL2Executor::getNormalizeL2Executor(
-        const NormalizeL2Attrs& attrs, const dnnl::primitive_attr& kernel_attrs, const VectorDims& dims) {
-    NormalizeContext ctx = { nullptr, attrs, kernel_attrs, dims };
-
-    OV_SWITCH(intel_cpu, NormalizeExecutorCreation, ctx, std::tie(attrs.input_prec, attrs.output_prec),
+    const NormalizeL2Attrs& attrs,
+    const dnnl::primitive_attr& kernel_attrs,
+    const VectorDims& dims) {
+    NormalizeContext ctx = {nullptr, attrs, kernel_attrs, dims};
+
+    OV_SWITCH(intel_cpu,
+              NormalizeExecutorCreation,
+              ctx,
+              std::tie(attrs.input_prec, attrs.output_prec),
               OV_CASE2(ov::element::u8, ov::element::u8, uint8_t, uint8_t),
               OV_CASE2(ov::element::i8, ov::element::u8, int8_t, uint8_t),
               OV_CASE2(ov::element::f32, ov::element::u8, float, uint8_t),
@@ -1499,7 +1546,9 @@ std::shared_ptr<NormalizeL2::NormalizeL2Executor> NormalizeL2::NormalizeL2Execut
 
 template <typename in_data_t, typename out_data_t>
 std::shared_ptr<NormalizeL2::NormalizeL2Executor> NormalizeL2::NormalizeL2Executor::makeExecutor(
-        const NormalizeL2Attrs& attrs, const dnnl::primitive_attr& kernel_attrs, const VectorDims& dims) {
+    const NormalizeL2Attrs& attrs,
+    const dnnl::primitive_attr& kernel_attrs,
+    const VectorDims& dims) {
     if (attrs.cornerCase)
         return std::make_shared<NormalizeL2CornerCaseExecutor<in_data_t, out_data_t>>(dims);
 #if defined(OPENVINO_ARCH_X86_64)
@@ -1516,6 +1565,6 @@ bool NormalizeL2::created() const {
     return getType() == Type::NormalizeL2;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/normalize.h b/src/plugins/intel_cpu/src/nodes/normalize.h
index a05925a15deb71..339848466537bb 100644
--- a/src/plugins/intel_cpu/src/nodes/normalize.h
+++ b/src/plugins/intel_cpu/src/nodes/normalize.h
@@ -5,14 +5,15 @@
 #pragma once
 
 #include <node.h>
-#include "onednn/dnnl.h"
-#include <cassert>
 
-#include <cpu/ref_eltwise.hpp>
+#include <cassert>
 #include <cpu/ref_depthwise_injector.hpp>
+#include <cpu/ref_eltwise.hpp>
+
+#include "onednn/dnnl.h"
+#include "openvino/core/parallel.hpp"
 #include "utils/bfloat16.hpp"
 #include "utils/cpu_utils.hpp"
-#include "openvino/core/parallel.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -31,22 +32,22 @@ struct jit_normalize_config_params {
 };
 
 struct jit_normalize_call_args {
-    const void *src;
-    void *dst;
-    const float *modulo;
-    const float *fused_factor;
+    const void* src;
+    void* dst;
+    const float* modulo;
+    const float* fused_factor;
     size_t src_stride;
     size_t dst_stride;
     size_t work_amount;
     size_t oc_off;
-    //ptr to array of post op inputs pointers (flat list)
+    // ptr to array of post op inputs pointers (flat list)
     const void** post_op_data;
 };
 
 struct jit_uni_normalize_modulo_kernel {
-    void (*ker_)(const jit_normalize_call_args *);
+    void (*ker_)(const jit_normalize_call_args*);
 
-    void operator()(const jit_normalize_call_args *args) {
+    void operator()(const jit_normalize_call_args* args) {
         assert(ker_);
         ker_(args);
     }
@@ -60,20 +61,23 @@ struct jit_uni_normalize_modulo_kernel {
 };
 
 struct jit_uni_normalize_kernel {
-    void (*ker_)(const jit_normalize_call_args *);
+    void (*ker_)(const jit_normalize_call_args*);
 
-    void operator()(const jit_normalize_call_args *args) {
+    void operator()(const jit_normalize_call_args* args) {
         assert(ker_);
         ker_(args);
     }
 
-    explicit jit_uni_normalize_kernel(jit_normalize_config_params jcp, const dnnl_primitive_attr &attr) : ker_(nullptr), jcp_(jcp), attr_(attr) {}
+    explicit jit_uni_normalize_kernel(jit_normalize_config_params jcp, const dnnl_primitive_attr& attr)
+        : ker_(nullptr),
+          jcp_(jcp),
+          attr_(attr) {}
     virtual ~jit_uni_normalize_kernel() {}
 
     virtual void create_ker() = 0;
 
     jit_normalize_config_params jcp_;
-    const dnnl_primitive_attr &attr_;
+    const dnnl_primitive_attr& attr_;
 };
 #endif
 class NormalizeL2 : public Node {
@@ -81,7 +85,7 @@ class NormalizeL2 : public Node {
     NormalizeL2(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void createPrimitive() override;
     bool created() const override;
@@ -96,10 +100,7 @@ class NormalizeL2 : public Node {
 
     bool isExecutable() const override;
 
-    enum class NormEpsMode {
-        ADD,
-        MAX
-    };
+    enum class NormEpsMode { ADD, MAX };
 
     struct NormalizeL2Attrs {
         LayoutType layout = LayoutType::ncsp;
@@ -120,7 +121,7 @@ class NormalizeL2 : public Node {
     class NormalizeL2Executor {
     public:
         NormalizeL2Executor() = default;
-        virtual void exec(const uint8_t *src_ptr, uint8_t *dst_ptr, const void **post_ops_data) = 0;
+        virtual void exec(const uint8_t* src_ptr, uint8_t* dst_ptr, const void** post_ops_data) = 0;
         virtual ~NormalizeL2Executor() = default;
 
         static std::shared_ptr<NormalizeL2Executor> getNormalizeL2Executor(const NormalizeL2Attrs& attrs,
@@ -128,7 +129,7 @@ class NormalizeL2 : public Node {
                                                                            const VectorDims& dims);
 
     protected:
-        inline float epsApply(const float &modulo, const NormEpsMode mode, const float eps) const {
+        inline float epsApply(const float& modulo, const NormEpsMode mode, const float eps) const {
             return mode == NormEpsMode::ADD ? modulo + eps : std::max(modulo, eps);
         }
 
@@ -145,7 +146,7 @@ class NormalizeL2 : public Node {
             VectorDims dims;
         };
 
-        template<typename T>
+        template <typename T>
         struct NormalizeExecutorCreation {
             using src_t = typename std::tuple_element<0, T>::type;
             using dst_t = typename std::tuple_element<1, T>::type;
@@ -156,9 +157,12 @@ class NormalizeL2 : public Node {
         };
     };
 
-    template <typename in_data_t, typename out_data_t> class NormalizeL2CornerCaseExecutor;
-    template <typename in_data_t, typename out_data_t> class NormalizeL2JitExecutor;
-    template <typename in_data_t, typename out_data_t> class NormalizeL2ReferenceExecutor;
+    template <typename in_data_t, typename out_data_t>
+    class NormalizeL2CornerCaseExecutor;
+    template <typename in_data_t, typename out_data_t>
+    class NormalizeL2JitExecutor;
+    template <typename in_data_t, typename out_data_t>
+    class NormalizeL2ReferenceExecutor;
 
     dnnl::primitive_attr kernel_attrs;
 
@@ -173,6 +177,6 @@ class NormalizeL2 : public Node {
     executorPtr execPtr = nullptr;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/one_hot.cpp b/src/plugins/intel_cpu/src/nodes/one_hot.cpp
index f9d74a0f75499c..2b3e0fc36cdcaf 100644
--- a/src/plugins/intel_cpu/src/nodes/one_hot.cpp
+++ b/src/plugins/intel_cpu/src/nodes/one_hot.cpp
@@ -4,6 +4,9 @@
 
 #include "one_hot.h"
 
+#include <string>
+#include <vector>
+
 #include "common/cpu_memcpy.h"
 #include "dnnl_types.h"
 #include "nodes/common/blocked_desc_creator.h"
@@ -12,9 +15,6 @@
 #include "selective_build.h"
 #include "shape_inference/custom/one_hot.hpp"
 
-#include <string>
-#include <vector>
-
 namespace ov {
 namespace intel_cpu {
 namespace node {
@@ -26,11 +26,13 @@ bool OneHot::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std
             errorMessage = "Only opset1 OneHot operation is supported";
             return false;
         }
-        if (std::dynamic_pointer_cast<const ov::opset1::Constant>(oneHot->get_input_node_shared_ptr(ON_VALUE_ID)) == nullptr) {
+        if (std::dynamic_pointer_cast<const ov::opset1::Constant>(oneHot->get_input_node_shared_ptr(ON_VALUE_ID)) ==
+            nullptr) {
             errorMessage = "Only const 'on_value' input is supported";
             return false;
         }
-        if (std::dynamic_pointer_cast<const ov::opset1::Constant>(oneHot->get_input_node_shared_ptr(OFF_VALUEAXES_ID)) == nullptr) {
+        if (std::dynamic_pointer_cast<const ov::opset1::Constant>(
+                oneHot->get_input_node_shared_ptr(OFF_VALUEAXES_ID)) == nullptr) {
             errorMessage = "Only const 'off_value' input is supported";
             return false;
         }
@@ -49,7 +51,8 @@ OneHot::OneHot(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr con
 
     errorPrefix = "OneHot layer with name '" + op->get_friendly_name() + "'";
     const auto oneHot = std::dynamic_pointer_cast<const ov::opset1::OneHot>(op);
-    const auto depthNode = std::dynamic_pointer_cast<const ov::opset1::Constant>(oneHot->get_input_node_shared_ptr(DEPTH_ID));
+    const auto depthNode =
+        std::dynamic_pointer_cast<const ov::opset1::Constant>(oneHot->get_input_node_shared_ptr(DEPTH_ID));
     if (depthNode) {
         depth = depthNode->cast_vector<uint32_t>()[0];
     }
@@ -73,7 +76,7 @@ OneHot::OneHot(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr con
     }
 
     if (!(((1 + srcDims.size()) == dstDims.size()) ||
-            (depthNode && (srcDims.size() == 1 && dstDims.size() == 1 && dstDims[0] == depth && srcDims[0] == 1))))
+          (depthNode && (srcDims.size() == 1 && dstDims.size() == 1 && dstDims[0] == depth && srcDims[0] == 1))))
         OPENVINO_THROW(errorPrefix, " has incorrect number of input/output dimensions!");
 }
 
@@ -106,10 +109,10 @@ void OneHot::initSupportedPrimitiveDescriptors() {
                          impl_desc_type::ref_any);
 }
 
-template<typename out_type>
+template <typename out_type>
 void OneHot::one_hot(size_t prefix_size, size_t suffix_size) {
-    const auto *src_data = getSrcDataAtPortAs<const in_type>(0);
-    auto *dst_data = getDstDataAtPortAs<out_type>(0);
+    const auto* src_data = getSrcDataAtPortAs<const in_type>(0);
+    auto* dst_data = getDstDataAtPortAs<out_type>(0);
 
     const out_type on_value = getSrcDataAtPortAs<const out_type>(2)[0];
     const out_type off_value = getSrcDataAtPortAs<const out_type>(3)[0];
@@ -147,7 +150,10 @@ void OneHot::execute(dnnl::stream strm) {
     std::size_t suffix_size = getParentEdgeAt(0)->getMemory().getShape().getElementsCount() / prefix_size;
 
     OneHotContext ctx = {this, prefix_size, suffix_size};
-    OV_SWITCH(intel_cpu, OneHotExecute, ctx, output_precision.size(),
+    OV_SWITCH(intel_cpu,
+              OneHotExecute,
+              ctx,
+              output_precision.size(),
               OV_CASE(sizeof(uint32_t), uint32_t),
               OV_CASE(sizeof(uint16_t), uint16_t),
               OV_CASE(sizeof(uint8_t), uint8_t))
@@ -157,6 +163,6 @@ bool OneHot::created() const {
     return getType() == Type::OneHot;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/one_hot.h b/src/plugins/intel_cpu/src/nodes/one_hot.h
index e2a3b84a753287..05762dbcf7df15 100644
--- a/src/plugins/intel_cpu/src/nodes/one_hot.h
+++ b/src/plugins/intel_cpu/src/nodes/one_hot.h
@@ -14,14 +14,16 @@ class OneHot : public Node {
 public:
     OneHot(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
-    void createPrimitive() override {};
+    void createPrimitive() override{};
     void execute(dnnl::stream strm) override;
     bool created() const override;
 
     bool needShapeInfer() const override;
-    bool needPrepareParams() const override { return false; };
+    bool needPrepareParams() const override {
+        return false;
+    };
     void executeDynamicImpl(dnnl::stream strm) override;
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
@@ -35,9 +37,9 @@ class OneHot : public Node {
         size_t suffix_size;
     };
 
-    template<typename dst_t>
+    template <typename dst_t>
     struct OneHotExecute {
-        void operator()(OneHotContext & ctx) {
+        void operator()(OneHotContext& ctx) {
             ctx.nodePtr->one_hot<dst_t>(ctx.prefix_size, ctx.suffix_size);
         }
     };
@@ -54,10 +56,10 @@ class OneHot : public Node {
     static const size_t ON_VALUE_ID = 2;
     static const size_t OFF_VALUEAXES_ID = 3;
 
-    template<typename out_type>
+    template <typename out_type>
     void one_hot(size_t prefix_size, size_t suffix_size);
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/pad.cpp b/src/plugins/intel_cpu/src/nodes/pad.cpp
index fb31a0a08fd2a2..eb1db0c6034a5e 100644
--- a/src/plugins/intel_cpu/src/nodes/pad.cpp
+++ b/src/plugins/intel_cpu/src/nodes/pad.cpp
@@ -4,13 +4,14 @@
 
 #include "pad.h"
 
-#include "openvino/core/parallel.hpp"
-#include "common/cpu_memcpy.h"
-#include "utils/bfloat16.hpp"
-#include "selective_build.h"
+#include <openvino/core/type/float16.hpp>
 #include <openvino/op/constant.hpp>
 #include <openvino/op/pad.hpp>
-#include <openvino/core/type/float16.hpp>
+
+#include "common/cpu_memcpy.h"
+#include "openvino/core/parallel.hpp"
+#include "selective_build.h"
+#include "utils/bfloat16.hpp"
 
 using namespace dnnl;
 
@@ -27,11 +28,7 @@ bool Pad::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::s
 
         auto pad = ov::as_type<const op::util::PadBase>(op.get());
         const auto pad_mode = pad->get_pad_mode();
-        if (!one_of(pad_mode,
-                    op::PadMode::CONSTANT,
-                    op::PadMode::EDGE,
-                    op::PadMode::REFLECT,
-                    op::PadMode::SYMMETRIC)) {
+        if (!one_of(pad_mode, op::PadMode::CONSTANT, op::PadMode::EDGE, op::PadMode::REFLECT, op::PadMode::SYMMETRIC)) {
             errorMessage = "Has unsupported pad_mode: " + ov::as_string(pad_mode);
             return false;
         }
@@ -64,7 +61,7 @@ Pad::Pad(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
     }
 
     shapeHasDataDependency = !ov::is_type<op::v0::Constant>(op->get_input_node_shared_ptr(PADS_BEGIN_ID)) ||
-            !ov::is_type<op::v0::Constant>(op->get_input_node_shared_ptr(PADS_END_ID));
+                             !ov::is_type<op::v0::Constant>(op->get_input_node_shared_ptr(PADS_END_ID));
 
     auto fillingInParameters = [&](VectorIdxs& parameter, const size_t type) {
         if (type < PADS_BEGIN_ID)
@@ -92,9 +89,8 @@ Pad::Pad(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
                                        ov::op::v0::Constant::get_type_info_static()) {
             if (!ov::is_scalar(pad->get_input_shape(PAD_VALUE_ID)))
                 OPENVINO_THROW(errorPrefix, "has non scalar 'pad_value' input");
-            attrs.padValue =
-                ov::as_type_ptr<const op::v0::Constant>(pad->get_input_node_shared_ptr(PAD_VALUE_ID))
-                    ->cast_vector<float>()[0];
+            attrs.padValue = ov::as_type_ptr<const op::v0::Constant>(pad->get_input_node_shared_ptr(PAD_VALUE_ID))
+                                 ->cast_vector<float>()[0];
             attrs.constPadValue = true;
         }
     } else if (pad_mode == op::PadMode::EDGE) {
@@ -129,13 +125,18 @@ void Pad::initSupportedPrimitiveDescriptors() {
 
     auto& creatorsMap = BlockedDescCreator::getCommonCreators();
     auto pushSupportedPrimitiveDescriptor = [&](LayoutType memoryFormat) {
-        config.inConfs[0].setMemDesc(creatorsMap.at(memoryFormat)->createSharedDesc(precision, getInputShapeAtPort(DATA_ID)));
-        config.inConfs[1].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(ov::element::i32, getInputShapeAtPort(PADS_BEGIN_ID)));
-        config.inConfs[2].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(ov::element::i32, getInputShapeAtPort(PADS_END_ID)));
+        config.inConfs[0].setMemDesc(
+            creatorsMap.at(memoryFormat)->createSharedDesc(precision, getInputShapeAtPort(DATA_ID)));
+        config.inConfs[1].setMemDesc(
+            creatorsMap.at(LayoutType::ncsp)->createSharedDesc(ov::element::i32, getInputShapeAtPort(PADS_BEGIN_ID)));
+        config.inConfs[2].setMemDesc(
+            creatorsMap.at(LayoutType::ncsp)->createSharedDesc(ov::element::i32, getInputShapeAtPort(PADS_END_ID)));
         if (isPadValueSpecified)
-            config.inConfs[3].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(ov::element::f32, getInputShapeAtPort(PAD_VALUE_ID)));
+            config.inConfs[3].setMemDesc(creatorsMap.at(LayoutType::ncsp)
+                                             ->createSharedDesc(ov::element::f32, getInputShapeAtPort(PAD_VALUE_ID)));
 
-        config.outConfs[0].setMemDesc(creatorsMap.at(memoryFormat)->createSharedDesc(precision, getOutputShapeAtPort(DATA_ID)));
+        config.outConfs[0].setMemDesc(
+            creatorsMap.at(memoryFormat)->createSharedDesc(precision, getOutputShapeAtPort(DATA_ID)));
         supportedPrimitiveDescriptors.push_back({config, impl_desc_type::ref});
     };
 
@@ -147,12 +148,9 @@ void Pad::initSupportedPrimitiveDescriptors() {
     auto canUseBlocked = [&](const size_t blockSize) {
         const auto& srcDims = inputDataShape.getDims();
         return srcDims[1] != Shape::UNDEFINED_DIM && srcDims[1] % blockSize == 0 &&
-               ((attrs.padMode == CONSTANT &&
-                    attrs.padsBegin[1] % static_cast<int32_t>(blockSize) == 0 &&
-                    attrs.padsEnd[1] % static_cast<int32_t>(blockSize) == 0) ||
-                (attrs.padMode != CONSTANT &&
-                    attrs.padsBegin[1] == 0 &&
-                    attrs.padsEnd[1] == 0));
+               ((attrs.padMode == CONSTANT && attrs.padsBegin[1] % static_cast<int32_t>(blockSize) == 0 &&
+                 attrs.padsEnd[1] % static_cast<int32_t>(blockSize) == 0) ||
+                (attrs.padMode != CONSTANT && attrs.padsBegin[1] == 0 && attrs.padsEnd[1] == 0));
     };
 
     if (numOfDims == 4 || numOfDims == 5) {
@@ -186,7 +184,7 @@ void Pad::createPrimitive() {
         // WA to prevent reading uninitialized data in case of the pad value is a parameter
         MemoryCPtr padValue = srcMemory.size() > PAD_VALUE_ID ? srcMemory[PAD_VALUE_ID] : nullptr;
         if (padValue && !getParentEdgeAt(PAD_VALUE_ID)->getParent()->isConstant()) {
-            //set artificial zero memory just to avoid reading garbage from the uninitilized input
+            // set artificial zero memory just to avoid reading garbage from the uninitilized input
             auto tmpPadValue = std::make_shared<Memory>(getEngine(), padValue->getDescPtr());
             tmpPadValue->nullify();
             srcMemory[PAD_VALUE_ID] = tmpPadValue;
@@ -207,11 +205,7 @@ bool Pad::isExecutable() const {
 
 void Pad::prepareParams() {
     updateLastInputDims();
-    execPtr = std::make_shared<PadExecutor>(
-        attrs,
-        srcMemory,
-        dstMemory,
-        errorPrefix);
+    execPtr = std::make_shared<PadExecutor>(attrs, srcMemory, dstMemory, errorPrefix);
 }
 
 Pad::PadExecutor::PadExecutor(const PadAttrs& attrs,
@@ -244,14 +238,13 @@ void Pad::PadExecutor::paramsInitialization(const PadAttrs& attrs,
     params.attrs.prc = srcMemPtr->getDesc().getPrecision();
     params.dataSize = params.attrs.prc.size();
 
-    auto fillingInParameters =
-        [&](VectorIdxs& parameter, const size_t type, const size_t size, const int value) {
-            const int* ptr = srcMemory[type]->getDataAs<const int32_t>();
-            parameter.resize(size);
-            for (size_t i = 0; i < size; i++) {
-                parameter[i] = static_cast<int>(ptr[i]);
-            }
-        };
+    auto fillingInParameters = [&](VectorIdxs& parameter, const size_t type, const size_t size, const int value) {
+        const int* ptr = srcMemory[type]->getDataAs<const int32_t>();
+        parameter.resize(size);
+        for (size_t i = 0; i < size; i++) {
+            parameter[i] = static_cast<int>(ptr[i]);
+        }
+    };
     // if pad begin/end/value dynamic
     if (params.attrs.padsBegin.empty())
         fillingInParameters(params.attrs.padsBegin, PADS_BEGIN_ID, srcDims.size(), 0);
@@ -272,8 +265,7 @@ void Pad::PadExecutor::paramsInitialization(const PadAttrs& attrs,
         params.attrs.padsEnd.push_back(0);
     } else {
         auto order = srcBlockMemDesc->getOrder();
-        VectorIdxs newPadsBegin(params.attrs.padsBegin.size(), 0),
-                   newPadsEnd(params.attrs.padsEnd.size(), 0);
+        VectorIdxs newPadsBegin(params.attrs.padsBegin.size(), 0), newPadsEnd(params.attrs.padsEnd.size(), 0);
         for (size_t i = 0; i < params.attrs.padsBegin.size(); ++i) {
             newPadsBegin[i] = params.attrs.padsBegin[order[i]];
             newPadsEnd[i] = params.attrs.padsEnd[order[i]];
@@ -371,9 +363,10 @@ void Pad::PadExecutor::innerParamsInitialization() {
     params.innerBeginShift = params.innerBeginPadCount * params.shift;
     params.innerEndShift = params.innerEndPadCount * params.shift;
     params.innerSrcShift = std::max(-1 * params.attrs.padsBegin[params.nDimsForWork], 0) * params.shift;
-    params.innerCopySize = (params.srcDims[params.nDimsForWork] +
-                            std::min(params.attrs.padsBegin[params.nDimsForWork], 0) +
-                            std::min(params.attrs.padsEnd[params.nDimsForWork], 0)) * params.shift;
+    params.innerCopySize =
+        (params.srcDims[params.nDimsForWork] + std::min(params.attrs.padsBegin[params.nDimsForWork], 0) +
+         std::min(params.attrs.padsEnd[params.nDimsForWork], 0)) *
+        params.shift;
 }
 
 void Pad::PadExecutor::exec(const MemoryPtr& srcMemPtr, const MemoryPtr& dstMemPtr) {
@@ -487,7 +480,9 @@ void Pad::PadExecutor::padConstantCommon(const MemoryPtr& srcMemPtr, const Memor
                 srcIdx += (indexes[idx] - params.attrs.padsBegin[idx]) * params.srcStrides[idx];
 
             std::fill_n(&dstData[dstIdx], params.innerBeginShift, value);
-            cpu_memcpy(&dstData[dstIdx + params.innerBeginShift], &srcData[srcIdx + params.innerSrcShift], params.innerCopySize * params.dataSize);
+            cpu_memcpy(&dstData[dstIdx + params.innerBeginShift],
+                       &srcData[srcIdx + params.innerSrcShift],
+                       params.innerCopySize * params.dataSize);
             std::fill_n(&dstData[dstIdx + params.innerBeginShift + params.innerCopySize], params.innerEndShift, value);
 
             parallel_step(params.nDimsForWork, params.dstDims, indexes);
@@ -528,7 +523,9 @@ void Pad::PadExecutor::padConstantZero(const MemoryPtr& srcMemPtr, const MemoryP
             srcIdx *= params.dataSize;
 
             memset(&dstData[dstIdx], 0, params.innerBeginShift);
-            cpu_memcpy(&dstData[dstIdx + params.innerBeginShift], &srcData[srcIdx + params.innerSrcShift], params.innerCopySize);
+            cpu_memcpy(&dstData[dstIdx + params.innerBeginShift],
+                       &srcData[srcIdx + params.innerSrcShift],
+                       params.innerCopySize);
             memset(&dstData[dstIdx + params.innerBeginShift + params.innerCopySize], 0, params.innerEndShift);
 
             parallel_step(params.nDimsForWork, params.dstDims, indexes);
@@ -565,7 +562,9 @@ void Pad::PadExecutor::padEdge(const MemoryPtr& srcMemPtr, const MemoryPtr& dstM
             for (size_t i = 0; i < params.innerBeginPadCount; ++i)
                 cpu_memcpy(&dstData[dstIdx + i * params.shift], &srcData[srcIdx], params.shift);
 
-            cpu_memcpy(&dstData[dstIdx + params.innerBeginShift], &srcData[srcIdx + params.innerSrcShift], params.innerCopySize);
+            cpu_memcpy(&dstData[dstIdx + params.innerBeginShift],
+                       &srcData[srcIdx + params.innerSrcShift],
+                       params.innerCopySize);
 
             for (size_t i = 0; i < params.innerEndPadCount; ++i)
                 cpu_memcpy(&dstData[dstIdx + params.innerBeginShift + params.innerCopySize + i * params.shift],
@@ -577,11 +576,15 @@ void Pad::PadExecutor::padEdge(const MemoryPtr& srcMemPtr, const MemoryPtr& dstM
     });
 }
 
-void Pad::PadExecutor::padReflectOrSymmetric(const MemoryPtr& srcMemPtr, const MemoryPtr& dstMemPtr, const bool isSymmetric) {
+void Pad::PadExecutor::padReflectOrSymmetric(const MemoryPtr& srcMemPtr,
+                                             const MemoryPtr& dstMemPtr,
+                                             const bool isSymmetric) {
     const uint8_t* srcData = srcMemPtr->getDataAs<const uint8_t>();
     uint8_t* dstData = dstMemPtr->getDataAs<uint8_t>();
     const size_t shift = isSymmetric ? 1 : 0;
-    const size_t endSrcShift = (params.srcDimsForReflectOrSymmetric[params.nDimsForWork] - params.srcODims[params.nDimsForWork]) * params.shift;
+    const size_t endSrcShift =
+        (params.srcDimsForReflectOrSymmetric[params.nDimsForWork] - params.srcODims[params.nDimsForWork]) *
+        params.shift;
 
     parallel_nt(params.nThreads, [&](const int ithr, const int nthr) {
         size_t start = 0, end = 0;
@@ -610,7 +613,9 @@ void Pad::PadExecutor::padReflectOrSymmetric(const MemoryPtr& srcMemPtr, const M
                            &srcData[srcIdx + (params.attrs.padsBegin[params.nDimsForWork] - shift - i) * params.shift],
                            params.shift);
 
-            cpu_memcpy(&dstData[dstIdx + params.innerBeginShift], &srcData[srcIdx + params.innerSrcShift], params.innerCopySize);
+            cpu_memcpy(&dstData[dstIdx + params.innerBeginShift],
+                       &srcData[srcIdx + params.innerSrcShift],
+                       params.innerCopySize);
 
             for (size_t i = 0; i < params.innerEndPadCount; ++i)
                 cpu_memcpy(&dstData[dstIdx + (params.srcODims[params.nDimsForWork] + i) * params.shift],
diff --git a/src/plugins/intel_cpu/src/nodes/pad.h b/src/plugins/intel_cpu/src/nodes/pad.h
index f2fcd9cc3c20a9..8664e3b1853068 100644
--- a/src/plugins/intel_cpu/src/nodes/pad.h
+++ b/src/plugins/intel_cpu/src/nodes/pad.h
@@ -32,12 +32,7 @@ class Pad : public Node {
 private:
     using VectorIdxs = std::vector<int32_t>;
 
-    enum PadMode {
-        CONSTANT = 0,
-        EDGE = 1,
-        REFLECT = 2,
-        SYMMETRIC = 3
-    };
+    enum PadMode { CONSTANT = 0, EDGE = 1, REFLECT = 2, SYMMETRIC = 3 };
 
     struct PadAttrs {
         PadMode padMode = CONSTANT;
@@ -60,10 +55,13 @@ class Pad : public Node {
 
     private:
         void padConstant(const MemoryPtr& srcMemPtr, const MemoryPtr& dstMemPtr);
-        template<typename T> void padConstantCommon(const MemoryPtr& srcMemPtr, const MemoryPtr& dstMemPtr);
+        template <typename T>
+        void padConstantCommon(const MemoryPtr& srcMemPtr, const MemoryPtr& dstMemPtr);
         void padConstantZero(const MemoryPtr& srcMemPtr, const MemoryPtr& dstMemPtr);
         void padEdge(const MemoryPtr& srcMemPtr, const MemoryPtr& dstMemPtr);
-        void padReflectOrSymmetric(const MemoryPtr& srcMemPtr, const MemoryPtr& dstMemPtr, const bool isSymmetric = false);
+        void padReflectOrSymmetric(const MemoryPtr& srcMemPtr,
+                                   const MemoryPtr& dstMemPtr,
+                                   const bool isSymmetric = false);
         void paramsInitialization(const PadAttrs& attrs,
                                   const std::vector<MemoryCPtr>& srcMemory,
                                   const std::vector<MemoryCPtr>& dstMemory);
@@ -77,7 +75,7 @@ class Pad : public Node {
             MemoryPtr dstMemPtr;
         };
 
-        template<typename T>
+        template <typename T>
         struct PadConstantEmitter {
             void operator()(PadContext& ctx) {
                 ctx.executor->padConstantCommon<T>(ctx.srcMemPtr, ctx.dstMemPtr);
@@ -126,6 +124,6 @@ class Pad : public Node {
     bool shapeHasDataDependency = false;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/paged_attn.cpp b/src/plugins/intel_cpu/src/nodes/paged_attn.cpp
index 8d927b2ed68ba2..04fd44c20508f8 100644
--- a/src/plugins/intel_cpu/src/nodes/paged_attn.cpp
+++ b/src/plugins/intel_cpu/src/nodes/paged_attn.cpp
@@ -4,25 +4,24 @@
 
 #include "paged_attn.h"
 
+#include <algorithm>
+#include <string>
+#include <vector>
+
 #include "common/arbitrary_order_desc_creator.h"
 #include "common/primitive_hashing_utils.hpp"
 #include "cpu/x64/cpu_isa_traits.hpp"
 #include "dnnl_extension_utils.h"
+#include "kernels/scaled_attn/attn_memcpy.hpp"
+#include "kernels/scaled_attn/attn_quant.hpp"
+#include "kernels/scaled_attn/executor_pa.hpp"
 #include "memory_desc/cpu_memory_desc_utils.h"
 #include "memory_desc/dnnl_blocked_memory_desc.h"
 #include "onednn/dnnl.h"
 #include "openvino/core/parallel.hpp"
 #include "openvino/util/common_util.hpp"
 #include "shape_inference/shape_inference_internal_dyn.hpp"
-
 #include "utils/plain_tensor.hpp"
-#include "kernels/scaled_attn/executor_pa.hpp"
-#include "kernels/scaled_attn/attn_memcpy.hpp"
-#include "kernels/scaled_attn/attn_quant.hpp"
-
-#include <algorithm>
-#include <string>
-#include <vector>
 
 using namespace ov::Extensions::Cpu;
 using namespace ov::Extensions::Cpu::XARCH;
@@ -73,50 +72,63 @@ void PagedAttention::initSupportedPrimitiveDescriptors() {
     auto orgInputNumber = getOriginalInputsNumber();
     config.inConfs.resize(orgInputNumber);
     config.outConfs.resize(getOriginalOutputsNumber());
-    config.inConfs[PagedAttentionExecutor::ID_Q].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        rtPrecision, getInputShapeAtPort(PagedAttentionExecutor::ID_Q)));
-    config.inConfs[PagedAttentionExecutor::ID_K].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        rtPrecision, getInputShapeAtPort(PagedAttentionExecutor::ID_K)));
-    config.inConfs[PagedAttentionExecutor::ID_V].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        rtPrecision, getInputShapeAtPort(PagedAttentionExecutor::ID_V)));
+    config.inConfs[PagedAttentionExecutor::ID_Q].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)
+            ->createSharedDesc(rtPrecision, getInputShapeAtPort(PagedAttentionExecutor::ID_Q)));
+    config.inConfs[PagedAttentionExecutor::ID_K].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)
+            ->createSharedDesc(rtPrecision, getInputShapeAtPort(PagedAttentionExecutor::ID_K)));
+    config.inConfs[PagedAttentionExecutor::ID_V].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)
+            ->createSharedDesc(rtPrecision, getInputShapeAtPort(PagedAttentionExecutor::ID_V)));
 
     OPENVINO_ASSERT(orgInputNumber == 13, "The input number of PagedAttention should be 13.");
     // kvcache, float, []
     auto past_key_input_mem_precision = getOriginalInputPrecisionAtPort(PagedAttentionExecutor::ID_KCACHE);
     auto past_value_input_mem_precision = getOriginalInputPrecisionAtPort(PagedAttentionExecutor::ID_VCACHE);
-    config.inConfs[PagedAttentionExecutor::ID_KCACHE].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        past_key_input_mem_precision, getInputShapeAtPort(PagedAttentionExecutor::ID_KCACHE)));
-    config.inConfs[PagedAttentionExecutor::ID_VCACHE].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        past_value_input_mem_precision, getInputShapeAtPort(PagedAttentionExecutor::ID_VCACHE)));
+    config.inConfs[PagedAttentionExecutor::ID_KCACHE].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)
+            ->createSharedDesc(past_key_input_mem_precision, getInputShapeAtPort(PagedAttentionExecutor::ID_KCACHE)));
+    config.inConfs[PagedAttentionExecutor::ID_VCACHE].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)
+            ->createSharedDesc(past_value_input_mem_precision, getInputShapeAtPort(PagedAttentionExecutor::ID_VCACHE)));
     // past_lens, int, [b_seq]
-    config.inConfs[PagedAttentionExecutor::ID_PAST_LENS].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        ov::element::i32, getInputShapeAtPort(PagedAttentionExecutor::ID_PAST_LENS)));
+    config.inConfs[PagedAttentionExecutor::ID_PAST_LENS].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)
+            ->createSharedDesc(ov::element::i32, getInputShapeAtPort(PagedAttentionExecutor::ID_PAST_LENS)));
     // subsequence_begins, int, [b_seq]
-    config.inConfs[PagedAttentionExecutor::ID_SUBSEQUENCE_BEGINS].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        ov::element::i32, getInputShapeAtPort(PagedAttentionExecutor::ID_SUBSEQUENCE_BEGINS)));
+    config.inConfs[PagedAttentionExecutor::ID_SUBSEQUENCE_BEGINS].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)
+            ->createSharedDesc(ov::element::i32, getInputShapeAtPort(PagedAttentionExecutor::ID_SUBSEQUENCE_BEGINS)));
     // block_indices, int, [num_blocks]
-    config.inConfs[PagedAttentionExecutor::ID_BLOCK_INDICES].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        ov::element::i32, getInputShapeAtPort(PagedAttentionExecutor::ID_BLOCK_INDICES)));
+    config.inConfs[PagedAttentionExecutor::ID_BLOCK_INDICES].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)
+            ->createSharedDesc(ov::element::i32, getInputShapeAtPort(PagedAttentionExecutor::ID_BLOCK_INDICES)));
     // block_indices_begins, int, [b_seq]
-    config.inConfs[PagedAttentionExecutor::ID_BLOCK_INDICES_BEGINS].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        ov::element::i32, getInputShapeAtPort(PagedAttentionExecutor::ID_BLOCK_INDICES_BEGINS)));
+    config.inConfs[PagedAttentionExecutor::ID_BLOCK_INDICES_BEGINS].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)
+            ->createSharedDesc(ov::element::i32, getInputShapeAtPort(PagedAttentionExecutor::ID_BLOCK_INDICES_BEGINS)));
     // scale, float, []
-    config.inConfs[PagedAttentionExecutor::ID_SCALE].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        ov::element::f32, getInputShapeAtPort(PagedAttentionExecutor::ID_SCALE)));
+    config.inConfs[PagedAttentionExecutor::ID_SCALE].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)
+            ->createSharedDesc(ov::element::f32, getInputShapeAtPort(PagedAttentionExecutor::ID_SCALE)));
     // sliding_window, int, []
-    config.inConfs[PagedAttentionExecutor::ID_SLIDING_WINDOW].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        ov::element::i32, getInputShapeAtPort(PagedAttentionExecutor::ID_SLIDING_WINDOW)));
+    config.inConfs[PagedAttentionExecutor::ID_SLIDING_WINDOW].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)
+            ->createSharedDesc(ov::element::i32, getInputShapeAtPort(PagedAttentionExecutor::ID_SLIDING_WINDOW)));
     // alibi_slopes, float, [H|0]
-    config.inConfs[PagedAttentionExecutor::ID_ALIBI_SLOPES].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        ov::element::f32, getInputShapeAtPort(PagedAttentionExecutor::ID_ALIBI_SLOPES)));
+    config.inConfs[PagedAttentionExecutor::ID_ALIBI_SLOPES].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)
+            ->createSharedDesc(ov::element::f32, getInputShapeAtPort(PagedAttentionExecutor::ID_ALIBI_SLOPES)));
     // max_context_len, int, []
-    config.inConfs[PagedAttentionExecutor::ID_MAX_CONTEXT_LEN].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        ov::element::i32, getInputShapeAtPort(PagedAttentionExecutor::ID_MAX_CONTEXT_LEN)));
+    config.inConfs[PagedAttentionExecutor::ID_MAX_CONTEXT_LEN].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)
+            ->createSharedDesc(ov::element::i32, getInputShapeAtPort(PagedAttentionExecutor::ID_MAX_CONTEXT_LEN)));
 
-    config.outConfs[0].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        rtPrecision, getOutputShapeAtPort(0)));
-    config.outConfs[1].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        ov::element::f32, getOutputShapeAtPort(1)));
+    config.outConfs[0].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)->createSharedDesc(rtPrecision, getOutputShapeAtPort(0)));
+    config.outConfs[1].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)->createSharedDesc(ov::element::f32, getOutputShapeAtPort(1)));
 
     supportedPrimitiveDescriptors.emplace_back(config, impl_desc_type::ref_any);
 }
@@ -194,7 +206,8 @@ void PagedAttention::execute(dnnl::stream strm) {
     m_executor->execute(inputs, outputs);
 }
 
-bool PagedAttention::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool PagedAttention::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                          std::string& errorMessage) noexcept {
     try {
         auto vCachePrecision = op->get_input_element_type(PagedAttentionExecutor::ID_VCACHE);
         auto kCachePrecision = op->get_input_element_type(PagedAttentionExecutor::ID_KCACHE);
@@ -206,7 +219,8 @@ bool PagedAttention::isSupportedOperation(const std::shared_ptr<const ov::Node>&
             }
         }
         int orgInput = static_cast<int>(op->get_input_size());
-        if (op->get_type_name() == std::string("PagedAttentionExtension") && orgInput == PagedAttentionExecutor::ID_SLIDING_WINDOW + 1) {
+        if (op->get_type_name() == std::string("PagedAttentionExtension") &&
+            orgInput == PagedAttentionExecutor::ID_SLIDING_WINDOW + 1) {
             return true;
         }
     } catch (...) {
diff --git a/src/plugins/intel_cpu/src/nodes/paged_attn.h b/src/plugins/intel_cpu/src/nodes/paged_attn.h
index adc0f1b634c1b2..b8edfbf97fce17 100644
--- a/src/plugins/intel_cpu/src/nodes/paged_attn.h
+++ b/src/plugins/intel_cpu/src/nodes/paged_attn.h
@@ -4,11 +4,11 @@
 
 #pragma once
 
+#include "kernels/scaled_attn/executor_pa.hpp"
 #include "memory_state.h"
 #include "node.h"
 #include "transformations/cpu_opset/common/op/sdpa.hpp"
 #include "utils/plain_tensor.hpp"
-#include "kernels/scaled_attn/executor_pa.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -41,7 +41,8 @@ class PagedAttention : public Node {
     ov::element::Type getRuntimePrecision() const override;
 
     std::shared_ptr<ov::Extensions::Cpu::PagedAttentionExecutor> m_executor;
-    template <typename T> struct AttentionExecutor;
+    template <typename T>
+    struct AttentionExecutor;
     friend struct PagedAttentionKey;
 
     bool m_hasScore = false;
diff --git a/src/plugins/intel_cpu/src/nodes/pooling.cpp b/src/plugins/intel_cpu/src/nodes/pooling.cpp
index c7b687d83c2d25..5d70117ef84910 100644
--- a/src/plugins/intel_cpu/src/nodes/pooling.cpp
+++ b/src/plugins/intel_cpu/src/nodes/pooling.cpp
@@ -4,28 +4,30 @@
 
 #include "pooling.h"
 
-#include "openvino/op/avg_pool.hpp"
-#include "openvino/op/max_pool.hpp"
-#include "fake_quantize.h"
+#include <memory_desc/cpu_memory_desc_utils.h>
+
 #include <memory>
 #include <oneapi/dnnl/dnnl.hpp>
 #include <string>
 #include <vector>
-#include "onednn/dnnl.h"
+
+#include "common/primitive_hashing_utils.hpp"
 #include "dnnl_extension_utils.h"
-#include "utils/general_utils.h"
-#include <memory_desc/cpu_memory_desc_utils.h>
+#include "fake_quantize.h"
 #include "memory_desc/dnnl_blocked_memory_desc.h"
 #include "nodes/node_config.h"
-#include "common/primitive_hashing_utils.hpp"
+#include "onednn/dnnl.h"
+#include "openvino/op/avg_pool.hpp"
+#include "openvino/op/max_pool.hpp"
+#include "utils/general_utils.h"
 
 // to access and change C pooling primitive desc internal padding field
-#include <common/primitive_desc_iface.hpp>
 #include <common/pooling_pd.hpp>
+#include <common/primitive_desc_iface.hpp>
 
 #if defined(OV_CPU_WITH_ACL)
-#include "executors/acl/acl_utils.hpp"
-#include "utils/debug_capabilities.h"
+#    include "executors/acl/acl_utils.hpp"
+#    include "utils/debug_capabilities.h"
 #endif
 
 using namespace dnnl;
@@ -108,35 +110,34 @@ dnnl::pooling_forward::primitive_desc createDescriptorHelper(const dnnl::engine&
         return memory::dims(orig_dims.begin(), orig_dims.end());
     };
 
-    auto desc = dnnl::pooling_forward::primitive_desc(
-        engine,
-        prop_kind::forward_inference,
-        alg,
-        in_candidate,
-        out_candidate,
-        convert(stride),
-        convert(kernel),
-        convert(effective_dilation),
-        convert(effective_pad_begin),
-        convert(effective_pad_end),
-        attr,
-        true);
+    auto desc = dnnl::pooling_forward::primitive_desc(engine,
+                                                      prop_kind::forward_inference,
+                                                      alg,
+                                                      in_candidate,
+                                                      out_candidate,
+                                                      convert(stride),
+                                                      convert(kernel),
+                                                      convert(effective_dilation),
+                                                      convert(effective_pad_begin),
+                                                      convert(effective_pad_end),
+                                                      attr,
+                                                      true);
 
     // @ TODO Since oneDNN 3.0 for primitives it is impossible to udpate internal fields of the particular primitive
     // if (alg == dnnl::algorithm::pooling_avg_include_padding) {
-        // In case of AVG including paddings the norm coeff should be calculated
-        // with tacking into account original pads. So we need to restore
-        // original values for end paddings.
-        //
-        // WA. Because onednn uses different formula to calculate AVG norm coeff
-        //     in compare with Caffe. In onednn coeff is always 1/(KH*KW)
-        //
-        // for (int i = 0; i < data_pad_end.size(); i++) {
-        //     if (data_pad_end[i] != effective_pad_end[i]) {
-        //         auto pooling_pd = static_cast<dnnl::impl::pooling_pd_t*>(desc_ptr->get());;
-        //         pooling_pd->desc()->padding[1][i] = static_cast<ptrdiff_t>(data_pad_end[i]);
-        //     }
-        // }
+    // In case of AVG including paddings the norm coeff should be calculated
+    // with tacking into account original pads. So we need to restore
+    // original values for end paddings.
+    //
+    // WA. Because onednn uses different formula to calculate AVG norm coeff
+    //     in compare with Caffe. In onednn coeff is always 1/(KH*KW)
+    //
+    // for (int i = 0; i < data_pad_end.size(); i++) {
+    //     if (data_pad_end[i] != effective_pad_end[i]) {
+    //         auto pooling_pd = static_cast<dnnl::impl::pooling_pd_t*>(desc_ptr->get());;
+    //         pooling_pd->desc()->padding[1][i] = static_cast<ptrdiff_t>(data_pad_end[i]);
+    //     }
+    // }
     // }
 
     return desc;
@@ -152,8 +153,8 @@ bool Pooling::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, st
                 return false;
             }
         } else if (!ov::is_type<const ov::op::v1::MaxPool>(op) && !ov::is_type<const ov::op::v8::MaxPool>(op) &&
-        !ov::is_type<const ov::op::v14::MaxPool>(op) && !ov::is_type<const ov::op::v1::AvgPool>(op) &&
-        !ov::is_type<const ov::op::v14::AvgPool>(op)) {
+                   !ov::is_type<const ov::op::v14::MaxPool>(op) && !ov::is_type<const ov::op::v1::AvgPool>(op) &&
+                   !ov::is_type<const ov::op::v14::AvgPool>(op)) {
             errorMessage = "Supported ops are MaxPool-1, MaxPool-8, MaxPool-14, AvgPool-1 and AvgPool-14";
             return false;
         }
@@ -185,7 +186,8 @@ Pooling::Pooling(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr c
         get_attributes(poolingAttrs.kernel, maxPoolOpBase->get_kernel());
         get_attributes(poolingAttrs.data_pad_begin, maxPoolOpBase->get_pads_begin());
         get_attributes(poolingAttrs.data_pad_end, maxPoolOpBase->get_pads_end());
-        poolingAttrs.auto_pad = (poolingAttrs.pad_type == ov::op::PadType::SAME_LOWER || poolingAttrs.pad_type == ov::op::PadType::SAME_UPPER);
+        poolingAttrs.auto_pad = (poolingAttrs.pad_type == ov::op::PadType::SAME_LOWER ||
+                                 poolingAttrs.pad_type == ov::op::PadType::SAME_UPPER);
     }
 
     if (auto maxPoolOp_v14 = ov::as_type_ptr<const ov::op::v14::MaxPool>(op)) {
@@ -205,12 +207,13 @@ Pooling::Pooling(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr c
         get_attributes(poolingAttrs.data_pad_begin, avgPoolOpBase->get_pads_begin());
         get_attributes(poolingAttrs.data_pad_end, avgPoolOpBase->get_pads_end());
         poolingAttrs.dilation.resize(poolingAttrs.kernel.size(), 1);
-        poolingAttrs.auto_pad = (avgPoolOpBase->get_auto_pad() == ov::op::PadType::SAME_LOWER || avgPoolOpBase->get_auto_pad() == ov::op::PadType::SAME_UPPER);
+        poolingAttrs.auto_pad = (avgPoolOpBase->get_auto_pad() == ov::op::PadType::SAME_LOWER ||
+                                 avgPoolOpBase->get_auto_pad() == ov::op::PadType::SAME_UPPER);
     }
     poolingAttrs.algorithm = algorithm;
 }
 
-std::vector<memory::format_tag> Pooling::getAvailableFormatsForDims(const Shape &dims) const {
+std::vector<memory::format_tag> Pooling::getAvailableFormatsForDims(const Shape& dims) const {
     if (dims.getRank() == 0)
         return {memory::format_tag::x};
     else if (dims.getRank() == 1)
@@ -218,21 +221,30 @@ std::vector<memory::format_tag> Pooling::getAvailableFormatsForDims(const Shape
     else if (dims.getRank() == 2)
         return {memory::format_tag::nc};
     else if (dims.getRank() == 3)
-        return { memory::format_tag::nCw8c, memory::format_tag::nCw16c, memory::format_tag::nwc, memory::format_tag::ncw};
+        return {memory::format_tag::nCw8c,
+                memory::format_tag::nCw16c,
+                memory::format_tag::nwc,
+                memory::format_tag::ncw};
     else if (dims.getRank() == 4)
-        return {memory::format_tag::nChw8c, memory::format_tag::nChw16c, memory::format_tag::nhwc, memory::format_tag::nchw};
+        return {memory::format_tag::nChw8c,
+                memory::format_tag::nChw16c,
+                memory::format_tag::nhwc,
+                memory::format_tag::nchw};
     else if (dims.getRank() == 5)
-        return {memory::format_tag::nCdhw8c, memory::format_tag::nCdhw16c, memory::format_tag::ndhwc, memory::format_tag::ncdhw};
+        return {memory::format_tag::nCdhw8c,
+                memory::format_tag::nCdhw16c,
+                memory::format_tag::ndhwc,
+                memory::format_tag::ncdhw};
     return {memory::format_tag::any};
 }
 
-void Pooling::initEffectiveAttributes(const Shape &inShape, const Shape &outShape) {
+void Pooling::initEffectiveAttributes(const Shape& inShape, const Shape& outShape) {
     poolingAttrs.effective_pad_begin = poolingAttrs.data_pad_begin;
     poolingAttrs.effective_pad_end.resize(poolingAttrs.data_pad_end.size());
     poolingAttrs.effective_dilation.resize(poolingAttrs.dilation.size(), 0);
 
-    const auto &inDims = inShape.getStaticDims();
-    const auto &outDims = outShape.getStaticDims();
+    const auto& inDims = inShape.getStaticDims();
+    const auto& outDims = outShape.getStaticDims();
 
     for (size_t i = 0; i < poolingAttrs.effective_pad_end.size(); i++) {
         int krn = poolingAttrs.kernel[i];
@@ -240,8 +252,8 @@ void Pooling::initEffectiveAttributes(const Shape &inShape, const Shape &outShap
         int src = inDims[2 + i];
         int dst = outDims[2 + i];
 
-        poolingAttrs.effective_pad_end[i] = (dst - 1) * poolingAttrs.stride[i] -
-                                            (src - (1 + (krn  - 1) * dil) + poolingAttrs.data_pad_begin[i]);
+        poolingAttrs.effective_pad_end[i] =
+            (dst - 1) * poolingAttrs.stride[i] - (src - (1 + (krn - 1) * dil) + poolingAttrs.data_pad_begin[i]);
         poolingAttrs.effective_dilation[i] = dil - 1;
     }
 }
@@ -258,8 +270,8 @@ void Pooling::getSupportedDescriptors() {
     ov::element::Type inputPrecision = getOriginalInputPrecisionAtPort(0);
     ov::element::Type outputPrecision = getOriginalOutputPrecisionAtPort(0);
 
-    const auto &parentShape = getInputShapeAtPort(0);
-    const auto &childShape = getOutputShapeAtPort(0);
+    const auto& parentShape = getInputShapeAtPort(0);
+    const auto& childShape = getOutputShapeAtPort(0);
     const size_t inputRank = getInputShapeAtPort(0).getRank();
 
     if (isDynamicNode()) {
@@ -280,36 +292,38 @@ void Pooling::getSupportedDescriptors() {
 
 #if defined(OV_CPU_WITH_ACL)
     // WA: we may specify any layout here (NCHW or NHWC) since both are supported by ACL
-    arm_compute::DataLayout dataLayout = (inShape.getDims().size() == 5) ? arm_compute::DataLayout::NDHWC : arm_compute::DataLayout::NCHW;
-    arm_compute::TensorInfo srcTensorInfo = arm_compute::TensorInfo(shapeCast(inShape.getDims()),
-                                                                    1,
-                                                                    precisionToAclDataType(inputPrecision),
-                                                                    dataLayout);
-    arm_compute::TensorInfo dstTensorInfo = arm_compute::TensorInfo(shapeCast(isDynamicNode() ? MemoryDescUtils::makeDummyShape(childShape).getDims() :
-                                                                                                childShape.getDims()),
-                                                                    1,
-                                                                    precisionToAclDataType(outputPrecision),
-                                                                    dataLayout);
+    arm_compute::DataLayout dataLayout =
+        (inShape.getDims().size() == 5) ? arm_compute::DataLayout::NDHWC : arm_compute::DataLayout::NCHW;
+    arm_compute::TensorInfo srcTensorInfo =
+        arm_compute::TensorInfo(shapeCast(inShape.getDims()), 1, precisionToAclDataType(inputPrecision), dataLayout);
+    arm_compute::TensorInfo dstTensorInfo = arm_compute::TensorInfo(
+        shapeCast(isDynamicNode() ? MemoryDescUtils::makeDummyShape(childShape).getDims() : childShape.getDims()),
+        1,
+        precisionToAclDataType(outputPrecision),
+        dataLayout);
     arm_compute::Pooling3dLayerInfo pool3d_info;
     arm_compute::PoolingLayerInfo pool_info;
-    useACL = AclPoolingExecutor::isSupported(srcTensorInfo,
-                                             dstTensorInfo,
-                                             poolingAttrs,
-                                             inShape.getDims().size(),
-                                             getOriginalOutputsNumber(),
-                                             dataLayout,
-                                             (getOriginalOutputsNumber() > 1) ? &getOutputShapeAtPort(1).getDims() : nullptr,
-                                             &pool_info,
-                                             &pool3d_info,
-                                             isDynamicNode());
-    //FIXME: 5D tensors case is not assigned to ACL because there is no way to check layout here
-    //NEPooling3dLayer supports NDHWC only
+    useACL =
+        AclPoolingExecutor::isSupported(srcTensorInfo,
+                                        dstTensorInfo,
+                                        poolingAttrs,
+                                        inShape.getDims().size(),
+                                        getOriginalOutputsNumber(),
+                                        dataLayout,
+                                        (getOriginalOutputsNumber() > 1) ? &getOutputShapeAtPort(1).getDims() : nullptr,
+                                        &pool_info,
+                                        &pool3d_info,
+                                        isDynamicNode());
+    // FIXME: 5D tensors case is not assigned to ACL because there is no way to check layout here
+    // NEPooling3dLayer supports NDHWC only
     if (inShape.getDims().size() == 5) {
         useACL = false;
-        DEBUG_LOG("FIXME: 5D tensors case is not assigned to ACL because there is no way to check layout in getSupportedDescriptors()");
+        DEBUG_LOG("FIXME: 5D tensors case is not assigned to ACL because there is no way to check layout in "
+                  "getSupportedDescriptors()");
     }
 #endif
-    if (useACL) return;
+    if (useACL)
+        return;
 
     // WA: LPT transformation has WA which allows average pooling has I8/U8 output precision instead of FP32,
     // so we explicitly set output precision as FP32
@@ -335,28 +349,37 @@ void Pooling::getSupportedDescriptors() {
     if ((inputRank < 3) || (inputRank > 5))
         OPENVINO_THROW("Pooling layer. Unsupported mode. Only 3D, 4D and 5D blobs are supported as input.");
 
-
-
-    initEffectiveAttributes(inShape,
-                            MemoryDescUtils::makeDummyShape(childShape));
+    initEffectiveAttributes(inShape, MemoryDescUtils::makeDummyShape(childShape));
 
     if (inputPrecision == ov::element::i8 || inputPrecision == ov::element::u8) {
         //  We have to extend i8i8_pooling_fwd_t from oneDNN to support BF16 output data type
         if (one_of(outputDataType, memory::data_type::bf16, memory::data_type::f16))
             outputDataType = memory::data_type::f32;
         // i8 layers supports only ndhwc and nhwc layouts
-        const auto in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(parentShape, inputDataType, inputRank == 3 ?
-                                  memory::format_tag::nwc : (inputRank == 4 ? memory::format_tag::nhwc : memory::format_tag::ndhwc));
-        const auto out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(childShape, outputDataType, inputRank == 3 ?
-                                   memory::format_tag::nwc : (inputRank == 4 ? memory::format_tag::nhwc : memory::format_tag::ndhwc));
-        createDescriptor({ in_candidate }, { out_candidate });
+        const auto in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(
+            parentShape,
+            inputDataType,
+            inputRank == 3 ? memory::format_tag::nwc
+                           : (inputRank == 4 ? memory::format_tag::nhwc : memory::format_tag::ndhwc));
+        const auto out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(
+            childShape,
+            outputDataType,
+            inputRank == 3 ? memory::format_tag::nwc
+                           : (inputRank == 4 ? memory::format_tag::nhwc : memory::format_tag::ndhwc));
+        createDescriptor({in_candidate}, {out_candidate});
     } else if ((inputRank == 3 || inputRank == 4 || inputRank == 5) && parentShape.getDims()[1] == 1) {
         // WA. We should force planar layout since it provides better performance
-        const auto in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(parentShape, inputDataType, inputRank == 3 ?
-                                  memory::format_tag::ncw : (inputRank == 4 ? memory::format_tag::nchw : memory::format_tag::ncdhw));
-        const auto out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(childShape, outputDataType, inputRank == 3 ?
-                                   memory::format_tag::ncw : (inputRank == 4 ? memory::format_tag::nchw : memory::format_tag::ncdhw));
-        createDescriptor({ in_candidate }, { out_candidate });
+        const auto in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(
+            parentShape,
+            inputDataType,
+            inputRank == 3 ? memory::format_tag::ncw
+                           : (inputRank == 4 ? memory::format_tag::nchw : memory::format_tag::ncdhw));
+        const auto out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(
+            childShape,
+            outputDataType,
+            inputRank == 3 ? memory::format_tag::ncw
+                           : (inputRank == 4 ? memory::format_tag::nchw : memory::format_tag::ncdhw));
+        createDescriptor({in_candidate}, {out_candidate});
     } else {
         if (!one_of(inputDataType, memory::data_type::bf16, memory::data_type::f16)) {
             inputDataType = memory::data_type::f32;
@@ -435,18 +458,17 @@ void Pooling::prepareParams() {
                           selected_pd->getImplementationType()};
         auto engine = getEngine();
         auto builder = [&engine](const PoolingKey& key) -> executorPtr {
-            auto prim_desc = createDescriptorHelper(
-                engine,
-                key.inp->getDnnlDesc(),
-                key.out->getDnnlDesc(),
-                key.alg,
-                key.stride,
-                key.kernel,
-                key.effective_pad_begin,
-                key.effective_pad_end,
-                key.effective_dilation,
-                key.data_pad_end,
-                key.attr);
+            auto prim_desc = createDescriptorHelper(engine,
+                                                    key.inp->getDnnlDesc(),
+                                                    key.out->getDnnlDesc(),
+                                                    key.alg,
+                                                    key.stride,
+                                                    key.kernel,
+                                                    key.effective_pad_begin,
+                                                    key.effective_pad_end,
+                                                    key.effective_dilation,
+                                                    key.data_pad_end,
+                                                    key.attr);
 
             auto first_desc = dnnl::pooling_forward::primitive_desc(prim_desc.get());
             const bool found = DnnlExtensionUtils::find_implementation(prim_desc, key.implType);
@@ -535,11 +557,9 @@ dnnl::algorithm Pooling::getPoolingAlgorithm() const {
     }
 }
 
-dnnl::pooling_forward::primitive_desc Pooling::createDescriptorInternal(
-    const dnnl::memory::desc& in_candidate,
-    const dnnl::memory::desc& out_candidate,
-    const dnnl::algorithm alg) {
-
+dnnl::pooling_forward::primitive_desc Pooling::createDescriptorInternal(const dnnl::memory::desc& in_candidate,
+                                                                        const dnnl::memory::desc& out_candidate,
+                                                                        const dnnl::algorithm alg) {
     auto attr = initPrimitiveAttr();
 
     return createDescriptorHelper(getEngine(),
@@ -555,8 +575,8 @@ dnnl::pooling_forward::primitive_desc Pooling::createDescriptorInternal(
                                   *attr);
 }
 
-void Pooling::createDescriptor(const std::vector<MemoryDescPtr> &inputDesc,
-                               const std::vector<MemoryDescPtr> &outputDesc) {
+void Pooling::createDescriptor(const std::vector<MemoryDescPtr>& inputDesc,
+                               const std::vector<MemoryDescPtr>& outputDesc) {
     auto inDesc = inputDesc[0]->isDefined() ? inputDesc[0] : inputDesc[0]->cloneWithNewDims(inShape.getStaticDims());
     auto dnnlInDesc = MemoryDescUtils::convertToDnnlMemoryDesc(inDesc);
     auto in_candidate = dnnlInDesc->getDnnlDesc();
@@ -594,21 +614,23 @@ void Pooling::initSupportedPrimitiveDescriptors() {
             std::vector<MemoryDescPtr> srcMemoryDescs;
             for (size_t i = 0; i < config.inConfs.size(); i++) {
                 config.inConfs[i].setMemDesc(
-                    creatorsMap.at(format)->createSharedDesc(getOriginalInputPrecisionAtPort(i), getInputShapeAtPort(i)));
+                    creatorsMap.at(format)->createSharedDesc(getOriginalInputPrecisionAtPort(i),
+                                                             getInputShapeAtPort(i)));
                 srcMemoryDescs.push_back(config.inConfs[i].getMemDesc());
             }
             std::vector<MemoryDescPtr> dstMemoryDescs;
             for (size_t i = 0; i < config.outConfs.size(); i++) {
                 config.outConfs[i].setMemDesc(
-                    creatorsMap.at(format)->createSharedDesc(getOriginalOutputPrecisionAtPort(i), getOutputShapeAtPort(i)));
+                    creatorsMap.at(format)->createSharedDesc(getOriginalOutputPrecisionAtPort(i),
+                                                             getOutputShapeAtPort(i)));
                 dstMemoryDescs.push_back(config.outConfs[i].getMemDesc());
             }
 
-            auto factory = std::make_shared<PoolingExecutorFactory>(
-                poolingAttrs,
-                srcMemoryDescs,
-                dstMemoryDescs,
-                std::make_shared<ExecutorContext>(context, getImplPriority()));
+            auto factory =
+                std::make_shared<PoolingExecutorFactory>(poolingAttrs,
+                                                         srcMemoryDescs,
+                                                         dstMemoryDescs,
+                                                         std::make_shared<ExecutorContext>(context, getImplPriority()));
             supportedPrimitiveDescriptors.emplace_back(config, impl_desc_type::undef, factory);
         };
 
@@ -633,7 +655,8 @@ void Pooling::initSupportedPrimitiveDescriptors() {
             outConfs.emplace_back(desc, BlockedMemoryDesc::FULL_MASK, inPlaceOutPort);
         }
 
-        // CPU plugin doesn't support second output of MaxPool-8, but anyway we should have out config for second port as stub
+        // CPU plugin doesn't support second output of MaxPool-8, but anyway we should have out config for second port
+        // as stub
         if (isNotMaxPool1) {
             const auto& creatorsMap = BlockedDescCreator::getCommonCreators();
             const auto outputPrecision = outConfs.front().getMemDesc()->getPrecision();
@@ -649,27 +672,38 @@ void Pooling::initSupportedPrimitiveDescriptors() {
     };
 #ifdef CPU_DEBUG_CAPS
     {
-       if (!customImplPriorities.empty()) {
-            DEBUG_LOG("#", getName(), " customImplPriorities [", 0 , "/", customImplPriorities.size(),
-                        "]: ", impl_type_to_string(customImplPriorities[0]));
-       }
+        if (!customImplPriorities.empty()) {
+            DEBUG_LOG("#",
+                      getName(),
+                      " customImplPriorities [",
+                      0,
+                      "/",
+                      customImplPriorities.size(),
+                      "]: ",
+                      impl_type_to_string(customImplPriorities[0]));
+        }
     }
 #endif
     for (auto& desc : descs) {
         auto first_desc = dnnl::primitive_desc(DnnlExtensionUtils::clone_primitive_desc(desc.get()));
         const bool first_match = customImplPriorities.empty();
-        DEBUG_LOG("#", getName(),
-            ", itpd.impl_info_str(): ", desc.impl_info_str(),
-            ", parsed imp_type: ", impl_type_to_string(parse_impl_name(desc.impl_info_str())),
-            ", first_match: ", first_match ? "true" : "false");
-        DnnlExtensionUtils::for_each_implementation(desc,
-                                                    first_match,
-                                                    [&](impl_desc_type implType) {
-                                                        return contains(getImplPriority(), implType);
-                                                    },
-                                                    [&](dnnl::primitive_desc& desc) {
-                                                        addSupportedPrimitiveDescriptor(desc);
-                                                    });
+        DEBUG_LOG("#",
+                  getName(),
+                  ", itpd.impl_info_str(): ",
+                  desc.impl_info_str(),
+                  ", parsed imp_type: ",
+                  impl_type_to_string(parse_impl_name(desc.impl_info_str())),
+                  ", first_match: ",
+                  first_match ? "true" : "false");
+        DnnlExtensionUtils::for_each_implementation(
+            desc,
+            first_match,
+            [&](impl_desc_type implType) {
+                return contains(getImplPriority(), implType);
+            },
+            [&](dnnl::primitive_desc& desc) {
+                addSupportedPrimitiveDescriptor(desc);
+            });
 
         // fallback. if none of the primitive types is present in the priority list just add first implementation
         // @todo this fallback is not necessary if primitive priority list is filled correctly
@@ -695,11 +729,11 @@ Node::AttrPtr Pooling::initPrimitiveAttr() {
     return attr;
 }
 
-void Pooling::setPostOps(dnnl::primitive_attr &attr) {
+void Pooling::setPostOps(dnnl::primitive_attr& attr) {
     dnnl::post_ops ops;
 
-    for (auto &node : fusedWith) {
-        auto* fakeQuantizeNode = dynamic_cast<FakeQuantize *>(node.get());
+    for (auto& node : fusedWith) {
+        auto* fakeQuantizeNode = dynamic_cast<FakeQuantize*>(node.get());
         if (fakeQuantizeNode) {
             fakeQuantizeNode->appendPostOps(ops, {}, postOpsArgs);
             continue;
@@ -716,5 +750,5 @@ void Pooling::setPostOps(dnnl::primitive_attr &attr) {
 }
 
 }  // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/pooling.h b/src/plugins/intel_cpu/src/nodes/pooling.h
index ffd96fc320036c..a51c575f18608f 100644
--- a/src/plugins/intel_cpu/src/nodes/pooling.h
+++ b/src/plugins/intel_cpu/src/nodes/pooling.h
@@ -19,7 +19,7 @@ class Pooling : public Node {
 
     void createDescriptor(const std::vector<MemoryDescPtr>& inputDesc,
                           const std::vector<MemoryDescPtr>& outputDesc) override;
-    std::vector<dnnl::memory::format_tag> getAvailableFormatsForDims(const Shape &dims) const override;
+    std::vector<dnnl::memory::format_tag> getAvailableFormatsForDims(const Shape& dims) const override;
     void getSupportedDescriptors() override;
     void initSupportedPrimitiveDescriptors() override;
     void initDescriptor(const NodeConfig& config) override;
@@ -41,13 +41,13 @@ class Pooling : public Node {
     using executorPtr = std::shared_ptr<DnnlExecutor>;
     executorPtr dnnlExecPtr = nullptr;
 
-    void setPostOps(dnnl::primitive_attr &attr);
+    void setPostOps(dnnl::primitive_attr& attr);
 
     PoolingAttrs poolingAttrs;
 
     std::shared_ptr<PoolingExecutor> execPtr = nullptr;
 
-    void initEffectiveAttributes(const Shape &inDims, const Shape &outDims);
+    void initEffectiveAttributes(const Shape& inDims, const Shape& outDims);
     dnnl::algorithm getPoolingAlgorithm() const;
     dnnl::pooling_forward::primitive_desc createDescriptorInternal(const dnnl::memory::desc& in_candidate,
                                                                    const dnnl::memory::desc& out_candidate,
@@ -61,6 +61,6 @@ class Pooling : public Node {
     bool useACL = false;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/priorbox.cpp b/src/plugins/intel_cpu/src/nodes/priorbox.cpp
index 4adc9038c4b35f..1e7fcc0bd385d2 100644
--- a/src/plugins/intel_cpu/src/nodes/priorbox.cpp
+++ b/src/plugins/intel_cpu/src/nodes/priorbox.cpp
@@ -9,8 +9,8 @@
 #include <memory>
 #include <vector>
 
-#include "openvino/core/parallel.hpp"
 #include "dnnl_types.h"
+#include "openvino/core/parallel.hpp"
 #include "openvino/opsets/opset1.hpp"
 #include "shape_inference/custom/priorbox.hpp"
 
@@ -28,7 +28,7 @@ float clip_less(float x, float threshold) {
     return x > threshold ? x : threshold;
 }
 
-}   // namespace
+}  // namespace
 
 bool PriorBox::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
@@ -129,10 +129,9 @@ void PriorBox::initSupportedPrimitiveDescriptors() {
     if (!supportedPrimitiveDescriptors.empty())
         return;
 
-    addSupportedPrimDesc(
-        {{LayoutType::ncsp, ov::element::i32}, {LayoutType::ncsp, ov::element::i32}},
-        {{LayoutType::ncsp, ov::element::f32}},
-        impl_desc_type::ref_any);
+    addSupportedPrimDesc({{LayoutType::ncsp, ov::element::i32}, {LayoutType::ncsp, ov::element::i32}},
+                         {{LayoutType::ncsp, ov::element::f32}},
+                         impl_desc_type::ref_any);
 }
 
 void PriorBox::createPrimitive() {
@@ -183,20 +182,20 @@ void PriorBox::execute(dnnl::stream strm) {
     }
 
     auto calculate_data =
-            [&dst_data, &IWI, &IHI, &idx](float center_x, float center_y, float box_width, float box_height, bool clip) {
-        if (clip) {
-            // order: xmin, ymin, xmax, ymax
-            dst_data[idx++] = clip_less((center_x - box_width) * IWI, 0);
-            dst_data[idx++] = clip_less((center_y - box_height) * IHI, 0);
-            dst_data[idx++] = clip_great((center_x + box_width) * IWI, 1);
-            dst_data[idx++] = clip_great((center_y + box_height) * IHI, 1);
-        } else {
-            dst_data[idx++] = (center_x - box_width) * IWI;
-            dst_data[idx++] = (center_y - box_height) * IHI;
-            dst_data[idx++] = (center_x + box_width) * IWI;
-            dst_data[idx++] = (center_y + box_height) * IHI;
-        }
-    };
+        [&dst_data, &IWI, &IHI, &idx](float center_x, float center_y, float box_width, float box_height, bool clip) {
+            if (clip) {
+                // order: xmin, ymin, xmax, ymax
+                dst_data[idx++] = clip_less((center_x - box_width) * IWI, 0);
+                dst_data[idx++] = clip_less((center_y - box_height) * IHI, 0);
+                dst_data[idx++] = clip_great((center_x + box_width) * IWI, 1);
+                dst_data[idx++] = clip_great((center_y + box_height) * IHI, 1);
+            } else {
+                dst_data[idx++] = (center_x - box_width) * IWI;
+                dst_data[idx++] = (center_y - box_height) * IHI;
+                dst_data[idx++] = (center_x + box_width) * IWI;
+                dst_data[idx++] = (center_y + box_height) * IHI;
+            }
+        };
 
     for (int64_t h = 0; h < H; ++h) {
         for (int64_t w = 0; w < W; ++w) {
@@ -312,6 +311,6 @@ bool PriorBox::created() const {
     return getType() == Type::PriorBox;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/priorbox.h b/src/plugins/intel_cpu/src/nodes/priorbox.h
index ced0492cd31dc6..69cf7c34266513 100644
--- a/src/plugins/intel_cpu/src/nodes/priorbox.h
+++ b/src/plugins/intel_cpu/src/nodes/priorbox.h
@@ -14,7 +14,7 @@ class PriorBox : public Node {
 public:
     PriorBox(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void createPrimitive() override;
     void execute(dnnl::stream strm) override;
@@ -23,7 +23,9 @@ class PriorBox : public Node {
     bool needShapeInfer() const override;
     bool needPrepareParams() const override;
 
-    void executeDynamicImpl(dnnl::stream strm) override { execute(strm); }
+    void executeDynamicImpl(dnnl::stream strm) override {
+        execute(strm);
+    }
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
@@ -46,6 +48,6 @@ class PriorBox : public Node {
     int number_of_priors;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/priorbox_clustered.cpp b/src/plugins/intel_cpu/src/nodes/priorbox_clustered.cpp
index 2010019b50a97d..360fdb50ee98b7 100644
--- a/src/plugins/intel_cpu/src/nodes/priorbox_clustered.cpp
+++ b/src/plugins/intel_cpu/src/nodes/priorbox_clustered.cpp
@@ -9,15 +9,16 @@
 #include <memory>
 #include <vector>
 
-#include "openvino/core/parallel.hpp"
 #include "dnnl_types.h"
+#include "openvino/core/parallel.hpp"
 #include "openvino/opsets/opset1.hpp"
 #include "shape_inference/custom/priorbox_clustered.hpp"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
-bool PriorBoxClustered::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool PriorBoxClustered::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                             std::string& errorMessage) noexcept {
     try {
         const auto priorBox = std::dynamic_pointer_cast<const ov::opset1::PriorBoxClustered>(op);
         if (!priorBox) {
@@ -79,10 +80,9 @@ void PriorBoxClustered::initSupportedPrimitiveDescriptors() {
     if (!supportedPrimitiveDescriptors.empty())
         return;
 
-    addSupportedPrimDesc(
-            {{LayoutType::ncsp, ov::element::i32}, {LayoutType::ncsp, ov::element::i32}},
-            {{LayoutType::ncsp, ov::element::f32}},
-            impl_desc_type::ref_any);
+    addSupportedPrimDesc({{LayoutType::ncsp, ov::element::i32}, {LayoutType::ncsp, ov::element::i32}},
+                         {{LayoutType::ncsp, ov::element::f32}},
+                         impl_desc_type::ref_any);
 }
 
 void PriorBoxClustered::createPrimitive() {
@@ -157,6 +157,6 @@ bool PriorBoxClustered::created() const {
     return getType() == Type::PriorBoxClustered;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/priorbox_clustered.h b/src/plugins/intel_cpu/src/nodes/priorbox_clustered.h
index 2696f77bcb0f2c..e10cb638de07c0 100644
--- a/src/plugins/intel_cpu/src/nodes/priorbox_clustered.h
+++ b/src/plugins/intel_cpu/src/nodes/priorbox_clustered.h
@@ -14,7 +14,7 @@ class PriorBoxClustered : public Node {
 public:
     PriorBoxClustered(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void createPrimitive() override;
     void execute(dnnl::stream strm) override;
@@ -23,7 +23,9 @@ class PriorBoxClustered : public Node {
     bool needShapeInfer() const override;
     bool needPrepareParams() const override;
 
-    void executeDynamicImpl(dnnl::stream strm) override { execute(strm); }
+    void executeDynamicImpl(dnnl::stream strm) override {
+        execute(strm);
+    }
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
@@ -40,6 +42,6 @@ class PriorBoxClustered : public Node {
     int number_of_priors;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/proposal.cpp b/src/plugins/intel_cpu/src/nodes/proposal.cpp
index cb29e4907de5da..7b2abd90b05e64 100644
--- a/src/plugins/intel_cpu/src/nodes/proposal.cpp
+++ b/src/plugins/intel_cpu/src/nodes/proposal.cpp
@@ -2,10 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "openvino/op/proposal.hpp"
+
 #include <string>
 #include <vector>
 
-#include "openvino/op/proposal.hpp"
 #include "openvino/core/parallel.hpp"
 #include "proposal.h"
 
@@ -13,7 +14,7 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 
-static std::vector<float> generate_anchors(proposal_conf &conf) {
+static std::vector<float> generate_anchors(proposal_conf& conf) {
     auto base_size = conf.base_size_;
     auto coordinates_offset = conf.coordinates_offset;
     auto round_ratios = conf.round_ratios;
@@ -45,10 +46,10 @@ static std::vector<float> generate_anchors(proposal_conf &conf) {
             ratio_h = ratio_w * ratios[ratio];
         }
 
-        float * const p_anchors_wm = anchors_ptr + 0 * num_ratios * num_scales + ratio * num_scales;
-        float * const p_anchors_hm = anchors_ptr + 1 * num_ratios * num_scales + ratio * num_scales;
-        float * const p_anchors_wp = anchors_ptr + 2 * num_ratios * num_scales + ratio * num_scales;
-        float * const p_anchors_hp = anchors_ptr + 3 * num_ratios * num_scales + ratio * num_scales;
+        float* const p_anchors_wm = anchors_ptr + 0 * num_ratios * num_scales + ratio * num_scales;
+        float* const p_anchors_hm = anchors_ptr + 1 * num_ratios * num_scales + ratio * num_scales;
+        float* const p_anchors_wp = anchors_ptr + 2 * num_ratios * num_scales + ratio * num_scales;
+        float* const p_anchors_hp = anchors_ptr + 3 * num_ratios * num_scales + ratio * num_scales;
 
         for (size_t scale = 0; scale < num_scales; ++scale) {
             // transformed width & height for given scale factors
@@ -144,8 +145,7 @@ void Proposal::initSupportedPrimitiveDescriptors() {
         addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32},
                               {LayoutType::ncsp, ov::element::f32},
                               {LayoutType::ncsp, ov::element::f32}},
-                             {{LayoutType::ncsp, ov::element::f32},
-                              {LayoutType::ncsp, ov::element::f32}},
+                             {{LayoutType::ncsp, ov::element::f32}, {LayoutType::ncsp, ov::element::f32}},
                              impl_desc_type::ref_any);
     } else {
         addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32},
@@ -165,10 +165,10 @@ void Proposal::execute(dnnl::stream strm) {
         const float* probabilitiesData = getSrcDataAtPortAs<const float>(PROBABILITIES_IN_IDX);
         const float* anchorsData = getSrcDataAtPortAs<const float>(ANCHORS_IN_IDX);
         const float* imgInfoData = getSrcDataAtPortAs<const float>(IMG_INFO_IN_IDX);
-        float* outRoiData = reinterpret_cast <float *>(getDstDataAtPort(ROI_OUT_IDX));
+        float* outRoiData = reinterpret_cast<float*>(getDstDataAtPort(ROI_OUT_IDX));
         float* outProbData = nullptr;
         if (store_prob)
-            outProbData = reinterpret_cast <float *>(getDstDataAtPort(PROBABILITIES_OUT_IDX));
+            outProbData = reinterpret_cast<float*>(getDstDataAtPort(PROBABILITIES_OUT_IDX));
 
         auto inProbDims = getParentEdgeAt(0)->getMemory().getStaticDims();
         const size_t imgInfoSize = getParentEdgeAt(2)->getMemory().getStaticDims()[0];
@@ -187,8 +187,15 @@ void Proposal::execute(dnnl::stream strm) {
             OPENVINO_THROW("Proposal operation image info input must have non negative scales.");
         }
 
-        ov::Extensions::Cpu::XARCH::proposal_exec(probabilitiesData, anchorsData, inProbDims,
-                {imgHeight, imgWidth, scaleHeight, scaleWidth}, anchors.data(), roi_indices.data(), outRoiData, outProbData, conf);
+        ov::Extensions::Cpu::XARCH::proposal_exec(probabilitiesData,
+                                                  anchorsData,
+                                                  inProbDims,
+                                                  {imgHeight, imgWidth, scaleHeight, scaleWidth},
+                                                  anchors.data(),
+                                                  roi_indices.data(),
+                                                  outRoiData,
+                                                  outProbData,
+                                                  conf);
     } catch (const ov::Exception& e) {
         std::string errorMsg = e.what();
         OPENVINO_THROW(errorMsg);
@@ -199,6 +206,6 @@ bool Proposal::created() const {
     return getType() == Type::Proposal;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/proposal.h b/src/plugins/intel_cpu/src/nodes/proposal.h
index c9fc8661de1fc9..65993d861b692b 100644
--- a/src/plugins/intel_cpu/src/nodes/proposal.h
+++ b/src/plugins/intel_cpu/src/nodes/proposal.h
@@ -1,7 +1,7 @@
 // Copyright (C) 2018-2024 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
- \
+
 #pragma once
 
 #include "node.h"
@@ -17,12 +17,14 @@ class Proposal : public Node {
 public:
     Proposal(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
 
-    bool needPrepareParams() const override { return false; };
+    bool needPrepareParams() const override {
+        return false;
+    };
     void executeDynamicImpl(dnnl::stream strm) override;
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
@@ -40,6 +42,6 @@ class Proposal : public Node {
     bool store_prob;  // store blob with proposal probabilities
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/proposal_imp.cpp b/src/plugins/intel_cpu/src/nodes/proposal_imp.cpp
index 844ef351e398f2..fd65a95a6e59f1 100644
--- a/src/plugins/intel_cpu/src/nodes/proposal_imp.cpp
+++ b/src/plugins/intel_cpu/src/nodes/proposal_imp.cpp
@@ -4,14 +4,14 @@
 
 #include "proposal_imp.hpp"
 
-#include <cstring>
+#include <algorithm>
 #include <cmath>
+#include <cstring>
 #include <string>
-#include <vector>
 #include <utility>
-#include <algorithm>
+#include <vector>
 #if defined(HAVE_AVX2)
-#include <immintrin.h>
+#    include <immintrin.h>
 #endif
 #include "openvino/core/parallel.hpp"
 
@@ -20,13 +20,24 @@ namespace Extensions {
 namespace Cpu {
 namespace XARCH {
 
-static
-void enumerate_proposals_cpu(const float* bottom4d, const float* d_anchor4d, const float* anchors,
-                             float* proposals, const int num_anchors, const int bottom_H,
-                             const int bottom_W, const float img_H, const float img_W,
-                             const float min_box_H, const float min_box_W, const int feat_stride,
-                             const float box_coordinate_scale, const float box_size_scale,
-                             float coordinates_offset, bool initial_clip, bool swap_xy, bool clip_before_nms) {
+static void enumerate_proposals_cpu(const float* bottom4d,
+                                    const float* d_anchor4d,
+                                    const float* anchors,
+                                    float* proposals,
+                                    const int num_anchors,
+                                    const int bottom_H,
+                                    const int bottom_W,
+                                    const float img_H,
+                                    const float img_W,
+                                    const float min_box_H,
+                                    const float min_box_W,
+                                    const int feat_stride,
+                                    const float box_coordinate_scale,
+                                    const float box_size_scale,
+                                    float coordinates_offset,
+                                    bool initial_clip,
+                                    bool swap_xy,
+                                    bool clip_before_nms) {
     const int bottom_area = bottom_H * bottom_W;
 
     const float* p_anchors_wm = anchors + 0 * num_anchors;
@@ -38,8 +49,8 @@ void enumerate_proposals_cpu(const float* bottom4d, const float* d_anchor4d, con
         const float x = static_cast<float>((swap_xy ? h : w) * feat_stride);
         const float y = static_cast<float>((swap_xy ? w : h) * feat_stride);
 
-        const float* p_box   = d_anchor4d + h * bottom_W + w;
-        const float* p_score = bottom4d   + h * bottom_W + w;
+        const float* p_box = d_anchor4d + h * bottom_W + w;
+        const float* p_score = bottom4d + h * bottom_W + w;
 
         float* p_proposal = proposals + (h * bottom_W + w) * num_anchors * 5;
 
@@ -98,11 +109,11 @@ void enumerate_proposals_cpu(const float* bottom4d, const float* d_anchor4d, con
             const float box_w = x1 - x0 + coordinates_offset;
             const float box_h = y1 - y0 + coordinates_offset;
 
-            p_proposal[5*anchor + 0] = x0;
-            p_proposal[5*anchor + 1] = y0;
-            p_proposal[5*anchor + 2] = x1;
-            p_proposal[5*anchor + 3] = y1;
-            p_proposal[5*anchor + 4] = (min_box_W <= box_w) * (min_box_H <= box_h) * score;
+            p_proposal[5 * anchor + 0] = x0;
+            p_proposal[5 * anchor + 1] = y0;
+            p_proposal[5 * anchor + 2] = x1;
+            p_proposal[5 * anchor + 3] = y1;
+            p_proposal[5 * anchor + 4] = (min_box_W <= box_w) * (min_box_H <= box_h) * score;
         }
     });
 }
@@ -126,10 +137,15 @@ static void unpack_boxes(const float* p_proposals, float* unpacked_boxes, int pr
     }
 }
 
-static void nms_cpu(const int num_boxes, int is_dead[],
-             const float* boxes, int index_out[], int* const num_out,
-             const int base_index, const float nms_thresh, const int max_num_out,
-             float coordinates_offset) {
+static void nms_cpu(const int num_boxes,
+                    int is_dead[],
+                    const float* boxes,
+                    int index_out[],
+                    int* const num_out,
+                    const int base_index,
+                    const float nms_thresh,
+                    const int max_num_out,
+                    float coordinates_offset) {
     const int num_proposals = num_boxes;
     int count = 0;
 
@@ -141,9 +157,9 @@ static void nms_cpu(const int num_boxes, int is_dead[],
     std::memset(is_dead, 0, num_boxes * sizeof(int));
 
 #if defined(HAVE_AVX2)
-    __m256  vc_fone = _mm256_set1_ps(coordinates_offset);
+    __m256 vc_fone = _mm256_set1_ps(coordinates_offset);
     __m256i vc_ione = _mm256_set1_epi32(1);
-    __m256  vc_zero = _mm256_set1_ps(0.0f);
+    __m256 vc_zero = _mm256_set1_ps(0.0f);
 
     __m256 vc_nms_thresh = _mm256_set1_ps(nms_thresh);
 #endif
@@ -164,13 +180,13 @@ static void nms_cpu(const int num_boxes, int is_dead[],
         __m256 vx1i = _mm256_set1_ps(x1[box]);
         __m256 vy1i = _mm256_set1_ps(y1[box]);
 
-        __m256 vA_width  = _mm256_sub_ps(vx1i, vx0i);
+        __m256 vA_width = _mm256_sub_ps(vx1i, vx0i);
         __m256 vA_height = _mm256_sub_ps(vy1i, vy0i);
-        __m256 vA_area   = _mm256_mul_ps(_mm256_add_ps(vA_width, vc_fone), _mm256_add_ps(vA_height, vc_fone));
+        __m256 vA_area = _mm256_mul_ps(_mm256_add_ps(vA_width, vc_fone), _mm256_add_ps(vA_height, vc_fone));
 
         for (; tail <= num_boxes - 8; tail += 8) {
-            __m256i *pdst = reinterpret_cast<__m256i*>(is_dead + tail);
-            __m256i  vdst = _mm256_loadu_si256(pdst);
+            __m256i* pdst = reinterpret_cast<__m256i*>(is_dead + tail);
+            __m256i vdst = _mm256_loadu_si256(pdst);
 
             __m256 vx0j = _mm256_loadu_ps(x0 + tail);
             __m256 vy0j = _mm256_loadu_ps(y0 + tail);
@@ -182,13 +198,13 @@ static void nms_cpu(const int num_boxes, int is_dead[],
             __m256 vx1 = _mm256_min_ps(vx1i, vx1j);
             __m256 vy1 = _mm256_min_ps(vy1i, vy1j);
 
-            __m256 vwidth  = _mm256_add_ps(_mm256_sub_ps(vx1, vx0), vc_fone);
+            __m256 vwidth = _mm256_add_ps(_mm256_sub_ps(vx1, vx0), vc_fone);
             __m256 vheight = _mm256_add_ps(_mm256_sub_ps(vy1, vy0), vc_fone);
             __m256 varea = _mm256_mul_ps(_mm256_max_ps(vc_zero, vwidth), _mm256_max_ps(vc_zero, vheight));
 
-            __m256 vB_width  = _mm256_sub_ps(vx1j, vx0j);
+            __m256 vB_width = _mm256_sub_ps(vx1j, vx0j);
             __m256 vB_height = _mm256_sub_ps(vy1j, vy0j);
-            __m256 vB_area   = _mm256_mul_ps(_mm256_add_ps(vB_width, vc_fone), _mm256_add_ps(vB_height, vc_fone));
+            __m256 vB_area = _mm256_mul_ps(_mm256_add_ps(vB_width, vc_fone), _mm256_add_ps(vB_height, vc_fone));
 
             __m256 vdivisor = _mm256_sub_ps(_mm256_add_ps(vA_area, vB_area), varea);
             __m256 vintersection_area = _mm256_div_ps(varea, vdivisor);
@@ -229,9 +245,9 @@ static void nms_cpu(const int num_boxes, int is_dead[],
                 const float y1 = std::min<float>(y1i, y1j);
 
                 // intersection area
-                const float width  = std::max<float>(0.0f,  x1 - x0 + coordinates_offset);
-                const float height = std::max<float>(0.0f,  y1 - y0 + coordinates_offset);
-                const float area   = width * height;
+                const float width = std::max<float>(0.0f, x1 - x0 + coordinates_offset);
+                const float height = std::max<float>(0.0f, y1 - y0 + coordinates_offset);
+                const float area = width * height;
 
                 // area of A, B
                 const float A_area = (x1i - x0i + coordinates_offset) * (y1i - y0i + coordinates_offset);
@@ -249,16 +265,23 @@ static void nms_cpu(const int num_boxes, int is_dead[],
     *num_out = count;
 }
 
-static void retrieve_rois_cpu(const int num_rois, const int item_index,
+static void retrieve_rois_cpu(const int num_rois,
+                              const int item_index,
                               const int num_proposals,
-                              const float* proposals, const int roi_indices[],
-                              float* rois, int post_nms_topn_,
-                              bool normalize, float img_h, float img_w, bool clip_after_nms, float* probs) {
-    const float *src_x0 = proposals + 0 * num_proposals;
-    const float *src_y0 = proposals + 1 * num_proposals;
-    const float *src_x1 = proposals + 2 * num_proposals;
-    const float *src_y1 = proposals + 3 * num_proposals;
-    const float *src_probs = proposals + 4 * num_proposals;
+                              const float* proposals,
+                              const int roi_indices[],
+                              float* rois,
+                              int post_nms_topn_,
+                              bool normalize,
+                              float img_h,
+                              float img_w,
+                              bool clip_after_nms,
+                              float* probs) {
+    const float* src_x0 = proposals + 0 * num_proposals;
+    const float* src_y0 = proposals + 1 * num_proposals;
+    const float* src_x1 = proposals + 2 * num_proposals;
+    const float* src_y1 = proposals + 3 * num_proposals;
+    const float* src_probs = proposals + 4 * num_proposals;
 
     parallel_for(num_rois, [&](size_t roi) {
         int index = roi_indices[roi];
@@ -302,16 +325,21 @@ static void retrieve_rois_cpu(const int num_rois, const int item_index,
     }
 }
 
-void proposal_exec(const float* input0, const float* input1,
-             std::vector<size_t> dims0, std::array<float, 4> img_info,
-             const float* anchors, int* roi_indices,
-             float* output0, float* output1, proposal_conf &conf) {
+void proposal_exec(const float* input0,
+                   const float* input1,
+                   std::vector<size_t> dims0,
+                   std::array<float, 4> img_info,
+                   const float* anchors,
+                   int* roi_indices,
+                   float* output0,
+                   float* output1,
+                   proposal_conf& conf) {
     // Prepare memory
-    const float *p_bottom_item = input0;
-    const float *p_d_anchor_item = input1;
+    const float* p_bottom_item = input0;
+    const float* p_d_anchor_item = input1;
 
-    float *p_roi_item = output0;
-    float *p_prob_item = output1;
+    float* p_roi_item = output0;
+    float* p_prob_item = output1;
     auto store_prob = p_prob_item != nullptr;
 
     // bottom shape: (2 x num_anchors) x H x W
@@ -360,24 +388,53 @@ void proposal_exec(const float* input0, const float* input1,
     for (int n = 0; n < nn; ++n) {
         enumerate_proposals_cpu(p_bottom_item + num_proposals + n * num_proposals * 2,
                                 p_d_anchor_item + n * num_proposals * 4,
-                                anchors, reinterpret_cast<float *>(&proposals_[0]),
-                                conf.anchors_shape_0, bottom_H, bottom_W, img_H, img_W,
-                                min_box_H, min_box_W, conf.feat_stride_,
-                                conf.box_coordinate_scale_, conf.box_size_scale_,
-                                conf.coordinates_offset, conf.initial_clip, conf.swap_xy, conf.clip_before_nms);
-        std::partial_sort(proposals_.begin(), proposals_.begin() + pre_nms_topn, proposals_.end(),
-                          [](const ProposalBox &struct1, const ProposalBox &struct2) {
+                                anchors,
+                                reinterpret_cast<float*>(&proposals_[0]),
+                                conf.anchors_shape_0,
+                                bottom_H,
+                                bottom_W,
+                                img_H,
+                                img_W,
+                                min_box_H,
+                                min_box_W,
+                                conf.feat_stride_,
+                                conf.box_coordinate_scale_,
+                                conf.box_size_scale_,
+                                conf.coordinates_offset,
+                                conf.initial_clip,
+                                conf.swap_xy,
+                                conf.clip_before_nms);
+        std::partial_sort(proposals_.begin(),
+                          proposals_.begin() + pre_nms_topn,
+                          proposals_.end(),
+                          [](const ProposalBox& struct1, const ProposalBox& struct2) {
                               return (struct1.score > struct2.score);
                           });
 
-        unpack_boxes(reinterpret_cast<float *>(&proposals_[0]), &unpacked_boxes[0], pre_nms_topn, store_prob);
-        nms_cpu(pre_nms_topn, &is_dead[0], &unpacked_boxes[0], roi_indices, &num_rois, 0, conf.nms_thresh_,
-                conf.post_nms_topn_, conf.coordinates_offset);
+        unpack_boxes(reinterpret_cast<float*>(&proposals_[0]), &unpacked_boxes[0], pre_nms_topn, store_prob);
+        nms_cpu(pre_nms_topn,
+                &is_dead[0],
+                &unpacked_boxes[0],
+                roi_indices,
+                &num_rois,
+                0,
+                conf.nms_thresh_,
+                conf.post_nms_topn_,
+                conf.coordinates_offset);
 
         float* p_probs = store_prob ? p_prob_item + n * conf.post_nms_topn_ : nullptr;
-        retrieve_rois_cpu(num_rois, n, pre_nms_topn, &unpacked_boxes[0], roi_indices,
+        retrieve_rois_cpu(num_rois,
+                          n,
+                          pre_nms_topn,
+                          &unpacked_boxes[0],
+                          roi_indices,
                           p_roi_item + n * conf.post_nms_topn_ * 5,
-                          conf.post_nms_topn_, conf.normalize_, img_H, img_W, conf.clip_after_nms, p_probs);
+                          conf.post_nms_topn_,
+                          conf.normalize_,
+                          img_H,
+                          img_W,
+                          conf.clip_after_nms,
+                          p_probs);
     }
 }
 
diff --git a/src/plugins/intel_cpu/src/nodes/proposal_imp.hpp b/src/plugins/intel_cpu/src/nodes/proposal_imp.hpp
index 212fc63e9fb111..ac98e05560a4c3 100644
--- a/src/plugins/intel_cpu/src/nodes/proposal_imp.hpp
+++ b/src/plugins/intel_cpu/src/nodes/proposal_imp.hpp
@@ -2,9 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include <array>
 #include <cstddef>
 #include <vector>
-#include <array>
 
 namespace ov {
 namespace Extensions {
@@ -37,10 +37,15 @@ struct proposal_conf {
 
 namespace XARCH {
 
-void proposal_exec(const float* input0, const float* input1,
-        std::vector<size_t> dims0, std::array<float, 4> img_info,
-        const float* anchors, int* roi_indices,
-        float* output0, float* output1, proposal_conf &conf);
+void proposal_exec(const float* input0,
+                   const float* input1,
+                   std::vector<size_t> dims0,
+                   std::array<float, 4> img_info,
+                   const float* anchors,
+                   int* roi_indices,
+                   float* output0,
+                   float* output1,
+                   proposal_conf& conf);
 
 }  // namespace XARCH
 }  // namespace Cpu
diff --git a/src/plugins/intel_cpu/src/nodes/psroi_pooling.cpp b/src/plugins/intel_cpu/src/nodes/psroi_pooling.cpp
index 80b1f577572ce3..ddd04f0184506c 100644
--- a/src/plugins/intel_cpu/src/nodes/psroi_pooling.cpp
+++ b/src/plugins/intel_cpu/src/nodes/psroi_pooling.cpp
@@ -2,17 +2,19 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "psroi_pooling.h"
+
 #include <cmath>
-#include <vector>
 #include <string>
+#include <vector>
+
+#include "cpu/x64/jit_generator.hpp"
 #include "dnnl_types.h"
+#include "nodes/common/blocked_desc_creator.h"
 #include "openvino/core/parallel.hpp"
-#include "utils/bfloat16.hpp"
-#include "selective_build.h"
 #include "openvino/opsets/opset1.hpp"
-#include "psroi_pooling.h"
-#include "cpu/x64/jit_generator.hpp"
-#include "nodes/common/blocked_desc_creator.h"
+#include "selective_build.h"
+#include "utils/bfloat16.hpp"
 #include "utils/ngraph_utils.hpp"
 
 using namespace dnnl;
@@ -114,7 +116,8 @@ PSROIPooling::PSROIPooling(const std::shared_ptr<ov::Node>& op, const GraphConte
         spatialBinsY = static_cast<size_t>(defPsroi->get_spatial_bins_y());
         transStd = defPsroi->get_trans_std();
         partSize = static_cast<size_t>(defPsroi->get_part_size());
-        // temporary workaround due to incorrect usage of group_size in the nGraph operation for the DeformablePSROIPooling
+        // temporary workaround due to incorrect usage of group_size in the nGraph operation for the
+        // DeformablePSROIPooling
         pooledHeight = groupSize;
         pooledWidth = groupSize;
     }
@@ -149,14 +152,12 @@ void PSROIPooling::initSupportedPrimitiveDescriptors() {
     auto dataPrecision = getOriginalInputPrecisionAtPort(0) == ov::element::bf16 ? ov::element::bf16 : ov::element::f32;
 
     if (getAlgorithm() == Algorithm::PSROIPoolingAverage || getAlgorithm() == Algorithm::PSROIPoolingBilinear) {
-        std::vector<std::pair<LayoutType, LayoutType>> dataFomats{
-            {LayoutType::ncsp, LayoutType::ncsp},
-            {LayoutType::nspc, LayoutType::nspc},
-            {LayoutType::nCsp16c, LayoutType::nCsp16c},
-            {LayoutType::nCsp8c, LayoutType::nCsp8c}
-        };
-
-        for (const auto &df : dataFomats) {
+        std::vector<std::pair<LayoutType, LayoutType>> dataFomats{{LayoutType::ncsp, LayoutType::ncsp},
+                                                                  {LayoutType::nspc, LayoutType::nspc},
+                                                                  {LayoutType::nCsp16c, LayoutType::nCsp16c},
+                                                                  {LayoutType::nCsp8c, LayoutType::nCsp8c}};
+
+        for (const auto& df : dataFomats) {
             addSupportedPrimDesc({{df.first, dataPrecision}, {LayoutType::ncsp, ov::element::f32}},
                                  {{df.second, dataPrecision}},
                                  impl_type);
@@ -187,17 +188,22 @@ inline float bilinearInterp(const inputType* data, const float x, const float y,
     float value12 = data[y2 * width_ + x1];
     float value21 = data[y1 * width_ + x2];
     float value22 = data[y2 * width_ + x2];
-    float value = (1 - distX) * (1 - distY) * value11 + (1 - distX) * distY * value12
-                  + distX * (1 - distY) * value21 + distX * distY * value22;
+    float value = (1 - distX) * (1 - distY) * value11 + (1 - distX) * distY * value12 + distX * (1 - distY) * value21 +
+                  distX * distY * value22;
     return value;
 }
 
-void PSROIPooling::unpackParams(const BlockedMemoryDesc& srcDesc, const BlockedMemoryDesc& dstDesc,
-                                          int& hInputStride, int& wInputStride,
-                                          int& hOutputStride, int& wOutputStride,
-                                          int& inBlockSize, int& outBlockSize,
-                                          int& outBlockCount,
-                                          unsigned long& inputChannelsPadding, unsigned long& outputChannelsPadding) {
+void PSROIPooling::unpackParams(const BlockedMemoryDesc& srcDesc,
+                                const BlockedMemoryDesc& dstDesc,
+                                int& hInputStride,
+                                int& wInputStride,
+                                int& hOutputStride,
+                                int& wOutputStride,
+                                int& inBlockSize,
+                                int& outBlockSize,
+                                int& outBlockCount,
+                                unsigned long& inputChannelsPadding,
+                                unsigned long& outputChannelsPadding) {
     const bool inpIsBlk = srcDesc.hasLayoutType(LayoutType::nCsp16c) || srcDesc.hasLayoutType(LayoutType::nCsp8c);
     const bool outIsBlk = dstDesc.hasLayoutType(LayoutType::nCsp16c) || dstDesc.hasLayoutType(LayoutType::nCsp8c);
     size_t expectedInBlockDimsSize = (inpIsBlk ? 5 : 4);
@@ -229,12 +235,16 @@ void PSROIPooling::unpackParams(const BlockedMemoryDesc& srcDesc, const BlockedM
     const auto& outOrder = dstDesc.getOrder();
     const auto& inOrder = srcDesc.getOrder();
     for (size_t i = 0; i < outOrder.size(); i++) {
-        if (outOrder[i] == 2) hOutStrIndex = i;
-        if (outOrder[i] == 3) wOutStrIndex = i;
+        if (outOrder[i] == 2)
+            hOutStrIndex = i;
+        if (outOrder[i] == 3)
+            wOutStrIndex = i;
     }
     for (size_t i = 0; i < inOrder.size(); i++) {
-        if (inOrder[i] == 2) hInStrIndex = i;
-        if (inOrder[i] == 3) wInStrIndex = i;
+        if (inOrder[i] == 2)
+            hInStrIndex = i;
+        if (inOrder[i] == 3)
+            wInStrIndex = i;
     }
     hInputStride = srcDesc.getStrides()[hInStrIndex];
     wInputStride = srcDesc.getStrides()[wInStrIndex];
@@ -243,22 +253,35 @@ void PSROIPooling::unpackParams(const BlockedMemoryDesc& srcDesc, const BlockedM
 }
 
 template <typename inputType, typename outputType>
-void PSROIPooling::executeAverage(const inputType *srcData, outputType *dstData, const float *bottomRois,
-                                            const int n, const int roiBatchInd,
-                                            const BlockedMemoryDesc& srcDesc, const BlockedMemoryDesc& dstDesc) {
+void PSROIPooling::executeAverage(const inputType* srcData,
+                                  outputType* dstData,
+                                  const float* bottomRois,
+                                  const int n,
+                                  const int roiBatchInd,
+                                  const BlockedMemoryDesc& srcDesc,
+                                  const BlockedMemoryDesc& dstDesc) {
     int inBlockSize, outBlockSize, outBlockCount, hInputStride, wInputStride, hOutputStride, wOutputStride;
     unsigned long inputChannelsPadding, outputChannelsPadding;
-    unpackParams(srcDesc, dstDesc, hInputStride, wInputStride, hOutputStride, wOutputStride,
-                 inBlockSize, outBlockSize, outBlockCount, inputChannelsPadding, outputChannelsPadding);
+    unpackParams(srcDesc,
+                 dstDesc,
+                 hInputStride,
+                 wInputStride,
+                 hOutputStride,
+                 wOutputStride,
+                 inBlockSize,
+                 outBlockSize,
+                 outBlockCount,
+                 inputChannelsPadding,
+                 outputChannelsPadding);
     const float roiStartW = static_cast<float>(round(bottomRois[1])) * spatialScale;
     const float roiStartH = static_cast<float>(round(bottomRois[2])) * spatialScale;
-    const float roiEndW   = static_cast<float>(round(bottomRois[3] + 1.0f)) * spatialScale;
-    const float roiEndH   = static_cast<float>(round(bottomRois[4] + 1.0f)) * spatialScale;
+    const float roiEndW = static_cast<float>(round(bottomRois[3] + 1.0f)) * spatialScale;
+    const float roiEndH = static_cast<float>(round(bottomRois[4] + 1.0f)) * spatialScale;
     // Force too small ROIs to be 1x1
-    const float roiWidth  = std::max<float>(roiEndW - roiStartW, 0.1f);  // avoid 0
+    const float roiWidth = std::max<float>(roiEndW - roiStartW, 0.1f);  // avoid 0
     const float roiHeight = std::max<float>(roiEndH - roiStartH, 0.1f);
 
-    auto avgPsroi = [&] (int c, int h, int w, int binOffIn, int binOffOut, int inBlkRes, int outBlkRes) {
+    auto avgPsroi = [&](int c, int h, int w, int binOffIn, int binOffOut, int inBlkRes, int outBlkRes) {
         float binSizeH = roiHeight / static_cast<float>(pooledHeight);
         float binSizeW = roiWidth / static_cast<float>(pooledWidth);
 
@@ -326,23 +349,36 @@ void PSROIPooling::executeAverage(const inputType *srcData, outputType *dstData,
 }
 
 template <typename inputType, typename outputType>
-void PSROIPooling::executeBilinear(const inputType *srcData, outputType *dstData, const float *bottomRois,
-                                             const int currentRoi, const int roiBatchInd,
-                                             const BlockedMemoryDesc& srcDesc, const BlockedMemoryDesc& dstDesc) {
+void PSROIPooling::executeBilinear(const inputType* srcData,
+                                   outputType* dstData,
+                                   const float* bottomRois,
+                                   const int currentRoi,
+                                   const int roiBatchInd,
+                                   const BlockedMemoryDesc& srcDesc,
+                                   const BlockedMemoryDesc& dstDesc) {
     int inBlockSize, outBlockSize, outBlockCount, hInputStride, wInputStride, hOutputStride, wOutputStride;
     unsigned long inputChannelsPadding, outputChannelsPadding;
-    unpackParams(srcDesc, dstDesc, hInputStride, wInputStride, hOutputStride, wOutputStride,
-                 inBlockSize, outBlockSize, outBlockCount, inputChannelsPadding, outputChannelsPadding);
+    unpackParams(srcDesc,
+                 dstDesc,
+                 hInputStride,
+                 wInputStride,
+                 hOutputStride,
+                 wOutputStride,
+                 inBlockSize,
+                 outBlockSize,
+                 outBlockCount,
+                 inputChannelsPadding,
+                 outputChannelsPadding);
     const float roiStartW = bottomRois[1] * spatialScale;
     const float roiStartH = bottomRois[2] * spatialScale;
     const float roiEndW = bottomRois[3] * spatialScale;
     const float roiEndH = bottomRois[4] * spatialScale;
-    const float roiWidth  = roiEndW - roiStartW;
+    const float roiWidth = roiEndW - roiStartW;
     const float roiHeight = roiEndH - roiStartH;
     size_t numBins = spatialBinsX * spatialBinsY;
     const int binCount = nh * nw;
 
-    auto bilinearPsroi = [&] (int c, int h, int w, int binOffOut, int outBlkRes) {
+    auto bilinearPsroi = [&](int c, int h, int w, int binOffOut, int outBlkRes) {
         float accum = 0.0f;
         int binOffIn, inBlkRes;
         size_t dstIndex = binOffOut + h * hOutputStride + w * wOutputStride + outBlkRes;
@@ -352,7 +388,8 @@ void PSROIPooling::executeBilinear(const inputType *srcData, outputType *dstData
             const float boxYmin = roiStartH + (binY + 0) * (roiHeight / spatialBinsY);
             const float boxYmax = roiStartH + (binY + 1) * (roiHeight / spatialBinsY);
             const float heightScale = nh > 1 ? (boxYmax - boxYmin) * (height - 1) / (pooledHeight - 1) : 0.0f;
-            const float inY = nh > 1 ? (h * heightScale + boxYmin * (height - 1)) : 0.5f * (boxYmin + boxYmax) * (height - 1);
+            const float inY =
+                nh > 1 ? (h * heightScale + boxYmin * (height - 1)) : 0.5f * (boxYmin + boxYmax) * (height - 1);
             for (size_t binX = 0; binX < spatialBinsX; binX++) {
                 size_t gc = c + (binY * spatialBinsX + binX) * nc;
                 if (srcDesc.hasLayoutType(LayoutType::nspc)) {
@@ -361,16 +398,19 @@ void PSROIPooling::executeBilinear(const inputType *srcData, outputType *dstData
                 } else {  // nchw, nChw16c, nChw8c
                     const int inputBlockIdx = (gc / inBlockSize) * inBlockSize;
                     binOffIn = (roiBatchInd * inputChannelsPadding + inputBlockIdx) * height * width;
-                    inBlkRes = ((srcDesc.hasLayoutType(LayoutType::nCsp16c) || srcDesc.hasLayoutType(LayoutType::nCsp8c))
-                                ? gc % inBlockSize : 0);
+                    inBlkRes =
+                        ((srcDesc.hasLayoutType(LayoutType::nCsp16c) || srcDesc.hasLayoutType(LayoutType::nCsp8c))
+                             ? gc % inBlockSize
+                             : 0);
                 }
-                const auto *bottomData = srcData + binOffIn;
+                const auto* bottomData = srcData + binOffIn;
 
                 const float boxXmin = roiStartW + (binX + 0) * (roiWidth / spatialBinsX);
                 const float boxXmax = roiStartW + (binX + 1) * (roiWidth / spatialBinsX);
 
                 const float widthScale = nw > 1 ? (boxXmax - boxXmin) * (width - 1) / (pooledWidth - 1) : 0.0f;
-                const float inX = nw > 1 ? (w * widthScale + boxXmin * (width - 1)) : 0.5f * (boxXmin + boxXmax) * (width - 1);
+                const float inX =
+                    nw > 1 ? (w * widthScale + boxXmin * (width - 1)) : 0.5f * (boxXmin + boxXmax) * (width - 1);
 
                 if (!(inY < 0 || inY > height - 1 || inX < 0 || inX > width - 1)) {
                     const int topYIndex = static_cast<int>(floorf(inY));
@@ -378,8 +418,10 @@ void PSROIPooling::executeBilinear(const inputType *srcData, outputType *dstData
                     const int leftXIndex = static_cast<int>(floorf(inX));
                     int rightXIndex = static_cast<int>(ceilf(inX));
 
-                    if (rightXIndex > width - 1) rightXIndex = width - 1;
-                    if (bottomYIndex > height - 1) bottomYIndex = height - 1;
+                    if (rightXIndex > width - 1)
+                        rightXIndex = width - 1;
+                    if (bottomYIndex > height - 1)
+                        bottomYIndex = height - 1;
 
                     auto topLeftIndex = topYIndex * hInputStride + leftXIndex * wInputStride + inBlkRes;
                     auto topRightIndex = topYIndex * hInputStride + rightXIndex * wInputStride + inBlkRes;
@@ -420,8 +462,10 @@ void PSROIPooling::executeBilinear(const inputType *srcData, outputType *dstData
             for (int c = cStart; c < cEnd; c++) {
                 const int outputBlockIdx = (c / inBlockSize) * inBlockSize;
                 const int binOffsetOutput = (currentRoi * outputChannelsPadding + outputBlockIdx) * binCount;
-                const int outputBlockResidual = ((srcDesc.hasLayoutType(LayoutType::nCsp16c) || srcDesc.hasLayoutType(LayoutType::nCsp8c))
-                                                 ? c % inBlockSize : 0);
+                const int outputBlockResidual =
+                    ((srcDesc.hasLayoutType(LayoutType::nCsp16c) || srcDesc.hasLayoutType(LayoutType::nCsp8c))
+                         ? c % inBlockSize
+                         : 0);
                 bilinearPsroi(c, h, w, outputBlockResidual, binOffsetOutput);
             }
         });
@@ -429,15 +473,20 @@ void PSROIPooling::executeBilinear(const inputType *srcData, outputType *dstData
 }
 
 template <typename inputType, typename outputType>
-void PSROIPooling::executeBilinearDeformable(const inputType *srcData, outputType *dstData, const float *bottomRois,
-                                                       const float *bottomTrans, const int numClasses, const int channelsEachClass,
-                                                       const int currentRoi, const int roiBatchInd) {
+void PSROIPooling::executeBilinearDeformable(const inputType* srcData,
+                                             outputType* dstData,
+                                             const float* bottomRois,
+                                             const float* bottomTrans,
+                                             const int numClasses,
+                                             const int channelsEachClass,
+                                             const int currentRoi,
+                                             const int roiBatchInd) {
     const float roiStartW = static_cast<float>(round(bottomRois[1])) * spatialScale - 0.5f;
     const float roiStartH = static_cast<float>(round(bottomRois[2])) * spatialScale - 0.5f;
-    const float roiEndW   = static_cast<float>(round(bottomRois[3]) + 1.0f) * spatialScale - 0.5f;
-    const float roiEndH   = static_cast<float>(round(bottomRois[4]) + 1.0f) * spatialScale - 0.5f;
+    const float roiEndW = static_cast<float>(round(bottomRois[3]) + 1.0f) * spatialScale - 0.5f;
+    const float roiEndH = static_cast<float>(round(bottomRois[4]) + 1.0f) * spatialScale - 0.5f;
     // Force too small ROIs to be 1x1
-    const float roiWidth  = std::max<float>(roiEndW - roiStartW, 0.1f);  // avoid 0
+    const float roiWidth = std::max<float>(roiEndW - roiStartW, 0.1f);  // avoid 0
     const float roiHeight = std::max<float>(roiEndH - roiStartH, 0.1f);
     parallel_for3d(nc, nh, nw, [&](int c, int h, int w) {
         size_t dstIndex = ((currentRoi * nc + c) * nh + h) * nw + w;
@@ -452,12 +501,15 @@ void PSROIPooling::executeBilinearDeformable(const inputType *srcData, outputTyp
         int partH = h * partSize / pooledHeight;
         int partW = w * partSize / pooledWidth;
         int classId = c / channelsEachClass;
-        float transX = noTrans ? 0 :
-                       bottomTrans[(((currentRoi * numClasses + classId) * 2) * partSize + partH)
-                                   * partSize + partW] * transStd;
-        float transY = noTrans ? 0 :
-                       bottomTrans[(((currentRoi * numClasses + classId) * 2 + 1) * partSize + partH)
-                                   * partSize + partW] * transStd;
+        float transX =
+            noTrans ? 0
+                    : bottomTrans[(((currentRoi * numClasses + classId) * 2) * partSize + partH) * partSize + partW] *
+                          transStd;
+        float transY =
+            noTrans
+                ? 0
+                : bottomTrans[(((currentRoi * numClasses + classId) * 2 + 1) * partSize + partH) * partSize + partW] *
+                      transStd;
 
         float wStart = w * binSizeW + roiStartW + transX * roiWidth;
         float hStart = h * binSizeH + roiStartH + transY * roiHeight;
@@ -480,8 +532,7 @@ void PSROIPooling::executeBilinearDeformable(const inputType *srcData, outputTyp
                 w1 = static_cast<float>((std::min)((std::max)(static_cast<double>(w1), 0.0), width - 1.0));
                 h1 = static_cast<float>((std::min)((std::max)(static_cast<double>(h1), 0.0), height - 1.0));
                 int c1 = static_cast<int>((c * groupSize + gh) * groupSize + gw);
-                float val = bilinearInterp<inputType>(offsetBottomData +
-                                                      c1 * height * width, w1, h1, width);
+                float val = bilinearInterp<inputType>(offsetBottomData + c1 * height * width, w1, h1, width);
 
                 sum += val;
                 count++;
@@ -493,9 +544,9 @@ void PSROIPooling::executeBilinearDeformable(const inputType *srcData, outputTyp
 
 template <typename inputType, typename outputType>
 void PSROIPooling::executeSpecified() {
-    const auto *srcData = getSrcDataAtPortAs<const inputType>(0);
-    const auto *bottomRoisBeginning = getSrcDataAtPortAs<const float>(1);
-    auto *dstData = getDstDataAtPortAs<outputType>(0);
+    const auto* srcData = getSrcDataAtPortAs<const inputType>(0);
+    const auto* bottomRoisBeginning = getSrcDataAtPortAs<const float>(1);
+    auto* dstData = getDstDataAtPortAs<outputType>(0);
 
     auto srcDesc = getParentEdgeAt(0)->getMemory().getDescWithType<BlockedMemoryDesc>();
     auto dstDesc = getChildEdgeAt(0)->getMemory().getDescWithType<BlockedMemoryDesc>();
@@ -509,7 +560,7 @@ void PSROIPooling::executeSpecified() {
     }
 
     //  for Deformable PSROIPooling
-    const float *bottomTrans = nullptr;
+    const float* bottomTrans = nullptr;
     int numClasses = 1;
     int channelsEachClass = outputDim;
     if (!noTrans) {
@@ -520,15 +571,21 @@ void PSROIPooling::executeSpecified() {
     }
 
     parallel_for(realRois, [&](int currentRoi) {
-        const float *bottomRois = bottomRoisBeginning + currentRoi * 5;
+        const float* bottomRois = bottomRoisBeginning + currentRoi * 5;
         int roiBatchInd = static_cast<int>(bottomRois[0]);
         if (getAlgorithm() == Algorithm::PSROIPoolingAverage) {
             executeAverage(srcData, dstData, bottomRois, currentRoi, roiBatchInd, *srcDesc, *dstDesc);
         } else if (getAlgorithm() == Algorithm::PSROIPoolingBilinear) {
             executeBilinear(srcData, dstData, bottomRois, currentRoi, roiBatchInd, *srcDesc, *dstDesc);
         } else if (getAlgorithm() == Algorithm::PSROIPoolingBilinearDeformable) {
-            executeBilinearDeformable(srcData, dstData, bottomRois, bottomTrans,
-                    numClasses, channelsEachClass, currentRoi, roiBatchInd);
+            executeBilinearDeformable(srcData,
+                                      dstData,
+                                      bottomRois,
+                                      bottomTrans,
+                                      numClasses,
+                                      channelsEachClass,
+                                      currentRoi,
+                                      roiBatchInd);
         }
     });
 
@@ -537,16 +594,16 @@ void PSROIPooling::executeSpecified() {
 
 namespace {
 struct PSROIPoolingContext {
-    PSROIPooling &node;
+    PSROIPooling& node;
 };
-}
+}  // namespace
 
-template<typename T>
+template <typename T>
 struct PSROIPooling::PSROIPoolingExecute {
     using srcT = typename std::tuple_element<0, T>::type;
     using dstT = typename std::tuple_element<1, T>::type;
 
-    void operator()(PSROIPoolingContext & ctx) {
+    void operator()(PSROIPoolingContext& ctx) {
         ctx.node.executeSpecified<srcT, dstT>();
     }
 };
@@ -557,15 +614,18 @@ void PSROIPooling::execute(dnnl::stream strm) {
 
     if (!((inputPrec == ov::element::bf16 && outputPrec == ov::element::bf16) ||
           (inputPrec == ov::element::f32 && outputPrec == ov::element::f32))) {
-            OPENVINO_THROW(errorPrefix + " has different precisions on input: " + inputPrec.get_type_name() +
+        OPENVINO_THROW(errorPrefix + " has different precisions on input: " + inputPrec.get_type_name() +
                        " and output: " + outputPrec.get_type_name());
     }
 
     PSROIPoolingContext ctx = {
-            *this,
+        *this,
     };
 
-    OV_SWITCH(intel_cpu, PSROIPoolingExecute, ctx, std::tie(inputPrec, outputPrec),
+    OV_SWITCH(intel_cpu,
+              PSROIPoolingExecute,
+              ctx,
+              std::tie(inputPrec, outputPrec),
               OV_CASE2(ov::element::f32, ov::element::f32, float, float),
               OV_CASE2(ov::element::bf16, ov::element::bf16, bfloat16_t, bfloat16_t))
 }
@@ -574,6 +634,6 @@ bool PSROIPooling::created() const {
     return getType() == Type::PSROIPooling;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/psroi_pooling.h b/src/plugins/intel_cpu/src/nodes/psroi_pooling.h
index 70693fdf489999..1dba67bf26fe1f 100644
--- a/src/plugins/intel_cpu/src/nodes/psroi_pooling.h
+++ b/src/plugins/intel_cpu/src/nodes/psroi_pooling.h
@@ -14,9 +14,9 @@ class PSROIPooling : public Node {
 public:
     PSROIPooling(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
-    void createPrimitive() override {};
+    void createPrimitive() override{};
     void execute(dnnl::stream strm) override;
     bool created() const override;
 
@@ -48,35 +48,53 @@ class PSROIPooling : public Node {
 
     std::string errorPrefix;
 
-    void unpackParams(const BlockedMemoryDesc& srcDesc, const BlockedMemoryDesc& dstDesc,
-                      int& hInputStride, int& wInputStride,
-                      int& hOutputStride, int& wOutputStride,
-                      int& inBlockSize, int& outBlockSize,
+    void unpackParams(const BlockedMemoryDesc& srcDesc,
+                      const BlockedMemoryDesc& dstDesc,
+                      int& hInputStride,
+                      int& wInputStride,
+                      int& hOutputStride,
+                      int& wOutputStride,
+                      int& inBlockSize,
+                      int& outBlockSize,
                       int& outBlockCount,
-                      unsigned long& inputChannelsPadding, unsigned long& outputChannelsPadding);
+                      unsigned long& inputChannelsPadding,
+                      unsigned long& outputChannelsPadding);
 
     template <typename inputType, typename outputType>
-    void executeAverage(const inputType *srcData, outputType *dstData, const float *bottomRois,
-                        const int n, const int roiBatchInd,
-                        const BlockedMemoryDesc& srcDesc, const BlockedMemoryDesc& dstDesc);
+    void executeAverage(const inputType* srcData,
+                        outputType* dstData,
+                        const float* bottomRois,
+                        const int n,
+                        const int roiBatchInd,
+                        const BlockedMemoryDesc& srcDesc,
+                        const BlockedMemoryDesc& dstDesc);
 
     template <typename inputType, typename outputType>
-    void executeBilinear(const inputType *srcData, outputType *dstData, const float *bottomRois,
-                         const int currentRoi, const int roiBatchInd,
-                         const BlockedMemoryDesc& srcDesc, const BlockedMemoryDesc& dstDesc);
+    void executeBilinear(const inputType* srcData,
+                         outputType* dstData,
+                         const float* bottomRois,
+                         const int currentRoi,
+                         const int roiBatchInd,
+                         const BlockedMemoryDesc& srcDesc,
+                         const BlockedMemoryDesc& dstDesc);
 
     template <typename inputType, typename outputType>
-    void executeBilinearDeformable(const inputType *srcData, outputType *dstData, const float *bottomRois,
-                                   const float *bottomTrans, const int numClasses, const int channelsEachClass,
-                                   const int currentRoi, const int roiBatchInd);
+    void executeBilinearDeformable(const inputType* srcData,
+                                   outputType* dstData,
+                                   const float* bottomRois,
+                                   const float* bottomTrans,
+                                   const int numClasses,
+                                   const int channelsEachClass,
+                                   const int currentRoi,
+                                   const int roiBatchInd);
 
     template <typename inputType, typename outputType>
     void executeSpecified();
 
-    template<typename T>
+    template <typename T>
     struct PSROIPoolingExecute;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/qkv_proj.cpp b/src/plugins/intel_cpu/src/nodes/qkv_proj.cpp
index f732fe883f85a1..ce7bfae07591d6 100644
--- a/src/plugins/intel_cpu/src/nodes/qkv_proj.cpp
+++ b/src/plugins/intel_cpu/src/nodes/qkv_proj.cpp
@@ -7,16 +7,16 @@
 #include <string>
 #include <vector>
 
-#include "common/primitive_hashing_utils.hpp"
 #include "common/bfloat16.hpp"
 #include "common/cpu_memcpy.h"
+#include "common/primitive_hashing_utils.hpp"
 #include "cpu/x64/cpu_isa_traits.hpp"
 #include "cpu/x64/jit_generator.hpp"
 #include "shape_inference/shape_inference_internal_dyn.hpp"
 #include "utils/plain_tensor.hpp"
 
 #if defined(OPENVINO_ARCH_X86_64)
-#include "kernels/x64/mlp_utils.hpp"
+#    include "kernels/x64/mlp_utils.hpp"
 #endif
 
 #include "openvino/core/parallel.hpp"
@@ -55,7 +55,7 @@ static std::vector<int> allocate_workers(const std::vector<int>& grouped_works,
 template <typename T>
 struct QKVProjection::Executor : public QKVProjection::ExecutorBase {
     std::vector<Work> works;
-    QKVProjection * m_node;
+    QKVProjection* m_node;
     DnnlScratchPadPtr m_scrachPad;
     MemoryPtr m_scratchMem;
     uint8_t* m_scratch_base = nullptr;
@@ -66,7 +66,7 @@ struct QKVProjection::Executor : public QKVProjection::ExecutorBase {
 
     WeightBuffer wbuffer;
 
-    Executor(QKVProjection * pnode, DnnlScratchPadPtr scrachPad) : m_node(pnode), m_scrachPad(scrachPad) {
+    Executor(QKVProjection* pnode, DnnlScratchPadPtr scrachPad) : m_node(pnode), m_scrachPad(scrachPad) {
         PlainTensor w0(pnode->getSrcMemoryAtPort(1));
         PlainTensor w1(pnode->getSrcMemoryAtPort(2));
         PlainTensor w2(pnode->getSrcMemoryAtPort(3));
@@ -104,7 +104,7 @@ struct QKVProjection::Executor : public QKVProjection::ExecutorBase {
                 if (blkN) {
                     auto& work = works[cur_work_id++];
                     work.blk_K_size = cache_blk_k_size;
-                    work.n0 = (start_blkN) * REG_BLK_N_SIZE;
+                    work.n0 = (start_blkN)*REG_BLK_N_SIZE;
                     work.n1 = (start_blkN + blkN) * REG_BLK_N_SIZE;
                     work.BN = blkN * REG_BLK_N_SIZE;
                     work.k0 = 0;
@@ -135,9 +135,16 @@ struct QKVProjection::Executor : public QKVProjection::ExecutorBase {
             create_works(w2.ptr_v(), 2, proj_size2, n_group_workers[2]);
         }
 
-        DEBUG_LOG("QKVProj hidden_size=", K, " proj_sizes=",
-                    proj_size0, ",", proj_size1, ",", proj_size2,
-                    " used_nthr=", cur_work_id);
+        DEBUG_LOG("QKVProj hidden_size=",
+                  K,
+                  " proj_sizes=",
+                  proj_size0,
+                  ",",
+                  proj_size1,
+                  ",",
+                  proj_size2,
+                  " used_nthr=",
+                  cur_work_id);
 
         wbuffer.alloc(works, weight_element_size);
 
@@ -145,9 +152,14 @@ struct QKVProjection::Executor : public QKVProjection::ExecutorBase {
             auto& work = works[ithr];
             if (work) {
                 if (quantized_int8)
-                    work.setup(wbuffer.get<int8_t>(ithr), reinterpret_cast<int8_t*>(work.p_raw_weights), stride_in_bytes, true);
+                    work.setup(wbuffer.get<int8_t>(ithr),
+                               reinterpret_cast<int8_t*>(work.p_raw_weights),
+                               stride_in_bytes,
+                               true);
                 else
-                    work.setup(wbuffer.get<T>(ithr), reinterpret_cast<ov::float16*>(work.p_raw_weights), stride_in_bytes);
+                    work.setup(wbuffer.get<T>(ithr),
+                               reinterpret_cast<ov::float16*>(work.p_raw_weights),
+                               stride_in_bytes);
             }
         });
     }
@@ -162,7 +174,7 @@ struct QKVProjection::Executor : public QKVProjection::ExecutorBase {
             for (auto& work : works) {
                 if (work) {
                     auto C_size = work.set_C(M, reinterpret_cast<float*>(cur_scratch_base));
-                    allocator.register_allocation(C_size, [&](void* ptr){
+                    allocator.register_allocation(C_size, [&](void* ptr) {
                         work.set_C(M, reinterpret_cast<float*>(ptr));
                     });
                 }
@@ -171,7 +183,7 @@ struct QKVProjection::Executor : public QKVProjection::ExecutorBase {
             if (m_node->m_config.quantized) {
                 m_quant_act.M = M;
                 m_quant_act.K = m_node->m_config.hidden_size;
-                allocator.register_allocation(m_quant_act.size(), [&](void* ptr){
+                allocator.register_allocation(m_quant_act.size(), [&](void* ptr) {
                     m_quant_act.setup(ptr);
                 });
             }
@@ -265,18 +277,17 @@ struct QKVProjection::Executor : public QKVProjection::ExecutorBase {
                     if (m_node->m_config.quantized) {
                         // dequantize output & convert to f32 in-place
                         auto* p_wsum = work.w_sum_per_oc.template ptr<float>();
-                        ov::Extensions::Cpu::XARCH::llm_mlp_dequantize_i32_f32(
-                            BM,
-                            work.BN,
-                            reinterpret_cast<int32_t*>(src),
-                            stride_src,
-                            src,
-                            stride_src,
-                            m_quant_act.scale,
-                            m_quant_act.zp,
-                            p_wsum,
-                            w_scale[work.output_id] + work.n0,
-                            asym);
+                        ov::Extensions::Cpu::XARCH::llm_mlp_dequantize_i32_f32(BM,
+                                                                               work.BN,
+                                                                               reinterpret_cast<int32_t*>(src),
+                                                                               stride_src,
+                                                                               src,
+                                                                               stride_src,
+                                                                               m_quant_act.scale,
+                                                                               m_quant_act.zp,
+                                                                               p_wsum,
+                                                                               w_scale[work.output_id] + work.n0,
+                                                                               asym);
                     }
                     // compress accumulation result into target
                     for (int mi = 0; mi < BM; mi++, src += stride_src, dst += stride_dst) {
@@ -298,8 +309,8 @@ struct QKVProjection::Executor : public QKVProjection::ExecutorBase {
 #else
 template <typename T>
 struct QKVProjection::Executor : public QKVProjection::ExecutorBase {
-    QKVProjection * m_pnode;
-    Executor(QKVProjection * pnode) : m_pnode(pnode) {}
+    QKVProjection* m_pnode;
+    Executor(QKVProjection* pnode) : m_pnode(pnode) {}
     void execute() override {}
 };
 #endif
@@ -327,7 +338,7 @@ QKVProjection::QKVProjection(const std::shared_ptr<ov::Node>& op, const GraphCon
     : Node(op, context, NgraphShapeInferFactory(op)) {
     std::string errorMessage;
 
-    const auto & config = context->getConfig();
+    const auto& config = context->getConfig();
     size_t concurrency = config.streamExecutorConfig.get_threads_per_stream();
     if (concurrency == 0)
         concurrency = parallel_get_max_threads();
@@ -357,7 +368,9 @@ void QKVProjection::initSupportedPrimitiveDescriptors() {
         }
     }
 
-    OPENVINO_ASSERT(rtPrecision == ov::element::bf16 || rtPrecision == ov::element::f16, "Unexpected rtPrecision:", rtPrecision);
+    OPENVINO_ASSERT(rtPrecision == ov::element::bf16 || rtPrecision == ov::element::f16,
+                    "Unexpected rtPrecision:",
+                    rtPrecision);
 
     if (m_config.quantized) {
         auto weightPrecision = ov::element::i8;
@@ -367,9 +380,21 @@ void QKVProjection::initSupportedPrimitiveDescriptors() {
         inPortConfigs.emplace_back(LayoutType::ncsp, weightPrecision, getInputShapeAtPort(1), false, -1);  // q_proj
         inPortConfigs.emplace_back(LayoutType::ncsp, weightPrecision, getInputShapeAtPort(2), false, -1);  // k_proj
         inPortConfigs.emplace_back(LayoutType::ncsp, weightPrecision, getInputShapeAtPort(3), false, -1);  // v_proj
-        inPortConfigs.emplace_back(LayoutType::ncsp, wScalePrecision, getInputShapeAtPort(4), false, -1);  // q_proj deq-scale per-OC
-        inPortConfigs.emplace_back(LayoutType::ncsp, wScalePrecision, getInputShapeAtPort(5), false, -1);  // k_proj deq-scale per-OC
-        inPortConfigs.emplace_back(LayoutType::ncsp, wScalePrecision, getInputShapeAtPort(6), false, -1);  // v_proj deq-scale per-OC
+        inPortConfigs.emplace_back(LayoutType::ncsp,
+                                   wScalePrecision,
+                                   getInputShapeAtPort(4),
+                                   false,
+                                   -1);  // q_proj deq-scale per-OC
+        inPortConfigs.emplace_back(LayoutType::ncsp,
+                                   wScalePrecision,
+                                   getInputShapeAtPort(5),
+                                   false,
+                                   -1);  // k_proj deq-scale per-OC
+        inPortConfigs.emplace_back(LayoutType::ncsp,
+                                   wScalePrecision,
+                                   getInputShapeAtPort(6),
+                                   false,
+                                   -1);  // v_proj deq-scale per-OC
 
         // initialize output port
         outPortConfigs.emplace_back(LayoutType::ncsp, rtPrecision, getOutputShapeAtPort(0), false, -1);
@@ -406,7 +431,7 @@ bool QKVProjection::isSupportedOperation(const std::shared_ptr<const ov::Node>&
                     errorMessage = "QKVProjection needs at least 3 cores to work";
                     return false;
                 }
-                float unbalance_ratio = static_cast<float>(concurrency % 3)/static_cast<float>(concurrency / 3);
+                float unbalance_ratio = static_cast<float>(concurrency % 3) / static_cast<float>(concurrency / 3);
                 if (unbalance_ratio > 0.2f) {
                     errorMessage = "QKVProjection needs number of cores to be nearly multiple of 3";
                     return false;
diff --git a/src/plugins/intel_cpu/src/nodes/qkv_proj.h b/src/plugins/intel_cpu/src/nodes/qkv_proj.h
index 7a94b3e704f976..8887a7fb072198 100644
--- a/src/plugins/intel_cpu/src/nodes/qkv_proj.h
+++ b/src/plugins/intel_cpu/src/nodes/qkv_proj.h
@@ -8,7 +8,7 @@
 #include "transformations/cpu_opset/x64/op/qkv_proj.hpp"
 
 #if defined(OPENVINO_ARCH_X86_64)
-#include "kernels/x64/mlp_kernel.hpp"
+#    include "kernels/x64/mlp_kernel.hpp"
 #endif
 
 namespace ov {
@@ -43,7 +43,8 @@ class QKVProjection : public Node {
         virtual ~ExecutorBase() = default;
     };
     std::shared_ptr<ExecutorBase> m_executor;
-    template <typename T> struct Executor;
+    template <typename T>
+    struct Executor;
 
     QKVProjectionNode::Config m_config;
 };
diff --git a/src/plugins/intel_cpu/src/nodes/random_uniform.cpp b/src/plugins/intel_cpu/src/nodes/random_uniform.cpp
index b40796bf8d93d6..081e29341fda99 100644
--- a/src/plugins/intel_cpu/src/nodes/random_uniform.cpp
+++ b/src/plugins/intel_cpu/src/nodes/random_uniform.cpp
@@ -12,7 +12,8 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 
-bool RandomUniform::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool RandomUniform::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                         std::string& errorMessage) noexcept {
     try {
         if (op->get_type_info() != op::v8::RandomUniform::get_type_info_static()) {
             errorMessage = "Only RandomUniform operation from the opset8 is supported by the CPU plugin.";
@@ -35,9 +36,9 @@ RandomUniform::RandomUniform(const std::shared_ptr<ov::Node>& op, const GraphCon
         THROW_CPU_NODE_ERR(errorMessage);
     }
 
-    // RandomUniform should generate new sequence each run even if all inputs are constants. So that method Node::IsConstant()
-    // doesn't return 'True' for RandomUniform with all constant inputs and the node generates new values for each inference,
-    // we set 'StrictNoConst' value for 'ConstantType' in ctor.
+    // RandomUniform should generate new sequence each run even if all inputs are constants. So that method
+    // Node::IsConstant() doesn't return 'True' for RandomUniform with all constant inputs and the node generates new
+    // values for each inference, we set 'StrictNoConst' value for 'ConstantType' in ctor.
     constant = ConstantType::StrictNoConst;
 
     auto rnd_op = as_type_ptr<op::v8::RandomUniform>(op);
@@ -72,9 +73,9 @@ void RandomUniform::initSupportedPrimitiveDescriptors() {
     }
 
     auto out_prc = getOriginalOutputPrecisionAtPort(0);
-    if (out_prc.is_real() && ((m_algo == PHILOX &&
-            !one_of(out_prc, ov::element::f32, ov::element::f16, ov::element::bf16)) ||
-            (m_algo == STL && !one_of(out_prc, ov::element::f32)))) {
+    if (out_prc.is_real() &&
+        ((m_algo == PHILOX && !one_of(out_prc, ov::element::f32, ov::element::f16, ov::element::bf16)) ||
+         (m_algo == STL && !one_of(out_prc, ov::element::f32)))) {
         out_prc = ov::element::f32;
     }
     if (!out_prc.is_real() && !one_of(out_prc, ov::element::i32, ov::element::i64)) {
@@ -104,7 +105,8 @@ void RandomUniform::createPrimitive() {
 
         jcp.out_data_type = m_output_prc;
 
-        m_jit_kernel = kernel::JitKernel<kernel::RandomUniformCompileParams, kernel::RandomUniformCallArgs>::createInstance<kernel::RandomUniform>(jcp);
+        m_jit_kernel = kernel::JitKernel<kernel::RandomUniformCompileParams,
+                                         kernel::RandomUniformCallArgs>::createInstance<kernel::RandomUniform>(jcp);
 
         if (m_jit_kernel) {
             if (auto selected_pd = getSelectedPrimitiveDescriptor()) {
@@ -118,7 +120,7 @@ void RandomUniform::createPrimitive() {
                 }
             }
         }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
     }
 
     if (m_const_inputs[SHAPE]) {
@@ -159,7 +161,7 @@ void RandomUniform::prepareParams() {
 
                 start = ithr * blocks_per_thr * block_size;
                 end = (ithr + 1) * blocks_per_thr * block_size;
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
             } else {
                 const auto groups_num = (m_out_el_num + PHILOX_GROUP_SIZE - 1) / PHILOX_GROUP_SIZE;
                 const auto groups_per_thr = (groups_num + nthr - 1) / nthr;
@@ -252,11 +254,7 @@ inline void runPhilox(uint64_t key, uint64_t counter, uint64_t n, uint32_t* res)
     res[3] = counter_32[1];
 }
 
-inline void convertToOutputType(const uint32_t* in,
-                                float min,
-                                float range,
-                                float* out,
-                                size_t el_to_copy) {
+inline void convertToOutputType(const uint32_t* in, float min, float range, float* out, size_t el_to_copy) {
     RandomUniform::OutputType out_val;
 
     for (size_t i = 0lu; i < el_to_copy; i++) {
@@ -265,11 +263,7 @@ inline void convertToOutputType(const uint32_t* in,
     }
 }
 
-inline void convertToOutputType(const uint32_t* in,
-                                float16 min,
-                                float16 range,
-                                float16* out,
-                                size_t el_to_copy) {
+inline void convertToOutputType(const uint32_t* in, float16 min, float16 range, float16* out, size_t el_to_copy) {
     RandomUniform::OutputType out_val;
 
     for (size_t i = 0lu; i < el_to_copy; i++) {
@@ -279,11 +273,7 @@ inline void convertToOutputType(const uint32_t* in,
     }
 }
 
-inline void convertToOutputType(const uint32_t* in,
-                                bfloat16 min,
-                                bfloat16 range,
-                                bfloat16* out,
-                                size_t el_to_copy) {
+inline void convertToOutputType(const uint32_t* in, bfloat16 min, bfloat16 range, bfloat16* out, size_t el_to_copy) {
     RandomUniform::OutputType out_val;
 
     for (size_t i = 0lu; i < el_to_copy; i++) {
@@ -293,21 +283,13 @@ inline void convertToOutputType(const uint32_t* in,
     }
 }
 
-inline void convertToOutputType(const uint32_t* in,
-                                int32_t min,
-                                int32_t range,
-                                int32_t* out,
-                                size_t el_to_copy) {
+inline void convertToOutputType(const uint32_t* in, int32_t min, int32_t range, int32_t* out, size_t el_to_copy) {
     for (size_t i = 0lu; i < el_to_copy; i++) {
         out[i] = static_cast<int32_t>(in[i] % range + min);
     }
 }
 
-inline void convertToOutputType(const uint32_t* in,
-                                int64_t min,
-                                int64_t range,
-                                int64_t* out,
-                                size_t el_to_copy) {
+inline void convertToOutputType(const uint32_t* in, int64_t min, int64_t range, int64_t* out, size_t el_to_copy) {
     for (size_t i = 0lu; i < el_to_copy; i++) {
         out[i] = static_cast<int64_t>(((static_cast<uint64_t>(in[i * 2]) << 32) + in[i * 2 + 1]) % range + min);
     }
@@ -315,7 +297,9 @@ inline void convertToOutputType(const uint32_t* in,
 
 }  // namespace
 
-std::pair<uint64_t, uint64_t> RandomUniform::computePhilox(void* out, size_t out_el_num, const std::pair<uint64_t, uint64_t>& prev_state) {
+std::pair<uint64_t, uint64_t> RandomUniform::computePhilox(void* out,
+                                                           size_t out_el_num,
+                                                           const std::pair<uint64_t, uint64_t>& prev_state) {
     // When both seed values are equal to zero RandomUniform should generate non-deterministic sequence.
     if (m_global_seed == 0lu && m_op_seed == 0lu) {
         std::srand(static_cast<unsigned int>(std::time(nullptr)));
@@ -332,25 +316,25 @@ std::pair<uint64_t, uint64_t> RandomUniform::computePhilox(void* out, size_t out
     if (m_jit_kernel) {
 #if defined(OPENVINO_ARCH_X86_64)
         parallel_nt(m_threads_num, [&](const int ithr, const int nthr) {
-                auto& p = m_thread_params[ithr];
-                if (p.work_amount == 0lu) {
-                    return;
-                }
-                auto n = n_state + p.n_shift;
+            auto& p = m_thread_params[ithr];
+            if (p.work_amount == 0lu) {
+                return;
+            }
+            auto n = n_state + p.n_shift;
 
-                kernel::RandomUniformCallArgs args;
+            kernel::RandomUniformCallArgs args;
 
-                args.dst_ptr     = (out_u8 + p.dst_shift);
-                args.key_ptr     = &m_global_seed;
-                args.counter_ptr = &counter;
-                args.n_ptr       = &n;
-                args.min_ptr     = &m_min_val;
-                args.range_ptr   = &m_range_val;
-                args.work_amount = p.work_amount;
+            args.dst_ptr = (out_u8 + p.dst_shift);
+            args.key_ptr = &m_global_seed;
+            args.counter_ptr = &counter;
+            args.n_ptr = &n;
+            args.min_ptr = &m_min_val;
+            args.range_ptr = &m_range_val;
+            args.work_amount = p.work_amount;
 
-                (*m_jit_kernel)(&args);
-            });
-#endif // OPENVINO_ARCH_X86_64
+            (*m_jit_kernel)(&args);
+        });
+#endif  // OPENVINO_ARCH_X86_64
     } else {
         auto threadBody = [&](const int ithr, const int nthr) {
             auto& p = m_thread_params[ithr];
@@ -362,18 +346,18 @@ std::pair<uint64_t, uint64_t> RandomUniform::computePhilox(void* out, size_t out
             auto work_rest = static_cast<int64_t>(p.work_amount);
             uint32_t res[4];
 
-#define EXEC_CASE(P)                                                                                    \
-            case element::P: {                                                                          \
-                auto out_t = reinterpret_cast<element_type_traits<element::P>::value_type *>(out_cur);  \
-                for (; work_rest > 0l; work_rest -= p.step, out_t += p.step) {                          \
-                    runPhilox(m_global_seed, counter, n, res);                                          \
-                    auto el_to_copy = std::min(p.step, static_cast<uint64_t>(work_rest));               \
-                    convertToOutputType(res, m_min_val.P, m_range_val.P, out_t, el_to_copy);            \
-                    if (++n == 0) {                                                                     \
-                        counter++;                                                                      \
-                    }                                                                                   \
-                }                                                                                       \
-            } break;
+#define EXEC_CASE(P)                                                                          \
+    case element::P: {                                                                        \
+        auto out_t = reinterpret_cast<element_type_traits<element::P>::value_type*>(out_cur); \
+        for (; work_rest > 0l; work_rest -= p.step, out_t += p.step) {                        \
+            runPhilox(m_global_seed, counter, n, res);                                        \
+            auto el_to_copy = std::min(p.step, static_cast<uint64_t>(work_rest));             \
+            convertToOutputType(res, m_min_val.P, m_range_val.P, out_t, el_to_copy);          \
+            if (++n == 0) {                                                                   \
+                counter++;                                                                    \
+            }                                                                                 \
+        }                                                                                     \
+    } break;
 
             switch (m_output_prc) {
                 EXEC_CASE(f32)
@@ -381,7 +365,8 @@ std::pair<uint64_t, uint64_t> RandomUniform::computePhilox(void* out, size_t out
                 EXEC_CASE(bf16)
                 EXEC_CASE(i32)
                 EXEC_CASE(i64)
-                default: THROW_CPU_NODE_ERR("Unsupported type of RandomUniform: ", m_output_prc.to_string());
+            default:
+                THROW_CPU_NODE_ERR("Unsupported type of RandomUniform: ", m_output_prc.to_string());
             }
 
 #undef EXEC_CASE
@@ -396,26 +381,32 @@ std::pair<uint64_t, uint64_t> RandomUniform::computePhilox(void* out, size_t out
         counter_state++;
     }
 
-    return { n_state, counter_state };
+    return {n_state, counter_state};
 }
 
 ////////////// STL algo ///////////////
 void RandomUniform::computeStl(void* out, size_t work_amount) {
     switch (m_output_prc) {
-        case element::f32: {
-            generateData<float, std::uniform_real_distribution<float>>(
-                    std::uniform_real_distribution<float>{m_min_val.f32, m_max_val.f32}, out, work_amount);
-        } break;
-        case element::i32: {
-            generateData<int32_t, std::uniform_int_distribution<int32_t>>(
-                    std::uniform_int_distribution<int32_t>{m_min_val.i32, m_max_val.i32}, out, work_amount);
-        } break;
-        case element::i64: {
-            generateData<int64_t, std::uniform_int_distribution<int64_t>>(
-                    std::uniform_int_distribution<int64_t>{m_min_val.i64, m_max_val.i64}, out, work_amount);
-        } break;
-        default:
-            THROW_CPU_NODE_ERR("has unsupported output type: ", m_output_prc);
+    case element::f32: {
+        generateData<float, std::uniform_real_distribution<float>>(
+            std::uniform_real_distribution<float>{m_min_val.f32, m_max_val.f32},
+            out,
+            work_amount);
+    } break;
+    case element::i32: {
+        generateData<int32_t, std::uniform_int_distribution<int32_t>>(
+            std::uniform_int_distribution<int32_t>{m_min_val.i32, m_max_val.i32},
+            out,
+            work_amount);
+    } break;
+    case element::i64: {
+        generateData<int64_t, std::uniform_int_distribution<int64_t>>(
+            std::uniform_int_distribution<int64_t>{m_min_val.i64, m_max_val.i64},
+            out,
+            work_amount);
+    } break;
+    default:
+        THROW_CPU_NODE_ERR("has unsupported output type: ", m_output_prc);
     }
 }
 
@@ -430,9 +421,9 @@ void RandomUniform::generateData(DISTR_TYPE distribution, void* out, size_t work
 //////////////////////////////////
 
 void RandomUniform::initEdgeValues(OutputType& dst, const void* src, const element::Type& output_type) {
-#define EL_CASE(E) \
-    case element::E: \
-        dst.E = *reinterpret_cast<const element_type_traits<element::E>::value_type *>(src); \
+#define EL_CASE(E)                                                                          \
+    case element::E:                                                                        \
+        dst.E = *reinterpret_cast<const element_type_traits<element::E>::value_type*>(src); \
         break;
 
     switch (output_type) {
@@ -442,16 +433,16 @@ void RandomUniform::initEdgeValues(OutputType& dst, const void* src, const eleme
         EL_CASE(i32)
         EL_CASE(i64)
         EL_CASE(f64)
-        default:
-            THROW_CPU_NODE_ERR("has unsupported output precision: ", output_type);
+    default:
+        THROW_CPU_NODE_ERR("has unsupported output precision: ", output_type);
     }
 
 #undef EL_CASE
 }
 
 void RandomUniform::evalRange() {
-#define EL_CASE(E) \
-    case element::E: \
+#define EL_CASE(E)                                 \
+    case element::E:                               \
         m_range_val.E = m_max_val.E - m_min_val.E; \
         break;
 
@@ -462,8 +453,8 @@ void RandomUniform::evalRange() {
         EL_CASE(i32)
         EL_CASE(i64)
         EL_CASE(f64)
-        default:
-            THROW_CPU_NODE_ERR("has unsupported output precision: ", m_output_prc);
+    default:
+        THROW_CPU_NODE_ERR("has unsupported output precision: ", m_output_prc);
     }
 
 #undef EL_CASE
@@ -485,9 +476,9 @@ std::string RandomUniform::getPrimitiveDescriptorType() const {
         str_type += t;
     };
 
-#define SEARCH_TYPE(_type)                                          \
-    if ((type & impl_desc_type::_type) == impl_desc_type::_type)    \
-        add_type(#_type)
+#define SEARCH_TYPE(_type)                                       \
+    if ((type & impl_desc_type::_type) == impl_desc_type::_type) \
+    add_type(#_type)
 
     SEARCH_TYPE(undef);
     SEARCH_TYPE(jit);
@@ -507,7 +498,9 @@ std::string RandomUniform::getPrimitiveDescriptorType() const {
 
     if (selectedPrimitiveDesc) {
         if (selectedPrimitiveDesc->getConfig().outConfs[0].getMemDesc()->getPrecision() != ov::element::u8) {
-            str_type += "_" + std::string(selectedPrimitiveDesc->getConfig().outConfs[0].getMemDesc()->getPrecision().get_type_name());
+            str_type +=
+                "_" + std::string(
+                          selectedPrimitiveDesc->getConfig().outConfs[0].getMemDesc()->getPrecision().get_type_name());
         } else {
             str_type += "_I8";
         }
@@ -528,6 +521,6 @@ bool RandomUniform::created() const {
     return getType() == Type::RandomUniform;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/random_uniform.hpp b/src/plugins/intel_cpu/src/nodes/random_uniform.hpp
index 237480cd06a667..b04d6b3635a10b 100644
--- a/src/plugins/intel_cpu/src/nodes/random_uniform.hpp
+++ b/src/plugins/intel_cpu/src/nodes/random_uniform.hpp
@@ -5,7 +5,9 @@
 #pragma once
 
 #include <node.h>
+
 #include <random>
+
 #include "kernels/x64/random_uniform.hpp"
 
 namespace ov {
@@ -15,14 +17,14 @@ namespace node {
 class RandomUniform : public Node {
 public:
     union OutputType {
-        float    f32;
-        float16  f16;
+        float f32;
+        float16 f16;
         bfloat16 bf16;
-        double   f64;
-        int32_t  i32;
+        double f64;
+        int32_t i32;
         uint32_t u32;
         uint16_t u16;
-        int64_t  i64;
+        int64_t i64;
     };
 
     RandomUniform(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr& context);
@@ -45,7 +47,9 @@ class RandomUniform : public Node {
 
     bool created() const override;
 
-    bool canBeInPlace() const override { return false; }
+    bool canBeInPlace() const override {
+        return false;
+    }
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
@@ -57,7 +61,9 @@ class RandomUniform : public Node {
 private:
     void computeStl(void* out, size_t work_amount);
 
-    std::pair<uint64_t, uint64_t> computePhilox(void* out, size_t work_amount, const std::pair<uint64_t, uint64_t>& prev_state);
+    std::pair<uint64_t, uint64_t> computePhilox(void* out,
+                                                size_t work_amount,
+                                                const std::pair<uint64_t, uint64_t>& prev_state);
 
     template <typename T, typename DISTR_TYPE>
     void generateData(DISTR_TYPE distribution, void* out, size_t work_amount);
@@ -76,7 +82,7 @@ class RandomUniform : public Node {
     ov::element::Type m_output_prc;
     uint64_t m_global_seed = 0lu;
     uint64_t m_op_seed = 0lu;
-    std::pair<uint64_t, uint64_t> m_state {0lu, 0lu};
+    std::pair<uint64_t, uint64_t> m_state{0lu, 0lu};
 
     VectorDims m_out_shape = {};
     uint64_t m_out_el_num = 1lu;
@@ -115,6 +121,6 @@ class RandomUniform : public Node {
     std::shared_ptr<kernel::JitKernelBase> m_jit_kernel;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/range.cpp b/src/plugins/intel_cpu/src/nodes/range.cpp
index be441a6c11c0e9..574265a90449f0 100644
--- a/src/plugins/intel_cpu/src/nodes/range.cpp
+++ b/src/plugins/intel_cpu/src/nodes/range.cpp
@@ -2,12 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "range.h"
+
 #include <string>
-#include "openvino/opsets/opset1.hpp"
+
 #include "openvino/core/parallel.hpp"
-#include "range.h"
-#include "utils/general_utils.h"
+#include "openvino/opsets/opset1.hpp"
 #include "shape_inference/shape_inference_internal_dyn.hpp"
+#include "utils/general_utils.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -15,7 +17,9 @@ namespace node {
 
 bool Range::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
-        if (!one_of(op->get_type_info(), ov::op::v0::Range::get_type_info_static(), ov::op::v4::Range::get_type_info_static())) {
+        if (!one_of(op->get_type_info(),
+                    ov::op::v0::Range::get_type_info_static(),
+                    ov::op::v4::Range::get_type_info_static())) {
             errorMessage = "Only opset1 and opset4 Range operation is supported";
             return false;
         }
@@ -62,13 +66,13 @@ void Range::initSupportedPrimitiveDescriptors() {
     std::vector<PortConfigurator> outDataConf;
 
     if (!(getOriginalInputPrecisionAtPort(RANGE_START) == ov::element::i32 &&
-            getOriginalInputPrecisionAtPort(RANGE_LIMIT) == ov::element::i32 &&
-            getOriginalInputPrecisionAtPort(RANGE_DELTA) == ov::element::i32 &&
-            getOriginalOutputPrecisionAtPort(0)     == ov::element::i32) &&
+          getOriginalInputPrecisionAtPort(RANGE_LIMIT) == ov::element::i32 &&
+          getOriginalInputPrecisionAtPort(RANGE_DELTA) == ov::element::i32 &&
+          getOriginalOutputPrecisionAtPort(0) == ov::element::i32) &&
         !(getOriginalInputPrecisionAtPort(RANGE_START) == ov::element::f32 &&
-            getOriginalInputPrecisionAtPort(RANGE_LIMIT) == ov::element::f32 &&
-            getOriginalInputPrecisionAtPort(RANGE_DELTA) == ov::element::f32 &&
-            getOriginalOutputPrecisionAtPort(0) == ov::element::f32)) {
+          getOriginalInputPrecisionAtPort(RANGE_LIMIT) == ov::element::f32 &&
+          getOriginalInputPrecisionAtPort(RANGE_DELTA) == ov::element::f32 &&
+          getOriginalOutputPrecisionAtPort(0) == ov::element::f32)) {
         inDataConf.reserve(inputShapes.size());
         for (size_t i = 0; i < inputShapes.size(); ++i)
             inDataConf.emplace_back(LayoutType::ncsp, ov::element::f32);
@@ -92,14 +96,14 @@ void Range::executeDynamicImpl(dnnl::stream strm) {
 void Range::execute(dnnl::stream strm) {
     StatusCode retcode = OK;
     switch (getParentEdgeAt(0)->getMemory().getDesc().getPrecision()) {
-        case ov::element::f32:
-            retcode = rangeKernel<float>();
-            break;
-        case ov::element::i32:
-            retcode = rangeKernel<int32_t>();
-            break;
-        default:
-            OPENVINO_THROW("Incorrect output precision. Only FP32 and I32 are supported!");
+    case ov::element::f32:
+        retcode = rangeKernel<float>();
+        break;
+    case ov::element::i32:
+        retcode = rangeKernel<int32_t>();
+        break;
+    default:
+        OPENVINO_THROW("Incorrect output precision. Only FP32 and I32 are supported!");
     }
     if (retcode == PARAMETER_MISMATCH) {
         std::string errorMsg = "Range indexes exceeds data tensor dimension";
@@ -108,7 +112,7 @@ void Range::execute(dnnl::stream strm) {
 }
 
 template <typename data_t>
-size_t Range::getWorkAmount(data_t *startPtr, data_t *stopPtr, data_t *stepPtr) const {
+size_t Range::getWorkAmount(data_t* startPtr, data_t* stopPtr, data_t* stepPtr) const {
     data_t start = 0, limit = 0, delta = 0;
     if (startPtr == nullptr)
         startPtr = &start;
@@ -135,7 +139,7 @@ Range::StatusCode Range::rangeKernel() {
     data_t start = 0, delta = 0;
     size_t work_amount_dst = getWorkAmount<data_t>(&start, nullptr, &delta);
     if (isDynamicNode()) {
-        VectorDims newOutputShape {work_amount_dst};
+        VectorDims newOutputShape{work_amount_dst};
         redefineOutputMemory({newOutputShape});
     }
     data_t* dst_data = getDstDataAtPortAs<data_t>(0);
@@ -154,6 +158,6 @@ bool Range::created() const {
     return getType() == Type::Range;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/range.h b/src/plugins/intel_cpu/src/nodes/range.h
index 49cf4dc532efd0..c11cf3ec3efc9c 100644
--- a/src/plugins/intel_cpu/src/nodes/range.h
+++ b/src/plugins/intel_cpu/src/nodes/range.h
@@ -14,12 +14,16 @@ class Range : public Node {
 public:
     Range(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
-    bool needPrepareParams() const override {return false;};
-    bool needShapeInfer() const override {return false;};
+    bool needPrepareParams() const override {
+        return false;
+    };
+    bool needShapeInfer() const override {
+        return false;
+    };
     void executeDynamicImpl(dnnl::stream strm) override;
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
@@ -41,6 +45,6 @@ class Range : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/rdft.cpp b/src/plugins/intel_cpu/src/nodes/rdft.cpp
index 4e506fb771277f..5220f037788123 100644
--- a/src/plugins/intel_cpu/src/nodes/rdft.cpp
+++ b/src/plugins/intel_cpu/src/nodes/rdft.cpp
@@ -2,22 +2,23 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "rdft.h"
+
+#include <cmath>
+#include <openvino/op/constant.hpp>
+#include <openvino/op/irdft.hpp>
+#include <openvino/op/rdft.hpp>
 #include <string>
 #include <vector>
-#include <cmath>
-#include "dnnl_extension_utils.h"
-#include "onednn/dnnl.h"
+
+#include "common/cpu_memcpy.h"
+#include "common/primitive_hashing_utils.hpp"
 #include "cpu/x64/cpu_isa_traits.hpp"
 #include "cpu/x64/jit_generator.hpp"
-#include "common/primitive_hashing_utils.hpp"
-
-#include "rdft.h"
+#include "dnnl_extension_utils.h"
+#include "onednn/dnnl.h"
 #include "openvino/core/parallel.hpp"
 #include "utils/general_utils.h"
-#include "common/cpu_memcpy.h"
-#include <openvino/op/rdft.hpp>
-#include <openvino/op/irdft.hpp>
-#include <openvino/op/constant.hpp>
 
 using namespace dnnl::impl;
 using namespace dnnl::impl::cpu::x64;
@@ -31,7 +32,6 @@ static constexpr size_t AXES_INDEX = 1;
 static constexpr size_t SIGNAL_SIZE_INDEX = 2;
 static constexpr double PI = 3.14159265358979323846;
 
-
 bool RDFT::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
         const bool isRDFT = is_type<const ov::op::v9::RDFT>(op);
@@ -55,7 +55,9 @@ static void normalizeAxes(std::vector<int>& axes, size_t rank) {
     }
 }
 
-static std::vector<int> getDefaultSignalSizes(const VectorDims& inputShape, const std::vector<int>& axes, bool inverse) {
+static std::vector<int> getDefaultSignalSizes(const VectorDims& inputShape,
+                                              const std::vector<int>& axes,
+                                              bool inverse) {
     std::vector<int> signalSizes;
     signalSizes.reserve(axes.size());
 
@@ -141,8 +143,8 @@ void RDFT::initSupportedPrimitiveDescriptors() {
         }
     }
 
-    std::vector<PortConfigurator> configurators({{LayoutType::ncsp, ov::element::f32},
-                                                 {LayoutType::ncsp, ov::element::i32}});
+    std::vector<PortConfigurator> configurators(
+        {{LayoutType::ncsp, ov::element::f32}, {LayoutType::ncsp, ov::element::i32}});
     if (inputShapes.size() > SIGNAL_SIZE_INDEX)
         configurators.push_back({LayoutType::ncsp, ov::element::i32});
 
@@ -163,11 +165,16 @@ void RDFT::execute(dnnl::stream strm) {
     const auto& inputStrides = inputMem.getDescWithType<BlockedMemoryDesc>()->getStrides();
     const auto& outputStrides = outputMem.getDescWithType<BlockedMemoryDesc>()->getStrides();
 
-    executor->execute(inputPtr, outputPtr,
-                      twiddles, rank,
-                      axes, signalSizes,
-                      inputShape, outputShape,
-                      inputStrides, outputStrides);
+    executor->execute(inputPtr,
+                      outputPtr,
+                      twiddles,
+                      rank,
+                      axes,
+                      signalSizes,
+                      inputShape,
+                      outputShape,
+                      inputStrides,
+                      outputStrides);
 }
 
 void RDFT::executeDynamicImpl(dnnl::stream strm) {
@@ -303,29 +310,57 @@ static void adjustInputSize(VectorDims& inputShape,
     }
 }
 
-void RDFTExecutor::execute(float* inputPtr, float* outputPtr,
+void RDFTExecutor::execute(float* inputPtr,
+                           float* outputPtr,
                            const std::vector<std::vector<float>>& twiddles,
-                           size_t rank, const std::vector<int>& axes,
+                           size_t rank,
+                           const std::vector<int>& axes,
                            std::vector<int> signalSizes,
-                           VectorDims inputShape, const VectorDims& outputShape,
-                           const VectorDims& inputStrides, const VectorDims& outputStrides) {
+                           VectorDims inputShape,
+                           const VectorDims& outputShape,
+                           const VectorDims& inputStrides,
+                           const VectorDims& outputStrides) {
     adjustInputSize(inputShape, signalSizes, outputShape, axes, isInverse);
 
     if (rank == 1) {
         auto twiddlesPtr = twiddles[0].data();
-        dftCommon(inputPtr, twiddlesPtr, outputPtr,
-                   inputShape[0], signalSizes[0], outputShape[0],
-                   isInverse ? complex_to_real : real_to_complex,
-                   canUseFFT(signalSizes[0]), false);
+        dftCommon(inputPtr,
+                  twiddlesPtr,
+                  outputPtr,
+                  inputShape[0],
+                  signalSizes[0],
+                  outputShape[0],
+                  isInverse ? complex_to_real : real_to_complex,
+                  canUseFFT(signalSizes[0]),
+                  false);
     } else {
         if (!isInverse)
-            rdftNd(inputPtr, outputPtr, twiddles, axes, signalSizes, inputShape, inputStrides, outputShape, outputStrides);
+            rdftNd(inputPtr,
+                   outputPtr,
+                   twiddles,
+                   axes,
+                   signalSizes,
+                   inputShape,
+                   inputStrides,
+                   outputShape,
+                   outputStrides);
         else
-            irdftNd(inputPtr, outputPtr, twiddles, axes, signalSizes, inputShape, inputStrides, outputShape, outputStrides);
+            irdftNd(inputPtr,
+                    outputPtr,
+                    twiddles,
+                    axes,
+                    signalSizes,
+                    inputShape,
+                    inputStrides,
+                    outputShape,
+                    outputStrides);
     }
 }
 
-static void coordsFromIndex(size_t index, std::vector<size_t>& coords, const std::vector<size_t>& shape, int excludeAxis) {
+static void coordsFromIndex(size_t index,
+                            std::vector<size_t>& coords,
+                            const std::vector<size_t>& shape,
+                            int excludeAxis) {
     for (size_t i = coords.size(); i > 0; i--) {
         if (static_cast<size_t>(excludeAxis) == i - 1) {
             coords[i - 1] = 0;
@@ -344,9 +379,12 @@ static size_t getOffset(const std::vector<size_t>& coords, const std::vector<siz
     return offset;
 }
 
-static void gatherReal(float* output, const float* input, size_t axis,
-                        const std::vector<size_t>& coords,
-                        size_t size, const std::vector<size_t>& strides) {
+static void gatherReal(float* output,
+                       const float* input,
+                       size_t axis,
+                       const std::vector<size_t>& coords,
+                       size_t size,
+                       const std::vector<size_t>& strides) {
     size_t inputOffset = getOffset(coords, strides);
 
     for (size_t i = 0; i < size; i++) {
@@ -355,9 +393,12 @@ static void gatherReal(float* output, const float* input, size_t axis,
     }
 }
 
-static void gatherComplex(float* output, const float* input, size_t axis,
-                                     const std::vector<size_t>& coords,
-                                     size_t size, const std::vector<size_t>& strides) {
+static void gatherComplex(float* output,
+                          const float* input,
+                          size_t axis,
+                          const std::vector<size_t>& coords,
+                          size_t size,
+                          const std::vector<size_t>& strides) {
     size_t inputOffset = getOffset(coords, strides);
 
     for (size_t i = 0; i < 2 * size; i += 2) {
@@ -367,9 +408,12 @@ static void gatherComplex(float* output, const float* input, size_t axis,
     }
 }
 
-static void scatterReal(float* output, const float* input, size_t axis,
-                         const std::vector<size_t>& coords,
-                         size_t size, const std::vector<size_t>& strides) {
+static void scatterReal(float* output,
+                        const float* input,
+                        size_t axis,
+                        const std::vector<size_t>& coords,
+                        size_t size,
+                        const std::vector<size_t>& strides) {
     size_t offset = getOffset(coords, strides);
 
     for (size_t i = 0; i < size; i++) {
@@ -378,9 +422,12 @@ static void scatterReal(float* output, const float* input, size_t axis,
     }
 }
 
-static void scatterComplex(float* output, const float* input, size_t axis,
-                            const std::vector<size_t>& coords,
-                            size_t size, const std::vector<size_t>& strides) {
+static void scatterComplex(float* output,
+                           const float* input,
+                           size_t axis,
+                           const std::vector<size_t>& coords,
+                           size_t size,
+                           const std::vector<size_t>& strides) {
     size_t offset = getOffset(coords, strides);
 
     for (size_t i = 0; i < 2 * size; i += 2) {
@@ -407,15 +454,15 @@ static void fftCopyInverseInputData(float* dst, float* src, size_t inputSize, si
             dst[2 * i + 1] = -src[1];
         }
     } else {
-        parallel_for(signalSize, [&] (size_t i) {
-                if (i < inputSize) {
-                    dst[2 * i] = src[2 * i];
-                    dst[2 * i + 1] = src[2 * i + 1];
-                } else {
-                    size_t src_idx = 2 * inputSize - 2 - i;
-                    dst[2 * i] = src[2 * src_idx];
-                    dst[2 * i + 1] = -src[2 * src_idx + 1];
-                }
+        parallel_for(signalSize, [&](size_t i) {
+            if (i < inputSize) {
+                dst[2 * i] = src[2 * i];
+                dst[2 * i + 1] = src[2 * i + 1];
+            } else {
+                size_t src_idx = 2 * inputSize - 2 - i;
+                dst[2 * i] = src[2 * src_idx];
+                dst[2 * i + 1] = -src[2 * src_idx + 1];
+            }
         });
     }
 }
@@ -427,7 +474,7 @@ static void fftCopyRealInputData(float* dst, float* src, size_t inputSize, bool
             dst[2 * i + 1] = 0;
         }
     } else {
-        parallel_for(inputSize, [&] (size_t i) {
+        parallel_for(inputSize, [&](size_t i) {
             dst[2 * i] = src[i];
             dst[2 * i + 1] = 0;
         });
@@ -440,15 +487,20 @@ static void fftCopyInverseRealOutput(float* dst, float* src, size_t signalSize,
             dst[i] = src[2 * i];
         }
     } else {
-        parallel_for(signalSize, [&] (size_t i) {
+        parallel_for(signalSize, [&](size_t i) {
             dst[i] = src[2 * i];
         });
     }
 }
 
-void RDFTExecutor::fft(float* input, const float* twiddlesPtr, float* output,
-                       size_t inputSize, size_t signalSize, size_t outputSize,
-                       enum dft_type type, bool parallelize) {
+void RDFTExecutor::fft(float* input,
+                       const float* twiddlesPtr,
+                       float* output,
+                       size_t inputSize,
+                       size_t signalSize,
+                       size_t outputSize,
+                       enum dft_type type,
+                       bool parallelize) {
     std::vector<float> scratchSpace(4 * signalSize, 0);
 
     float* inputPtr = input;
@@ -465,7 +517,7 @@ void RDFTExecutor::fft(float* input, const float* twiddlesPtr, float* output,
     size_t numBlocks = 0;
     size_t blockSize = 0;
 
-    auto blockIteration = [&] (size_t block) {
+    auto blockIteration = [&](size_t block) {
         size_t inputOffset = block * blockSize;
         size_t outputOffset = block * blockSize / 2;
         float cos = twiddlesPtr[2 * block];
@@ -515,38 +567,48 @@ void RDFTExecutor::fft(float* input, const float* twiddlesPtr, float* output,
     }
 }
 
-void RDFTExecutor::dftCommon(float* inputPtr, const float* twiddlesPtr, float* outputPtr,
-                              size_t inputSize, size_t signalSize, size_t outputSize,
-                              enum dft_type type, bool useFFT, bool parallelize) {
+void RDFTExecutor::dftCommon(float* inputPtr,
+                             const float* twiddlesPtr,
+                             float* outputPtr,
+                             size_t inputSize,
+                             size_t signalSize,
+                             size_t outputSize,
+                             enum dft_type type,
+                             bool useFFT,
+                             bool parallelize) {
     if (useFFT) {
-        fft(inputPtr, twiddlesPtr, outputPtr,
-            inputSize, signalSize, outputSize,
-            type, parallelize);
+        fft(inputPtr, twiddlesPtr, outputPtr, inputSize, signalSize, outputSize, type, parallelize);
     } else {
-        dft(inputPtr, twiddlesPtr, outputPtr,
-            inputSize, signalSize, outputSize,
-            type, parallelize);
+        dft(inputPtr, twiddlesPtr, outputPtr, inputSize, signalSize, outputSize, type, parallelize);
     }
 }
 
 void RDFTExecutor::dftOnAxis(enum dft_type type,
-                               float* inputPtr, float* outputPtr,
-                               const float* twiddlesPtr, int axis,
-                               size_t signalSize,
-                               const VectorDims& inputShape,
-                               const VectorDims& inputStrides,
-                               const VectorDims& outputShape,
-                               const VectorDims& outputStrides,
-                               const std::vector<size_t>& iterationRange) {
+                             float* inputPtr,
+                             float* outputPtr,
+                             const float* twiddlesPtr,
+                             int axis,
+                             size_t signalSize,
+                             const VectorDims& inputShape,
+                             const VectorDims& inputStrides,
+                             const VectorDims& outputShape,
+                             const VectorDims& outputStrides,
+                             const std::vector<size_t>& iterationRange) {
     size_t inputSize = inputShape[axis];
     size_t outputSize = outputShape[axis];
 
-    void (*gather)(float* output, const float* input,
-                   size_t axis, const std::vector<size_t>& coords,
-                   size_t size, const std::vector<size_t>& strides) = nullptr;
-    void (*scatter)(float* output, const float* input,
-                    size_t axis, const std::vector<size_t>& coords,
-                    size_t size, const std::vector<size_t>& strides) = nullptr;
+    void (*gather)(float* output,
+                   const float* input,
+                   size_t axis,
+                   const std::vector<size_t>& coords,
+                   size_t size,
+                   const std::vector<size_t>& strides) = nullptr;
+    void (*scatter)(float* output,
+                    const float* input,
+                    size_t axis,
+                    const std::vector<size_t>& coords,
+                    size_t size,
+                    const std::vector<size_t>& strides) = nullptr;
 
     size_t gatherSize = 0;
     size_t scatterSize = 0;
@@ -574,24 +636,27 @@ void RDFTExecutor::dftOnAxis(enum dft_type type,
 
     bool useFFT = canUseFFT(signalSize);
 
-    size_t totalWorkSize = std::accumulate(iterationRange.begin(),
-                                           iterationRange.end(),
-                                           1, std::multiplies<size_t>()) / iterationRange[axis];
+    size_t totalWorkSize = std::accumulate(iterationRange.begin(), iterationRange.end(), 1, std::multiplies<size_t>()) /
+                           iterationRange[axis];
     bool parallelizeOuterAxes = totalWorkSize > signalSize;
 
     if (parallelizeOuterAxes) {
-        parallel_for(totalWorkSize, [&] (size_t i) {
+        parallel_for(totalWorkSize, [&](size_t i) {
             std::vector<size_t> coords(iterationRange.size(), 0);
             std::vector<float> gatherScatterBuffer(gatherSize + scatterSize);
             float* gatherBuffer = &gatherScatterBuffer[0];
             float* scatterBuffer = &gatherScatterBuffer[gatherSize];
             coordsFromIndex(i, coords, iterationRange, axis);
-            gather(gatherBuffer, inputPtr,
-                   axis, coords,
-                   inputSize, inputStrides);
-            dftCommon(gatherBuffer, twiddlesPtr, scatterBuffer,
-                       inputSize, signalSize, outputSize,
-                       type, useFFT, !parallelizeOuterAxes);
+            gather(gatherBuffer, inputPtr, axis, coords, inputSize, inputStrides);
+            dftCommon(gatherBuffer,
+                      twiddlesPtr,
+                      scatterBuffer,
+                      inputSize,
+                      signalSize,
+                      outputSize,
+                      type,
+                      useFFT,
+                      !parallelizeOuterAxes);
             scatter(outputPtr, scatterBuffer, axis, coords, outputSize, outputStrides);
         });
     } else {
@@ -601,19 +666,24 @@ void RDFTExecutor::dftOnAxis(enum dft_type type,
         float* scatterBuffer = &gatherScatterBuffer[gatherSize];
         for (size_t i = 0; i < totalWorkSize; i++) {
             coordsFromIndex(i, coords, iterationRange, axis);
-            gather(gatherBuffer, inputPtr,
-                   axis, coords,
-                   inputSize, inputStrides);
-            dftCommon(gatherBuffer, twiddlesPtr, scatterBuffer,
-                       inputSize, signalSize, outputSize,
-                       type, useFFT, !parallelizeOuterAxes);
+            gather(gatherBuffer, inputPtr, axis, coords, inputSize, inputStrides);
+            dftCommon(gatherBuffer,
+                      twiddlesPtr,
+                      scatterBuffer,
+                      inputSize,
+                      signalSize,
+                      outputSize,
+                      type,
+                      useFFT,
+                      !parallelizeOuterAxes);
             scatter(outputPtr, scatterBuffer, axis, coords, outputSize, outputStrides);
         }
     }
 }
 
 // N-dimensional real DFT
-void RDFTExecutor::rdftNd(float* inputPtr, float* outputPtr,
+void RDFTExecutor::rdftNd(float* inputPtr,
+                          float* outputPtr,
                           const std::vector<std::vector<float>>& twiddles,
                           const std::vector<int>& axes,
                           const std::vector<int>& signalSizes,
@@ -623,27 +693,38 @@ void RDFTExecutor::rdftNd(float* inputPtr, float* outputPtr,
                           const VectorDims& outputStrides) {
     const std::vector<size_t> iterationRange(outputShape.begin(), outputShape.end() - 1);
 
-    dftOnAxis(real_to_complex, inputPtr, outputPtr,
-                twiddles.back().data(), axes.back(),
-                signalSizes.back(),
-                inputShape, inputStrides,
-                outputShape, outputStrides,
-                iterationRange);
+    dftOnAxis(real_to_complex,
+              inputPtr,
+              outputPtr,
+              twiddles.back().data(),
+              axes.back(),
+              signalSizes.back(),
+              inputShape,
+              inputStrides,
+              outputShape,
+              outputStrides,
+              iterationRange);
     inputPtr = outputPtr;
 
     for (size_t i = 0; i < axes.size() - 1; i++) {
         auto axis = axes[i];
-        dftOnAxis(complex_to_complex, inputPtr, outputPtr,
-                    twiddles[i].data(), axis,
-                    signalSizes[i],
-                    outputShape, outputStrides,
-                    outputShape, outputStrides,
-                    iterationRange);
+        dftOnAxis(complex_to_complex,
+                  inputPtr,
+                  outputPtr,
+                  twiddles[i].data(),
+                  axis,
+                  signalSizes[i],
+                  outputShape,
+                  outputStrides,
+                  outputShape,
+                  outputStrides,
+                  iterationRange);
     }
 }
 
 // N-dimensional real inverse DFT
-void RDFTExecutor::irdftNd(float* inputPtr, float* outputPtr,
+void RDFTExecutor::irdftNd(float* inputPtr,
+                           float* outputPtr,
                            const std::vector<std::vector<float>>& twiddles,
                            const std::vector<int>& axes,
                            const std::vector<int>& signalSizes,
@@ -654,12 +735,17 @@ void RDFTExecutor::irdftNd(float* inputPtr, float* outputPtr,
     const std::vector<size_t> iterationRange(inputShape.begin(), inputShape.end() - 1);
 
     if (axes.size() == 1) {
-        dftOnAxis(complex_to_real, inputPtr, outputPtr,
-                    twiddles[0].data(), axes[0],
-                    signalSizes[0],
-                    inputShape, originalInputStrides,
-                    outputShape, outputStrides,
-                    iterationRange);
+        dftOnAxis(complex_to_real,
+                  inputPtr,
+                  outputPtr,
+                  twiddles[0].data(),
+                  axes[0],
+                  signalSizes[0],
+                  inputShape,
+                  originalInputStrides,
+                  outputShape,
+                  outputStrides,
+                  iterationRange);
         return;
     }
 
@@ -680,20 +766,30 @@ void RDFTExecutor::irdftNd(float* inputPtr, float* outputPtr,
 
     for (size_t i = 0; i < axes.size() - 1; i++) {
         auto axis = axes[i];
-        dftOnAxis(complex_to_complex, inputPtr, output,
-                    twiddles[i].data(), axis,
-                    signalSizes[i],
-                    inputShape, originalInputStrides,
-                    inputShape, inputStrides,
-                    iterationRange);
+        dftOnAxis(complex_to_complex,
+                  inputPtr,
+                  output,
+                  twiddles[i].data(),
+                  axis,
+                  signalSizes[i],
+                  inputShape,
+                  originalInputStrides,
+                  inputShape,
+                  inputStrides,
+                  iterationRange);
         inputPtr = output;
     }
-    dftOnAxis(complex_to_real, inputPtr, outputPtr,
-                twiddles.back().data(), axes.back(),
-                signalSizes.back(),
-                inputShape, inputStrides,
-                outputShape, outputStrides,
-                iterationRange);
+    dftOnAxis(complex_to_real,
+              inputPtr,
+              outputPtr,
+              twiddles.back().data(),
+              axes.back(),
+              signalSizes.back(),
+              inputShape,
+              inputStrides,
+              outputShape,
+              outputStrides,
+              iterationRange);
 }
 
 std::vector<float> RDFTExecutor::generateTwiddlesFFT(size_t N) {
@@ -708,8 +804,10 @@ std::vector<float> RDFTExecutor::generateTwiddlesFFT(size_t N) {
     return twiddles;
 }
 
-std::vector<float> RDFTExecutor::generateTwiddlesCommon(size_t signalSize, size_t outputSize,
-                                                          enum dft_type type, bool useFFT) {
+std::vector<float> RDFTExecutor::generateTwiddlesCommon(size_t signalSize,
+                                                        size_t outputSize,
+                                                        enum dft_type type,
+                                                        bool useFFT) {
     if (useFFT) {
         return generateTwiddlesFFT(signalSize);
     }
@@ -765,10 +863,10 @@ struct RDFTJitExecutor : public RDFTExecutor {
         std::vector<float> twiddles(inputSize * outputSize * 2);
         int simdSize = vlen / sizeof(float);
         if (type == real_to_complex) {
-            simdSize /= 2; // there are two floats per one complex element in the output
+            simdSize /= 2;  // there are two floats per one complex element in the output
         }
 
-        parallel_for2d(outputSize / simdSize, inputSize, [&] (size_t K, size_t n) {
+        parallel_for2d(outputSize / simdSize, inputSize, [&](size_t K, size_t n) {
             if (type == real_to_complex) {
                 for (int k = 0; k < simdSize; k++) {
                     double angle = 2 * PI * (K * simdSize + k) * n / inputSize;
@@ -782,13 +880,14 @@ struct RDFTJitExecutor : public RDFTExecutor {
                 }
                 for (int k = 0; k < simdSize; k++) {
                     double angle = 2 * PI * (K * simdSize + k) * n / inputSize;
-                    twiddles[((K * inputSize + n) * 2 + 1) * simdSize + k] = isInverse ? std::sin(angle) : -std::sin(angle);
+                    twiddles[((K * inputSize + n) * 2 + 1) * simdSize + k] =
+                        isInverse ? std::sin(angle) : -std::sin(angle);
                 }
             }
         });
         if ((outputSize % simdSize) != 0) {
             size_t start = (outputSize / simdSize) * simdSize;
-            parallel_for2d(outputSize - start, inputSize, [&] (size_t k, size_t n) {
+            parallel_for2d(outputSize - start, inputSize, [&](size_t k, size_t n) {
                 k += start;
                 double angle = 2 * PI * k * n / inputSize;
                 twiddles[2 * (k * inputSize + n)] = std::cos(angle);
@@ -798,40 +897,34 @@ struct RDFTJitExecutor : public RDFTExecutor {
         return twiddles;
     }
 
-    void dft(float* inputPtr, const float* twiddlesPtr, float* outputPtr,
-             size_t inputSize, size_t signalSize, size_t outputSize,
-             enum dft_type type, bool parallelize) override {
+    void dft(float* inputPtr,
+             const float* twiddlesPtr,
+             float* outputPtr,
+             size_t inputSize,
+             size_t signalSize,
+             size_t outputSize,
+             enum dft_type type,
+             bool parallelize) override {
         jit_dft_kernel* kernel = type == complex_to_complex ? dftKernel.get() : rdftKernel.get();
         if (parallelize) {
             const int cachelineSize = 64;
             size_t blockSize = 4 * cachelineSize / sizeof(float);
             size_t numBlocks = (outputSize + blockSize - 1) / blockSize;
-            parallel_nt(numBlocks, [&] (size_t i, size_t nthr) {
+            parallel_nt(numBlocks, [&](size_t i, size_t nthr) {
                 if (numBlocks > nthr) {
                     auto newBlockSize = (((outputSize / nthr) + blockSize - 1) / blockSize) * blockSize;
                     blockSize = newBlockSize;
                     numBlocks = nthr;
                 }
                 jit_dft_args args{};
-                args.input = inputPtr,
-                args.twiddles = twiddlesPtr,
-                args.output = outputPtr,
-                args.input_size = inputSize,
-                args.signal_size = signalSize,
-                args.output_start = i * blockSize,
-                args.output_end = std::min(outputSize - i * blockSize, blockSize),
-                (*kernel)(&args);
+                args.input = inputPtr, args.twiddles = twiddlesPtr, args.output = outputPtr,
+                args.input_size = inputSize, args.signal_size = signalSize, args.output_start = i * blockSize,
+                args.output_end = std::min(outputSize - i * blockSize, blockSize), (*kernel)(&args);
             });
         } else {
             jit_dft_args args{};
-            args.input = inputPtr,
-            args.twiddles = twiddlesPtr,
-            args.output = outputPtr,
-            args.input_size = inputSize,
-            args.signal_size = signalSize,
-            args.output_start = 0,
-            args.output_end = outputSize,
-            (*kernel)(&args);
+            args.input = inputPtr, args.twiddles = twiddlesPtr, args.output = outputPtr, args.input_size = inputSize,
+            args.signal_size = signalSize, args.output_start = 0, args.output_end = outputSize, (*kernel)(&args);
         }
     }
 
@@ -845,122 +938,141 @@ struct RDFTJitExecutor : public RDFTExecutor {
 struct RDFTRefExecutor : public RDFTExecutor {
     RDFTRefExecutor(bool inverse) : RDFTExecutor(inverse) {}
 
-    private:
-        std::vector<float> generateTwiddlesDFT(size_t inputSize, size_t outputSize, enum dft_type type) override {
-            std::vector<float> twiddles(inputSize * outputSize * 2);
-            parallel_for2d(outputSize, inputSize, [&] (size_t k, size_t n) {
-                double angle = 2 * PI * k * n / inputSize;
-                if (!isInverse)
-                    angle = -angle;
-                twiddles[(k * inputSize + n) * 2] = std::cos(angle);
-                twiddles[(k * inputSize + n) * 2 + 1] = std::sin(angle);
-            });
-            return twiddles;
-        }
+private:
+    std::vector<float> generateTwiddlesDFT(size_t inputSize, size_t outputSize, enum dft_type type) override {
+        std::vector<float> twiddles(inputSize * outputSize * 2);
+        parallel_for2d(outputSize, inputSize, [&](size_t k, size_t n) {
+            double angle = 2 * PI * k * n / inputSize;
+            if (!isInverse)
+                angle = -angle;
+            twiddles[(k * inputSize + n) * 2] = std::cos(angle);
+            twiddles[(k * inputSize + n) * 2 + 1] = std::sin(angle);
+        });
+        return twiddles;
+    }
 
-        void dftRealToComplex(float* inputPtr, const float* twiddlesPtr, float* outputPtr,
-                     size_t inputSize, size_t outputSize, bool parallelize) {
-            auto dftIteration = [&] (size_t k) {
-                float real = 0, imag = 0;
-                for (size_t n = 0; n < inputSize; n++) {
-                    float cos = twiddlesPtr[2 * (k * inputSize + n)];
-                    float sin = twiddlesPtr[2 * (k * inputSize + n) + 1];
-                    real += inputPtr[n] * cos;
-                    imag += inputPtr[n] * sin;
-                }
-                outputPtr[2 * k] = real;
-                outputPtr[2 * k + 1] = imag;
-            };
-            if (parallelize) {
-                parallel_for(outputSize, dftIteration);
-            } else {
-                for (size_t k = 0; k < outputSize; k++) {
-                    dftIteration(k);
-                }
+    void dftRealToComplex(float* inputPtr,
+                          const float* twiddlesPtr,
+                          float* outputPtr,
+                          size_t inputSize,
+                          size_t outputSize,
+                          bool parallelize) {
+        auto dftIteration = [&](size_t k) {
+            float real = 0, imag = 0;
+            for (size_t n = 0; n < inputSize; n++) {
+                float cos = twiddlesPtr[2 * (k * inputSize + n)];
+                float sin = twiddlesPtr[2 * (k * inputSize + n) + 1];
+                real += inputPtr[n] * cos;
+                imag += inputPtr[n] * sin;
+            }
+            outputPtr[2 * k] = real;
+            outputPtr[2 * k + 1] = imag;
+        };
+        if (parallelize) {
+            parallel_for(outputSize, dftIteration);
+        } else {
+            for (size_t k = 0; k < outputSize; k++) {
+                dftIteration(k);
             }
         }
+    }
 
-        void dftComplexToComplex(float* inputPtr, const float* twiddlesPtr, float* outputPtr,
-                     size_t inputSize, size_t signalSize, size_t outputSize, bool parallelize) {
-            auto dftIteration = [&] (size_t k) {
-                float real = 0, imag = 0;
-                for (size_t n = 0; n < inputSize; n++) {
+    void dftComplexToComplex(float* inputPtr,
+                             const float* twiddlesPtr,
+                             float* outputPtr,
+                             size_t inputSize,
+                             size_t signalSize,
+                             size_t outputSize,
+                             bool parallelize) {
+        auto dftIteration = [&](size_t k) {
+            float real = 0, imag = 0;
+            for (size_t n = 0; n < inputSize; n++) {
+                float cos = twiddlesPtr[2 * (k * outputSize + n)];
+                float sin = twiddlesPtr[2 * (k * outputSize + n) + 1];
+                float inputReal = inputPtr[2 * n];
+                float inputImag = inputPtr[2 * n + 1];
+                real += inputReal * cos - inputImag * sin;
+                imag += inputImag * cos + inputReal * sin;
+            }
+            if (isInverse) {
+                float* inp = inputPtr + 2 * (inputSize - 2 + outputSize % 2);
+                for (size_t n = inputSize; n < signalSize; n++, inp -= 2) {
                     float cos = twiddlesPtr[2 * (k * outputSize + n)];
                     float sin = twiddlesPtr[2 * (k * outputSize + n) + 1];
-                    float inputReal = inputPtr[2 * n];
-                    float inputImag = inputPtr[2 * n + 1];
+                    float inputReal = inp[0];
+                    float inputImag = -inp[1];
                     real += inputReal * cos - inputImag * sin;
                     imag += inputImag * cos + inputReal * sin;
                 }
-                if (isInverse) {
-                    float* inp = inputPtr + 2 * (inputSize - 2 + outputSize % 2);
-                    for (size_t n = inputSize; n < signalSize; n++, inp -= 2) {
-                        float cos = twiddlesPtr[2 * (k * outputSize + n)];
-                        float sin = twiddlesPtr[2 * (k * outputSize + n) + 1];
-                        float inputReal = inp[0];
-                        float inputImag = -inp[1];
-                        real += inputReal * cos - inputImag * sin;
-                        imag += inputImag * cos + inputReal * sin;
-                    }
-                    real /= outputSize;
-                    imag /= outputSize;
-                }
-                outputPtr[2 * k] = real;
-                outputPtr[2 * k + 1] = imag;
-            };
-            if (parallelize) {
-                parallel_for(outputSize, dftIteration);
-            } else {
-                for (size_t k = 0; k < outputSize; k++) {
-                    dftIteration(k);
-                }
+                real /= outputSize;
+                imag /= outputSize;
+            }
+            outputPtr[2 * k] = real;
+            outputPtr[2 * k + 1] = imag;
+        };
+        if (parallelize) {
+            parallel_for(outputSize, dftIteration);
+        } else {
+            for (size_t k = 0; k < outputSize; k++) {
+                dftIteration(k);
             }
         }
+    }
 
-        void dftComplexToReal(float* inputPtr, const float* twiddlesPtr, float* outputPtr,
-                     size_t inputSize, size_t signalSize, size_t outputSize, bool parallelize) {
-            auto dftIteration = [&] (size_t k) {
-                float real = 0;
-                for (size_t n = 0; n < inputSize; n++) {
+    void dftComplexToReal(float* inputPtr,
+                          const float* twiddlesPtr,
+                          float* outputPtr,
+                          size_t inputSize,
+                          size_t signalSize,
+                          size_t outputSize,
+                          bool parallelize) {
+        auto dftIteration = [&](size_t k) {
+            float real = 0;
+            for (size_t n = 0; n < inputSize; n++) {
+                float cos = twiddlesPtr[2 * (k * outputSize + n)];
+                float sin = twiddlesPtr[2 * (k * outputSize + n) + 1];
+                float inputReal = inputPtr[2 * n];
+                float inputImag = inputPtr[2 * n + 1];
+                real += inputReal * cos - inputImag * sin;
+            }
+            if (isInverse) {
+                float* inp = inputPtr + 2 * (inputSize - 2 + outputSize % 2);
+                for (size_t n = inputSize; n < signalSize; n++, inp -= 2) {
                     float cos = twiddlesPtr[2 * (k * outputSize + n)];
                     float sin = twiddlesPtr[2 * (k * outputSize + n) + 1];
-                    float inputReal = inputPtr[2 * n];
-                    float inputImag = inputPtr[2 * n + 1];
-                    real += inputReal * cos - inputImag * sin;
-                }
-                if (isInverse) {
-                    float* inp = inputPtr + 2 * (inputSize - 2 + outputSize % 2);
-                    for (size_t n = inputSize; n < signalSize; n++, inp -= 2) {
-                        float cos = twiddlesPtr[2 * (k * outputSize + n)];
-                        float sin = twiddlesPtr[2 * (k * outputSize + n) + 1];
-                        float inputReal = inp[0];
-                        float inputImag = inp[1];
-                        real += inputReal * cos + inputImag * sin;
-                    }
-                    real /= outputSize;
-                }
-                outputPtr[k] = real;
-            };
-            if (parallelize) {
-                parallel_for(outputSize, dftIteration);
-            } else {
-                for (size_t k = 0; k < outputSize; k++) {
-                    dftIteration(k);
+                    float inputReal = inp[0];
+                    float inputImag = inp[1];
+                    real += inputReal * cos + inputImag * sin;
                 }
+                real /= outputSize;
+            }
+            outputPtr[k] = real;
+        };
+        if (parallelize) {
+            parallel_for(outputSize, dftIteration);
+        } else {
+            for (size_t k = 0; k < outputSize; k++) {
+                dftIteration(k);
             }
         }
+    }
 
-        void dft(float* inputPtr, const float* twiddlesPtr, float* outputPtr,
-                 size_t inputSize, size_t signalSize, size_t outputSize,
-                 enum dft_type type, bool parallelize) override {
-            if (type == real_to_complex) {
-                dftRealToComplex(inputPtr, twiddlesPtr, outputPtr, inputSize, outputSize, parallelize);
-            } else if (type == complex_to_complex) {
-                dftComplexToComplex(inputPtr, twiddlesPtr, outputPtr, inputSize, signalSize, outputSize, parallelize);
-            } else if (type == complex_to_real) {
-                dftComplexToReal(inputPtr, twiddlesPtr, outputPtr, inputSize, signalSize, outputSize, parallelize);
-            }
+    void dft(float* inputPtr,
+             const float* twiddlesPtr,
+             float* outputPtr,
+             size_t inputSize,
+             size_t signalSize,
+             size_t outputSize,
+             enum dft_type type,
+             bool parallelize) override {
+        if (type == real_to_complex) {
+            dftRealToComplex(inputPtr, twiddlesPtr, outputPtr, inputSize, outputSize, parallelize);
+        } else if (type == complex_to_complex) {
+            dftComplexToComplex(inputPtr, twiddlesPtr, outputPtr, inputSize, signalSize, outputSize, parallelize);
+        } else if (type == complex_to_real) {
+            dftComplexToReal(inputPtr, twiddlesPtr, outputPtr, inputSize, signalSize, outputSize, parallelize);
         }
+    }
 };
 
 struct RDFTKey {
@@ -983,7 +1095,7 @@ void RDFT::createPrimitive() {
     RDFTKey key{};
     key.isInverse = inverse;
 
-    auto buildExecutor = [&] (const RDFTKey& key) -> std::shared_ptr<RDFTExecutor> {
+    auto buildExecutor = [&](const RDFTKey& key) -> std::shared_ptr<RDFTExecutor> {
         std::shared_ptr<RDFTExecutor> executor;
         NodeDesc* primDesc = getSelectedPrimitiveDescriptor();
 #if defined(OPENVINO_ARCH_X86_64)
@@ -1003,6 +1115,6 @@ void RDFT::createPrimitive() {
 
     Node::createPrimitive();
 }
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/rdft.h b/src/plugins/intel_cpu/src/nodes/rdft.h
index d834900f92d3fb..fccd6500a50f7c 100644
--- a/src/plugins/intel_cpu/src/nodes/rdft.h
+++ b/src/plugins/intel_cpu/src/nodes/rdft.h
@@ -12,63 +12,86 @@ namespace intel_cpu {
 namespace node {
 
 struct RDFTExecutor {
-    public:
-        RDFTExecutor(bool inverse) : isInverse(inverse) {}
-        virtual ~RDFTExecutor() = default;
-        void execute(float* inputPtr, float* outputPtr,
-                     const std::vector<std::vector<float>>& twiddles,
-                     size_t rank, const std::vector<int>& axes,
-                     std::vector<int> signalSizes,
-                     VectorDims inputShape, const VectorDims& outputShape,
-                     const VectorDims& inputStrides, const VectorDims& outputStrides);
+public:
+    RDFTExecutor(bool inverse) : isInverse(inverse) {}
+    virtual ~RDFTExecutor() = default;
+    void execute(float* inputPtr,
+                 float* outputPtr,
+                 const std::vector<std::vector<float>>& twiddles,
+                 size_t rank,
+                 const std::vector<int>& axes,
+                 std::vector<int> signalSizes,
+                 VectorDims inputShape,
+                 const VectorDims& outputShape,
+                 const VectorDims& inputStrides,
+                 const VectorDims& outputStrides);
 
-        std::vector<std::vector<float>> generateTwiddles(const std::vector<int>& signalSizes,
-                                                         const std::vector<size_t>& outputShape,
-                                                         const std::vector<int>& axes);
+    std::vector<std::vector<float>> generateTwiddles(const std::vector<int>& signalSizes,
+                                                     const std::vector<size_t>& outputShape,
+                                                     const std::vector<int>& axes);
 
-    protected:
-        bool isInverse;
+protected:
+    bool isInverse;
 
-    private:
-        virtual bool canUseFFT(size_t dim);
-        virtual void dft(float* inputPtr, const float* twiddlesPtr, float* outputPtr,
-                         size_t inputSize, size_t signalSize, size_t outputSize,
-                         enum dft_type type, bool parallelize) = 0;
-        virtual void fft(float* input, const float* twiddlesPtr, float* output,
-                         size_t inputSize, size_t signalSize, size_t outputSize,
-                         enum dft_type type, bool parallelize);
-        void dftCommon(float* inputPtr, const float* twiddlesPtr, float* outputPtr,
-                        size_t inputSize, size_t signalSize, size_t outputSize,
-                        enum dft_type type, bool useFFT, bool parallelize);
-        void dftOnAxis(enum dft_type type,
-                         float* inputPtr, float* outputPtr,
-                         const float* twiddlesPtr, int axis,
-                         size_t signalSize,
-                         const VectorDims& inputShape,
-                         const VectorDims& inputStrides,
-                         const VectorDims& outputShape,
-                         const VectorDims& outputStrides,
-                         const std::vector<size_t>& iteration_range);
-        void rdftNd(float* inputPtr, float* outputPtr,
-                    const std::vector<std::vector<float>>& twiddles,
-                    const std::vector<int>& axes,
-                    const std::vector<int>& signalSizes,
-                    const VectorDims& inputShape,
-                    const VectorDims& inputStrides,
-                    const VectorDims& outputShape,
-                    const VectorDims& outputStrides);
-        void irdftNd(float* inputPtr, float* outputPtr,
-                     const std::vector<std::vector<float>>& twiddles,
-                     const std::vector<int>& axes,
-                     const std::vector<int>& signalSizes,
-                     const VectorDims& inputShape,
-                     const VectorDims& inputStrides,
-                     const VectorDims& outputShape,
-                     const VectorDims& outputStrides);
-        virtual std::vector<float> generateTwiddlesDFT(size_t inputSize, size_t outputSize, enum dft_type type) = 0;
-        std::vector<float> generateTwiddlesFFT(size_t N);
-        std::vector<float> generateTwiddlesCommon(size_t inputSize, size_t outputSize,
-                                                  enum dft_type type, bool useFFT);
+private:
+    virtual bool canUseFFT(size_t dim);
+    virtual void dft(float* inputPtr,
+                     const float* twiddlesPtr,
+                     float* outputPtr,
+                     size_t inputSize,
+                     size_t signalSize,
+                     size_t outputSize,
+                     enum dft_type type,
+                     bool parallelize) = 0;
+    virtual void fft(float* input,
+                     const float* twiddlesPtr,
+                     float* output,
+                     size_t inputSize,
+                     size_t signalSize,
+                     size_t outputSize,
+                     enum dft_type type,
+                     bool parallelize);
+    void dftCommon(float* inputPtr,
+                   const float* twiddlesPtr,
+                   float* outputPtr,
+                   size_t inputSize,
+                   size_t signalSize,
+                   size_t outputSize,
+                   enum dft_type type,
+                   bool useFFT,
+                   bool parallelize);
+    void dftOnAxis(enum dft_type type,
+                   float* inputPtr,
+                   float* outputPtr,
+                   const float* twiddlesPtr,
+                   int axis,
+                   size_t signalSize,
+                   const VectorDims& inputShape,
+                   const VectorDims& inputStrides,
+                   const VectorDims& outputShape,
+                   const VectorDims& outputStrides,
+                   const std::vector<size_t>& iteration_range);
+    void rdftNd(float* inputPtr,
+                float* outputPtr,
+                const std::vector<std::vector<float>>& twiddles,
+                const std::vector<int>& axes,
+                const std::vector<int>& signalSizes,
+                const VectorDims& inputShape,
+                const VectorDims& inputStrides,
+                const VectorDims& outputShape,
+                const VectorDims& outputStrides);
+    void irdftNd(float* inputPtr,
+                 float* outputPtr,
+                 const std::vector<std::vector<float>>& twiddles,
+                 const std::vector<int>& axes,
+                 const std::vector<int>& signalSizes,
+                 const VectorDims& inputShape,
+                 const VectorDims& inputStrides,
+                 const VectorDims& outputShape,
+                 const VectorDims& outputStrides);
+    virtual std::vector<float> generateTwiddlesDFT(size_t inputSize, size_t outputSize, enum dft_type type) = 0;
+    std::vector<float> generateTwiddlesFFT(size_t N);
+    std::vector<float> generateTwiddlesCommon(size_t inputSize, size_t outputSize, enum dft_type type, bool useFFT);
 };
 
 class RDFT : public Node {
@@ -102,6 +125,6 @@ class RDFT : public Node {
     bool isSignalSizesConstant = false;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/reduce.cpp b/src/plugins/intel_cpu/src/nodes/reduce.cpp
index 1bc0209e0d9c69..7828e11f9d413a 100644
--- a/src/plugins/intel_cpu/src/nodes/reduce.cpp
+++ b/src/plugins/intel_cpu/src/nodes/reduce.cpp
@@ -4,26 +4,26 @@
 
 #include "reduce.h"
 
-#include "fake_quantize.h"
-#include "eltwise.h"
+#include <algorithm>
+#include <set>
 #include <string>
 #include <vector>
-#include <set>
-#include "onednn/dnnl.h"
-#include "dnnl_extension_utils.h"
-#include "utils/bfloat16.hpp"
-#include "emitters/plugin/x64/jit_bf16_emitters.hpp"
-#include "openvino/core/parallel.hpp"
-#include <algorithm>
 
-#include "cpu/x64/jit_generator.hpp"
-#include "cpu/x64/jit_uni_eltwise.hpp"
+#include "common/primitive_hashing_utils.hpp"
 #include "cpu/x64/injectors/jit_uni_depthwise_injector.hpp"
-#include "cpu/x64/injectors/jit_uni_quantization_injector.hpp"
 #include "cpu/x64/injectors/jit_uni_eltwise_injector.hpp"
+#include "cpu/x64/injectors/jit_uni_quantization_injector.hpp"
+#include "cpu/x64/jit_generator.hpp"
+#include "cpu/x64/jit_uni_eltwise.hpp"
+#include "dnnl_extension_utils.h"
+#include "eltwise.h"
+#include "emitters/plugin/x64/jit_bf16_emitters.hpp"
+#include "fake_quantize.h"
+#include "onednn/dnnl.h"
+#include "openvino/core/parallel.hpp"
 #include "openvino/opsets/opset1.hpp"
 #include "openvino/opsets/opset4.hpp"
-#include "common/primitive_hashing_utils.hpp"
+#include "utils/bfloat16.hpp"
 
 using namespace dnnl;
 
@@ -32,42 +32,55 @@ using namespace dnnl::impl::cpu::x64;
 using namespace dnnl::impl::utils;
 using namespace Xbyak;
 
-#define SET_SRC_DIM_VALUE(batch, channel, depth, height, width) IB = batch;   \
-                                                                IC = channel; \
-                                                                ID = depth;   \
-                                                                IH = height;  \
-                                                                IW = width;
-#define SET_DST_DIM_VALUE(batch, channel, depth, height, width) OB = batch;   \
-                                                                OC = channel; \
-                                                                OD = depth;   \
-                                                                OH = height;  \
-                                                                OW = width;
-
-#define GET_OFF(field) offsetof(jit_reduce_call_args, field)
+#define SET_SRC_DIM_VALUE(batch, channel, depth, height, width) \
+    IB = batch;                                                 \
+    IC = channel;                                               \
+    ID = depth;                                                 \
+    IH = height;                                                \
+    IW = width;
+#define SET_DST_DIM_VALUE(batch, channel, depth, height, width) \
+    OB = batch;                                                 \
+    OC = channel;                                               \
+    OD = depth;                                                 \
+    OH = height;                                                \
+    OW = width;
+
+#define GET_OFF(field)      offsetof(jit_reduce_call_args, field)
 #define GET_OFF_POST(field) offsetof(jit_reduce_post_call_args, field)
 
-#define GET_PTR_N_PLN              const uint8_t    *in_ptr_n      = in_ptr       + src_data_size * ib * IC * ID * IH * IW;               \
-                                         uint8_t    *out_ptr_n     = out_ptr      + dst_data_size * ob * OC * OD * OH * OW;
-#define GET_PTR_NC_PLN             const uint8_t    *in_ptr_nc     = in_ptr_n     + src_data_size * ic * ID * IH * IW;                    \
-                                         uint8_t    *out_ptr_nc    = out_ptr_n    + dst_data_size * oc * OD * OH * OW;
-#define GET_PTR_NCD_PLN            const uint8_t    *in_ptr_ncd    = in_ptr_nc    + src_data_size * id * IH * IW;                         \
-                                         uint8_t    *out_ptr_ncd   = out_ptr_nc   + dst_data_size * od * OH * OW;
-#define GET_PTR_NCDH_PLN           const uint8_t    *in_ptr_ncdh   = in_ptr_ncd   + src_data_size * ih * IW;                              \
-                                         uint8_t    *out_ptr_ncdh  = out_ptr_ncd  + dst_data_size * oh * OW;
-#define GET_PTR_NCD_BASE_PTR_N_PLN const uint8_t    *in_ptr_ncd    = in_ptr_n     + src_data_size * (ic * ID + id) * IH * IW;             \
-                                         uint8_t    *out_ptr_ncd   = out_ptr_n    + dst_data_size * (oc * OD + od) * OH * OW;
-#define GET_PTR_N_BLK              const uint8_t    *in_ptr_n      = in_ptr       + src_data_size * ib * ICB * ID * IH * IW * blk_size;   \
-                                         uint8_t    *out_ptr_n     = out_ptr      + dst_data_size * ob * OCB * OD * OH * OW * blk_size;
-#define GET_PTR_NC_BLK             const uint8_t    *in_ptr_nc     = in_ptr_n     + src_data_size * icb * ID * IH * IW * blk_size;        \
-                                         uint8_t    *out_ptr_nc    = out_ptr_n    + dst_data_size * ocb * OD * OH * OW * blk_size;
-#define GET_PTR_NCD_BLK            const uint8_t    *in_ptr_ncd    = in_ptr_nc    + src_data_size * id * IH * IW * blk_size;              \
-                                         uint8_t    *out_ptr_ncd   = out_ptr_nc   + dst_data_size * od * OH * OW * blk_size;
-#define GET_PTR_NCDH_BLK           const uint8_t    *in_ptr_ncdh   = in_ptr_ncd   + src_data_size * ih * IW * blk_size;                   \
-                                         uint8_t    *out_ptr_ncdh  = out_ptr_ncd  + dst_data_size * oh * OW * blk_size;
-#define GET_PTR_NCDHW_BLK          const uint8_t    *in_ptr_ncdhw  = in_ptr_ncdh  + src_data_size * iw * blk_size;                        \
-                                         uint8_t    *out_ptr_ncdhw = out_ptr_ncdh + dst_data_size * ow * blk_size;
-#define GET_PTR_NCD_BASE_PTR_N_BLK const uint8_t    *in_ptr_ncd    = in_ptr_n     + src_data_size * (icb * ID + id) * IH * IW * blk_size; \
-                                         uint8_t    *out_ptr_ncd   = out_ptr_n    + dst_data_size * (ocb * OD + od) * OH * OW * blk_size;
+#define GET_PTR_N_PLN                                                          \
+    const uint8_t* in_ptr_n = in_ptr + src_data_size * ib * IC * ID * IH * IW; \
+    uint8_t* out_ptr_n = out_ptr + dst_data_size * ob * OC * OD * OH * OW;
+#define GET_PTR_NC_PLN                                                       \
+    const uint8_t* in_ptr_nc = in_ptr_n + src_data_size * ic * ID * IH * IW; \
+    uint8_t* out_ptr_nc = out_ptr_n + dst_data_size * oc * OD * OH * OW;
+#define GET_PTR_NCD_PLN                                                   \
+    const uint8_t* in_ptr_ncd = in_ptr_nc + src_data_size * id * IH * IW; \
+    uint8_t* out_ptr_ncd = out_ptr_nc + dst_data_size * od * OH * OW;
+#define GET_PTR_NCDH_PLN                                               \
+    const uint8_t* in_ptr_ncdh = in_ptr_ncd + src_data_size * ih * IW; \
+    uint8_t* out_ptr_ncdh = out_ptr_ncd + dst_data_size * oh * OW;
+#define GET_PTR_NCD_BASE_PTR_N_PLN                                                   \
+    const uint8_t* in_ptr_ncd = in_ptr_n + src_data_size * (ic * ID + id) * IH * IW; \
+    uint8_t* out_ptr_ncd = out_ptr_n + dst_data_size * (oc * OD + od) * OH * OW;
+#define GET_PTR_N_BLK                                                                      \
+    const uint8_t* in_ptr_n = in_ptr + src_data_size * ib * ICB * ID * IH * IW * blk_size; \
+    uint8_t* out_ptr_n = out_ptr + dst_data_size * ob * OCB * OD * OH * OW * blk_size;
+#define GET_PTR_NC_BLK                                                                   \
+    const uint8_t* in_ptr_nc = in_ptr_n + src_data_size * icb * ID * IH * IW * blk_size; \
+    uint8_t* out_ptr_nc = out_ptr_n + dst_data_size * ocb * OD * OH * OW * blk_size;
+#define GET_PTR_NCD_BLK                                                              \
+    const uint8_t* in_ptr_ncd = in_ptr_nc + src_data_size * id * IH * IW * blk_size; \
+    uint8_t* out_ptr_ncd = out_ptr_nc + dst_data_size * od * OH * OW * blk_size;
+#define GET_PTR_NCDH_BLK                                                          \
+    const uint8_t* in_ptr_ncdh = in_ptr_ncd + src_data_size * ih * IW * blk_size; \
+    uint8_t* out_ptr_ncdh = out_ptr_ncd + dst_data_size * oh * OW * blk_size;
+#define GET_PTR_NCDHW_BLK                                                      \
+    const uint8_t* in_ptr_ncdhw = in_ptr_ncdh + src_data_size * iw * blk_size; \
+    uint8_t* out_ptr_ncdhw = out_ptr_ncdh + dst_data_size * ow * blk_size;
+#define GET_PTR_NCD_BASE_PTR_N_BLK                                                               \
+    const uint8_t* in_ptr_ncd = in_ptr_n + src_data_size * (icb * ID + id) * IH * IW * blk_size; \
+    uint8_t* out_ptr_ncd = out_ptr_n + dst_data_size * (ocb * OD + od) * OH * OW * blk_size;
 
 namespace ov {
 namespace intel_cpu {
@@ -99,13 +112,13 @@ size_t ReduceKey::hash() const {
     return seed;
 }
 
-bool ReduceKey::operator==(const ReduceKey &rhs) const {
+bool ReduceKey::operator==(const ReduceKey& rhs) const {
     return jcp.layout == rhs.jcp.layout && jcp.reduce_mode == rhs.jcp.reduce_mode &&
-           jcp.fuse_low_precision == rhs.jcp.fuse_low_precision &&
-           jcp.fuse_broadcast == rhs.jcp.fuse_broadcast && jcp.round_to_zero == rhs.jcp.round_to_zero &&
-           jcp.src_dt == rhs.jcp.src_dt && jcp.dst_dt == rhs.jcp.dst_dt && *postOps.get() == *rhs.postOps.get();
+           jcp.fuse_low_precision == rhs.jcp.fuse_low_precision && jcp.fuse_broadcast == rhs.jcp.fuse_broadcast &&
+           jcp.round_to_zero == rhs.jcp.round_to_zero && jcp.src_dt == rhs.jcp.src_dt && jcp.dst_dt == rhs.jcp.dst_dt &&
+           *postOps.get() == *rhs.postOps.get();
 }
-} // namespace
+}  // namespace
 
 // some utility functions
 static inline bool isFloatCompatible(memory::data_type type) {
@@ -119,7 +132,8 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_reduce_kernel_f32)
 
     explicit jit_uni_reduce_kernel_f32(jit_reduce_config_params jcp)
-    : jit_uni_reduce_kernel(jcp), jit_generator(jit_name()) {}
+        : jit_uni_reduce_kernel(jcp),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -128,7 +142,8 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
 
     void generate() override {
         if (jcp_.reduce_mode == Algorithm::ReduceLogSumExp) {
-            exp_injector = std::make_shared<jit_uni_eltwise_injector_f32<isa>>(this, alg_kind::eltwise_exp, 0.f, 0.f, 1.f);
+            exp_injector =
+                std::make_shared<jit_uni_eltwise_injector_f32<isa>>(this, alg_kind::eltwise_exp, 0.f, 0.f, 1.f);
         }
 
         if (mayiuse(avx512_core))
@@ -146,15 +161,18 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
         if (planar_layout)
             mov(reg_reduce_w, ptr[reg_params + GET_OFF(reduce_w)]);
 
-        if (jcp_.reduce_mode == Algorithm::ReduceAnd || jcp_.reduce_mode == Algorithm::ReduceL1 || jcp_.reduce_mode == Algorithm::ReduceMax ||
-            jcp_.reduce_mode == Algorithm::ReduceMin || jcp_.reduce_mode == Algorithm::ReduceProd || jcp_.reduce_mode == Algorithm::ReduceOr) {
+        if (jcp_.reduce_mode == Algorithm::ReduceAnd || jcp_.reduce_mode == Algorithm::ReduceL1 ||
+            jcp_.reduce_mode == Algorithm::ReduceMax || jcp_.reduce_mode == Algorithm::ReduceMin ||
+            jcp_.reduce_mode == Algorithm::ReduceProd || jcp_.reduce_mode == Algorithm::ReduceOr) {
             mov(reg_table, l_table);
         }
 
-        if (isa == cpu::x64::avx512_core || jcp_.reduce_mode == Algorithm::ReduceAnd || jcp_.reduce_mode == Algorithm::ReduceOr)
+        if (isa == cpu::x64::avx512_core || jcp_.reduce_mode == Algorithm::ReduceAnd ||
+            jcp_.reduce_mode == Algorithm::ReduceOr)
             uni_vpxor(vmm_zero, vmm_zero, vmm_zero);
 
-        if ((isa == cpu::x64::avx512_core && jcp_.reduce_mode == Algorithm::ReduceAnd) || jcp_.reduce_mode == Algorithm::ReduceOr) {
+        if ((isa == cpu::x64::avx512_core && jcp_.reduce_mode == Algorithm::ReduceAnd) ||
+            jcp_.reduce_mode == Algorithm::ReduceOr) {
             uni_vmovups(vmm_aux, table_val(0));
         }
 
@@ -166,8 +184,9 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
         if (mayiuse(avx512_core))
             uni_vcvtneps2bf16->emit_data();
 
-        if (jcp_.reduce_mode == Algorithm::ReduceAnd || jcp_.reduce_mode == Algorithm::ReduceL1 || jcp_.reduce_mode == Algorithm::ReduceMax ||
-            jcp_.reduce_mode == Algorithm::ReduceMin || jcp_.reduce_mode == Algorithm::ReduceProd || jcp_.reduce_mode == Algorithm::ReduceOr) {
+        if (jcp_.reduce_mode == Algorithm::ReduceAnd || jcp_.reduce_mode == Algorithm::ReduceL1 ||
+            jcp_.reduce_mode == Algorithm::ReduceMax || jcp_.reduce_mode == Algorithm::ReduceMin ||
+            jcp_.reduce_mode == Algorithm::ReduceProd || jcp_.reduce_mode == Algorithm::ReduceOr) {
             prepare_aux_table();
         } else if (jcp_.reduce_mode == Algorithm::ReduceLogSumExp) {
             exp_injector->prepare_table();
@@ -175,13 +194,15 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
     size_t vlen = cpu_isa_traits<isa>::vlen;
     bool planar_layout = false;
     bool support_intermediate_int = false;
 
-    Xbyak::Address table_val(int index) { return ptr[reg_table + index * vlen]; }
+    Xbyak::Address table_val(int index) {
+        return ptr[reg_table + index * vlen];
+    }
 
     Xbyak::Reg64 reg_src = r8;
     Xbyak::Reg64 reg_dst = r9;
@@ -290,7 +311,7 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
             cmp(reg_work_batch, 0);
             je(reduce_to_gather_label, T_NEAR);
 
-            cmp(reg_reduce_w, 1); // planar layout reducing W
+            cmp(reg_reduce_w, 1);  // planar layout reducing W
             je(reduce_to_scalar_label, T_NEAR);
         }
 
@@ -300,7 +321,7 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
         {
             int step = vlen / sizeof(float) < 8 ? 8 : vlen / sizeof(float);
             cmp(reg_work_amount, step);
-            jl(reduce_main_end_label, T_NEAR); //avoid illegal loading and storing
+            jl(reduce_main_end_label, T_NEAR);  // avoid illegal loading and storing
 
             if (jcp_.reduce_mode == Algorithm::ReduceL1) {
                 uni_vmovups(vmm_aux, table_val(1));
@@ -340,42 +361,42 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
         {
             // init dst, dst loading is embedded in horiz_reduce_store
             switch (jcp_.reduce_mode) {
-                case Algorithm::ReduceAnd:
+            case Algorithm::ReduceAnd:
+                uni_vmovups(vmm_dst, table_val(0));
+                break;
+            case Algorithm::ReduceProd:
+                if (isFloatCompatible(jcp_.src_dt))
                     uni_vmovups(vmm_dst, table_val(0));
-                    break;
-                case Algorithm::ReduceProd:
-                    if (isFloatCompatible(jcp_.src_dt))
-                        uni_vmovups(vmm_dst, table_val(0));
-                    else
-                        uni_vmovups(vmm_dst, table_val(6));
-                    break;
-                case Algorithm::ReduceL1:
-                    uni_vmovups(vmm_aux, table_val(1));
-                    uni_vpxor(vmm_dst, vmm_dst, vmm_dst);
-                    break;
-                case Algorithm::ReduceL2:
-                case Algorithm::ReduceLogSum:
-                case Algorithm::ReduceLogSumExp:
-                case Algorithm::ReduceMean:
-                case Algorithm::ReduceOr:
-                case Algorithm::ReduceSum:
-                case Algorithm::ReduceSumSquare:
-                    uni_vpxor(vmm_dst, vmm_dst, vmm_dst);
-                    break;
-                case Algorithm::ReduceMax:
-                    if (isFloatCompatible(jcp_.dst_dt))
-                        uni_vmovups(vmm_dst, table_val(2));
-                    else
-                        uni_vmovups(vmm_dst, table_val(4));
-                    break;
-                case Algorithm::ReduceMin:
-                    if (isFloatCompatible(jcp_.dst_dt))
-                        uni_vmovups(vmm_dst, table_val(3));
-                    else
-                        uni_vmovups(vmm_dst, table_val(5));
-                    break;
-                default:
-                    assert(!"unsupported reduce mode");
+                else
+                    uni_vmovups(vmm_dst, table_val(6));
+                break;
+            case Algorithm::ReduceL1:
+                uni_vmovups(vmm_aux, table_val(1));
+                uni_vpxor(vmm_dst, vmm_dst, vmm_dst);
+                break;
+            case Algorithm::ReduceL2:
+            case Algorithm::ReduceLogSum:
+            case Algorithm::ReduceLogSumExp:
+            case Algorithm::ReduceMean:
+            case Algorithm::ReduceOr:
+            case Algorithm::ReduceSum:
+            case Algorithm::ReduceSumSquare:
+                uni_vpxor(vmm_dst, vmm_dst, vmm_dst);
+                break;
+            case Algorithm::ReduceMax:
+                if (isFloatCompatible(jcp_.dst_dt))
+                    uni_vmovups(vmm_dst, table_val(2));
+                else
+                    uni_vmovups(vmm_dst, table_val(4));
+                break;
+            case Algorithm::ReduceMin:
+                if (isFloatCompatible(jcp_.dst_dt))
+                    uni_vmovups(vmm_dst, table_val(3));
+                else
+                    uni_vmovups(vmm_dst, table_val(5));
+                break;
+            default:
+                assert(!"unsupported reduce mode");
             }
             // reduce
             reduce_main_loop();
@@ -396,7 +417,7 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
         {
             int step = 1;
             cmp(reg_work_amount, step);
-            jl(reduce_main_end_label, T_NEAR); //avoid illegal loading and storing
+            jl(reduce_main_end_label, T_NEAR);  // avoid illegal loading and storing
 
             mov(reg_idx, ptr[reg_params + GET_OFF(idx)]);
             uni_vmovdqu(vmm_idx, ptr[reg_idx]);
@@ -578,40 +599,40 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
 
     inline void reduce_gather(Vmm vmm_dst, int offset) {
         switch (jcp_.src_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                if (isa == cpu::x64::avx512_core) {
-                    kxnord(k_mask, k_mask, k_mask);
-                    if (jcp_.src_dt == memory::data_type::f32) {
-                        vgatherdps(vmm_src | k_mask, ptr[reg_src + offset + vmm_idx]);
-                    } else {
-                        vpgatherdd(vmm_src | k_mask, ptr[reg_src + offset + vmm_idx]);
-                        if (!support_intermediate_int) {
-                            uni_vcvtdq2ps(vmm_src, vmm_src);
-                        }
-                    }
-                } else if (isa == cpu::x64::avx2) {
-                    uni_vpcmpeqd(vmm_mask, vmm_mask, vmm_mask);
-                    if (jcp_.src_dt == memory::data_type::f32) {
-                        vgatherdps(vmm_src, ptr[reg_src + offset + vmm_idx], vmm_mask);
-                    } else {
-                        vpgatherdd(vmm_src, ptr[reg_src + offset + vmm_idx], vmm_mask);
-                        if (!support_intermediate_int) {
-                            uni_vcvtdq2ps(vmm_src, vmm_src);
-                        }
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            if (isa == cpu::x64::avx512_core) {
+                kxnord(k_mask, k_mask, k_mask);
+                if (jcp_.src_dt == memory::data_type::f32) {
+                    vgatherdps(vmm_src | k_mask, ptr[reg_src + offset + vmm_idx]);
+                } else {
+                    vpgatherdd(vmm_src | k_mask, ptr[reg_src + offset + vmm_idx]);
+                    if (!support_intermediate_int) {
+                        uni_vcvtdq2ps(vmm_src, vmm_src);
                     }
+                }
+            } else if (isa == cpu::x64::avx2) {
+                uni_vpcmpeqd(vmm_mask, vmm_mask, vmm_mask);
+                if (jcp_.src_dt == memory::data_type::f32) {
+                    vgatherdps(vmm_src, ptr[reg_src + offset + vmm_idx], vmm_mask);
                 } else {
-                    pack_gathered_vector(vmm_src, vmm_idx, offset, jcp_.src_dt);
+                    vpgatherdd(vmm_src, ptr[reg_src + offset + vmm_idx], vmm_mask);
+                    if (!support_intermediate_int) {
+                        uni_vcvtdq2ps(vmm_src, vmm_src);
+                    }
                 }
-                break;
-            case memory::data_type::bf16:
-            case memory::data_type::f16:
-            case memory::data_type::s8:
-            case memory::data_type::u8:
+            } else {
                 pack_gathered_vector(vmm_src, vmm_idx, offset, jcp_.src_dt);
-                break;
-            default:
-                assert(!"unknown src_dt");
+            }
+            break;
+        case memory::data_type::bf16:
+        case memory::data_type::f16:
+        case memory::data_type::s8:
+        case memory::data_type::u8:
+            pack_gathered_vector(vmm_src, vmm_idx, offset, jcp_.src_dt);
+            break;
+        default:
+            assert(!"unknown src_dt");
         }
         reduce_kernel(vmm_src, vmm_dst);
     }
@@ -624,46 +645,46 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
             mov(reg_tmp_64.cvt32(), ptr[rsp + i * sizeof(int)]);
             Xbyak::Address table_idx = ptr[reg_src + offset + reg_tmp_64];
             switch (src_dt) {
-                case memory::data_type::f32:
-                case memory::data_type::s32:
-                    mov(reg_tmp_64.cvt32(), table_idx);
-                    mov(ptr[rsp + i * sizeof(int)], reg_tmp_64.cvt32());
-                    break;
-                case memory::data_type::bf16:
-                case memory::data_type::f16:
-                    mov(reg_tmp_64.cvt16(), table_idx);
-                    mov(ptr[rsp + i * 2], reg_tmp_64.cvt16());
-                    break;
-                case memory::data_type::s8:
-                case memory::data_type::u8:
-                    mov(reg_tmp_64.cvt8(), table_idx);
-                    mov(ptr[rsp + i * sizeof(char)], reg_tmp_64.cvt8());
-                    break;
-                default:
-                    assert(!"unknown src_dt");
-            }
-        }
-
-        switch (src_dt) {
             case memory::data_type::f32:
             case memory::data_type::s32:
-                uni_vmovups(vmm_val, ptr[rsp]);
+                mov(reg_tmp_64.cvt32(), table_idx);
+                mov(ptr[rsp + i * sizeof(int)], reg_tmp_64.cvt32());
                 break;
             case memory::data_type::bf16:
-                uni_vpmovzxwd(vmm_val, ptr[rsp]);
-                uni_vpslld(vmm_val, vmm_val, 16);
-                break;
             case memory::data_type::f16:
-                vcvtph2ps(vmm_val, ptr[rsp]);
+                mov(reg_tmp_64.cvt16(), table_idx);
+                mov(ptr[rsp + i * 2], reg_tmp_64.cvt16());
                 break;
             case memory::data_type::s8:
-                uni_vpmovsxbd(vmm_val, ptr[rsp]);
-                break;
             case memory::data_type::u8:
-                uni_vpmovzxbd(vmm_val, ptr[rsp]);
+                mov(reg_tmp_64.cvt8(), table_idx);
+                mov(ptr[rsp + i * sizeof(char)], reg_tmp_64.cvt8());
                 break;
             default:
                 assert(!"unknown src_dt");
+            }
+        }
+
+        switch (src_dt) {
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovups(vmm_val, ptr[rsp]);
+            break;
+        case memory::data_type::bf16:
+            uni_vpmovzxwd(vmm_val, ptr[rsp]);
+            uni_vpslld(vmm_val, vmm_val, 16);
+            break;
+        case memory::data_type::f16:
+            vcvtph2ps(vmm_val, ptr[rsp]);
+            break;
+        case memory::data_type::s8:
+            uni_vpmovsxbd(vmm_val, ptr[rsp]);
+            break;
+        case memory::data_type::u8:
+            uni_vpmovzxbd(vmm_val, ptr[rsp]);
+            break;
+        default:
+            assert(!"unknown src_dt");
         }
 
         if (convert_i32_to_f32(src_dt))
@@ -790,100 +811,100 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
 
     inline void reduce_kernel(Vmm vmm_src, Vmm vmm_dst) {
         switch (jcp_.reduce_mode) {
-            case Algorithm::ReduceAnd:
-                if (isa == cpu::x64::avx512_core) {
-                    vcmpps(k_mask, vmm_src, vmm_zero, _cmp_neq_uq);
-                    vblendmps(vmm_src | k_mask, vmm_zero, vmm_aux);
-                } else {
-                    uni_cmpneqps(vmm_src, vmm_src, vmm_zero);
-                }
-                uni_vandps(vmm_dst, vmm_dst, vmm_src);
-                break;
-            case Algorithm::ReduceL1:
-                uni_vandps(vmm_src, vmm_src, vmm_aux);
-                uni_vaddps(vmm_dst, vmm_dst, vmm_src);
-                break;
-            case Algorithm::ReduceLogSum:
-            case Algorithm::ReduceMean:
-            case Algorithm::ReduceSum:
-                uni_vaddps(vmm_dst, vmm_dst, vmm_src);
-                break;
-            case Algorithm::ReduceMax:
-                uni_vmaxps(vmm_dst, vmm_dst, vmm_src);
-                break;
-            case Algorithm::ReduceMin:
-                uni_vminps(vmm_dst, vmm_dst, vmm_src);
-                break;
-            case Algorithm::ReduceL2:
-            case Algorithm::ReduceSumSquare:
-                uni_vmulps(vmm_src, vmm_src, vmm_src);
-                uni_vaddps(vmm_dst, vmm_dst, vmm_src);
-                break;
-            case Algorithm::ReduceLogSumExp:
-                exp_injector->compute_vector_range(vmm_src.getIdx(), vmm_src.getIdx() + 1);
-                uni_vaddps(vmm_dst, vmm_dst, vmm_src);
-                break;
-            case Algorithm::ReduceOr:
-                if (isa == cpu::x64::avx512_core) {
-                    vcmpps(k_mask, vmm_src, vmm_zero, _cmp_neq_uq);
-                    vblendmps(vmm_src | k_mask, vmm_zero, vmm_aux);
-                }
-                uni_vorps(vmm_dst, vmm_dst, vmm_src);
-                break;
-            case Algorithm::ReduceProd:
-                if (isFloatCompatible(jcp_.src_dt)) {
-                    uni_vmulps(vmm_dst, vmm_dst, vmm_src);
-                } else {
-                    uni_vpmulld(vmm_dst, vmm_dst, vmm_src);
-                }
-                break;
-            default:
-                assert(!"unsupported reduce mode");
+        case Algorithm::ReduceAnd:
+            if (isa == cpu::x64::avx512_core) {
+                vcmpps(k_mask, vmm_src, vmm_zero, _cmp_neq_uq);
+                vblendmps(vmm_src | k_mask, vmm_zero, vmm_aux);
+            } else {
+                uni_cmpneqps(vmm_src, vmm_src, vmm_zero);
+            }
+            uni_vandps(vmm_dst, vmm_dst, vmm_src);
+            break;
+        case Algorithm::ReduceL1:
+            uni_vandps(vmm_src, vmm_src, vmm_aux);
+            uni_vaddps(vmm_dst, vmm_dst, vmm_src);
+            break;
+        case Algorithm::ReduceLogSum:
+        case Algorithm::ReduceMean:
+        case Algorithm::ReduceSum:
+            uni_vaddps(vmm_dst, vmm_dst, vmm_src);
+            break;
+        case Algorithm::ReduceMax:
+            uni_vmaxps(vmm_dst, vmm_dst, vmm_src);
+            break;
+        case Algorithm::ReduceMin:
+            uni_vminps(vmm_dst, vmm_dst, vmm_src);
+            break;
+        case Algorithm::ReduceL2:
+        case Algorithm::ReduceSumSquare:
+            uni_vmulps(vmm_src, vmm_src, vmm_src);
+            uni_vaddps(vmm_dst, vmm_dst, vmm_src);
+            break;
+        case Algorithm::ReduceLogSumExp:
+            exp_injector->compute_vector_range(vmm_src.getIdx(), vmm_src.getIdx() + 1);
+            uni_vaddps(vmm_dst, vmm_dst, vmm_src);
+            break;
+        case Algorithm::ReduceOr:
+            if (isa == cpu::x64::avx512_core) {
+                vcmpps(k_mask, vmm_src, vmm_zero, _cmp_neq_uq);
+                vblendmps(vmm_src | k_mask, vmm_zero, vmm_aux);
+            }
+            uni_vorps(vmm_dst, vmm_dst, vmm_src);
+            break;
+        case Algorithm::ReduceProd:
+            if (isFloatCompatible(jcp_.src_dt)) {
+                uni_vmulps(vmm_dst, vmm_dst, vmm_src);
+            } else {
+                uni_vpmulld(vmm_dst, vmm_dst, vmm_src);
+            }
+            break;
+        default:
+            assert(!"unsupported reduce mode");
         }
     }
 
     inline void reduce_kernel_scalar(Xmm xmm_src, Xmm xmm_dst) {
         switch (jcp_.reduce_mode) {
-            case Algorithm::ReduceAnd:
-                uni_cmpneqps(xmm_src, xmm_src, xmm_zero);
-                uni_vandps(xmm_dst, xmm_dst, xmm_src);
-                break;
-            case Algorithm::ReduceL1:
-                uni_vandps(xmm_src, xmm_src, xmm_aux);
-                uni_vaddps(xmm_dst, xmm_dst, xmm_src);
-                break;
-            case Algorithm::ReduceLogSum:
-            case Algorithm::ReduceMean:
-            case Algorithm::ReduceSum:
-                uni_vaddps(xmm_dst, xmm_dst, xmm_src);
-                break;
-            case Algorithm::ReduceMax:
-                uni_vmaxps(xmm_dst, xmm_dst, xmm_src);
-                break;
-            case Algorithm::ReduceMin:
-                uni_vminps(xmm_dst, xmm_dst, xmm_src);
-                break;
-            case Algorithm::ReduceL2:
-            case Algorithm::ReduceSumSquare:
-                uni_vmulps(xmm_src, xmm_src, xmm_src);
-                uni_vaddps(xmm_dst, xmm_dst, xmm_src);
-                break;
-            case Algorithm::ReduceLogSumExp:
-                exp_injector->compute_vector_range(xmm_src.getIdx(), xmm_src.getIdx() + 1);
-                uni_vaddps(xmm_dst, xmm_dst, xmm_src);
-                break;
-            case Algorithm::ReduceOr:
-                uni_vorps(xmm_dst, xmm_dst, xmm_src);
-                break;
-            case Algorithm::ReduceProd:
-                if (isFloatCompatible(jcp_.src_dt)) {
-                    uni_vmulps(xmm_dst, xmm_dst, xmm_src);
-                } else {
-                    uni_vpmulld(xmm_dst, xmm_dst, xmm_src);
-                }
-                break;
-            default:
-                assert(!"unsupported reduce mode");
+        case Algorithm::ReduceAnd:
+            uni_cmpneqps(xmm_src, xmm_src, xmm_zero);
+            uni_vandps(xmm_dst, xmm_dst, xmm_src);
+            break;
+        case Algorithm::ReduceL1:
+            uni_vandps(xmm_src, xmm_src, xmm_aux);
+            uni_vaddps(xmm_dst, xmm_dst, xmm_src);
+            break;
+        case Algorithm::ReduceLogSum:
+        case Algorithm::ReduceMean:
+        case Algorithm::ReduceSum:
+            uni_vaddps(xmm_dst, xmm_dst, xmm_src);
+            break;
+        case Algorithm::ReduceMax:
+            uni_vmaxps(xmm_dst, xmm_dst, xmm_src);
+            break;
+        case Algorithm::ReduceMin:
+            uni_vminps(xmm_dst, xmm_dst, xmm_src);
+            break;
+        case Algorithm::ReduceL2:
+        case Algorithm::ReduceSumSquare:
+            uni_vmulps(xmm_src, xmm_src, xmm_src);
+            uni_vaddps(xmm_dst, xmm_dst, xmm_src);
+            break;
+        case Algorithm::ReduceLogSumExp:
+            exp_injector->compute_vector_range(xmm_src.getIdx(), xmm_src.getIdx() + 1);
+            uni_vaddps(xmm_dst, xmm_dst, xmm_src);
+            break;
+        case Algorithm::ReduceOr:
+            uni_vorps(xmm_dst, xmm_dst, xmm_src);
+            break;
+        case Algorithm::ReduceProd:
+            if (isFloatCompatible(jcp_.src_dt)) {
+                uni_vmulps(xmm_dst, xmm_dst, xmm_src);
+            } else {
+                uni_vpmulld(xmm_dst, xmm_dst, xmm_src);
+            }
+            break;
+        default:
+            assert(!"unsupported reduce mode");
         }
     }
 
@@ -908,56 +929,56 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
             store_vector(ptr[reg_dst + 4 * jcp_.dst_data_size], vmm_dst_aux, jcp_.dst_dt);
     }
 
-    inline void load_vector(Vmm vmm_src, const Xbyak::Address &op, memory::data_type src_dt) {
+    inline void load_vector(Vmm vmm_src, const Xbyak::Address& op, memory::data_type src_dt) {
         switch (src_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovups(vmm_src, op);
-                break;
-            case memory::data_type::bf16:
-                uni_vpmovzxwd(vmm_src, op);
-                uni_vpslld(vmm_src, vmm_src, 16);
-                break;
-            case memory::data_type::f16:
-                vcvtph2ps(vmm_src, op);
-                break;
-            case memory::data_type::s8:
-                uni_vpmovsxbd(vmm_src, op);
-                break;
-            case memory::data_type::u8:
-                uni_vpmovzxbd(vmm_src, op);
-                break;
-            default:
-                assert(!"unknown src_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovups(vmm_src, op);
+            break;
+        case memory::data_type::bf16:
+            uni_vpmovzxwd(vmm_src, op);
+            uni_vpslld(vmm_src, vmm_src, 16);
+            break;
+        case memory::data_type::f16:
+            vcvtph2ps(vmm_src, op);
+            break;
+        case memory::data_type::s8:
+            uni_vpmovsxbd(vmm_src, op);
+            break;
+        case memory::data_type::u8:
+            uni_vpmovzxbd(vmm_src, op);
+            break;
+        default:
+            assert(!"unknown src_dt");
         }
 
         if (convert_i32_to_f32(src_dt))
             uni_vcvtdq2ps(vmm_src, vmm_src);
     }
 
-    inline void load_scalar(Xmm xmm_src, const Xbyak::Address &op, memory::data_type src_dt) {
+    inline void load_scalar(Xmm xmm_src, const Xbyak::Address& op, memory::data_type src_dt) {
         switch (src_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovss(xmm_src, op);
-                break;
-            case memory::data_type::bf16:
-                uni_vpinsrw(xmm_src, xmm_src, op, 0x0);
-                uni_vpslld(xmm_src, xmm_src, 16);
-                break;
-            case memory::data_type::f16:
-                vcvtph2ps(xmm_src, op);
-                break;
-            case memory::data_type::s8:
-                movsx(reg_tmp_32, op);
-                uni_vmovq(xmm_src, reg_tmp_64);
-                break;
-            case memory::data_type::u8:
-                movzx(reg_tmp_32, op);
-                uni_vmovq(xmm_src, reg_tmp_64);
-                break;
-            default:
-                assert(!"unknown src_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovss(xmm_src, op);
+            break;
+        case memory::data_type::bf16:
+            uni_vpinsrw(xmm_src, xmm_src, op, 0x0);
+            uni_vpslld(xmm_src, xmm_src, 16);
+            break;
+        case memory::data_type::f16:
+            vcvtph2ps(xmm_src, op);
+            break;
+        case memory::data_type::s8:
+            movsx(reg_tmp_32, op);
+            uni_vmovq(xmm_src, reg_tmp_64);
+            break;
+        case memory::data_type::u8:
+            movzx(reg_tmp_32, op);
+            uni_vmovq(xmm_src, reg_tmp_64);
+            break;
+        default:
+            assert(!"unknown src_dt");
         }
 
         if (convert_i32_to_f32(src_dt)) {
@@ -965,63 +986,64 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
         }
     }
 
-    inline void store_vector(const Xbyak::Address &op, Vmm vmm_dst, memory::data_type dst_dt) {
+    inline void store_vector(const Xbyak::Address& op, Vmm vmm_dst, memory::data_type dst_dt) {
         Xmm xmm_dst = Xmm(vmm_dst.getIdx());
         Ymm ymm_dst = Ymm(vmm_dst.getIdx());
         if (jcp_.round_to_zero && !support_intermediate_int) {
-            uni_vroundps(vmm_dst, vmm_dst, 3); // rounding to zero
+            uni_vroundps(vmm_dst, vmm_dst, 3);  // rounding to zero
         }
         if (convert_f32_to_i32(dst_dt)) {
             uni_vcvtps2dq(vmm_dst, vmm_dst);
         }
 
         switch (dst_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovups(op, vmm_dst);
-                break;
-            case memory::data_type::bf16:
-                uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())}, {static_cast<size_t>(ymm_dst.getIdx())});
-                vmovdqu16(op, ymm_dst);
-                break;
-            case memory::data_type::f16:
-                vcvtps2ph(op, vmm_dst, 0x4);
-                break;
-            case memory::data_type::s8:
-                if (isa == cpu::x64::avx512_core) {
-                    vpmovsdb(op, vmm_dst);
-                } else {
-                    uni_vpackssdw(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != cpu::x64::sse41)
-                        vpermq(ymm_dst, ymm_dst, 0x08);
-                    uni_vpacksswb(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != cpu::x64::sse41)
-                        vmovq(op, xmm_dst);
-                    else
-                        uni_vmovd(op, xmm_dst);
-                }
-                break;
-            case memory::data_type::u8:
-                if (isa == cpu::x64::avx512_core) {
-                    vpmaxsd(vmm_dst, vmm_zero, vmm_dst);
-                    vpmovusdb(op, vmm_dst);
-                } else {
-                    uni_vpackusdw(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != cpu::x64::sse41)
-                        vpermq(ymm_dst, ymm_dst, 0x08);
-                    uni_vpackuswb(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != cpu::x64::sse41)
-                        vmovq(op, xmm_dst);
-                    else
-                        uni_vmovd(op, xmm_dst);
-                }
-                break;
-            default:
-                assert(!"unknown dst_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovups(op, vmm_dst);
+            break;
+        case memory::data_type::bf16:
+            uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
+                                         {static_cast<size_t>(ymm_dst.getIdx())});
+            vmovdqu16(op, ymm_dst);
+            break;
+        case memory::data_type::f16:
+            vcvtps2ph(op, vmm_dst, 0x4);
+            break;
+        case memory::data_type::s8:
+            if (isa == cpu::x64::avx512_core) {
+                vpmovsdb(op, vmm_dst);
+            } else {
+                uni_vpackssdw(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != cpu::x64::sse41)
+                    vpermq(ymm_dst, ymm_dst, 0x08);
+                uni_vpacksswb(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != cpu::x64::sse41)
+                    vmovq(op, xmm_dst);
+                else
+                    uni_vmovd(op, xmm_dst);
+            }
+            break;
+        case memory::data_type::u8:
+            if (isa == cpu::x64::avx512_core) {
+                vpmaxsd(vmm_dst, vmm_zero, vmm_dst);
+                vpmovusdb(op, vmm_dst);
+            } else {
+                uni_vpackusdw(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != cpu::x64::sse41)
+                    vpermq(ymm_dst, ymm_dst, 0x08);
+                uni_vpackuswb(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != cpu::x64::sse41)
+                    vmovq(op, xmm_dst);
+                else
+                    uni_vmovd(op, xmm_dst);
+            }
+            break;
+        default:
+            assert(!"unknown dst_dt");
         }
     }
 
-    inline void store_scalar(const Xbyak::Address &op, Xmm xmm_dst, memory::data_type dst_dt) {
+    inline void store_scalar(const Xbyak::Address& op, Xmm xmm_dst, memory::data_type dst_dt) {
         if (jcp_.round_to_zero && !support_intermediate_int) {
             uni_vroundps(xmm_dst, xmm_dst, 3);
         }
@@ -1030,33 +1052,33 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
         }
 
         switch (dst_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovss(op, xmm_dst);
-                break;
-            case memory::data_type::bf16:
-                uni_vpsrld(xmm_dst, xmm_dst, 16);
-                uni_vpextrw(op, xmm_dst, 0x0);
-                break;
-            case memory::data_type::f16:
-                vcvtps2ph(xmm_dst, xmm_dst, 0x4);
-                movq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_16);
-                break;
-            case memory::data_type::s8:
-                uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
-                uni_vmovq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_8);
-                break;
-            case memory::data_type::u8:
-                uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
-                uni_vmovq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_8);
-                break;
-            default:
-                assert(!"unknown dst_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovss(op, xmm_dst);
+            break;
+        case memory::data_type::bf16:
+            uni_vpsrld(xmm_dst, xmm_dst, 16);
+            uni_vpextrw(op, xmm_dst, 0x0);
+            break;
+        case memory::data_type::f16:
+            vcvtps2ph(xmm_dst, xmm_dst, 0x4);
+            movq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_16);
+            break;
+        case memory::data_type::s8:
+            uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
+            uni_vmovq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_8);
+            break;
+        case memory::data_type::u8:
+            uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
+            uni_vmovq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_8);
+            break;
+        default:
+            assert(!"unknown dst_dt");
         }
     }
 
@@ -1083,10 +1105,10 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
     }
 
     inline void horiz_store(Xbyak::Xmm xmm_dst, memory::data_type dst_dt, bool load_embedded) {
-        uni_vmovshdup(xmm_aux3, xmm_dst);          // dst:1,2,3,4; aux3:2,2,4,4
-        horiz_ps(xmm_dst, xmm_aux3);               // dst:f(1,2),f(2,2),f(3,4),f(4,4)
-        uni_vmovhlps(xmm_aux3, xmm_aux3, xmm_dst); // aux3:f(3,4),f(4,4),4,4
-        horiz_ps(xmm_dst, xmm_aux3);               // dst:f(1,2,3,4),...
+        uni_vmovshdup(xmm_aux3, xmm_dst);           // dst:1,2,3,4; aux3:2,2,4,4
+        horiz_ps(xmm_dst, xmm_aux3);                // dst:f(1,2),f(2,2),f(3,4),f(4,4)
+        uni_vmovhlps(xmm_aux3, xmm_aux3, xmm_dst);  // aux3:f(3,4),f(4,4),4,4
+        horiz_ps(xmm_dst, xmm_aux3);                // dst:f(1,2,3,4),...
         if (load_embedded) {
             load_scalar(xmm_aux3, ptr[reg_dst], dst_dt);
             horiz_ps(xmm_dst, xmm_aux3);
@@ -1096,35 +1118,35 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
 
     inline void horiz_ps(const Xmm& xmm, const Operand& op) {
         switch (jcp_.reduce_mode) {
-            case Algorithm::ReduceAnd:
-                uni_vandps(xmm, xmm, op);
-                break;
-            case Algorithm::ReduceL1:
-            case Algorithm::ReduceL2:
-            case Algorithm::ReduceLogSum:
-            case Algorithm::ReduceMean:
-            case Algorithm::ReduceSum:
-            case Algorithm::ReduceSumSquare:
-            case Algorithm::ReduceLogSumExp:
-                uni_vaddps(xmm, xmm, op);
-                break;
-            case Algorithm::ReduceMax:
-                uni_vmaxps(xmm, xmm, op);
-                break;
-            case Algorithm::ReduceMin:
-                uni_vminps(xmm, xmm, op);
-                break;
-            case Algorithm::ReduceOr:
-                uni_vorps(xmm, xmm, op);
-                break;
-            case Algorithm::ReduceProd:
-                if (isFloatCompatible(jcp_.src_dt))
-                    uni_vmulps(xmm, xmm, op);
-                else
-                    uni_vpmulld(xmm, xmm, op);
-                break;
-            default:
-                assert(!"unsupported reduce mode");
+        case Algorithm::ReduceAnd:
+            uni_vandps(xmm, xmm, op);
+            break;
+        case Algorithm::ReduceL1:
+        case Algorithm::ReduceL2:
+        case Algorithm::ReduceLogSum:
+        case Algorithm::ReduceMean:
+        case Algorithm::ReduceSum:
+        case Algorithm::ReduceSumSquare:
+        case Algorithm::ReduceLogSumExp:
+            uni_vaddps(xmm, xmm, op);
+            break;
+        case Algorithm::ReduceMax:
+            uni_vmaxps(xmm, xmm, op);
+            break;
+        case Algorithm::ReduceMin:
+            uni_vminps(xmm, xmm, op);
+            break;
+        case Algorithm::ReduceOr:
+            uni_vorps(xmm, xmm, op);
+            break;
+        case Algorithm::ReduceProd:
+            if (isFloatCompatible(jcp_.src_dt))
+                uni_vmulps(xmm, xmm, op);
+            else
+                uni_vpmulld(xmm, xmm, op);
+            break;
+        default:
+            assert(!"unsupported reduce mode");
         }
     }
 
@@ -1156,13 +1178,13 @@ struct jit_uni_reduce_kernel_f32 : public jit_uni_reduce_kernel, public jit_gene
     }
 
     const struct aux_vals_type {
-        int float_one = 0x3f800000; // 1.0f
-        int float_abs = 0x7fffffff; // mask to make positive
-        int float_min = 0xff7fffff; // float minimum
-        int float_max = 0x7f7fffff; // float maximum
-        int int32_min = 0xcf000000; // -2^31 presented in float
-        int int32_max = 0x4effffff; // 2^31-1 presented in float
-        int int32_one = 0x00000001; // integer 1
+        int float_one = 0x3f800000;  // 1.0f
+        int float_abs = 0x7fffffff;  // mask to make positive
+        int float_min = 0xff7fffff;  // float minimum
+        int float_max = 0x7f7fffff;  // float maximum
+        int int32_min = 0xcf000000;  // -2^31 presented in float
+        int int32_max = 0x4effffff;  // 2^31-1 presented in float
+        int int32_one = 0x00000001;  // integer 1
     } aux_vals;
 };
 
@@ -1170,8 +1192,9 @@ template <cpu_isa_t isa>
 struct jit_uni_reduce_post_kernel_f32 : public jit_uni_reduce_post_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_reduce_post_kernel_f32)
 
-    explicit jit_uni_reduce_post_kernel_f32(jit_reduce_config_params jcp, const dnnl_primitive_attr &attr)
-    : jit_uni_reduce_post_kernel(jcp, attr), jit_generator(jit_name()) {}
+    explicit jit_uni_reduce_post_kernel_f32(jit_reduce_config_params jcp, const dnnl_primitive_attr& attr)
+        : jit_uni_reduce_post_kernel(jcp, attr),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -1179,23 +1202,30 @@ struct jit_uni_reduce_post_kernel_f32 : public jit_uni_reduce_post_kernel, publi
     }
 
     void generate() override {
-        const auto &p = attr_.post_ops_;
+        const auto& p = attr_.post_ops_;
         for (int i = 0; i < p.len(); i++) {
-            auto &post_op = p.entry_[i];
+            auto& post_op = p.entry_[i];
             if (post_op.is_eltwise()) {
-                eltwise_injectors.push_back(std::make_shared<jit_uni_eltwise_injector_f32<isa>>(
-                        this, post_op.eltwise.alg, post_op.eltwise.alpha, post_op.eltwise.beta, post_op.eltwise.scale));
+                eltwise_injectors.push_back(std::make_shared<jit_uni_eltwise_injector_f32<isa>>(this,
+                                                                                                post_op.eltwise.alg,
+                                                                                                post_op.eltwise.alpha,
+                                                                                                post_op.eltwise.beta,
+                                                                                                post_op.eltwise.scale));
             } else if (post_op.is_depthwise()) {
-                depthwise_injectors.push_back(std::make_shared<jit_uni_depthwise_injector_f32<isa>>(
-                        this, post_op));
+                depthwise_injectors.push_back(std::make_shared<jit_uni_depthwise_injector_f32<isa>>(this, post_op));
             } else if (post_op.is_quantization()) {
-                quantization_injectors.push_back(std::make_shared<jit_uni_quantization_injector_f32<isa>>(
-                        this, post_op, vmm_d_weights, vmm_d_bias, reg_d_weights, reg_d_bias));
+                quantization_injectors.push_back(std::make_shared<jit_uni_quantization_injector_f32<isa>>(this,
+                                                                                                          post_op,
+                                                                                                          vmm_d_weights,
+                                                                                                          vmm_d_bias,
+                                                                                                          reg_d_weights,
+                                                                                                          reg_d_bias));
             }
         }
 
         if (jcp_.reduce_mode == Algorithm::ReduceLogSum || jcp_.reduce_mode == Algorithm::ReduceLogSumExp) {
-            log_injector = std::make_shared<jit_uni_eltwise_injector_f32<isa>>(this, alg_kind::eltwise_log, 0.f, 0.f, 1.f);
+            log_injector =
+                std::make_shared<jit_uni_eltwise_injector_f32<isa>>(this, alg_kind::eltwise_log, 0.f, 0.f, 1.f);
         }
 
         if (mayiuse(avx512_core))
@@ -1265,8 +1295,8 @@ struct jit_uni_reduce_post_kernel_f32 : public jit_uni_reduce_post_kernel, publi
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
     size_t vlen = cpu_isa_traits<isa>::vlen;
     bool planar_layout = false;
     bool post_reduce = true;
@@ -1519,13 +1549,13 @@ struct jit_uni_reduce_post_kernel_f32 : public jit_uni_reduce_post_kernel, publi
     }
 
     void apply_post_ops(memory::data_type dst_dt, bool is_broadcast) {
-        const auto &p = attr_.post_ops_;
+        const auto& p = attr_.post_ops_;
         int eltwise_inj_idx = 0;
         int depthwise_inj_idx = 0;
         int quantization_inj_idx = 0;
         int post_ops_data_offset = 0;
         if (jcp_.round_to_zero) {
-            uni_vroundps(vmm_dst, vmm_dst, 3); // rounding to zero
+            uni_vroundps(vmm_dst, vmm_dst, 3);  // rounding to zero
         }
 
         for (int i = 0; i < p.len(); i++) {
@@ -1537,8 +1567,11 @@ struct jit_uni_reduce_post_kernel_f32 : public jit_uni_reduce_post_kernel, publi
                 mov(reg_d_weights, ptr[reg_post_ops_data + post_ops_data_offset]);
                 add(reg_d_weights, reg_oc_off);
 
-                depthwise_injectors[depthwise_inj_idx]->compute_vector_range(
-                        vmm_dst.getIdx(), vmm_dst.getIdx() + 1, reg_d_weights, reg_d_weights, is_broadcast);
+                depthwise_injectors[depthwise_inj_idx]->compute_vector_range(vmm_dst.getIdx(),
+                                                                             vmm_dst.getIdx() + 1,
+                                                                             reg_d_weights,
+                                                                             reg_d_weights,
+                                                                             is_broadcast);
 
                 post_ops_data_offset += depthwise_injectors[depthwise_inj_idx]->memoryStep();
                 depthwise_inj_idx++;
@@ -1548,15 +1581,25 @@ struct jit_uni_reduce_post_kernel_f32 : public jit_uni_reduce_post_kernel, publi
 
                 int s_idx = vmm_dst.getIdx();
 
-                quantization_injectors[quantization_inj_idx]->init_crop_ptrs(reg_post_ops_data + post_ops_data_offset, reg_oc_off);
+                quantization_injectors[quantization_inj_idx]->init_crop_ptrs(reg_post_ops_data + post_ops_data_offset,
+                                                                             reg_oc_off);
                 quantization_injectors[quantization_inj_idx]->compute_crop(s_idx, s_idx + 1, 0, 0, is_broadcast);
 
-                quantization_injectors[quantization_inj_idx]->init_input_scale_shift_ptrs(reg_post_ops_data + post_ops_data_offset, reg_oc_off);
-                quantization_injectors[quantization_inj_idx]->compute_input_scale_shift(s_idx, s_idx + 1, 0, do_rounding, 0, is_broadcast);
+                quantization_injectors[quantization_inj_idx]->init_input_scale_shift_ptrs(
+                    reg_post_ops_data + post_ops_data_offset,
+                    reg_oc_off);
+                quantization_injectors[quantization_inj_idx]
+                    ->compute_input_scale_shift(s_idx, s_idx + 1, 0, do_rounding, 0, is_broadcast);
 
                 if (do_dequantization) {
-                    quantization_injectors[quantization_inj_idx]->init_output_scale_shift_ptrs(reg_post_ops_data + post_ops_data_offset, reg_oc_off);
-                    quantization_injectors[quantization_inj_idx]->compute_output_scale_shift(s_idx, s_idx + 1, 0, 0, is_broadcast);
+                    quantization_injectors[quantization_inj_idx]->init_output_scale_shift_ptrs(
+                        reg_post_ops_data + post_ops_data_offset,
+                        reg_oc_off);
+                    quantization_injectors[quantization_inj_idx]->compute_output_scale_shift(s_idx,
+                                                                                             s_idx + 1,
+                                                                                             0,
+                                                                                             0,
+                                                                                             is_broadcast);
                 }
 
                 post_ops_data_offset += quantization_injectors[quantization_inj_idx]->memoryStep();
@@ -1597,56 +1640,56 @@ struct jit_uni_reduce_post_kernel_f32 : public jit_uni_reduce_post_kernel, publi
             load_scalar(xmm_val, ptr[reg_dst + offset * jcp_.dst_data_size], jcp_.dst_dt);
     }
 
-    inline void load_vector(Vmm vmm_src, const Xbyak::Address &op, memory::data_type src_dt) {
+    inline void load_vector(Vmm vmm_src, const Xbyak::Address& op, memory::data_type src_dt) {
         switch (src_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovups(vmm_src, op);
-                break;
-            case memory::data_type::bf16:
-                uni_vpmovzxwd(vmm_src, op);
-                uni_vpslld(vmm_src, vmm_src, 16);
-                break;
-            case memory::data_type::f16:
-                vcvtph2ps(vmm_src, op);
-                break;
-            case memory::data_type::s8:
-                uni_vpmovsxbd(vmm_src, op);
-                break;
-            case memory::data_type::u8:
-                uni_vpmovzxbd(vmm_src, op);
-                break;
-            default:
-                assert(!"unknown src_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovups(vmm_src, op);
+            break;
+        case memory::data_type::bf16:
+            uni_vpmovzxwd(vmm_src, op);
+            uni_vpslld(vmm_src, vmm_src, 16);
+            break;
+        case memory::data_type::f16:
+            vcvtph2ps(vmm_src, op);
+            break;
+        case memory::data_type::s8:
+            uni_vpmovsxbd(vmm_src, op);
+            break;
+        case memory::data_type::u8:
+            uni_vpmovzxbd(vmm_src, op);
+            break;
+        default:
+            assert(!"unknown src_dt");
         }
 
         if (!isFloatCompatible(src_dt))
             uni_vcvtdq2ps(vmm_src, vmm_src);
     }
 
-    inline void load_scalar(Xmm xmm_src, const Xbyak::Address &op, memory::data_type src_dt) {
+    inline void load_scalar(Xmm xmm_src, const Xbyak::Address& op, memory::data_type src_dt) {
         switch (src_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovss(xmm_src, op);
-                break;
-            case memory::data_type::bf16:
-                uni_vpinsrw(xmm_src, xmm_src, op, 0x0);
-                uni_vpslld(xmm_src, xmm_src, 16);
-                break;
-            case memory::data_type::f16:
-                vcvtph2ps(xmm_src, op);
-                break;
-            case memory::data_type::s8:
-                movsx(reg_tmp_32, op);
-                uni_vmovq(xmm_src, reg_tmp_64);
-                break;
-            case memory::data_type::u8:
-                movzx(reg_tmp_32, op);
-                uni_vmovq(xmm_src, reg_tmp_64);
-                break;
-            default:
-                assert(!"unknown src_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovss(xmm_src, op);
+            break;
+        case memory::data_type::bf16:
+            uni_vpinsrw(xmm_src, xmm_src, op, 0x0);
+            uni_vpslld(xmm_src, xmm_src, 16);
+            break;
+        case memory::data_type::f16:
+            vcvtph2ps(xmm_src, op);
+            break;
+        case memory::data_type::s8:
+            movsx(reg_tmp_32, op);
+            uni_vmovq(xmm_src, reg_tmp_64);
+            break;
+        case memory::data_type::u8:
+            movzx(reg_tmp_32, op);
+            uni_vmovq(xmm_src, reg_tmp_64);
+            break;
+        default:
+            assert(!"unknown src_dt");
         }
 
         if (!isFloatCompatible(src_dt)) {
@@ -1654,7 +1697,7 @@ struct jit_uni_reduce_post_kernel_f32 : public jit_uni_reduce_post_kernel, publi
         }
     }
 
-    inline void store_vector(const Xbyak::Address &op, Vmm vmm_dst, memory::data_type dst_dt) {
+    inline void store_vector(const Xbyak::Address& op, Vmm vmm_dst, memory::data_type dst_dt) {
         Xmm xmm_dst = Xmm(vmm_dst.getIdx());
         Ymm ymm_dst = Ymm(vmm_dst.getIdx());
         // If there is post ops fusing, necessary rounding has ready been done, no need to do it again.
@@ -1666,52 +1709,53 @@ struct jit_uni_reduce_post_kernel_f32 : public jit_uni_reduce_post_kernel, publi
         }
 
         switch (dst_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovups(op, vmm_dst);
-                break;
-            case memory::data_type::bf16:
-                uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())}, {static_cast<size_t>(ymm_dst.getIdx())});
-                vmovdqu16(op, ymm_dst);
-                break;
-            case memory::data_type::f16:
-                vcvtps2ph(op, vmm_dst, 0x4);
-                break;
-            case memory::data_type::s8:
-                if (isa == cpu::x64::avx512_core) {
-                    vpmovsdb(op, vmm_dst);
-                } else {
-                    uni_vpackssdw(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != cpu::x64::sse41)
-                        vpermq(ymm_dst, ymm_dst, 0x08);
-                    uni_vpacksswb(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != cpu::x64::sse41)
-                        vmovq(op, xmm_dst);
-                    else
-                        uni_vmovd(op, xmm_dst);
-                }
-                break;
-            case memory::data_type::u8:
-                if (isa == cpu::x64::avx512_core) {
-                    vpmaxsd(vmm_dst, vmm_zero, vmm_dst);
-                    vpmovusdb(op, vmm_dst);
-                } else {
-                    uni_vpackusdw(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != cpu::x64::sse41)
-                        vpermq(ymm_dst, ymm_dst, 0x08);
-                    uni_vpackuswb(vmm_dst, vmm_dst, vmm_dst);
-                    if (isa != cpu::x64::sse41)
-                        vmovq(op, xmm_dst);
-                    else
-                        uni_vmovd(op, xmm_dst);
-                }
-                break;
-            default:
-                assert(!"unknown dst_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovups(op, vmm_dst);
+            break;
+        case memory::data_type::bf16:
+            uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
+                                         {static_cast<size_t>(ymm_dst.getIdx())});
+            vmovdqu16(op, ymm_dst);
+            break;
+        case memory::data_type::f16:
+            vcvtps2ph(op, vmm_dst, 0x4);
+            break;
+        case memory::data_type::s8:
+            if (isa == cpu::x64::avx512_core) {
+                vpmovsdb(op, vmm_dst);
+            } else {
+                uni_vpackssdw(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != cpu::x64::sse41)
+                    vpermq(ymm_dst, ymm_dst, 0x08);
+                uni_vpacksswb(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != cpu::x64::sse41)
+                    vmovq(op, xmm_dst);
+                else
+                    uni_vmovd(op, xmm_dst);
+            }
+            break;
+        case memory::data_type::u8:
+            if (isa == cpu::x64::avx512_core) {
+                vpmaxsd(vmm_dst, vmm_zero, vmm_dst);
+                vpmovusdb(op, vmm_dst);
+            } else {
+                uni_vpackusdw(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != cpu::x64::sse41)
+                    vpermq(ymm_dst, ymm_dst, 0x08);
+                uni_vpackuswb(vmm_dst, vmm_dst, vmm_dst);
+                if (isa != cpu::x64::sse41)
+                    vmovq(op, xmm_dst);
+                else
+                    uni_vmovd(op, xmm_dst);
+            }
+            break;
+        default:
+            assert(!"unknown dst_dt");
         }
     }
 
-    inline void store_scalar(const Xbyak::Address &op, Xmm xmm_dst, memory::data_type dst_dt) {
+    inline void store_scalar(const Xbyak::Address& op, Xmm xmm_dst, memory::data_type dst_dt) {
         if (!post_ops_fusing && jcp_.round_to_zero) {
             uni_vroundps(xmm_dst, xmm_dst, 3);
         }
@@ -1720,33 +1764,33 @@ struct jit_uni_reduce_post_kernel_f32 : public jit_uni_reduce_post_kernel, publi
         }
 
         switch (dst_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovss(op, xmm_dst);
-                break;
-            case memory::data_type::bf16:
-                uni_vpsrld(xmm_dst, xmm_dst, 16);
-                uni_vpextrw(op, xmm_dst, 0x0);
-                break;
-            case memory::data_type::f16:
-                vcvtps2ph(xmm_dst, xmm_dst, 0x4);
-                movq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_16);
-                break;
-            case memory::data_type::s8:
-                uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
-                uni_vmovq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_8);
-                break;
-            case memory::data_type::u8:
-                uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
-                uni_vmovq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_8);
-                break;
-            default:
-                assert(!"unknown dst_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovss(op, xmm_dst);
+            break;
+        case memory::data_type::bf16:
+            uni_vpsrld(xmm_dst, xmm_dst, 16);
+            uni_vpextrw(op, xmm_dst, 0x0);
+            break;
+        case memory::data_type::f16:
+            vcvtps2ph(xmm_dst, xmm_dst, 0x4);
+            movq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_16);
+            break;
+        case memory::data_type::s8:
+            uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
+            uni_vmovq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_8);
+            break;
+        case memory::data_type::u8:
+            uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
+            uni_vmovq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_8);
+            break;
+        default:
+            assert(!"unknown dst_dt");
         }
     }
 
@@ -1773,10 +1817,10 @@ struct jit_uni_reduce_post_kernel_f32 : public jit_uni_reduce_post_kernel, publi
     }
 
     inline void horiz_store(Xbyak::Xmm xmm_dst, memory::data_type dst_dt, bool load_embedded) {
-        uni_vmovshdup(xmm_aux3, xmm_dst);          // dst:1,2,3,4; aux3:2,2,4,4
-        horiz_ps(xmm_dst, xmm_aux3);               // dst:f(1,2),f(2,2),f(3,4),f(4,4)
-        uni_vmovhlps(xmm_aux3, xmm_aux3, xmm_dst); // aux3:f(3,4),f(4,4),4,4
-        horiz_ps(xmm_dst, xmm_aux3);               // dst:f(1,2,3,4),...
+        uni_vmovshdup(xmm_aux3, xmm_dst);           // dst:1,2,3,4; aux3:2,2,4,4
+        horiz_ps(xmm_dst, xmm_aux3);                // dst:f(1,2),f(2,2),f(3,4),f(4,4)
+        uni_vmovhlps(xmm_aux3, xmm_aux3, xmm_dst);  // aux3:f(3,4),f(4,4),4,4
+        horiz_ps(xmm_dst, xmm_aux3);                // dst:f(1,2,3,4),...
         if (jcp_.fuse_low_precision && (post_reduce || post_ops_fusing)) {
             if (load_embedded) {
                 load_scalar(xmm_aux3, ptr[reg_src], memory::data_type::f32);
@@ -1794,94 +1838,106 @@ struct jit_uni_reduce_post_kernel_f32 : public jit_uni_reduce_post_kernel, publi
 
     inline void horiz_ps(const Xmm& xmm, const Operand& op) {
         switch (jcp_.reduce_mode) {
-            case Algorithm::ReduceAnd:
-                uni_vandps(xmm, xmm, op);
-                break;
-            case Algorithm::ReduceL1:
-            case Algorithm::ReduceL2:
-            case Algorithm::ReduceLogSum:
-            case Algorithm::ReduceMean:
-            case Algorithm::ReduceSum:
-            case Algorithm::ReduceSumSquare:
-            case Algorithm::ReduceLogSumExp:
-                uni_vaddps(xmm, xmm, op);
-                break;
-            case Algorithm::ReduceMax:
-                uni_vmaxps(xmm, xmm, op);
-                break;
-            case Algorithm::ReduceMin:
-                uni_vminps(xmm, xmm, op);
-                break;
-            case Algorithm::ReduceOr:
-                uni_vorps(xmm, xmm, op);
-                break;
-            case Algorithm::ReduceProd:
-                uni_vmulps(xmm, xmm, op);
-                break;
-            default:
-                assert(!"unsupported reduce mode");
+        case Algorithm::ReduceAnd:
+            uni_vandps(xmm, xmm, op);
+            break;
+        case Algorithm::ReduceL1:
+        case Algorithm::ReduceL2:
+        case Algorithm::ReduceLogSum:
+        case Algorithm::ReduceMean:
+        case Algorithm::ReduceSum:
+        case Algorithm::ReduceSumSquare:
+        case Algorithm::ReduceLogSumExp:
+            uni_vaddps(xmm, xmm, op);
+            break;
+        case Algorithm::ReduceMax:
+            uni_vmaxps(xmm, xmm, op);
+            break;
+        case Algorithm::ReduceMin:
+            uni_vminps(xmm, xmm, op);
+            break;
+        case Algorithm::ReduceOr:
+            uni_vorps(xmm, xmm, op);
+            break;
+        case Algorithm::ReduceProd:
+            uni_vmulps(xmm, xmm, op);
+            break;
+        default:
+            assert(!"unsupported reduce mode");
         }
     }
 };
 
-#endif // OPENVINO_ARCH_X86_64
-
-const std::map<const ov::DiscreteTypeInfo, std::function<void(const std::shared_ptr<ov::Node>& op, Reduce& node)>>& Reduce::getInitializers() {
-    static const std::map<const ov::DiscreteTypeInfo, std::function<void(const std::shared_ptr<ov::Node>&, Reduce&)>> initializers = {
-        {ov::opset4::ReduceL1::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
-            node.algorithm = Algorithm::ReduceL1;
-        }},
-        {ov::opset4::ReduceL2::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
-            node.algorithm = Algorithm::ReduceL2;
-        }},
-        {ov::opset1::ReduceLogicalAnd::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
-            node.algorithm = Algorithm::ReduceAnd;
-        }},
-        {ov::opset1::ReduceLogicalOr::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
-            node.algorithm = Algorithm::ReduceOr;
-        }},
-        {ov::opset1::ReduceMax::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
-            node.algorithm = Algorithm::ReduceMax;
-        }},
-        {ov::opset1::ReduceMean::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
-            node.algorithm = Algorithm::ReduceMean;
-        }},
-        {ov::opset1::ReduceMin::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
-            node.algorithm = Algorithm::ReduceMin;
-        }},
-        {ov::opset1::ReduceProd::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
-            node.algorithm = Algorithm::ReduceProd;
-        }},
-        {ov::opset1::ReduceSum::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
-            node.algorithm = Algorithm::ReduceSum;
-        }}
-    };
+#endif  // OPENVINO_ARCH_X86_64
+
+const std::map<const ov::DiscreteTypeInfo, std::function<void(const std::shared_ptr<ov::Node>& op, Reduce& node)>>&
+Reduce::getInitializers() {
+    static const std::map<const ov::DiscreteTypeInfo, std::function<void(const std::shared_ptr<ov::Node>&, Reduce&)>>
+        initializers = {
+            {ov::opset4::ReduceL1::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
+                 node.algorithm = Algorithm::ReduceL1;
+             }},
+            {ov::opset4::ReduceL2::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
+                 node.algorithm = Algorithm::ReduceL2;
+             }},
+            {ov::opset1::ReduceLogicalAnd::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
+                 node.algorithm = Algorithm::ReduceAnd;
+             }},
+            {ov::opset1::ReduceLogicalOr::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
+                 node.algorithm = Algorithm::ReduceOr;
+             }},
+            {ov::opset1::ReduceMax::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
+                 node.algorithm = Algorithm::ReduceMax;
+             }},
+            {ov::opset1::ReduceMean::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
+                 node.algorithm = Algorithm::ReduceMean;
+             }},
+            {ov::opset1::ReduceMin::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
+                 node.algorithm = Algorithm::ReduceMin;
+             }},
+            {ov::opset1::ReduceProd::get_type_info_static(),
+             [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
+                 node.algorithm = Algorithm::ReduceProd;
+             }},
+            {ov::opset1::ReduceSum::get_type_info_static(), [](const std::shared_ptr<ov::Node>& op, Reduce& node) {
+                 node.algorithm = Algorithm::ReduceSum;
+             }}};
     return initializers;
 }
 
 bool Reduce::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
         if (std::dynamic_pointer_cast<const ov::op::util::ArithmeticReductionKeepDims>(op) == nullptr &&
-                std::dynamic_pointer_cast<const ov::op::util::LogicalReductionKeepDims>(op) == nullptr) {
-            errorMessage = "Reduce node with name " + op->get_friendly_name() + " is not derived from ArithmeticReductionKeepDims or LogicalReductionKeepDims";
+            std::dynamic_pointer_cast<const ov::op::util::LogicalReductionKeepDims>(op) == nullptr) {
+            errorMessage = "Reduce node with name " + op->get_friendly_name() +
+                           " is not derived from ArithmeticReductionKeepDims or LogicalReductionKeepDims";
             return false;
         }
         if (const auto reduce = std::dynamic_pointer_cast<const ov::op::util::ArithmeticReductionKeepDims>(op)) {
-            auto reduceConst = std::dynamic_pointer_cast<const ov::opset1::Constant>(reduce->get_input_node_shared_ptr(REDUCE_INDEXES));
+            auto reduceConst = std::dynamic_pointer_cast<const ov::opset1::Constant>(
+                reduce->get_input_node_shared_ptr(REDUCE_INDEXES));
             if (!reduceConst) {
                 errorMessage = "Second tensor is not constant";
                 return false;
             }
         }
         if (const auto reduce = std::dynamic_pointer_cast<const ov::op::util::LogicalReductionKeepDims>(op)) {
-            auto reduceConst = std::dynamic_pointer_cast<const ov::opset1::Constant>(reduce->get_input_node_shared_ptr(REDUCE_INDEXES));
+            auto reduceConst = std::dynamic_pointer_cast<const ov::opset1::Constant>(
+                reduce->get_input_node_shared_ptr(REDUCE_INDEXES));
             if (!reduceConst) {
                 errorMessage = "Second tensor is not constant";
                 return false;
             }
         }
         if (getInitializers().find(op->get_type_info()) == getInitializers().end()) {
-            errorMessage = "Doesn't support Reduce algorithm: " +  std::string(op->get_type_info().name);
+            errorMessage = "Doesn't support Reduce algorithm: " + std::string(op->get_type_info().name);
             return false;
         }
         if (std::dynamic_pointer_cast<ov::opset1::Constant>(op->get_input_node_shared_ptr(REDUCE_INDEXES)) == nullptr) {
@@ -1902,13 +1958,15 @@ Reduce::Reduce(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr con
         getInitializers().at(op->get_type_info())(op, *this);
         if (const auto reduce = std::dynamic_pointer_cast<ov::op::util::ArithmeticReductionKeepDims>(op)) {
             keep_dims = reduce->get_keep_dims();
-            auto reduceConst = std::dynamic_pointer_cast<const ov::opset1::Constant>(reduce->get_input_node_shared_ptr(REDUCE_INDEXES));
+            auto reduceConst = std::dynamic_pointer_cast<const ov::opset1::Constant>(
+                reduce->get_input_node_shared_ptr(REDUCE_INDEXES));
             if (!reduceConst)
                 OPENVINO_THROW(errorPrefix, " second tensor is not constant!");
             raw_axes = reduceConst->cast_vector<int>();
         } else if (const auto reduce = std::dynamic_pointer_cast<ov::op::util::LogicalReductionKeepDims>(op)) {
             keep_dims = reduce->get_keep_dims();
-            auto reduceConst = std::dynamic_pointer_cast<const ov::opset1::Constant>(reduce->get_input_node_shared_ptr(REDUCE_INDEXES));
+            auto reduceConst = std::dynamic_pointer_cast<const ov::opset1::Constant>(
+                reduce->get_input_node_shared_ptr(REDUCE_INDEXES));
             if (!reduceConst)
                 OPENVINO_THROW(errorPrefix, " second tensor is not constant!");
             raw_axes = reduceConst->cast_vector<int>();
@@ -1940,7 +1998,8 @@ void Reduce::getSupportedDescriptors() {
     } else {
         // In fact, after the Reduce operation, the shape must be a scalar if the previous one was 1d.
         // But for now, 0d tensor (scalar) is emulated as 1d tensor. Skip checking in such cases.
-        bool is_emulated_0d_as_1d = getInputShapeAtPort(REDUCE_DATA).getRank() == 1 && getOutputShapeAtPort(0).getRank() == 1;
+        bool is_emulated_0d_as_1d =
+            getInputShapeAtPort(REDUCE_DATA).getRank() == 1 && getOutputShapeAtPort(0).getRank() == 1;
         if (getInputShapeAtPort(REDUCE_DATA).getRank() <= getOutputShapeAtPort(0).getRank() && !is_emulated_0d_as_1d)
             OPENVINO_THROW(errorPrefix, "gets incorrect number of input/output dimensions!");
     }
@@ -1960,14 +2019,15 @@ void Reduce::initSupportedPrimitiveDescriptors() {
 
     jit_mode = canApplyJIT(input_prec, output_prec);
 
-    auto is_precision_sensitive_reduce = [](const Algorithm &algorithm) {
+    auto is_precision_sensitive_reduce = [](const Algorithm& algorithm) {
         return algorithm != Algorithm::ReduceAnd && algorithm != Algorithm::ReduceOr &&
                algorithm != Algorithm::ReduceMin && algorithm != Algorithm::ReduceMax;
     };
 
     if (jit_mode) {
-        // Since in jit mode we use the output memory as an intermediate accumulator for certain reduce modes, we can't use BF16/FP16 output precision due to
-        // the possible accuracy loss. Therefore, for such mods, we will change the output precision to FP32.
+        // Since in jit mode we use the output memory as an intermediate accumulator for certain reduce modes, we can't
+        // use BF16/FP16 output precision due to the possible accuracy loss. Therefore, for such mods, we will change
+        // the output precision to FP32.
         if (ov::element::bf16 == output_prec) {
             if (!mayiuse(avx512_core) || is_precision_sensitive_reduce(algorithm))
                 output_prec = ov::element::f32;
@@ -1978,8 +2038,8 @@ void Reduce::initSupportedPrimitiveDescriptors() {
 
         if (!fusedWith.empty()) {
             // In jit mode we use the output memory as an intermediate accumulator for certain reduce modes.
-            // If the post ops node has a lower precision for such modes, working buffer with original precision is needed,
-            // in order to avoid accuracy loss.
+            // If the post ops node has a lower precision for such modes, working buffer with original precision is
+            // needed, in order to avoid accuracy loss.
             auto fused_prec = fusedWith[fusedWith.size() - 1]->getOriginalOutputPrecisionAtPort(0);
             if (output_prec == ov::element::f32 && fused_prec != ov::element::f32) {
                 if (algorithm != Algorithm::ReduceAnd && algorithm != Algorithm::ReduceOr &&
@@ -2012,15 +2072,21 @@ void Reduce::initSupportedPrimitiveDescriptors() {
 
     auto& creatorsMap = BlockedDescCreator::getCommonCreators();
 
-    auto pushDesc = [&](LayoutType inFormat, LayoutType outFormat, ov::element::Type inPrecision,
-            ov::element::Type outPrecision, impl_desc_type impl_type, bool useAclExecutor = false) {
-        config.inConfs[REDUCE_DATA].setMemDesc(creatorsMap.at(inFormat)->createSharedDesc(inPrecision, getInputShapeAtPort(REDUCE_DATA)));
-        config.inConfs[REDUCE_INDEXES].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(ov::element::i32,
-                                                                                                 getInputShapeAtPort(REDUCE_INDEXES)));
-        config.outConfs[0].setMemDesc(creatorsMap.at(outFormat)->createSharedDesc(outPrecision, getOutputShapeAtPort(0)));
+    auto pushDesc = [&](LayoutType inFormat,
+                        LayoutType outFormat,
+                        ov::element::Type inPrecision,
+                        ov::element::Type outPrecision,
+                        impl_desc_type impl_type,
+                        bool useAclExecutor = false) {
+        config.inConfs[REDUCE_DATA].setMemDesc(
+            creatorsMap.at(inFormat)->createSharedDesc(inPrecision, getInputShapeAtPort(REDUCE_DATA)));
+        config.inConfs[REDUCE_INDEXES].setMemDesc(
+            creatorsMap.at(LayoutType::ncsp)->createSharedDesc(ov::element::i32, getInputShapeAtPort(REDUCE_INDEXES)));
+        config.outConfs[0].setMemDesc(
+            creatorsMap.at(outFormat)->createSharedDesc(outPrecision, getOutputShapeAtPort(0)));
 
         if (useAclExecutor) {
-#if defined (OV_CPU_WITH_ACL)
+#if defined(OV_CPU_WITH_ACL)
             std::vector<MemoryDescPtr> srcMemoryDescs;
             for (size_t i = 0; i < config.inConfs.size(); i++) {
                 srcMemoryDescs.push_back(config.inConfs[i].getMemDesc());
@@ -2030,8 +2096,11 @@ void Reduce::initSupportedPrimitiveDescriptors() {
                 dstMemoryDescs.push_back(config.outConfs[i].getMemDesc());
             }
 
-            auto factory = std::make_shared<ReduceExecutorFactory>(reduceAttrs, srcMemoryDescs, dstMemoryDescs,
-                                                                   std::make_shared<ExecutorContext>(context, getImplPriority()));
+            auto factory =
+                std::make_shared<ReduceExecutorFactory>(reduceAttrs,
+                                                        srcMemoryDescs,
+                                                        dstMemoryDescs,
+                                                        std::make_shared<ExecutorContext>(context, getImplPriority()));
             if (!factory->isEmpty()) {
                 supportedPrimitiveDescriptors.push_back({config, impl_type, factory});
             }
@@ -2041,25 +2110,25 @@ void Reduce::initSupportedPrimitiveDescriptors() {
         }
     };
 
-#if defined (OV_CPU_WITH_ACL)
-        // acl doesn't support empty input
-        if (!isDynamicNode() && shape_size(getInputShapeAtPort(REDUCE_DATA).getStaticDims()) == 0) {
-            canUseAclExecutor = false;
-        } else {
-            reduceAttrs.operation = algorithm;
-            reduceAttrs.keepDims = keep_dims;
-            reduceAttrs.axes = raw_axes;
-            for (auto &axis : reduceAttrs.axes) {
-                if (axis < 0)
-                    axis += static_cast<int>(getInputShapeAtPort(REDUCE_DATA).getRank());
-            }
-            pushDesc(LayoutType::nspc, LayoutType::nspc, input_prec, output_prec, impl_desc_type::undef, true);
-            pushDesc(LayoutType::ncsp, LayoutType::ncsp, input_prec, output_prec, impl_desc_type::undef, true);
-            canUseAclExecutor = !supportedPrimitiveDescriptors.empty();
+#if defined(OV_CPU_WITH_ACL)
+    // acl doesn't support empty input
+    if (!isDynamicNode() && shape_size(getInputShapeAtPort(REDUCE_DATA).getStaticDims()) == 0) {
+        canUseAclExecutor = false;
+    } else {
+        reduceAttrs.operation = algorithm;
+        reduceAttrs.keepDims = keep_dims;
+        reduceAttrs.axes = raw_axes;
+        for (auto& axis : reduceAttrs.axes) {
+            if (axis < 0)
+                axis += static_cast<int>(getInputShapeAtPort(REDUCE_DATA).getRank());
         }
+        pushDesc(LayoutType::nspc, LayoutType::nspc, input_prec, output_prec, impl_desc_type::undef, true);
+        pushDesc(LayoutType::ncsp, LayoutType::ncsp, input_prec, output_prec, impl_desc_type::undef, true);
+        canUseAclExecutor = !supportedPrimitiveDescriptors.empty();
+    }
 
-        if (canUseAclExecutor)
-            return;
+    if (canUseAclExecutor)
+        return;
 #endif
 
     if (jit_mode) {
@@ -2072,7 +2141,7 @@ void Reduce::initSupportedPrimitiveDescriptors() {
 
         pushDesc(LayoutType::ncsp, LayoutType::ncsp, input_prec, output_prec, impl_type);
         if ((getInputShapeAtPort(REDUCE_DATA).getRank() == 4 || getInputShapeAtPort(REDUCE_DATA).getRank() == 5) &&
-                getInputShapeAtPort(REDUCE_DATA).getMinDims()[1] > 1) {
+            getInputShapeAtPort(REDUCE_DATA).getMinDims()[1] > 1) {
             if (keep_dims) {
                 if (mayiuse(cpu::x64::avx512_core)) {
                     pushDesc(LayoutType::nspc, LayoutType::nspc, input_prec, output_prec, impl_type);
@@ -2106,7 +2175,7 @@ void Reduce::prepareParams() {
     const auto& src_shape = srcMemPtr->getStaticDims();
     dst_size = dstMemPtr->getSize();
     empty_input = shape_size(src_shape) == 0;
-#if defined (OV_CPU_WITH_ACL)
+#if defined(OV_CPU_WITH_ACL)
     if (canUseAclExecutor) {
         std::vector<MemoryDescPtr> srcMemoryDescs;
         for (size_t i = 0; i < getParentEdges().size(); i++) {
@@ -2117,7 +2186,10 @@ void Reduce::prepareParams() {
 
         auto selectedPD = getSelectedPrimitiveDescriptor();
         if (!empty_input) {
-            aclExecPtr = selectedPD->getExecutorFactoryAs<ReduceExecutorFactory>()->makeExecutor(reduceAttrs, srcMemoryDescs, dstMemoryDescs, {});
+            aclExecPtr = selectedPD->getExecutorFactoryAs<ReduceExecutorFactory>()->makeExecutor(reduceAttrs,
+                                                                                                 srcMemoryDescs,
+                                                                                                 dstMemoryDescs,
+                                                                                                 {});
             selectedPD->setImplementationType(aclExecPtr->getImplType());
         } else {
             selectedPD->setImplementationType(acl);
@@ -2134,7 +2206,7 @@ void Reduce::prepareParams() {
         reduce_axes = raw_axes;
     }
 
-    const VectorDims &dst_dims = dstMemPtr->getDesc().getShape().getDims();
+    const VectorDims& dst_dims = dstMemPtr->getDesc().getShape().getDims();
     calc_process_dst_dims(reduce_axes, dst_dims);
     if (jit_mode) {
         set_reduce_dim_flags();
@@ -2153,7 +2225,7 @@ void Reduce::prepareParams() {
         } else if (mayiuse(cpu::x64::sse41)) {
             post_kernel.reset(new jit_uni_reduce_post_kernel_f32<cpu::x64::sse41>(key.jcp, *attr.get()));
         }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
         if (post_kernel)
             post_kernel->create_ker();
 
@@ -2164,7 +2236,8 @@ void Reduce::prepareParams() {
         setPostOps(attr, dst_dims, true);
 
         auto reduce_post_jcp = jcp;
-        reduce_post_jcp.src_dt = fuse_low_precision ? DnnlExtensionUtils::ElementTypeToDataType(intermediate_prec) : jcp.src_dt;
+        reduce_post_jcp.src_dt =
+            fuse_low_precision ? DnnlExtensionUtils::ElementTypeToDataType(intermediate_prec) : jcp.src_dt;
         reduce_post_jcp.src_data_size = DnnlExtensionUtils::sizeOfDataType(reduce_post_jcp.src_dt);
         ReduceKey key = {reduce_post_jcp, attr.get_post_ops()};
         auto cache = context->getParamsCache();
@@ -2211,8 +2284,10 @@ void Reduce::createPrimitive() {
 
     auto selectedPD = getSelectedPrimitiveDescriptor();
     jcp = jit_reduce_config_params();
-    jcp.src_dt = DnnlExtensionUtils::ElementTypeToDataType(selectedPD->getConfig().inConfs[REDUCE_DATA].getMemDesc()->getPrecision());
-    jcp.dst_dt = DnnlExtensionUtils::ElementTypeToDataType(selectedPD->getConfig().outConfs[0].getMemDesc()->getPrecision());
+    jcp.src_dt = DnnlExtensionUtils::ElementTypeToDataType(
+        selectedPD->getConfig().inConfs[REDUCE_DATA].getMemDesc()->getPrecision());
+    jcp.dst_dt =
+        DnnlExtensionUtils::ElementTypeToDataType(selectedPD->getConfig().outConfs[0].getMemDesc()->getPrecision());
     jcp.src_data_size = DnnlExtensionUtils::sizeOfDataType(jcp.src_dt);
     jcp.dst_data_size = DnnlExtensionUtils::sizeOfDataType(jcp.dst_dt);
     jcp.layout = layout;
@@ -2224,7 +2299,7 @@ void Reduce::createPrimitive() {
     compile_post_kernel = true;
 #else
     compile_post_kernel = false;
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
     if (mayiuse(cpu::x64::avx512_core)) {
         blk_size = 16;
@@ -2264,7 +2339,7 @@ void Reduce::createPrimitive() {
     }
 }
 
-void Reduce::create_reduce_kernel(std::shared_ptr<jit_uni_reduce_kernel> &kernel, const jit_reduce_config_params &jcp) {
+void Reduce::create_reduce_kernel(std::shared_ptr<jit_uni_reduce_kernel>& kernel, const jit_reduce_config_params& jcp) {
 #if defined(OPENVINO_ARCH_X86_64)
     if (mayiuse(cpu::x64::avx512_core)) {
         kernel.reset(new jit_uni_reduce_kernel_f32<cpu::x64::avx512_core>(jcp));
@@ -2273,7 +2348,7 @@ void Reduce::create_reduce_kernel(std::shared_ptr<jit_uni_reduce_kernel> &kernel
     } else if (mayiuse(cpu::x64::sse41)) {
         kernel.reset(new jit_uni_reduce_kernel_f32<cpu::x64::sse41>(jcp));
     }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
     if (kernel)
         kernel->create_ker();
     jit_mode = jit_mode && kernel;
@@ -2287,8 +2362,8 @@ void Reduce::execute(dnnl::stream strm) {
     auto dstMemPtr = getDstMemoryAtPort(0);
     auto srcMemPtr = getSrcMemoryAtPort(REDUCE_DATA);
 
-    const uint8_t *src_data = srcMemPtr->getDataAs<const uint8_t>();
-    uint8_t *dst_data = dstMemPtr->getDataAs<uint8_t>();
+    const uint8_t* src_data = srcMemPtr->getDataAs<const uint8_t>();
+    uint8_t* dst_data = dstMemPtr->getDataAs<uint8_t>();
 
     if (empty_input && dst_size > 0) {
 #if defined(OPENVINO_ARCH_X86_64)
@@ -2306,10 +2381,10 @@ void Reduce::execute(dnnl::stream strm) {
 
     if (jit_mode) {
         if (is_hybrid_layout) {
-            dst_data = reinterpret_cast<uint8_t *>(prc_mem.get_data_handle());
+            dst_data = reinterpret_cast<uint8_t*>(prc_mem.get_data_handle());
         }
         reduce_type(src_data, dst_data);
-#if defined (OV_CPU_WITH_ACL)
+#if defined(OV_CPU_WITH_ACL)
     } else if (aclExecPtr) {
         std::vector<MemoryCPtr> srcMemory;
         for (size_t i = 0; i < getParentEdges().size(); i++) {
@@ -2322,8 +2397,8 @@ void Reduce::execute(dnnl::stream strm) {
 #endif
     } else {
         if (layout == ReduceLayoutType::reduce_ncsp) {
-            auto in_ptr = reinterpret_cast<const float *>(src_data);
-            auto out_ptr = reinterpret_cast<float *>(dst_data);
+            auto in_ptr = reinterpret_cast<const float*>(src_data);
+            auto out_ptr = reinterpret_cast<float*>(dst_data);
             reduce_ref(in_ptr, out_ptr);
         } else {
             OPENVINO_THROW(errorPrefix, " supports only plain layout on machine w/o sse42.");
@@ -2331,7 +2406,7 @@ void Reduce::execute(dnnl::stream strm) {
     }
 }
 
-void Reduce::reduce_type(const uint8_t *in_ptr, uint8_t *out_ptr) {
+void Reduce::reduce_type(const uint8_t* in_ptr, uint8_t* out_ptr) {
     reduce_stride = IW;
 
     if (layout == ReduceLayoutType::reduce_ncsp || layout == ReduceLayoutType::reduce_nspc) {
@@ -2345,7 +2420,7 @@ void Reduce::reduce_type(const uint8_t *in_ptr, uint8_t *out_ptr) {
     }
 
     if (is_hybrid_layout) {
-        uint8_t *proc_ptr = out_ptr;
+        uint8_t* proc_ptr = out_ptr;
         auto dstMemPtr = getDstMemoryAtPort(0);
         out_ptr = dstMemPtr->getDataAs<uint8_t>();
         if (layout == ReduceLayoutType::reduce_nspc) {
@@ -2356,25 +2431,32 @@ void Reduce::reduce_type(const uint8_t *in_ptr, uint8_t *out_ptr) {
     }
 }
 
-void Reduce::reduce_PLN(const uint8_t *in_ptr, uint8_t *out_ptr) {
+void Reduce::reduce_PLN(const uint8_t* in_ptr, uint8_t* out_ptr) {
     output_info_reassign(&out_ptr);
     init_dst_data(out_ptr, dst_size);
 
     if (ReduceN && !ReduceC && !ReduceD && !ReduceH && !ReduceW) {
         size_t IA = IC * ID * IH * IW;
         reduce_stride = IA;
-        parallel_for(IA / blk_size, [&](size_t iba){
+        parallel_for(IA / blk_size, [&](size_t iba) {
             size_t oba = iba;
-            reduce_kernel_process(in_ptr + iba * blk_size * src_data_size, out_ptr + oba * blk_size * dst_data_size,
-                                  blk_size, 0, IB);
+            reduce_kernel_process(in_ptr + iba * blk_size * src_data_size,
+                                  out_ptr + oba * blk_size * dst_data_size,
+                                  blk_size,
+                                  0,
+                                  IB);
         });
 
         size_t tail_start = IA / blk_size * blk_size;
-        reduce_kernel_process(in_ptr + tail_start * src_data_size, out_ptr + tail_start * dst_data_size,
-                              IA - tail_start, 0, IB);
+        reduce_kernel_process(in_ptr + tail_start * src_data_size,
+                              out_ptr + tail_start * dst_data_size,
+                              IA - tail_start,
+                              0,
+                              IB);
     } else {
         for (size_t ib = 0; ib < IB; ib++) {
-            size_t ob = ReduceN ? 0 : ib; GET_PTR_N_PLN;
+            size_t ob = ReduceN ? 0 : ib;
+            GET_PTR_N_PLN;
             if (!ReduceC && !ReduceD && ReduceW) {
                 size_t work_amount = ReduceH ? IH * IW : IW;
                 if (work_amount < blk_size && mayiuse(cpu::x64::avx2)) {
@@ -2390,34 +2472,44 @@ void Reduce::reduce_PLN(const uint8_t *in_ptr, uint8_t *out_ptr) {
                         size_t ok = ik;
                         reduce_kernel_process(in_ptr_n + ik * blk_size * inner_size * src_data_size,
                                               out_ptr_n + ok * blk_size * output_inner_size * dst_data_size,
-                                              work_amount, 1, 0, static_cast<int *>(&index_buf[0]));
+                                              work_amount,
+                                              1,
+                                              0,
+                                              static_cast<int*>(&index_buf[0]));
                     });
                     size_t tail_start = IK * blk_size;
                     size_t IT = outer_size - tail_start;
                     parallel_for(IT, [&](size_t it) {
                         size_t ot = it;
                         reduce_kernel_process(in_ptr_n + (tail_start + it) * inner_size * src_data_size,
-                                              out_ptr_n + (tail_start + ot) * output_inner_size * dst_data_size, work_amount, 1);
+                                              out_ptr_n + (tail_start + ot) * output_inner_size * dst_data_size,
+                                              work_amount,
+                                              1);
                     });
                 } else {
                     if (ReduceH) {
                         parallel_for2d(IC, ID, [&](size_t ic, size_t id) {
-                            size_t oc = ic, od = id; GET_PTR_NCD_BASE_PTR_N_PLN;
+                            size_t oc = ic, od = id;
+                            GET_PTR_NCD_BASE_PTR_N_PLN;
                             reduce_kernel_process(in_ptr_ncd, out_ptr_ncd, work_amount, 1);
                         });
                     } else {
                         parallel_for3d(IC, ID, IH, [&](size_t ic, size_t id, size_t ih) {
-                            size_t oc = ic, od = id; GET_PTR_NCD_BASE_PTR_N_PLN;
-                            size_t oh = ih; GET_PTR_NCDH_PLN;
+                            size_t oc = ic, od = id;
+                            GET_PTR_NCD_BASE_PTR_N_PLN;
+                            size_t oh = ih;
+                            GET_PTR_NCDH_PLN;
                             reduce_kernel_process(in_ptr_ncdh, out_ptr_ncdh, work_amount, 1);
                         });
                     }
                 }
             } else if (ReduceH && ReduceW) {
                 for (size_t ic = 0; ic < IC; ic++) {
-                    size_t oc = ReduceC ? 0 : ic; GET_PTR_NC_PLN;
+                    size_t oc = ReduceC ? 0 : ic;
+                    GET_PTR_NC_PLN;
                     for (size_t id = 0; id < ID; id++) {
-                        size_t od = ReduceD ? 0 : id; GET_PTR_NCD_PLN;
+                        size_t od = ReduceD ? 0 : id;
+                        GET_PTR_NCD_PLN;
                         reduce_kernel_process(in_ptr_ncd, out_ptr_ncd, IH * IW, 1);
                     }
                 }
@@ -2425,32 +2517,44 @@ void Reduce::reduce_PLN(const uint8_t *in_ptr, uint8_t *out_ptr) {
                 if (ReduceCDW_opt) {
                     // reduce parallelly in HW dimensions
                     // step1: ReduceC && ReduceD && !ReduceH && !ReduceW
-                    uint8_t *prc_ptr_n = &vec_reduceCDW_prc[0];
+                    uint8_t* prc_ptr_n = &vec_reduceCDW_prc[0];
                     init_dst_data(prc_ptr_n, prc_size);
                     size_t IS = IH * IW;
                     reduce_stride = IS;
-                    parallel_for(IS / blk_size, [&](size_t ibs){
+                    parallel_for(IS / blk_size, [&](size_t ibs) {
                         size_t pbs = ibs;
-                        reduce_kernel_process(in_ptr_n + ibs * blk_size * src_data_size, prc_ptr_n + pbs * blk_size * prc_data_size,
-                                              blk_size, 0, IC * ID);
+                        reduce_kernel_process(in_ptr_n + ibs * blk_size * src_data_size,
+                                              prc_ptr_n + pbs * blk_size * prc_data_size,
+                                              blk_size,
+                                              0,
+                                              IC * ID);
                     });
                     size_t tail_start = IS / blk_size * blk_size;
-                    reduce_kernel_process(in_ptr_n + tail_start * src_data_size, prc_ptr_n + tail_start * prc_data_size,
-                                          IS - tail_start, 0, IC * ID);
+                    reduce_kernel_process(in_ptr_n + tail_start * src_data_size,
+                                          prc_ptr_n + tail_start * prc_data_size,
+                                          IS - tail_start,
+                                          0,
+                                          IC * ID);
                     // step2: ReduceW
                     reduce_kernel_reassign();
-                    parallel_for(PH, [&](size_t ph){
+                    parallel_for(PH, [&](size_t ph) {
                         size_t oh = ph;
-                        reduce_kernel_process(prc_ptr_n + ph * PW * prc_data_size, out_ptr_n + oh * OW * dst_data_size, IW, 1);
+                        reduce_kernel_process(prc_ptr_n + ph * PW * prc_data_size,
+                                              out_ptr_n + oh * OW * dst_data_size,
+                                              IW,
+                                              1);
                     });
                     reduce_kernel_restore();
                 } else {
                     for (size_t ic = 0; ic < IC; ic++) {
-                        size_t oc = ReduceC ? 0 : ic; GET_PTR_NC_PLN;
+                        size_t oc = ReduceC ? 0 : ic;
+                        GET_PTR_NC_PLN;
                         for (size_t id = 0; id < ID; id++) {
-                            size_t od = ReduceD ? 0 : id; GET_PTR_NCD_PLN;
-                            parallel_for(IH, [&](size_t ih){
-                                size_t oh = ih; GET_PTR_NCDH_PLN;
+                            size_t od = ReduceD ? 0 : id;
+                            GET_PTR_NCD_PLN;
+                            parallel_for(IH, [&](size_t ih) {
+                                size_t oh = ih;
+                                GET_PTR_NCDH_PLN;
                                 reduce_kernel_process(in_ptr_ncdh, out_ptr_ncdh, IW, 1);
                             });
                         }
@@ -2458,26 +2562,36 @@ void Reduce::reduce_PLN(const uint8_t *in_ptr, uint8_t *out_ptr) {
                 }
             } else if (ReduceW) {
                 for (size_t ic = 0; ic < IC; ic++) {
-                    size_t oc = ReduceC ? 0 : ic; GET_PTR_NC_PLN;
+                    size_t oc = ReduceC ? 0 : ic;
+                    GET_PTR_NC_PLN;
                     for (size_t id = 0; id < ID; id++) {
-                        size_t od = ReduceD ? 0 : id; GET_PTR_NCD_PLN;
+                        size_t od = ReduceD ? 0 : id;
+                        GET_PTR_NCD_PLN;
                         for (size_t ih = 0; ih < IH; ih++) {
-                            size_t oh = ReduceH ? 0 : ih; GET_PTR_NCDH_PLN;
+                            size_t oh = ReduceH ? 0 : ih;
+                            GET_PTR_NCDH_PLN;
                             reduce_kernel_process(in_ptr_ncdh, out_ptr_ncdh, IW, 1);
                         }
                     }
                 }
             } else if (!ReduceC && !ReduceD && ReduceH && !ReduceW) {
                 parallel_for2d(IC, ID, [&](size_t ic, size_t id) {
-                    size_t oc = ic, od = id; GET_PTR_NCD_BASE_PTR_N_PLN;
-                    parallel_for(IW / blk_size, [&](size_t ibw){
+                    size_t oc = ic, od = id;
+                    GET_PTR_NCD_BASE_PTR_N_PLN;
+                    parallel_for(IW / blk_size, [&](size_t ibw) {
                         size_t obw = ibw;
-                        reduce_kernel_process(in_ptr_ncd + ibw * blk_size * src_data_size, out_ptr_ncd + obw * blk_size * dst_data_size,
-                                              blk_size, 0, IH);
+                        reduce_kernel_process(in_ptr_ncd + ibw * blk_size * src_data_size,
+                                              out_ptr_ncd + obw * blk_size * dst_data_size,
+                                              blk_size,
+                                              0,
+                                              IH);
                     });
                     size_t tail_start = IW / blk_size * blk_size;
-                    reduce_kernel_process(in_ptr_ncd + tail_start * src_data_size, out_ptr_ncd + tail_start * dst_data_size,
-                                          IW - tail_start, 0, IH);
+                    reduce_kernel_process(in_ptr_ncd + tail_start * src_data_size,
+                                          out_ptr_ncd + tail_start * dst_data_size,
+                                          IW - tail_start,
+                                          0,
+                                          IH);
                 });
             } else if (!ReduceC && ReduceD && ReduceH && !ReduceW) {
                 size_t IWB = IW / blk_size;
@@ -2485,20 +2599,26 @@ void Reduce::reduce_PLN(const uint8_t *in_ptr, uint8_t *out_ptr) {
                     if (IWB > 0) {
                         // reduce parallelly in D dimension
                         // step1: !ReduceD && ReduceH && !ReduceW
-                        uint8_t *prc_ptr_n = &vec_reduceDH_prc[0];
+                        uint8_t* prc_ptr_n = &vec_reduceDH_prc[0];
                         init_dst_data(prc_ptr_n, prc_size);
-                        parallel_for2d(ID, IWB, [&](size_t id, size_t iwb){
+                        parallel_for2d(ID, IWB, [&](size_t id, size_t iwb) {
                             size_t pd = id, pwb = iwb;
                             reduce_kernel_process(in_ptr_n + (id * IH * IW + iwb * blk_size) * src_data_size,
-                                                prc_ptr_n + (pd * PW + pwb * blk_size) * prc_data_size, blk_size, 0, IH);
+                                                  prc_ptr_n + (pd * PW + pwb * blk_size) * prc_data_size,
+                                                  blk_size,
+                                                  0,
+                                                  IH);
                         });
                         // step2: ReduceD
                         reduce_stride = PW;
                         reduce_kernel_reassign();
-                        parallel_for(IWB, [&](size_t iwb){
+                        parallel_for(IWB, [&](size_t iwb) {
                             size_t pwb = iwb, owb = iwb;
                             reduce_kernel_process(prc_ptr_n + pwb * blk_size * prc_data_size,
-                                                out_ptr_n + owb * blk_size * dst_data_size, blk_size, 0, ID);
+                                                  out_ptr_n + owb * blk_size * dst_data_size,
+                                                  blk_size,
+                                                  0,
+                                                  ID);
                         });
                         reduce_kernel_restore();
                     }
@@ -2506,60 +2626,90 @@ void Reduce::reduce_PLN(const uint8_t *in_ptr, uint8_t *out_ptr) {
                     reduce_stride = IW;
                     size_t tail_start = IWB * blk_size;
                     parallel_for(IW - tail_start, [&](size_t i_tail) {
-                        reduce_kernel_process(in_ptr_n + (tail_start + i_tail) * src_data_size, out_ptr_n + (tail_start + i_tail) * dst_data_size,
-                                            1, 0, ID * IH);
+                        reduce_kernel_process(in_ptr_n + (tail_start + i_tail) * src_data_size,
+                                              out_ptr_n + (tail_start + i_tail) * dst_data_size,
+                                              1,
+                                              0,
+                                              ID * IH);
                     });
                 } else {
                     parallel_for(IC, [&](size_t ic) {
-                        size_t oc = ic; GET_PTR_NC_PLN;
-                        parallel_for(IWB, [&](size_t iwb){
+                        size_t oc = ic;
+                        GET_PTR_NC_PLN;
+                        parallel_for(IWB, [&](size_t iwb) {
                             size_t owb = iwb;
-                            reduce_kernel_process(in_ptr_nc + iwb * blk_size * src_data_size, out_ptr_nc + owb * blk_size * dst_data_size,
-                                                blk_size, 0, ID * IH);
+                            reduce_kernel_process(in_ptr_nc + iwb * blk_size * src_data_size,
+                                                  out_ptr_nc + owb * blk_size * dst_data_size,
+                                                  blk_size,
+                                                  0,
+                                                  ID * IH);
                         });
                         size_t tail_start = IWB * blk_size;
                         parallel_for(IW - tail_start, [&](size_t i_tail) {
-                            reduce_kernel_process(in_ptr_nc + (tail_start + i_tail) * src_data_size, out_ptr_nc + (tail_start + i_tail) * dst_data_size,
-                                                1, 0, ID * IH);
+                            reduce_kernel_process(in_ptr_nc + (tail_start + i_tail) * src_data_size,
+                                                  out_ptr_nc + (tail_start + i_tail) * dst_data_size,
+                                                  1,
+                                                  0,
+                                                  ID * IH);
                         });
                     });
                 }
             } else if (ReduceC && ReduceD && ReduceH && !ReduceW) {
-                parallel_for(IW / blk_size, [&](size_t ibw){
+                parallel_for(IW / blk_size, [&](size_t ibw) {
                     size_t obw = ibw;
-                    reduce_kernel_process(in_ptr_n + ibw * blk_size * src_data_size, out_ptr_n + obw * blk_size * dst_data_size,
-                                          blk_size, 0, IC * ID * IH);
+                    reduce_kernel_process(in_ptr_n + ibw * blk_size * src_data_size,
+                                          out_ptr_n + obw * blk_size * dst_data_size,
+                                          blk_size,
+                                          0,
+                                          IC * ID * IH);
                 });
 
                 size_t tail_start = IW / blk_size * blk_size;
-                reduce_kernel_process(in_ptr_n + tail_start * src_data_size, out_ptr_n + tail_start * dst_data_size,
-                                      IW - tail_start, 0, IC * ID * IH);
+                reduce_kernel_process(in_ptr_n + tail_start * src_data_size,
+                                      out_ptr_n + tail_start * dst_data_size,
+                                      IW - tail_start,
+                                      0,
+                                      IC * ID * IH);
             } else if (ReduceC && !ReduceD && !ReduceH && !ReduceW) {
                 size_t IS = ID * IH * IW;
                 reduce_stride = IS;
-                parallel_for(IS / blk_size, [&](size_t ibs){
+                parallel_for(IS / blk_size, [&](size_t ibs) {
                     size_t obs = ibs;
-                    reduce_kernel_process(in_ptr_n + ibs * blk_size * src_data_size, out_ptr_n + obs * blk_size * dst_data_size,
-                                          blk_size, 0, IC);
+                    reduce_kernel_process(in_ptr_n + ibs * blk_size * src_data_size,
+                                          out_ptr_n + obs * blk_size * dst_data_size,
+                                          blk_size,
+                                          0,
+                                          IC);
                 });
 
                 size_t tail_start = IS / blk_size * blk_size;
-                reduce_kernel_process(in_ptr_n + tail_start * src_data_size, out_ptr_n + tail_start * dst_data_size,
-                                      IS - tail_start, 0, IC);
+                reduce_kernel_process(in_ptr_n + tail_start * src_data_size,
+                                      out_ptr_n + tail_start * dst_data_size,
+                                      IS - tail_start,
+                                      0,
+                                      IC);
             } else {
                 for (size_t ic = 0; ic < IC; ic++) {
-                    size_t oc = ReduceC ? 0 : ic; GET_PTR_NC_PLN;
+                    size_t oc = ReduceC ? 0 : ic;
+                    GET_PTR_NC_PLN;
                     for (size_t id = 0; id < ID; id++) {
-                        size_t od = ReduceD ? 0 : id; GET_PTR_NCD_PLN;
+                        size_t od = ReduceD ? 0 : id;
+                        GET_PTR_NCD_PLN;
                         for (size_t ih = 0; ih < IH; ih++) {
-                            size_t oh = ReduceH ? 0 : ih; GET_PTR_NCDH_PLN;
+                            size_t oh = ReduceH ? 0 : ih;
+                            GET_PTR_NCDH_PLN;
                             for (size_t ibw = 0; ibw < IW / blk_size; ibw++) {
                                 size_t obw = ibw;
                                 reduce_kernel_process(in_ptr_ncdh + ibw * blk_size * src_data_size,
-                                                      out_ptr_ncdh + obw * blk_size * dst_data_size, blk_size, 0);
+                                                      out_ptr_ncdh + obw * blk_size * dst_data_size,
+                                                      blk_size,
+                                                      0);
                             }
                             size_t tail_start = IW / blk_size * blk_size;
-                            reduce_kernel_process(in_ptr_ncdh + tail_start * src_data_size, out_ptr_ncdh + tail_start * dst_data_size, IW - tail_start, 0);
+                            reduce_kernel_process(in_ptr_ncdh + tail_start * src_data_size,
+                                                  out_ptr_ncdh + tail_start * dst_data_size,
+                                                  IW - tail_start,
+                                                  0);
                         }
                     }
                 }
@@ -2571,21 +2721,23 @@ void Reduce::reduce_PLN(const uint8_t *in_ptr, uint8_t *out_ptr) {
     reduce_kernel_post_process(out_ptr);
 }
 
-void Reduce::reduce_BLK(const uint8_t *in_ptr, uint8_t *out_ptr) {
+void Reduce::reduce_BLK(const uint8_t* in_ptr, uint8_t* out_ptr) {
     size_t ICB = div_up(IC, blk_size);
     size_t OCB = div_up(OC, blk_size);
     output_info_reassign(&out_ptr);
     init_dst_data(out_ptr, dst_size);
 
     for (size_t ib = 0; ib < IB; ib++) {
-        size_t ob = ReduceN ? 0 : ib; GET_PTR_N_BLK;
+        size_t ob = ReduceN ? 0 : ib;
+        GET_PTR_N_BLK;
         if (!ReduceC && !ReduceD && ReduceH && ReduceW) {
             if (!ReduceN || (ReduceN && ib == IB - 1)) {
                 apply_division = getAlgorithm() == Algorithm::ReduceMean && attr.get()->post_ops_.len() == 0;
                 apply_post_kernel = !apply_division;
             }
             parallel_for2d(ICB, ID, [&](size_t icb, size_t id) {
-                size_t ocb = icb, od = id; GET_PTR_NCD_BASE_PTR_N_BLK;
+                size_t ocb = icb, od = id;
+                GET_PTR_NCD_BASE_PTR_N_BLK;
                 reduce_kernel_process(in_ptr_ncd, out_ptr_ncd, IH * IW * blk_size);
             });
         } else if (ReduceC && ReduceD && ReduceH && ReduceW) {
@@ -2595,10 +2747,11 @@ void Reduce::reduce_BLK(const uint8_t *in_ptr, uint8_t *out_ptr) {
                 size_t prc_size = ICB * blk_size * dst_data_size;
                 std::vector<uint8_t> vec_prc(prc_size);
                 init_dst_data(vec_prc.data(), prc_size);
-                uint8_t *out_ptr_n_cp = out_ptr_n;
+                uint8_t* out_ptr_n_cp = out_ptr_n;
                 out_ptr_n = vec_prc.data();
                 parallel_for(ICB, [&](size_t icb) {
-                    size_t ocb = icb; GET_PTR_NC_BLK;
+                    size_t ocb = icb;
+                    GET_PTR_NC_BLK;
                     reduce_kernel_process(in_ptr_nc, out_ptr_nc, ID * IH * IW * blk_size);
                 });
                 // step2: ReduceC
@@ -2610,11 +2763,14 @@ void Reduce::reduce_BLK(const uint8_t *in_ptr, uint8_t *out_ptr) {
             }
         } else if (ReduceW) {
             for (size_t icb = 0; icb < ICB; icb++) {
-                size_t ocb = ReduceC ? 0 : icb; GET_PTR_NC_BLK;
+                size_t ocb = ReduceC ? 0 : icb;
+                GET_PTR_NC_BLK;
                 for (size_t id = 0; id < ID; id++) {
-                    size_t od = ReduceD ? 0 : id; GET_PTR_NCD_BLK;
+                    size_t od = ReduceD ? 0 : id;
+                    GET_PTR_NCD_BLK;
                     for (size_t ih = 0; ih < IH; ih++) {
-                        size_t oh = ReduceH ? 0 : ih; GET_PTR_NCDH_BLK;
+                        size_t oh = ReduceH ? 0 : ih;
+                        GET_PTR_NCDH_BLK;
                         reduce_kernel_process(in_ptr_ncdh, out_ptr_ncdh, IW * blk_size);
                     }
                 }
@@ -2622,21 +2778,29 @@ void Reduce::reduce_BLK(const uint8_t *in_ptr, uint8_t *out_ptr) {
         } else if (ReduceC && !ReduceD && !ReduceH && !ReduceW) {
             reduce_stride = ID * IH * IW * blk_size;
             parallel_for3d(ID, IH, IW, [&](size_t id, size_t ih, size_t iw) {
-                size_t icb = 0, ocb = 0; GET_PTR_NC_BLK;
-                size_t od = id; GET_PTR_NCD_BLK;
-                size_t oh = ih; GET_PTR_NCDH_BLK;
-                size_t ow = iw; GET_PTR_NCDHW_BLK;
+                size_t icb = 0, ocb = 0;
+                GET_PTR_NC_BLK;
+                size_t od = id;
+                GET_PTR_NCD_BLK;
+                size_t oh = ih;
+                GET_PTR_NCDH_BLK;
+                size_t ow = iw;
+                GET_PTR_NCDHW_BLK;
                 reduce_kernel_process(in_ptr_ncdhw, out_ptr_ncdhw, blk_size, 0, ICB);
             });
         } else {
             for (size_t icb = 0; icb < ICB; icb++) {
-                size_t ocb = ReduceC ? 0 : icb; GET_PTR_NC_BLK;
+                size_t ocb = ReduceC ? 0 : icb;
+                GET_PTR_NC_BLK;
                 for (size_t id = 0; id < ID; id++) {
-                    size_t od = ReduceD ? 0 : id; GET_PTR_NCD_BLK;
+                    size_t od = ReduceD ? 0 : id;
+                    GET_PTR_NCD_BLK;
                     for (size_t ih = 0; ih < IH; ih++) {
-                        size_t oh = ReduceH ? 0 : ih; GET_PTR_NCDH_BLK;
+                        size_t oh = ReduceH ? 0 : ih;
+                        GET_PTR_NCDH_BLK;
                         parallel_for(IW, [&](size_t iw) {
-                            size_t ow = iw; GET_PTR_NCDHW_BLK;
+                            size_t ow = iw;
+                            GET_PTR_NCDHW_BLK;
                             reduce_kernel_process(in_ptr_ncdhw, out_ptr_ncdhw, blk_size);
                         });
                     }
@@ -2651,31 +2815,36 @@ void Reduce::reduce_BLK(const uint8_t *in_ptr, uint8_t *out_ptr) {
     }
 }
 
-void Reduce::reduce_BLK_concern_padding(const uint8_t *in_ptr, uint8_t *out_ptr) {
+void Reduce::reduce_BLK_concern_padding(const uint8_t* in_ptr, uint8_t* out_ptr) {
     size_t ICB = div_up(IC, blk_size);
     size_t OCB = div_up(OC, blk_size);
     output_info_reassign(&out_ptr);
     init_dst_data(out_ptr, dst_size);
 
-    auto reduceSkipPadding = [&](const uint8_t *in_ptr_ncd, uint8_t *out_ptr_ncd, size_t ic) {
+    auto reduceSkipPadding = [&](const uint8_t* in_ptr_ncd, uint8_t* out_ptr_ncd, size_t ic) {
         size_t blk_valid_size = IC - ic;
         for (size_t ih = 0; ih < IH; ih++) {
-            size_t oh = ReduceH ? 0 : ih; GET_PTR_NCDH_BLK;
+            size_t oh = ReduceH ? 0 : ih;
+            GET_PTR_NCDH_BLK;
             for (size_t iw = 0; iw < IW; iw++) {
-                size_t ow = ReduceW ? 0 : iw; GET_PTR_NCDHW_BLK;
+                size_t ow = ReduceW ? 0 : iw;
+                GET_PTR_NCDHW_BLK;
                 reduce_kernel_process(in_ptr_ncdhw, out_ptr_ncdhw, blk_valid_size);
             }
         }
     };
 
     for (size_t ib = 0; ib < IB; ib++) {
-        size_t ob = ReduceN ? 0 : ib; GET_PTR_N_BLK;
+        size_t ob = ReduceN ? 0 : ib;
+        GET_PTR_N_BLK;
         if (!ReduceD && ReduceH && ReduceW) {
             for (size_t icb = 0; icb < ICB; icb++) {
-                size_t ocb = 0;;
+                size_t ocb = 0;
+                ;
                 size_t ic = icb * blk_size;
                 parallel_for(ID, [&](size_t id) {
-                    size_t od = id; GET_PTR_NCD_BASE_PTR_N_BLK;
+                    size_t od = id;
+                    GET_PTR_NCD_BASE_PTR_N_BLK;
                     if (ic + blk_size <= IC) {
                         reduce_kernel_process(in_ptr_ncd, out_ptr_ncd, IH * IW * blk_size);
                     } else {
@@ -2685,26 +2854,31 @@ void Reduce::reduce_BLK_concern_padding(const uint8_t *in_ptr, uint8_t *out_ptr)
             }
         } else if (ReduceD && ReduceH && ReduceW) {
             for (size_t icb = 0; icb < ICB; icb++) {
-                size_t ocb = 0; GET_PTR_NC_BLK;
+                size_t ocb = 0;
+                GET_PTR_NC_BLK;
                 size_t ic = icb * blk_size;
                 if (ic + blk_size <= IC) {
                     reduce_kernel_process(in_ptr_nc, out_ptr_nc, ID * IH * IW * blk_size);
                 } else {
                     for (size_t id = 0; id < ID; id++) {
-                        size_t od = 0; GET_PTR_NCD_BLK;
+                        size_t od = 0;
+                        GET_PTR_NCD_BLK;
                         reduceSkipPadding(in_ptr_ncd, out_ptr_ncd, ic);
                     }
                 }
             }
         } else if (ReduceW) {
             for (size_t icb = 0; icb < ICB; icb++) {
-                size_t ocb = 0; GET_PTR_NC_BLK;
+                size_t ocb = 0;
+                GET_PTR_NC_BLK;
                 size_t ic = icb * blk_size;
                 for (size_t id = 0; id < ID; id++) {
-                    size_t od = ReduceD ? 0 : id; GET_PTR_NCD_BLK;
+                    size_t od = ReduceD ? 0 : id;
+                    GET_PTR_NCD_BLK;
                     if (ic + blk_size <= IC) {
                         for (size_t ih = 0; ih < IH; ih++) {
-                            size_t oh = ReduceH ? 0 : ih; GET_PTR_NCDH_BLK;
+                            size_t oh = ReduceH ? 0 : ih;
+                            GET_PTR_NCDH_BLK;
                             reduce_kernel_process(in_ptr_ncdh, out_ptr_ncdh, IW * blk_size);
                         }
                     } else {
@@ -2714,15 +2888,19 @@ void Reduce::reduce_BLK_concern_padding(const uint8_t *in_ptr, uint8_t *out_ptr)
             }
         } else {
             for (size_t icb = 0; icb < ICB; icb++) {
-                size_t ocb = 0; GET_PTR_NC_BLK;
+                size_t ocb = 0;
+                GET_PTR_NC_BLK;
                 size_t ic = icb * blk_size;
                 for (size_t id = 0; id < ID; id++) {
-                    size_t od = ReduceD ? 0 : id; GET_PTR_NCD_BLK;
+                    size_t od = ReduceD ? 0 : id;
+                    GET_PTR_NCD_BLK;
                     if (ic + blk_size <= IC) {
                         for (size_t ih = 0; ih < IH; ih++) {
-                            size_t oh = ReduceH ? 0 : ih; GET_PTR_NCDH_BLK;
+                            size_t oh = ReduceH ? 0 : ih;
+                            GET_PTR_NCDH_BLK;
                             parallel_for(IW, [&](size_t iw) {
-                                size_t ow = iw; GET_PTR_NCDHW_BLK;
+                                size_t ow = iw;
+                                GET_PTR_NCDHW_BLK;
                                 reduce_kernel_process(in_ptr_ncdhw, out_ptr_ncdhw, blk_size);
                             });
                         }
@@ -2738,13 +2916,17 @@ void Reduce::reduce_BLK_concern_padding(const uint8_t *in_ptr, uint8_t *out_ptr)
     reduce_kernel_post_process(out_ptr);
 }
 
-inline void Reduce::reduce_kernel_process(const uint8_t *in_p, uint8_t *out_p, size_t work_amount,
-                                                    size_t reduce_w, size_t work_batch, const int *tab_idx) {
+inline void Reduce::reduce_kernel_process(const uint8_t* in_p,
+                                          uint8_t* out_p,
+                                          size_t work_amount,
+                                          size_t reduce_w,
+                                          size_t work_batch,
+                                          const int* tab_idx) {
     const float divisor = apply_division ? static_cast<float>(IB * IC * ID * IH * IW / (OB * OC * OD * OH * OW)) : 1;
     auto arg = jit_reduce_call_args();
-    arg.src = static_cast<const void *>(in_p);
+    arg.src = static_cast<const void*>(in_p);
     arg.idx = tab_idx;
-    arg.dst = static_cast<void *>(out_p);
+    arg.dst = static_cast<void*>(out_p);
     arg.work_amount = work_amount;
     arg.work_batch = work_batch;
     arg.reduce_w = reduce_w;
@@ -2755,22 +2937,22 @@ inline void Reduce::reduce_kernel_process(const uint8_t *in_p, uint8_t *out_p, s
     (*reduce_kernel)(&arg);
 }
 
-inline void Reduce::reduce_kernel_post_process(uint8_t *out_ptr) {
-    const uint8_t *in_ptr = fuse_low_precision ? static_cast<uint8_t *>(&intermediate_buf[0]) : nullptr;
+inline void Reduce::reduce_kernel_post_process(uint8_t* out_ptr) {
+    const uint8_t* in_ptr = fuse_low_precision ? static_cast<uint8_t*>(&intermediate_buf[0]) : nullptr;
     const size_t integerDivisor = empty_input ? 1 : IB * IC * ID * IH * IW / (OB * OC * OD * OH * OW);
     const float divisor = static_cast<float>(integerDivisor);
     if (layout == ReduceLayoutType::reduce_ncsp) {
         parallel_for2d(OB, OC, [&](size_t ob, size_t oc) {
-            const uint8_t *in_p = in_ptr + (ob * OC + oc) * OD * OH * OW * intermediate_data_size;
-            uint8_t *out_p = out_ptr + (ob * OC + oc) * OD * OH * OW * dst_data_size;
+            const uint8_t* in_p = in_ptr + (ob * OC + oc) * OD * OH * OW * intermediate_data_size;
+            uint8_t* out_p = out_ptr + (ob * OC + oc) * OD * OH * OW * dst_data_size;
             auto arg = jit_reduce_post_call_args();
-            arg.src = static_cast<const void *>(in_p);
-            arg.dst = static_cast<void *>(out_p);
+            arg.src = static_cast<const void*>(in_p);
+            arg.dst = static_cast<void*>(out_p);
             arg.oc_off = oc * sizeof(float);
             arg.channel_size = OC;
             arg.work_amount = OD * OH * OW;
             arg.divisor = &divisor;
-            arg.post_op_data = static_cast<const void **>(postOpsDataPtrs.data());
+            arg.post_op_data = static_cast<const void**>(postOpsDataPtrs.data());
             (*reduce_post_kernel)(&arg);
         });
     } else if (layout == ReduceLayoutType::reduce_nspc) {
@@ -2780,16 +2962,16 @@ inline void Reduce::reduce_kernel_post_process(uint8_t *out_ptr) {
             OP *= OH;
         size_t work_amount = OB * OC * OD * OH * OW / OP;
         auto op_loop = [&](size_t op) {
-            const uint8_t *in_p = in_ptr + op * work_amount * intermediate_data_size;
-            uint8_t *out_p = out_ptr + op * work_amount * dst_data_size;
+            const uint8_t* in_p = in_ptr + op * work_amount * intermediate_data_size;
+            uint8_t* out_p = out_ptr + op * work_amount * dst_data_size;
             auto arg = jit_reduce_post_call_args();
-            arg.src = static_cast<const void *>(in_p);
-            arg.dst = static_cast<void *>(out_p);
+            arg.src = static_cast<const void*>(in_p);
+            arg.dst = static_cast<void*>(out_p);
             arg.oc_off = 0;
-            arg.channel_size = OW; // OW is related to nspc-ncsp dimension reinterpret
+            arg.channel_size = OW;  // OW is related to nspc-ncsp dimension reinterpret
             arg.work_amount = work_amount;
             arg.divisor = &divisor;
-            arg.post_op_data = static_cast<const void **>(postOpsDataPtrs.data());
+            arg.post_op_data = static_cast<const void**>(postOpsDataPtrs.data());
             (*reduce_post_kernel)(&arg);
         };
 
@@ -2799,16 +2981,16 @@ inline void Reduce::reduce_kernel_post_process(uint8_t *out_ptr) {
     } else {
         size_t OCB = div_up(OC, blk_size);
         parallel_for2d(OB, OCB, [&](size_t ob, size_t ocb) {
-            const uint8_t *in_p = in_ptr + (ob * OCB + ocb) * OD * OH * OW * blk_size * intermediate_data_size;
-            uint8_t *out_p = out_ptr + (ob * OCB + ocb) * OD * OH * OW * blk_size * dst_data_size;
+            const uint8_t* in_p = in_ptr + (ob * OCB + ocb) * OD * OH * OW * blk_size * intermediate_data_size;
+            uint8_t* out_p = out_ptr + (ob * OCB + ocb) * OD * OH * OW * blk_size * dst_data_size;
             auto arg = jit_reduce_post_call_args();
-            arg.src = static_cast<const void *>(in_p);
-            arg.dst = static_cast<void *>(out_p);
+            arg.src = static_cast<const void*>(in_p);
+            arg.dst = static_cast<void*>(out_p);
             arg.reduce_c = ReduceC ? 1 : 0;
             arg.oc_off = ocb * blk_size * sizeof(float);
             arg.work_amount = OD * OH * OW * blk_size;
             arg.divisor = &divisor;
-            arg.post_op_data = static_cast<const void **>(postOpsDataPtrs.data());
+            arg.post_op_data = static_cast<const void**>(postOpsDataPtrs.data());
             (*reduce_post_kernel)(&arg);
         });
     }
@@ -2826,10 +3008,10 @@ inline void Reduce::reduce_kernel_restore() {
     }
 }
 
-inline void Reduce::output_info_reassign(uint8_t **out_ptr) {
+inline void Reduce::output_info_reassign(uint8_t** out_ptr) {
     if (fuse_low_precision) {
         tmp_ptr = *out_ptr;
-        *out_ptr = static_cast<uint8_t *>(&intermediate_buf[0]);
+        *out_ptr = static_cast<uint8_t*>(&intermediate_buf[0]);
         tmp_prec = output_prec;
         output_prec = intermediate_prec;
         tmp_data_size = dst_data_size;
@@ -2838,7 +3020,7 @@ inline void Reduce::output_info_reassign(uint8_t **out_ptr) {
         dst_size = intermediate_size;
     }
 }
-inline void Reduce::output_info_restore(uint8_t **out_ptr) {
+inline void Reduce::output_info_restore(uint8_t** out_ptr) {
     if (fuse_low_precision) {
         *out_ptr = tmp_ptr;
         output_prec = tmp_prec;
@@ -2847,7 +3029,7 @@ inline void Reduce::output_info_restore(uint8_t **out_ptr) {
     }
 }
 
-void Reduce::nspc2ncsp(uint8_t *proc_ptr, uint8_t *out_ptr) {
+void Reduce::nspc2ncsp(uint8_t* proc_ptr, uint8_t* out_ptr) {
     // dimension reinterpret after nspc reusing routine reduce_PLN
     // demote -- nspc -- ncsp
     //  DIM0  --   B  --  B
@@ -2864,8 +3046,8 @@ void Reduce::nspc2ncsp(uint8_t *proc_ptr, uint8_t *out_ptr) {
     const size_t stride0 = stride1 * DIM1;
 
     if (dst_data_size == 4) {
-        auto src_data = reinterpret_cast<const float *>(proc_ptr);
-        auto dst_data = reinterpret_cast<float *>(out_ptr);
+        auto src_data = reinterpret_cast<const float*>(proc_ptr);
+        auto dst_data = reinterpret_cast<float*>(out_ptr);
         parallel_for2d(DIM0, stride1, [&](size_t b, size_t j) {
             auto src_off = b * stride0 + j * DIM1;
             auto dst_off = b * stride0 + j;
@@ -2876,8 +3058,8 @@ void Reduce::nspc2ncsp(uint8_t *proc_ptr, uint8_t *out_ptr) {
             }
         });
     } else if (dst_data_size == 2) {
-        auto src_data = reinterpret_cast<const uint16_t *>(proc_ptr);
-        auto dst_data = reinterpret_cast<uint16_t *>(out_ptr);
+        auto src_data = reinterpret_cast<const uint16_t*>(proc_ptr);
+        auto dst_data = reinterpret_cast<uint16_t*>(out_ptr);
         parallel_for2d(DIM0, stride1, [&](size_t b, size_t j) {
             auto src_off = b * stride0 + j * DIM1;
             auto dst_off = b * stride0 + j;
@@ -2888,8 +3070,8 @@ void Reduce::nspc2ncsp(uint8_t *proc_ptr, uint8_t *out_ptr) {
             }
         });
     } else {
-        auto src_data = reinterpret_cast<const uint8_t *>(proc_ptr);
-        auto dst_data = reinterpret_cast<uint8_t *>(out_ptr);
+        auto src_data = reinterpret_cast<const uint8_t*>(proc_ptr);
+        auto dst_data = reinterpret_cast<uint8_t*>(out_ptr);
         parallel_for2d(DIM0, stride1, [&](size_t b, size_t j) {
             auto src_off = b * stride0 + j * DIM1;
             auto dst_off = b * stride0 + j;
@@ -2902,7 +3084,7 @@ void Reduce::nspc2ncsp(uint8_t *proc_ptr, uint8_t *out_ptr) {
     }
 }
 
-void Reduce::blocked2ncsp(uint8_t *proc_ptr, uint8_t *out_ptr) {
+void Reduce::blocked2ncsp(uint8_t* proc_ptr, uint8_t* out_ptr) {
     const size_t DIM0 = OB;
     const size_t DIM1 = OC;
     const size_t DIM2 = OD;
@@ -2913,8 +3095,8 @@ void Reduce::blocked2ncsp(uint8_t *proc_ptr, uint8_t *out_ptr) {
     const size_t dst_stride0 = stride1 * DIM1;
 
     if (dst_data_size == 4) {
-        auto src_data = reinterpret_cast<const float *>(proc_ptr);
-        auto dst_data = reinterpret_cast<float *>(out_ptr);
+        auto src_data = reinterpret_cast<const float*>(proc_ptr);
+        auto dst_data = reinterpret_cast<float*>(out_ptr);
         parallel_for2d(DIM0, stride1, [&](size_t b, size_t j) {
             auto src_off = b * src_stride0 + j * blk_size;
             auto dst_off = b * dst_stride0 + j;
@@ -2934,8 +3116,8 @@ void Reduce::blocked2ncsp(uint8_t *proc_ptr, uint8_t *out_ptr) {
             }
         });
     } else if (dst_data_size == 2) {
-        auto src_data = reinterpret_cast<const uint16_t *>(proc_ptr);
-        auto dst_data = reinterpret_cast<uint16_t *>(out_ptr);
+        auto src_data = reinterpret_cast<const uint16_t*>(proc_ptr);
+        auto dst_data = reinterpret_cast<uint16_t*>(out_ptr);
         parallel_for2d(DIM0, stride1, [&](size_t b, size_t j) {
             auto src_off = b * src_stride0 + j * blk_size;
             auto dst_off = b * dst_stride0 + j;
@@ -2955,8 +3137,8 @@ void Reduce::blocked2ncsp(uint8_t *proc_ptr, uint8_t *out_ptr) {
             }
         });
     } else {
-        auto src_data = reinterpret_cast<const uint8_t *>(proc_ptr);
-        auto dst_data = reinterpret_cast<uint8_t *>(out_ptr);
+        auto src_data = reinterpret_cast<const uint8_t*>(proc_ptr);
+        auto dst_data = reinterpret_cast<uint8_t*>(out_ptr);
         parallel_for2d(DIM0, stride1, [&](size_t b, size_t j) {
             auto src_off = b * src_stride0 + j * blk_size;
             auto dst_off = b * dst_stride0 + j;
@@ -2978,94 +3160,135 @@ void Reduce::blocked2ncsp(uint8_t *proc_ptr, uint8_t *out_ptr) {
     }
 }
 
-inline void Reduce::init_dst_data(uint8_t *out_ptr, size_t dst_size) {
+inline void Reduce::init_dst_data(uint8_t* out_ptr, size_t dst_size) {
     switch (algorithm) {
-        case Algorithm::ReduceL1:
-        case Algorithm::ReduceL2:
-        case Algorithm::ReduceLogSum:
-        case Algorithm::ReduceLogSumExp:
-        case Algorithm::ReduceMean:
-        case Algorithm::ReduceOr:
-        case Algorithm::ReduceSum:
-        case Algorithm::ReduceSumSquare:
-            memset(out_ptr, 0, dst_size);
-            break;
-        case Algorithm::ReduceAnd:
-        case Algorithm::ReduceProd:
-            if (output_prec == ov::element::f32) {
-                auto out_p = reinterpret_cast<float *>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = static_cast<float>(1); });
-            } else if (output_prec == ov::element::i32) {
-                auto out_p = reinterpret_cast<int32_t *>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = static_cast<int32_t>(1); });
-            } else if (output_prec == ov::element::bf16) {
-                auto out_p = reinterpret_cast<bfloat16_t*>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = static_cast<bfloat16_t>(1); });
-            } else if (output_prec == ov::element::f16) {
-                auto out_p = reinterpret_cast<ov::float16*>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = static_cast<ov::float16>(1); });
-            } else if (output_prec == ov::element::u8) {
-                auto out_p = reinterpret_cast<uint8_t *>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = static_cast<uint8_t>(1); });
-            } else if (output_prec == ov::element::i8) {
-                auto out_p = reinterpret_cast<int8_t *>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = static_cast<int8_t>(1); });
-            }
-            break;
-        case Algorithm::ReduceMax:
-            if (output_prec == ov::element::f32) {
-                auto out_p = reinterpret_cast<float *>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = std::numeric_limits<float>::lowest(); });
-            } else if (output_prec == ov::element::i32) {
-                auto out_p = reinterpret_cast<int32_t *>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = std::numeric_limits<int32_t>::min(); });
-            } else if (output_prec == ov::element::bf16) {
-                auto out_p = reinterpret_cast<bfloat16_t*>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = std::numeric_limits<bfloat16_t>::lowest(); });
-            } else if (output_prec == ov::element::f16) {
-                auto out_p = reinterpret_cast<ov::float16*>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = std::numeric_limits<ov::float16>::lowest(); });
-            } else if (output_prec == ov::element::u8) {
-                auto out_p = reinterpret_cast<uint8_t *>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = std::numeric_limits<uint8_t>::min(); });
-            } else if (output_prec == ov::element::i8) {
-                auto out_p = reinterpret_cast<int8_t *>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = std::numeric_limits<int8_t>::min(); });
-            }
-            break;
-        case Algorithm::ReduceMin:
-            if (output_prec == ov::element::f32) {
-                auto out_p = reinterpret_cast<float *>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = std::numeric_limits<float>::max(); });
-            } else if (output_prec == ov::element::i32) {
-                auto out_p = reinterpret_cast<int32_t *>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = std::numeric_limits<int32_t>::max(); });
-            } else if (output_prec == ov::element::bf16) {
-                auto out_p = reinterpret_cast<bfloat16_t*>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = std::numeric_limits<bfloat16_t>::max(); });
-            } else if (output_prec == ov::element::f16) {
-                auto out_p = reinterpret_cast<ov::float16*>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = std::numeric_limits<ov::float16>::max(); });
-            } else if (output_prec == ov::element::u8) {
-                auto out_p = reinterpret_cast<uint8_t *>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = std::numeric_limits<uint8_t>::max(); });
-            } else if (output_prec == ov::element::i8) {
-                auto out_p = reinterpret_cast<int8_t *>(out_ptr);
-                parallel_for(dst_size / dst_data_size, [&](size_t i) { out_p[i] = std::numeric_limits<int8_t>::max(); });
-            }
-            break;
-        default:
-            OPENVINO_THROW(errorPrefix, " gets unsupported reduce mode.");
+    case Algorithm::ReduceL1:
+    case Algorithm::ReduceL2:
+    case Algorithm::ReduceLogSum:
+    case Algorithm::ReduceLogSumExp:
+    case Algorithm::ReduceMean:
+    case Algorithm::ReduceOr:
+    case Algorithm::ReduceSum:
+    case Algorithm::ReduceSumSquare:
+        memset(out_ptr, 0, dst_size);
+        break;
+    case Algorithm::ReduceAnd:
+    case Algorithm::ReduceProd:
+        if (output_prec == ov::element::f32) {
+            auto out_p = reinterpret_cast<float*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = static_cast<float>(1);
+            });
+        } else if (output_prec == ov::element::i32) {
+            auto out_p = reinterpret_cast<int32_t*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = static_cast<int32_t>(1);
+            });
+        } else if (output_prec == ov::element::bf16) {
+            auto out_p = reinterpret_cast<bfloat16_t*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = static_cast<bfloat16_t>(1);
+            });
+        } else if (output_prec == ov::element::f16) {
+            auto out_p = reinterpret_cast<ov::float16*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = static_cast<ov::float16>(1);
+            });
+        } else if (output_prec == ov::element::u8) {
+            auto out_p = reinterpret_cast<uint8_t*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = static_cast<uint8_t>(1);
+            });
+        } else if (output_prec == ov::element::i8) {
+            auto out_p = reinterpret_cast<int8_t*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = static_cast<int8_t>(1);
+            });
+        }
+        break;
+    case Algorithm::ReduceMax:
+        if (output_prec == ov::element::f32) {
+            auto out_p = reinterpret_cast<float*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = std::numeric_limits<float>::lowest();
+            });
+        } else if (output_prec == ov::element::i32) {
+            auto out_p = reinterpret_cast<int32_t*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = std::numeric_limits<int32_t>::min();
+            });
+        } else if (output_prec == ov::element::bf16) {
+            auto out_p = reinterpret_cast<bfloat16_t*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = std::numeric_limits<bfloat16_t>::lowest();
+            });
+        } else if (output_prec == ov::element::f16) {
+            auto out_p = reinterpret_cast<ov::float16*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = std::numeric_limits<ov::float16>::lowest();
+            });
+        } else if (output_prec == ov::element::u8) {
+            auto out_p = reinterpret_cast<uint8_t*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = std::numeric_limits<uint8_t>::min();
+            });
+        } else if (output_prec == ov::element::i8) {
+            auto out_p = reinterpret_cast<int8_t*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = std::numeric_limits<int8_t>::min();
+            });
+        }
+        break;
+    case Algorithm::ReduceMin:
+        if (output_prec == ov::element::f32) {
+            auto out_p = reinterpret_cast<float*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = std::numeric_limits<float>::max();
+            });
+        } else if (output_prec == ov::element::i32) {
+            auto out_p = reinterpret_cast<int32_t*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = std::numeric_limits<int32_t>::max();
+            });
+        } else if (output_prec == ov::element::bf16) {
+            auto out_p = reinterpret_cast<bfloat16_t*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = std::numeric_limits<bfloat16_t>::max();
+            });
+        } else if (output_prec == ov::element::f16) {
+            auto out_p = reinterpret_cast<ov::float16*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = std::numeric_limits<ov::float16>::max();
+            });
+        } else if (output_prec == ov::element::u8) {
+            auto out_p = reinterpret_cast<uint8_t*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = std::numeric_limits<uint8_t>::max();
+            });
+        } else if (output_prec == ov::element::i8) {
+            auto out_p = reinterpret_cast<int8_t*>(out_ptr);
+            parallel_for(dst_size / dst_data_size, [&](size_t i) {
+                out_p[i] = std::numeric_limits<int8_t>::max();
+            });
+        }
+        break;
+    default:
+        OPENVINO_THROW(errorPrefix, " gets unsupported reduce mode.");
     }
 }
 
 inline void Reduce::create_hybrid_working_memory() {
     auto rank = getInputShapeAtPort(REDUCE_DATA).getRank();
-    memory::format_tag format = (layout == ReduceLayoutType::reduce_nspc) ? (rank == 4 ? memory::format_tag::nhwc : memory::format_tag::ndhwc)
-                                        : (rank == 4 ? (mayiuse(cpu::x64::avx512_core) ? memory::format_tag::nChw16c : memory::format_tag::nChw8c)
-                                                     : (mayiuse(cpu::x64::avx512_core) ? memory::format_tag::nCdhw16c : memory::format_tag::nCdhw8c));
+    memory::format_tag format =
+        (layout == ReduceLayoutType::reduce_nspc)
+            ? (rank == 4 ? memory::format_tag::nhwc : memory::format_tag::ndhwc)
+            : (rank == 4
+                   ? (mayiuse(cpu::x64::avx512_core) ? memory::format_tag::nChw16c : memory::format_tag::nChw8c)
+                   : (mayiuse(cpu::x64::avx512_core) ? memory::format_tag::nCdhw16c : memory::format_tag::nCdhw8c));
     auto prc_dims = rank == 4 ? std::vector<size_t>{OB, OC, OH, OW} : std::vector<size_t>{OB, OC, OD, OH, OW};
-    auto desc = dnnl::memory::desc(DnnlExtensionUtils::convertToDnnlDims(prc_dims), DnnlExtensionUtils::ElementTypeToDataType(output_prec), format);
+    auto desc = dnnl::memory::desc(DnnlExtensionUtils::convertToDnnlDims(prc_dims),
+                                   DnnlExtensionUtils::ElementTypeToDataType(output_prec),
+                                   format);
     prc_mem = dnnl::memory(desc, getEngine());
     dst_size = desc.get_size();
 }
@@ -3078,8 +3301,8 @@ inline void Reduce::create_opt_working_memory() {
         }
     }
 
-    ReduceDH_opt = layout == ReduceLayoutType::reduce_nspc && support_split &&
-                   !ReduceC && ReduceD && ReduceH && !ReduceW && IC == 1 && ID > 1;
+    ReduceDH_opt = layout == ReduceLayoutType::reduce_nspc && support_split && !ReduceC && ReduceD && ReduceH &&
+                   !ReduceW && IC == 1 && ID > 1;
     if (ReduceDH_opt) {
         PD = ID;
         PW = IW / blk_size * blk_size;
@@ -3091,8 +3314,8 @@ inline void Reduce::create_opt_working_memory() {
         return;
     }
 
-    ReduceCDW_opt = layout == ReduceLayoutType::reduce_ncsp && support_split &&
-                    ReduceC && ReduceD && !ReduceH && ReduceW;
+    ReduceCDW_opt =
+        layout == ReduceLayoutType::reduce_ncsp && support_split && ReduceC && ReduceD && !ReduceH && ReduceW;
     if (ReduceCDW_opt) {
         PH = IH;
         PW = IW;
@@ -3104,12 +3327,12 @@ inline void Reduce::create_opt_working_memory() {
     }
 }
 
-inline void Reduce::calc_process_dst_dims(std::vector<int> &reduce_axes, const VectorDims &dst_dims) {
+inline void Reduce::calc_process_dst_dims(std::vector<int>& reduce_axes, const VectorDims& dst_dims) {
     std::set<size_t> axes;
     VectorDims out_dims;
     process_dst_dims.clear();
     axes_for_reduction.clear();
-    for (auto &axis : reduce_axes) {
+    for (auto& axis : reduce_axes) {
         if (axis < 0)
             axis += src_dims.size();
         if (static_cast<size_t>(axis) > src_dims.size())
@@ -3125,7 +3348,8 @@ inline void Reduce::calc_process_dst_dims(std::vector<int> &reduce_axes, const V
             }
         }
         if (found) {
-            if (keep_dims) out_dims.push_back(1);
+            if (keep_dims)
+                out_dims.push_back(1);
             process_dst_dims.push_back(1);
             axes_for_reduction.push_back(i);
         } else {
@@ -3149,7 +3373,11 @@ inline void Reduce::set_reduce_dim_flags() {
     size_t dims_size = src_dims.size();
     if (dims_size == 5) {
         SET_SRC_DIM_VALUE(src_dims[0], src_dims[1], src_dims[2], src_dims[3], src_dims[4]);
-        SET_DST_DIM_VALUE(process_dst_dims[0], process_dst_dims[1], process_dst_dims[2], process_dst_dims[3], process_dst_dims[4]);
+        SET_DST_DIM_VALUE(process_dst_dims[0],
+                          process_dst_dims[1],
+                          process_dst_dims[2],
+                          process_dst_dims[3],
+                          process_dst_dims[4]);
     } else if (dims_size == 4) {
         SET_SRC_DIM_VALUE(src_dims[0], src_dims[1], 1, src_dims[2], src_dims[3]);
         SET_DST_DIM_VALUE(process_dst_dims[0], process_dst_dims[1], 1, process_dst_dims[2], process_dst_dims[3]);
@@ -3181,8 +3409,16 @@ inline void Reduce::set_reduce_dim_flags() {
     //    W -- H
     //    C -- W
     if (layout == ReduceLayoutType::reduce_nspc) {
-        size_t ITmp = IC; IC = ID; ID = IH; IH = IW; IW = ITmp;
-        size_t OTmp = OC; OC = OD; OD = OH; OH = OW; OW = OTmp;
+        size_t ITmp = IC;
+        IC = ID;
+        ID = IH;
+        IH = IW;
+        IW = ITmp;
+        size_t OTmp = OC;
+        OC = OD;
+        OD = OH;
+        OH = OW;
+        OW = OTmp;
     }
 
     ReduceN = IB != OB && OB == 1;
@@ -3202,60 +3438,85 @@ inline void Reduce::set_reduce_dim_flags() {
     // must be done after the above dimension change
     create_opt_working_memory();
 
-    ReduceAll_opt = layout == ReduceLayoutType::reduce_blocked && support_split &&
-                    ReduceC && ReduceD && ReduceH && ReduceW;
+    ReduceAll_opt =
+        layout == ReduceLayoutType::reduce_blocked && support_split && ReduceC && ReduceD && ReduceH && ReduceW;
     if (!set_use_aux_kernel) {
         use_aux_kernel = (ReduceDH_opt || ReduceCDW_opt || ReduceAll_opt) && precision_change;
         set_use_aux_kernel = true;
     }
 }
 
-inline void Reduce::reduce_ref(const float *in_ptr, float *out_ptr) {
+inline void Reduce::reduce_ref(const float* in_ptr, float* out_ptr) {
     switch (algorithm) {
-        case Algorithm::ReduceAnd:
-            reduce_ref_process(in_ptr, out_ptr, 1, [](float x, float y)->float { return x && y; });
-            break;
-        case Algorithm::ReduceL1:
-            reduce_ref_process(in_ptr, out_ptr, 0, [](float old, float y)->float { return old + (y >= 0 ? y : -y); });
-            break;
-        case Algorithm::ReduceL2:
-            reduce_ref_process(in_ptr, out_ptr, 0, [](float old, float y)->float { return old + y * y; });
-            break;
-        case Algorithm::ReduceLogSum:
-            reduce_ref_process(in_ptr, out_ptr, 0, [](float x, float y)->float { return x + y; });
-            break;
-        case Algorithm::ReduceLogSumExp:
-            reduce_ref_process(in_ptr, out_ptr, 0, [](float old, float y)->float { return old + expf(y); });
-            break;
-        case Algorithm::ReduceMax:
-            reduce_ref_process(in_ptr, out_ptr, std::numeric_limits<float>::lowest(),
-                                                    [](float x, float y)->float { return x > y ? x : y; });
-            break;
-        case Algorithm::ReduceMean:
-            reduce_ref_process(in_ptr, out_ptr, 0, [](float x, float y)->float { return x + y; });
-            break;
-        case Algorithm::ReduceMin:
-            reduce_ref_process(in_ptr, out_ptr, std::numeric_limits<float>::max(),
-                                                    [](float x, float y)->float { return x < y ? x : y; });
-            break;
-        case Algorithm::ReduceOr:
-            reduce_ref_process(in_ptr, out_ptr, 0, [](float x, float y)->float { return x || y; });
-            break;
-        case Algorithm::ReduceProd:
-            reduce_ref_process(in_ptr, out_ptr, 1, [](float x, float y)->float { return x * y; });
-            break;
-        case Algorithm::ReduceSum:
-            reduce_ref_process(in_ptr, out_ptr, 0, [](float x, float y)->float { return x + y; });
-            break;
-        case Algorithm::ReduceSumSquare:
-            reduce_ref_process(in_ptr, out_ptr, 0, [](float old, float y)->float { return old + y * y; });
-            break;
+    case Algorithm::ReduceAnd:
+        reduce_ref_process(in_ptr, out_ptr, 1, [](float x, float y) -> float {
+            return x && y;
+        });
+        break;
+    case Algorithm::ReduceL1:
+        reduce_ref_process(in_ptr, out_ptr, 0, [](float old, float y) -> float {
+            return old + (y >= 0 ? y : -y);
+        });
+        break;
+    case Algorithm::ReduceL2:
+        reduce_ref_process(in_ptr, out_ptr, 0, [](float old, float y) -> float {
+            return old + y * y;
+        });
+        break;
+    case Algorithm::ReduceLogSum:
+        reduce_ref_process(in_ptr, out_ptr, 0, [](float x, float y) -> float {
+            return x + y;
+        });
+        break;
+    case Algorithm::ReduceLogSumExp:
+        reduce_ref_process(in_ptr, out_ptr, 0, [](float old, float y) -> float {
+            return old + expf(y);
+        });
+        break;
+    case Algorithm::ReduceMax:
+        reduce_ref_process(in_ptr, out_ptr, std::numeric_limits<float>::lowest(), [](float x, float y) -> float {
+            return x > y ? x : y;
+        });
+        break;
+    case Algorithm::ReduceMean:
+        reduce_ref_process(in_ptr, out_ptr, 0, [](float x, float y) -> float {
+            return x + y;
+        });
+        break;
+    case Algorithm::ReduceMin:
+        reduce_ref_process(in_ptr, out_ptr, std::numeric_limits<float>::max(), [](float x, float y) -> float {
+            return x < y ? x : y;
+        });
+        break;
+    case Algorithm::ReduceOr:
+        reduce_ref_process(in_ptr, out_ptr, 0, [](float x, float y) -> float {
+            return x || y;
+        });
+        break;
+    case Algorithm::ReduceProd:
+        reduce_ref_process(in_ptr, out_ptr, 1, [](float x, float y) -> float {
+            return x * y;
+        });
+        break;
+    case Algorithm::ReduceSum:
+        reduce_ref_process(in_ptr, out_ptr, 0, [](float x, float y) -> float {
+            return x + y;
+        });
+        break;
+    case Algorithm::ReduceSumSquare:
+        reduce_ref_process(in_ptr, out_ptr, 0, [](float old, float y) -> float {
+            return old + y * y;
+        });
+        break;
     default:
         OPENVINO_THROW(errorPrefix, "gets unsupported reduce mode.");
     }
 }
 
-void Reduce::reduce_ref_process(const float *in_ptr, float *out_ptr, float init_value, std::function<float(float, float)> func) {
+void Reduce::reduce_ref_process(const float* in_ptr,
+                                float* out_ptr,
+                                float init_value,
+                                std::function<float(float, float)> func) {
     size_t work_amount_dst = 1, reduced_dims_work_amount = 1;
     for (size_t i = 0; i < process_dst_dims.size(); i++)
         work_amount_dst *= process_dst_dims[i];
@@ -3263,7 +3524,8 @@ void Reduce::reduce_ref_process(const float *in_ptr, float *out_ptr, float init_
         reduced_dims_work_amount *= src_dims[i];
     reduced_dims_work_amount /= work_amount_dst;
 
-    VectorDims src_strides = getParentEdgeAt(REDUCE_DATA)->getMemory().getDescWithType<BlockedMemoryDesc>()->getStrides();
+    VectorDims src_strides =
+        getParentEdgeAt(REDUCE_DATA)->getMemory().getDescWithType<BlockedMemoryDesc>()->getStrides();
     parallel_nt(0, [&](const int ithr, const int nthr) {
         int j;
         size_t i, start = 0, end = 0;
@@ -3310,49 +3572,49 @@ void Reduce::reduce_ref_process(const float *in_ptr, float *out_ptr, float init_
     reduce_ref_map(out_ptr, work_amount_dst, reduced_dims_work_amount);
 }
 
-inline void Reduce::reduce_ref_map(float *out_ptr, size_t work_amount_dst, size_t reduced_dims_work_amount) {
+inline void Reduce::reduce_ref_map(float* out_ptr, size_t work_amount_dst, size_t reduced_dims_work_amount) {
     switch (algorithm) {
-        case Algorithm::ReduceAnd:
-        case Algorithm::ReduceL1:
-        case Algorithm::ReduceMax:
-        case Algorithm::ReduceMin:
-        case Algorithm::ReduceOr:
-        case Algorithm::ReduceProd:
-        case Algorithm::ReduceSum:
-        case Algorithm::ReduceSumSquare:
-            break;
-        case Algorithm::ReduceL2:
-            parallel_for(work_amount_dst, [&](size_t i) {
-                out_ptr[i] = std::sqrt(out_ptr[i]);
-            });
-            break;
-        case Algorithm::ReduceLogSum:
-        case Algorithm::ReduceLogSumExp:
-            parallel_for(work_amount_dst, [&](size_t i) {
-                out_ptr[i] = logf(out_ptr[i]);
-            });
-            break;
-        case Algorithm::ReduceMean:
-            parallel_for(work_amount_dst, [&](size_t i) {
-                out_ptr[i] /= reduced_dims_work_amount;
-            });
-            break;
-        default:
-            OPENVINO_THROW(errorPrefix, "gets unsupported reduce mode.");
+    case Algorithm::ReduceAnd:
+    case Algorithm::ReduceL1:
+    case Algorithm::ReduceMax:
+    case Algorithm::ReduceMin:
+    case Algorithm::ReduceOr:
+    case Algorithm::ReduceProd:
+    case Algorithm::ReduceSum:
+    case Algorithm::ReduceSumSquare:
+        break;
+    case Algorithm::ReduceL2:
+        parallel_for(work_amount_dst, [&](size_t i) {
+            out_ptr[i] = std::sqrt(out_ptr[i]);
+        });
+        break;
+    case Algorithm::ReduceLogSum:
+    case Algorithm::ReduceLogSumExp:
+        parallel_for(work_amount_dst, [&](size_t i) {
+            out_ptr[i] = logf(out_ptr[i]);
+        });
+        break;
+    case Algorithm::ReduceMean:
+        parallel_for(work_amount_dst, [&](size_t i) {
+            out_ptr[i] /= reduced_dims_work_amount;
+        });
+        break;
+    default:
+        OPENVINO_THROW(errorPrefix, "gets unsupported reduce mode.");
     }
 }
 
-void Reduce::setPostOps(dnnl::primitive_attr &attr, const VectorDims &postOpDims, bool initWeights) {
+void Reduce::setPostOps(dnnl::primitive_attr& attr, const VectorDims& postOpDims, bool initWeights) {
     dnnl::post_ops ops;
     postOpsDataPtrs.clear();
-    for (auto &node : fusedWith) {
-        auto* fakeQuantizeNode = dynamic_cast<FakeQuantize *>(node.get());
+    for (auto& node : fusedWith) {
+        auto* fakeQuantizeNode = dynamic_cast<FakeQuantize*>(node.get());
         if (fakeQuantizeNode) {
             fakeQuantizeNode->appendPostOps(ops, {}, postOpsDataPtrs);
             continue;
         }
 
-        auto* eltwiseNode = dynamic_cast<Eltwise *>(node.get());
+        auto* eltwiseNode = dynamic_cast<Eltwise*>(node.get());
         if (eltwiseNode) {
             eltwiseNode->appendPostOps(ops, postOpDims, postOpsDataPtrs, getFusingAxis());
             continue;
@@ -3370,7 +3632,7 @@ void Reduce::setPostOps(dnnl::primitive_attr &attr, const VectorDims &postOpDims
 void Reduce::setJITBeyond5D() {
     jit_beyond_5D = false;
     if (getInputShapeAtPort(REDUCE_DATA).getRank() > 5) {
-        for (auto &axis : raw_axes) {
+        for (auto& axis : raw_axes) {
             if (axis < 0)
                 axis += static_cast<int>(getInputShapeAtPort(REDUCE_DATA).getRank());
         }
@@ -3421,26 +3683,23 @@ std::vector<int> Reduce::update_src_dims() {
     return reduce_axes;
 }
 
-bool Reduce::canApplyJIT(const ov::element::Type &input_prec, const ov::element::Type &output_prec) const {
-    static const ov::element::Type supportedPrecisions[] = {
-            ov::element::f32,
-            ov::element::f16,
-            ov::element::bf16,
-            ov::element::i32,
-            ov::element::i8,
-            ov::element::u8
-    };
+bool Reduce::canApplyJIT(const ov::element::Type& input_prec, const ov::element::Type& output_prec) const {
+    static const ov::element::Type supportedPrecisions[] =
+        {ov::element::f32, ov::element::f16, ov::element::bf16, ov::element::i32, ov::element::i8, ov::element::u8};
 
     return (mayiuse(cpu::x64::sse41)) && (getInputShapeAtPort(REDUCE_DATA).getRank() <= 5 || jit_beyond_5D) &&
-           std::find(std::begin(supportedPrecisions), std::end(supportedPrecisions), input_prec) != std::end(supportedPrecisions) &&
-           std::find(std::begin(supportedPrecisions), std::end(supportedPrecisions), output_prec) != std::end(supportedPrecisions);
+           std::find(std::begin(supportedPrecisions), std::end(supportedPrecisions), input_prec) !=
+               std::end(supportedPrecisions) &&
+           std::find(std::begin(supportedPrecisions), std::end(supportedPrecisions), output_prec) !=
+               std::end(supportedPrecisions);
 }
 
 int Reduce::getFusingAxis() const {
     int channelAxis = 1;
     if (!keep_dims) {
-        for (auto &raw_axis : raw_axes) {
-            int axis = raw_axis >= 0 ? raw_axis : raw_axis + static_cast<int>(getInputShapeAtPort(REDUCE_DATA).getRank());
+        for (auto& raw_axis : raw_axes) {
+            int axis =
+                raw_axis >= 0 ? raw_axis : raw_axis + static_cast<int>(getInputShapeAtPort(REDUCE_DATA).getRank());
             if (axis == 1) {
                 // channel axis has been reduced and doesn't exist any more
                 channelAxis = -1;
@@ -3456,7 +3715,8 @@ int Reduce::getFusingAxis() const {
 bool Reduce::canFuse(const NodePtr& node) const {
     ov::element::Type input_prec = getOriginalInputPrecisionAtPort(REDUCE_DATA);
     ov::element::Type output_prec = getOriginalOutputPrecisionAtPort(0);
-    if (!canApplyJIT(input_prec, output_prec) || jit_beyond_5D || algorithm == Algorithm::ReduceAnd || algorithm == Algorithm::ReduceOr) {
+    if (!canApplyJIT(input_prec, output_prec) || jit_beyond_5D || algorithm == Algorithm::ReduceAnd ||
+        algorithm == Algorithm::ReduceOr) {
         return false;
     }
 
@@ -3467,6 +3727,6 @@ bool Reduce::created() const {
     return getType() == Type::Reduce;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/reduce.h b/src/plugins/intel_cpu/src/nodes/reduce.h
index c790cefb0583b0..0ad826c4381055 100644
--- a/src/plugins/intel_cpu/src/nodes/reduce.h
+++ b/src/plugins/intel_cpu/src/nodes/reduce.h
@@ -11,17 +11,13 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 
-enum ReduceLayoutType {
-    reduce_ncsp,
-    reduce_nspc,
-    reduce_blocked
-};
+enum ReduceLayoutType { reduce_ncsp, reduce_nspc, reduce_blocked };
 
 struct jit_reduce_config_params {
     ReduceLayoutType layout;
     Algorithm reduce_mode;
     bool fuse_low_precision;
-    bool fuse_broadcast;    // if post ops fusion needs broadcast
+    bool fuse_broadcast;  // if post ops fusion needs broadcast
     bool round_to_zero;
     dnnl::memory::data_type src_dt;
     dnnl::memory::data_type dst_dt;
@@ -30,32 +26,34 @@ struct jit_reduce_config_params {
 };
 
 struct jit_reduce_call_args {
-    const void *src;
-    const int *idx;
-    void *dst;
+    const void* src;
+    const int* idx;
+    void* dst;
     size_t work_amount;
     size_t work_batch;
-    size_t reduce_w = 2;    // only used in planar layout  [1: reduce width dimension]   [0: reduce other dimension] [other value: N/A]
-    size_t reduce_stride;   // only used in planar layout while reducing dimensions except for width
-    size_t can_divide;      // if apply division in reduce_kernel [1: Yes] [0: No]
-    const float *divisor;   // mean = sum / divisor
+    size_t reduce_w =
+        2;  // only used in planar layout  [1: reduce width dimension]   [0: reduce other dimension] [other value: N/A]
+    size_t reduce_stride;  // only used in planar layout while reducing dimensions except for width
+    size_t can_divide;     // if apply division in reduce_kernel [1: Yes] [0: No]
+    const float* divisor;  // mean = sum / divisor
 };
 
 struct jit_reduce_post_call_args {
-    const void *src;
-    void *dst;
+    const void* src;
+    void* dst;
     size_t work_amount;
-    size_t reduce_c = 2;    // only used in blocked layout [1: reduce channel dimension] [0: reduce other dimension] [other value: N/A]
-    size_t oc_off;          // offset in byte along channel on output tensor
-    size_t channel_size;    // only for post ops fusion of nspc layout
-    const float *divisor;   // mean = sum / divisor
+    size_t reduce_c =
+        2;  // only used in blocked layout [1: reduce channel dimension] [0: reduce other dimension] [other value: N/A]
+    size_t oc_off;         // offset in byte along channel on output tensor
+    size_t channel_size;   // only for post ops fusion of nspc layout
+    const float* divisor;  // mean = sum / divisor
     const void** post_op_data;
 };
 
 struct jit_uni_reduce_kernel {
-    void (*ker_)(const jit_reduce_call_args *);
+    void (*ker_)(const jit_reduce_call_args*);
 
-    void operator()(const jit_reduce_call_args *args) {
+    void operator()(const jit_reduce_call_args* args) {
         assert(ker_);
         ker_(args);
     }
@@ -69,20 +67,23 @@ struct jit_uni_reduce_kernel {
 };
 
 struct jit_uni_reduce_post_kernel {
-    void (*ker_)(const jit_reduce_post_call_args *);
+    void (*ker_)(const jit_reduce_post_call_args*);
 
-    void operator()(const jit_reduce_post_call_args *args) {
+    void operator()(const jit_reduce_post_call_args* args) {
         assert(ker_);
         ker_(args);
     }
 
-    explicit jit_uni_reduce_post_kernel(jit_reduce_config_params jcp, const dnnl_primitive_attr &attr) : ker_(nullptr), jcp_(jcp), attr_(attr) {}
+    explicit jit_uni_reduce_post_kernel(jit_reduce_config_params jcp, const dnnl_primitive_attr& attr)
+        : ker_(nullptr),
+          jcp_(jcp),
+          attr_(attr) {}
     virtual ~jit_uni_reduce_post_kernel() {}
 
     virtual void create_ker() = 0;
 
     jit_reduce_config_params jcp_;
-    const dnnl_primitive_attr &attr_;
+    const dnnl_primitive_attr& attr_;
 };
 
 class Reduce : public Node {
@@ -106,32 +107,39 @@ class Reduce : public Node {
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
 private:
-    void reduce_type(const uint8_t *in_ptr, uint8_t *out_ptr);
-    void reduce_PLN(const uint8_t *in_ptr, uint8_t *out_ptr);
-    void reduce_BLK(const uint8_t *in_ptr, uint8_t *out_ptr);
-    void reduce_BLK_concern_padding(const uint8_t *in_ptr, uint8_t *out_ptr);
-    inline void reduce_kernel_process(const uint8_t *in_p, uint8_t *out_p, size_t work_amount,
-                                      size_t reduce_w = 2, size_t work_batch = 1, const int *tab_idx = NULL);
-    inline void reduce_kernel_post_process(uint8_t *out_ptr);
+    void reduce_type(const uint8_t* in_ptr, uint8_t* out_ptr);
+    void reduce_PLN(const uint8_t* in_ptr, uint8_t* out_ptr);
+    void reduce_BLK(const uint8_t* in_ptr, uint8_t* out_ptr);
+    void reduce_BLK_concern_padding(const uint8_t* in_ptr, uint8_t* out_ptr);
+    inline void reduce_kernel_process(const uint8_t* in_p,
+                                      uint8_t* out_p,
+                                      size_t work_amount,
+                                      size_t reduce_w = 2,
+                                      size_t work_batch = 1,
+                                      const int* tab_idx = NULL);
+    inline void reduce_kernel_post_process(uint8_t* out_ptr);
     inline void reduce_kernel_reassign();
     inline void reduce_kernel_restore();
-    inline void output_info_reassign(uint8_t **out_ptr);
-    inline void output_info_restore(uint8_t **out_ptr);
-    inline void init_dst_data(uint8_t *out_ptr, size_t dst_size);
+    inline void output_info_reassign(uint8_t** out_ptr);
+    inline void output_info_restore(uint8_t** out_ptr);
+    inline void init_dst_data(uint8_t* out_ptr, size_t dst_size);
     inline void create_hybrid_working_memory();
     inline void create_opt_working_memory();
-    inline void calc_process_dst_dims(std::vector<int> &reduce_axes, const VectorDims &dst_dim);
+    inline void calc_process_dst_dims(std::vector<int>& reduce_axes, const VectorDims& dst_dim);
     inline void set_reduce_dim_flags();
-    inline void reduce_ref(const float *in_ptr, float *out_ptr);
-    void reduce_ref_process(const float *in_ptr, float *out_ptr, float init_value, std::function<float(float, float)> func);
-    void create_reduce_kernel(std::shared_ptr<jit_uni_reduce_kernel> &kernel, const jit_reduce_config_params &jcp);
-    inline void reduce_ref_map(float *out_ptr, size_t work_amount_dst, size_t reduced_dims_work_amount);
-    void nspc2ncsp(uint8_t *proc_ptr, uint8_t *out_ptr);
-    void blocked2ncsp(uint8_t *proc_ptr, uint8_t *out_ptr);
-    void setPostOps(dnnl::primitive_attr &attr, const VectorDims &postOpDims, bool initWeights = false);
+    inline void reduce_ref(const float* in_ptr, float* out_ptr);
+    void reduce_ref_process(const float* in_ptr,
+                            float* out_ptr,
+                            float init_value,
+                            std::function<float(float, float)> func);
+    void create_reduce_kernel(std::shared_ptr<jit_uni_reduce_kernel>& kernel, const jit_reduce_config_params& jcp);
+    inline void reduce_ref_map(float* out_ptr, size_t work_amount_dst, size_t reduced_dims_work_amount);
+    void nspc2ncsp(uint8_t* proc_ptr, uint8_t* out_ptr);
+    void blocked2ncsp(uint8_t* proc_ptr, uint8_t* out_ptr);
+    void setPostOps(dnnl::primitive_attr& attr, const VectorDims& postOpDims, bool initWeights = false);
     void setJITBeyond5D();
     std::vector<int> update_src_dims();
-    bool canApplyJIT(const ov::element::Type &input_prec, const ov::element::Type &output_prec) const;
+    bool canApplyJIT(const ov::element::Type& input_prec, const ov::element::Type& output_prec) const;
 
     size_t blk_size;
     static const size_t REDUCE_DATA = 0;
@@ -160,7 +168,7 @@ class Reduce : public Node {
     size_t src_data_size, dst_data_size, prc_data_size, intermediate_data_size, tmp_data_size;
     size_t dst_size, prc_size, intermediate_size, tmp_size;
     size_t reduce_stride;
-    uint8_t *tmp_ptr;
+    uint8_t* tmp_ptr;
     ReduceLayoutType layout;
     ov::element::Type input_prec, output_prec, intermediate_prec, tmp_prec;
     VectorDims src_dims;
@@ -185,17 +193,19 @@ class Reduce : public Node {
     std::shared_ptr<jit_uni_reduce_kernel> reduce_tmp_kernel;
     std::shared_ptr<jit_uni_reduce_post_kernel> reduce_post_kernel;
 
-    static const std::map<const ov::DiscreteTypeInfo, std::function<void(const std::shared_ptr<ov::Node>& op, Reduce& node)>>& getInitializers();
+    static const std::map<const ov::DiscreteTypeInfo,
+                          std::function<void(const std::shared_ptr<ov::Node>& op, Reduce& node)>>&
+    getInitializers();
 
     std::string errorPrefix;
 
-#if defined (OV_CPU_WITH_ACL)
+#if defined(OV_CPU_WITH_ACL)
     ReduceAttrs reduceAttrs;
     bool canUseAclExecutor = false;
     std::shared_ptr<ReduceExecutor> aclExecPtr = nullptr;
 #endif
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/nodes/reference.cpp b/src/plugins/intel_cpu/src/nodes/reference.cpp
index b84836c869deb3..aaab28e4302fd2 100644
--- a/src/plugins/intel_cpu/src/nodes/reference.cpp
+++ b/src/plugins/intel_cpu/src/nodes/reference.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "reference.h"
+
 #include "common/cpu_memcpy.h"
 #include "shape_inference/shape_inference.hpp"
 
@@ -26,10 +27,13 @@ namespace node {
 Reference::Reference(const std::shared_ptr<ov::Node>& op,
                      const GraphContext::CPtr& context,
                      const std::string& errorMessage)
-    : Node(op, context, ReferenceShapeInferFactory(op)), ovCoreNode(op), additionalErrorMessage(errorMessage) {
+    : Node(op, context, ReferenceShapeInferFactory(op)),
+      ovCoreNode(op),
+      additionalErrorMessage(errorMessage) {
     if (!op->has_evaluate()) {
         OPENVINO_THROW_NOT_IMPLEMENTED(
-            "Cannot fallback on ngraph reference implementation. Ngraph::Node::evaluate() is not implemented for op: ", *op);
+            "Cannot fallback on ngraph reference implementation. Ngraph::Node::evaluate() is not implemented for op: ",
+            *op);
     }
 
     setType(Type::Reference);
@@ -101,7 +105,9 @@ void Reference::executeDynamicImpl(dnnl::stream strm) {
             auto memory = getDstMemoryAtPort(i);
             auto& tensor = outputs[i];
             if (memory->getSize() != tensor.get_byte_size()) {
-                THROW_CPU_NODE_ERR("output tensor data size mismatch occurred during the inference on output port number ", i);
+                THROW_CPU_NODE_ERR(
+                    "output tensor data size mismatch occurred during the inference on output port number ",
+                    i);
             }
             if (tensor.get_element_type() == element::string) {
                 auto srcPtr = tensor.data<StringMemory::OvString>();
@@ -130,7 +136,9 @@ ov::TensorVector Reference::prepareInputs() const {
                               ? ov::Shape{}
                               : getParentEdgeAt(i)->getMemory().getStaticDims();
 
-        if (std::any_of(shape.begin(), shape.end(), [](const size_t dim) { return dim == 0lu; } )) {
+        if (std::any_of(shape.begin(), shape.end(), [](const size_t dim) {
+                return dim == 0lu;
+            })) {
             inputs.push_back(ov::Tensor(ovCoreNode->get_input_element_type(i), shape));
         } else {
             CPU_NODE_ASSERT(srcDataPtr, "has empty input data on port ", i);
@@ -148,7 +156,9 @@ ov::TensorVector Reference::prepareOutputs() const {
                               ? ov::Shape{}
                               : getChildEdgeAt(i)->getMemory().getStaticDims();
 
-        if (std::any_of(shape.begin(), shape.end(), [](const size_t dim) { return dim == 0lu; } )) {
+        if (std::any_of(shape.begin(), shape.end(), [](const size_t dim) {
+                return dim == 0lu;
+            })) {
             outputs.push_back(ov::Tensor(ovCoreNode->get_output_element_type(i), shape));
         } else {
             CPU_NODE_ASSERT(dstDataPtr, "has empty output data on port ", i);
@@ -158,6 +168,6 @@ ov::TensorVector Reference::prepareOutputs() const {
     return outputs;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/reference.h b/src/plugins/intel_cpu/src/nodes/reference.h
index 25a285a4e72709..09b633e8a4e66a 100644
--- a/src/plugins/intel_cpu/src/nodes/reference.h
+++ b/src/plugins/intel_cpu/src/nodes/reference.h
@@ -21,8 +21,12 @@ class Reference : public Node {
     bool created() const override;
 
     bool needShapeInfer() const override;
-    bool needPrepareParams() const override { return false; }
-    bool isExecutable() const override { return true; }
+    bool needPrepareParams() const override {
+        return false;
+    }
+    bool isExecutable() const override {
+        return true;
+    }
     void executeDynamicImpl(dnnl::stream strm) override;
 
 private:
@@ -34,6 +38,6 @@ class Reference : public Node {
     const std::string additionalErrorMessage;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/region_yolo.cpp b/src/plugins/intel_cpu/src/nodes/region_yolo.cpp
index c575237f48e042..b7d98064713fd0 100644
--- a/src/plugins/intel_cpu/src/nodes/region_yolo.cpp
+++ b/src/plugins/intel_cpu/src/nodes/region_yolo.cpp
@@ -2,18 +2,20 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "region_yolo.h"
+
 #include <cmath>
-#include <vector>
 #include <string>
-#include "dnnl_types.h"
-#include "openvino/core/parallel.hpp"
-#include "region_yolo.h"
-#include "nodes/common/blocked_desc_creator.h"
-#include "openvino/opsets/opset1.hpp"
+#include <vector>
+
 #include "common/cpu_convert.h"
-#include "cpu/x64/jit_generator.hpp"
 #include "cpu/x64/injectors/jit_uni_eltwise_injector.hpp"
+#include "cpu/x64/jit_generator.hpp"
+#include "dnnl_types.h"
 #include "emitters/plugin/x64/jit_bf16_emitters.hpp"
+#include "nodes/common/blocked_desc_creator.h"
+#include "openvino/core/parallel.hpp"
+#include "openvino/opsets/opset1.hpp"
 #include "utils/bfloat16.hpp"
 
 using namespace dnnl::impl::cpu;
@@ -21,7 +23,7 @@ using namespace dnnl::impl::cpu::x64;
 using namespace dnnl::impl::utils;
 
 #if defined(OPENVINO_ARCH_X86_64)
-#define GET_OFF(field) offsetof(jit_args_logistic, field)
+#    define GET_OFF(field) offsetof(jit_args_logistic, field)
 #endif
 
 namespace ov {
@@ -32,7 +34,10 @@ template <cpu_isa_t isa>
 struct jit_uni_logistic_kernel_f32 : public jit_uni_logistic_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_logistic_kernel_f32)
 
-    jit_uni_logistic_kernel_f32(jit_logistic_config_params jcp) : jit_uni_logistic_kernel(), jit_generator(jit_name()), jcp_(jcp) {}
+    jit_uni_logistic_kernel_f32(jit_logistic_config_params jcp)
+        : jit_uni_logistic_kernel(),
+          jit_generator(jit_name()),
+          jcp_(jcp) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -40,7 +45,8 @@ struct jit_uni_logistic_kernel_f32 : public jit_uni_logistic_kernel, public jit_
     }
 
     void generate() override {
-        exp_injector.reset(new jit_uni_eltwise_injector_f32<isa>(this, dnnl::impl::alg_kind::eltwise_exp, 0.f, 0.f, 1.f));
+        exp_injector.reset(
+            new jit_uni_eltwise_injector_f32<isa>(this, dnnl::impl::alg_kind::eltwise_exp, 0.f, 0.f, 1.f));
 
         if (mayiuse(avx512_core))
             uni_vcvtneps2bf16.reset(new jit_uni_vcvtneps2bf16(this, isa));
@@ -57,7 +63,8 @@ struct jit_uni_logistic_kernel_f32 : public jit_uni_logistic_kernel, public jit_
         Xbyak::Label exit_label;
 
         int step = vlen / sizeof(float);
-        L(main_loop_label); {
+        L(main_loop_label);
+        {
             cmp(reg_work_amount, step);
             jl(tail_loop_label, T_NEAR);
 
@@ -73,7 +80,8 @@ struct jit_uni_logistic_kernel_f32 : public jit_uni_logistic_kernel, public jit_
         }
 
         step = 1;
-        L(tail_loop_label); {
+        L(tail_loop_label);
+        {
             cmp(reg_work_amount, step);
             jl(exit_label, T_NEAR);
 
@@ -104,7 +112,9 @@ struct jit_uni_logistic_kernel_f32 : public jit_uni_logistic_kernel, public jit_
     using Vmm = typename conditional3<isa == x64::sse41, Xbyak::Xmm, isa == x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
     size_t vlen = cpu_isa_traits<isa>::vlen;
 
-    Xbyak::Address table_val(int index) { return ptr[reg_table + index * vlen]; }
+    Xbyak::Address table_val(int index) {
+        return ptr[reg_table + index * vlen];
+    }
 
     Xbyak::Reg64 reg_src = r8;
     Xbyak::Reg64 reg_dst = r9;
@@ -169,61 +179,62 @@ struct jit_uni_logistic_kernel_f32 : public jit_uni_logistic_kernel, public jit_
 
     const struct vals_for_logistic_activate_type {
         int mask_sign = 0x80000000;  // 0 //  mask to extract sign
-        int float_1   = 0x3f800000;  // 1 //  1.0f
+        int float_1 = 0x3f800000;    // 1 //  1.0f
     } vals_for_logistic_activate;
 
-    inline void load_vector(Vmm vmm_src, const Xbyak::Address &op, ov::element::Type src_dt) {
+    inline void load_vector(Vmm vmm_src, const Xbyak::Address& op, ov::element::Type src_dt) {
         switch (src_dt) {
-            case ov::element::f32:
-                uni_vmovups(vmm_src, op);
-                break;
-            case ov::element::bf16:
-                vpmovzxwd(vmm_src, op);
-                uni_vpslld(vmm_src, vmm_src, 16);
-                break;
-            default:
-                assert(!"unknown src_dt");
+        case ov::element::f32:
+            uni_vmovups(vmm_src, op);
+            break;
+        case ov::element::bf16:
+            vpmovzxwd(vmm_src, op);
+            uni_vpslld(vmm_src, vmm_src, 16);
+            break;
+        default:
+            assert(!"unknown src_dt");
         }
     }
-    inline void store_vector(const Xbyak::Address &op, Vmm vmm_dst, ov::element::Type dst_dt) {
+    inline void store_vector(const Xbyak::Address& op, Vmm vmm_dst, ov::element::Type dst_dt) {
         Xbyak::Ymm ymm_dst = Xbyak::Ymm(vmm_dst.getIdx());
 
         switch (dst_dt) {
-            case ov::element::f32:
-                uni_vmovups(op, vmm_dst);
-                break;
-            case ov::element::bf16:
-                uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())}, {static_cast<size_t>(ymm_dst.getIdx())});
-                vmovdqu16(op, ymm_dst);
-                break;
-            default:
-                assert(!"unknown dst_dt");
+        case ov::element::f32:
+            uni_vmovups(op, vmm_dst);
+            break;
+        case ov::element::bf16:
+            uni_vcvtneps2bf16->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
+                                         {static_cast<size_t>(ymm_dst.getIdx())});
+            vmovdqu16(op, ymm_dst);
+            break;
+        default:
+            assert(!"unknown dst_dt");
         }
     }
-    inline void load_scalar(Xbyak::Xmm xmm_src, const Xbyak::Address &op, ov::element::Type src_dt) {
+    inline void load_scalar(Xbyak::Xmm xmm_src, const Xbyak::Address& op, ov::element::Type src_dt) {
         switch (src_dt) {
-            case ov::element::f32:
-                uni_vmovss(xmm_src, op);
-                break;
-            case ov::element::bf16:
-                uni_vpinsrw(xmm_src, xmm_src, op, 0x0);
-                uni_vpslld(xmm_src, xmm_src, 16);
-                break;
-            default:
-                assert(!"unknown src_dt");
+        case ov::element::f32:
+            uni_vmovss(xmm_src, op);
+            break;
+        case ov::element::bf16:
+            uni_vpinsrw(xmm_src, xmm_src, op, 0x0);
+            uni_vpslld(xmm_src, xmm_src, 16);
+            break;
+        default:
+            assert(!"unknown src_dt");
         }
     }
-    inline void store_scalar(const Xbyak::Address &op, Xbyak::Xmm xmm_dst, ov::element::Type dst_dt) {
+    inline void store_scalar(const Xbyak::Address& op, Xbyak::Xmm xmm_dst, ov::element::Type dst_dt) {
         switch (dst_dt) {
-            case ov::element::f32:
-                uni_vmovss(op, xmm_dst);
-                break;
-            case ov::element::bf16:
-                uni_vpsrld(xmm_dst, xmm_dst, 16);
-                uni_vpextrw(op, xmm_dst, 0x0);
-                break;
-           default:
-                assert(!"unknown dst_dt");
+        case ov::element::f32:
+            uni_vmovss(op, xmm_dst);
+            break;
+        case ov::element::bf16:
+            uni_vpsrld(xmm_dst, xmm_dst, 16);
+            uni_vpextrw(op, xmm_dst, 0x0);
+            break;
+        default:
+            assert(!"unknown dst_dt");
         }
     }
 };
@@ -298,9 +309,7 @@ void RegionYolo::initSupportedPrimitiveDescriptors() {
         impl_type = impl_desc_type::ref;
     }
 
-    addSupportedPrimDesc({{LayoutType::ncsp, input_prec}},
-                         {{LayoutType::ncsp, output_prec}},
-                         impl_type);
+    addSupportedPrimDesc({{LayoutType::ncsp, input_prec}}, {{LayoutType::ncsp, output_prec}}, impl_type);
 }
 
 void RegionYolo::createPrimitive() {
@@ -347,7 +356,7 @@ inline float RegionYolo::logistic_scalar(float src) {
     return src;
 }
 
-inline void RegionYolo::calculate_logistic(size_t start_index, int count, uint8_t * dst_data) {
+inline void RegionYolo::calculate_logistic(size_t start_index, int count, uint8_t* dst_data) {
     auto dst_data_size = output_prec.size();
     if (logistic_kernel) {
         int blocks_num = div_up(count, block_size);
@@ -379,9 +388,9 @@ inline void RegionYolo::calculate_logistic(size_t start_index, int count, uint8_
 }
 
 void RegionYolo::execute(dnnl::stream strm) {
-    const auto &inShape = getParentEdgeAt(0)->getMemory().getShape();
-    const auto &inDims = inShape.getStaticDims();
-    size_t B =  (inShape.getRank() > 0) ? inDims[0] : 1;
+    const auto& inShape = getParentEdgeAt(0)->getMemory().getShape();
+    const auto& inDims = inShape.getStaticDims();
+    size_t B = (inShape.getRank() > 0) ? inDims[0] : 1;
     size_t IC = (inShape.getRank() > 1) ? inDims[1] : 1;
     size_t IH = (inShape.getRank() > 2) ? inDims[2] : 1;
     size_t IW = (inShape.getRank() > 3) ? inDims[3] : 1;
@@ -394,7 +403,7 @@ void RegionYolo::execute(dnnl::stream strm) {
         // Region layer (Yolo v2)
         end_index = IW * IH;
         num_ = num;
-        output_size = B * IH * IW * IC; // different shape combinations with the same overall size;
+        output_size = B * IH * IW * IC;  // different shape combinations with the same overall size;
     } else {
         // Yolo layer (Yolo v3)
         end_index = IW * IH * (classes + 1);
@@ -411,11 +420,14 @@ void RegionYolo::execute(dnnl::stream strm) {
     size_t inputs_size = IH * IW * num_ * (classes + coords + 1);
     size_t total_size = 2 * IH * IW;
 
-    const auto *src_data = getSrcDataAtPortAs<const uint8_t>(0);
-    auto *dst_data = getDstDataAtPortAs<uint8_t>(0);
+    const auto* src_data = getSrcDataAtPortAs<const uint8_t>(0);
+    auto* dst_data = getDstDataAtPortAs<uint8_t>(0);
 
-    cpu_convert(src_data, dst_data, getParentEdgeAt(0)->getMemory().getDesc().getPrecision(),
-                getChildEdgeAt(0)->getMemory().getDesc().getPrecision(), output_size);
+    cpu_convert(src_data,
+                dst_data,
+                getParentEdgeAt(0)->getMemory().getDesc().getPrecision(),
+                getChildEdgeAt(0)->getMemory().getDesc().getPrecision(),
+                output_size);
 
     for (size_t b = 0; b < B; b++) {
         for (int n = 0; n < num_; n++) {
@@ -432,7 +444,11 @@ void RegionYolo::execute(dnnl::stream strm) {
         int batch_offset = inputs_size / num;
         for (size_t b = 0; b < B * num; b++) {
             softmax_kernel->execute(src_data + input_prec.size() * (index + b * batch_offset),
-                                    dst_data + output_prec.size() * (index + b * batch_offset), 1, classes, IH, IW);
+                                    dst_data + output_prec.size() * (index + b * batch_offset),
+                                    1,
+                                    classes,
+                                    IH,
+                                    IW);
         }
     }
 }
@@ -441,6 +457,6 @@ bool RegionYolo::created() const {
     return getType() == Type::RegionYolo;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/region_yolo.h b/src/plugins/intel_cpu/src/nodes/region_yolo.h
index c4330ca2741bf5..00ab3697bf7bca 100644
--- a/src/plugins/intel_cpu/src/nodes/region_yolo.h
+++ b/src/plugins/intel_cpu/src/nodes/region_yolo.h
@@ -25,9 +25,12 @@ struct jit_logistic_config_params {
 };
 
 struct jit_uni_logistic_kernel {
-    void (*ker_)(const jit_args_logistic *);
+    void (*ker_)(const jit_args_logistic*);
 
-    void operator()(const jit_args_logistic *args) { assert(ker_); ker_(args); }
+    void operator()(const jit_args_logistic* args) {
+        assert(ker_);
+        ker_(args);
+    }
 
     virtual void create_ker() = 0;
 
@@ -39,7 +42,7 @@ class RegionYolo : public Node {
 public:
     RegionYolo(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void createPrimitive() override;
     void execute(dnnl::stream strm) override;
@@ -49,7 +52,9 @@ class RegionYolo : public Node {
 
 protected:
     bool needPrepareParams() const override;
-    void executeDynamicImpl(dnnl::stream strm) override { execute(strm); }
+    void executeDynamicImpl(dnnl::stream strm) override {
+        execute(strm);
+    }
 
 private:
     int classes;
@@ -71,9 +76,9 @@ class RegionYolo : public Node {
     };
 
     inline float logistic_scalar(float src);
-    inline void calculate_logistic(size_t start_index, int count, uint8_t * dst_data);
+    inline void calculate_logistic(size_t start_index, int count, uint8_t* dst_data);
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/reorder.cpp b/src/plugins/intel_cpu/src/nodes/reorder.cpp
index 7257e31369bd66..67ef17e3aa9d87 100644
--- a/src/plugins/intel_cpu/src/nodes/reorder.cpp
+++ b/src/plugins/intel_cpu/src/nodes/reorder.cpp
@@ -3,24 +3,26 @@
 //
 
 #include "reorder.h"
-#include <memory>
-#include <string>
-#include <dnnl_types.h>
+
 #include <dnnl_extension_utils.h>
-#include "openvino/core/parallel.hpp"
-#include "utils/general_utils.h"
-#include <cpu/x64/cpu_isa_traits.hpp>
-#include "nodes/common/cpu_memcpy.h"
-#include "nodes/common/cpu_convert.h"
-#include "nodes/common/reorder_prim.h"
-#include "convert.h"
+#include <dnnl_types.h>
+
 #include <common/primitive_hashing_utils.hpp>
+#include <cpu/x64/cpu_isa_traits.hpp>
+#include <memory>
 #include <shape_inference/shape_inference_pass_through.hpp>
+#include <string>
 
+#include "convert.h"
 #include "cpu/x64/cpu_isa_traits.hpp"
-#include "utils/precision_support.h"
+#include "nodes/common/cpu_convert.h"
+#include "nodes/common/cpu_memcpy.h"
+#include "nodes/common/reorder_prim.h"
 #include "nodes/executors/executor.hpp"
 #include "nodes/executors/transpose_list.hpp"
+#include "openvino/core/parallel.hpp"
+#include "utils/general_utils.h"
+#include "utils/precision_support.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -30,13 +32,22 @@ bool Reorder::isExecutable() const {
     return Node::isExecutable() && !isOptimized;
 }
 
-Reorder::Reorder(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) :
-        Node(op, context, PassThroughShapeInferFactory()) {
+Reorder::Reorder(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, PassThroughShapeInferFactory()) {
     THROW_CPU_NODE_ERR("could not create CPU node from Core node.");
 }
 
-Reorder::Reorder(const MemoryDesc& input, const MemoryDesc& output, const std::string& name, const GraphContext::CPtr context) :
-    Node("Reorder", {input.getShape()}, {output.getShape()}, {input.getPrecision()}, {output.getPrecision()}, name, context) {
+Reorder::Reorder(const MemoryDesc& input,
+                 const MemoryDesc& output,
+                 const std::string& name,
+                 const GraphContext::CPtr context)
+    : Node("Reorder",
+           {input.getShape()},
+           {output.getShape()},
+           {input.getPrecision()},
+           {output.getPrecision()},
+           name,
+           context) {
     this->input = input.clone();
     this->output = output.clone();
 }
@@ -85,24 +96,25 @@ void Reorder::initSupportedPrimitiveDescriptors() {
         shapeInference = std::make_shared<ShapeInferPassThrough>();
     }
 
-    if (isDynamic && (config.inConfs[0].getMemDesc()->getShape().getRank() != config.outConfs[0].getMemDesc()->getShape().getRank()))
+    if (isDynamic &&
+        (config.inConfs[0].getMemDesc()->getShape().getRank() != config.outConfs[0].getMemDesc()->getShape().getRank()))
         THROW_CPU_NODE_ERR("doesn't support case when input and output shapes have different rank and dynamic.");
     if (!isOptimized) {
-        const auto &inShape = getInputShapeAtPort(0);
-        if (one_of(inShape.getRank(), 4u, 5u) &&
-                config.inConfs[0].getMemDesc()->hasLayoutType(LayoutType::nspc) &&
-                config.outConfs[0].getMemDesc()->hasLayoutType(LayoutType::ncsp) &&
-                config.inConfs[0].getMemDesc()->getPrecision() == ov::element::f32 &&
-                config.outConfs[0].getMemDesc()->getPrecision() == ov::element::f32) {
-            // oneDNN JIT reorder shows bad perf for nspc to ncsp reorder case so we fallback on simple c++ implementation
+        const auto& inShape = getInputShapeAtPort(0);
+        if (one_of(inShape.getRank(), 4u, 5u) && config.inConfs[0].getMemDesc()->hasLayoutType(LayoutType::nspc) &&
+            config.outConfs[0].getMemDesc()->hasLayoutType(LayoutType::ncsp) &&
+            config.inConfs[0].getMemDesc()->getPrecision() == ov::element::f32 &&
+            config.outConfs[0].getMemDesc()->getPrecision() == ov::element::f32) {
+            // oneDNN JIT reorder shows bad perf for nspc to ncsp reorder case so we fallback on simple c++
+            // implementation
             isNspc2NcspCase = true;
-        } else if (!dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2) &&
-                   one_of(inShape.getRank(), 4u, 5u) &&
+        } else if (!dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2) && one_of(inShape.getRank(), 4u, 5u) &&
                    config.inConfs[0].getMemDesc()->hasLayoutType(LayoutType::ncsp) &&
                    config.outConfs[0].getMemDesc()->hasLayoutType(LayoutType::nspc) &&
                    config.inConfs[0].getMemDesc()->getPrecision() == config.outConfs[0].getMemDesc()->getPrecision() &&
                    config.inConfs[0].getMemDesc()->getPrecision().size() == 1) {
-            // oneDNN doesn't provide JIT reorder impl for non-avx2 targets so we fallback on simple c++ implementation which shows better perf
+            // oneDNN doesn't provide JIT reorder impl for non-avx2 targets so we fallback on simple c++ implementation
+            // which shows better perf
             isNcsp2NspcCase = true;
         }
     }
@@ -121,7 +133,8 @@ void Reorder::executeDynamicImpl(dnnl::stream strm) {
 }
 
 void Reorder::prepareReorderAsTranspose(MemoryDescPtr parentDesc, MemoryDescPtr childDesc) {
-    auto getOrderAndBlockedDims = [](const MemoryDesc& lhs, const MemoryDesc& rhs) -> std::pair<std::vector<size_t>, std::vector<size_t>> {
+    auto getOrderAndBlockedDims = [](const MemoryDesc& lhs,
+                                     const MemoryDesc& rhs) -> std::pair<std::vector<size_t>, std::vector<size_t>> {
         const auto& in = lhs.as<BlockedMemoryDesc>()->getBlockDims();
         const auto rank = lhs.getShape().getRank();
 
@@ -148,7 +161,8 @@ void Reorder::prepareReorderAsTranspose(MemoryDescPtr parentDesc, MemoryDescPtr
     const auto& transposeOrder = order.first;
     const auto& transposedBlockDims = order.second;
 
-    auto transposedDesc = std::make_shared<CpuBlockedMemoryDesc>(parentDesc->getPrecision(), Shape{transposedBlockDims});
+    auto transposedDesc =
+        std::make_shared<CpuBlockedMemoryDesc>(parentDesc->getPrecision(), Shape{transposedBlockDims});
 
     TransposeParams transposeParams;
     transposeParams.permuteParams.src_block_dims = parentDesc->as<BlockedMemoryDesc>()->getBlockDims();
@@ -164,10 +178,7 @@ void Reorder::prepareReorderAsTranspose(MemoryDescPtr parentDesc, MemoryDescPtr
                                                               std::vector<MemoryDescPtr>{transposedDesc},
                                                               transpose_context);
     dnnl::primitive_attr attr;
-    transposeExecutor = factory->makeExecutor(transposeParams,
-                                              {parentDesc},
-                                              {transposedDesc},
-                                              attr);
+    transposeExecutor = factory->makeExecutor(transposeParams, {parentDesc}, {transposedDesc}, attr);
     getSelectedPrimitiveDescriptor()->setImplementationType(transposeExecutor->implType());
     return;
 }
@@ -198,8 +209,8 @@ void Reorder::prepareParams() {
         return true;
     };
 
-    const auto&  parentDesc = srcMemPtr->getDescPtr();
-    const auto&  childDesc = dstMemPtr->getDescPtr();
+    const auto& parentDesc = srcMemPtr->getDescPtr();
+    const auto& childDesc = dstMemPtr->getDescPtr();
 
 #if defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)
     // @todo current oneDNN v3.2 lacks optimized jit implementation for fp16 reorders.
@@ -213,7 +224,7 @@ void Reorder::prepareParams() {
 #endif
 
     if ((isNspc2NcspCase || isNcsp2NspcCase) && isSupportedDesc(*childDesc) && isSupportedDesc(*parentDesc)) {
-        const auto &inDims = srcMemPtr->getStaticDims();
+        const auto& inDims = srcMemPtr->getStaticDims();
         // Check that child strides are consistent with parent dims if the child is inplace.
         // The strides must be dense except for the channel one (since the child num channels might differ)
         const auto childSubBlocksAreDense = [&]() {
@@ -223,15 +234,15 @@ void Reorder::prepareParams() {
             if (dstStrides.back() != 1)
                 return false;
             for (int i = inDims.size() - 1; i > 0; i--) {
-                if (dstStrides[i-1] != dstStrides[i] * inDims[dstOrder[i]] && dstOrder[i] != channelDim)
+                if (dstStrides[i - 1] != dstStrides[i] * inDims[dstOrder[i]] && dstOrder[i] != channelDim)
                     return false;
             }
             return true;
         };
         if (isNspc2NcspCase) {
             canUseNspc2Ncsp = inDims[1] <= 64 && inDims[1] >= 16 &&
-                (parentDesc->as<BlockedMemoryDesc>()->getPaddedElementsCount() / inDims[1]) >= 128 &&
-                childSubBlocksAreDense();
+                              (parentDesc->as<BlockedMemoryDesc>()->getPaddedElementsCount() / inDims[1]) >= 128 &&
+                              childSubBlocksAreDense();
         } else if (isNcsp2NspcCase) {
             canUseNcsp2Nspc = childSubBlocksAreDense();
         }
@@ -294,7 +305,8 @@ void Reorder::createReorderPrimitive(const DnnlMemoryDescPtr& srcDesc, const Dnn
     }
 
     DEBUG_LOG("CreateReorderPrimitive is called for node", getName(), " src desc: ", src_desc, " dst_desc: ", dst_desc);
-    CPU_NODE_ASSERT(src_desc.get_ndims() == dst_desc.get_ndims(), "OneDNN doesn't support reorder with different ranks.");
+    CPU_NODE_ASSERT(src_desc.get_ndims() == dst_desc.get_ndims(),
+                    "OneDNN doesn't support reorder with different ranks.");
     auto result = getReorderPrim(context->getParamsCache(), getEngine(), src_desc, dst_desc);
     CPU_NODE_ASSERT(result, "could not create reorder primitive: unsupported reorder case.");
     prim = result;
@@ -342,7 +354,7 @@ void Reorder::optimizedNcsp2Nspc() {
 
     const size_t src_batch_stride = DIM1 * DIM2 * DIM3 * DIM4;
     const size_t dst_batch_stride = dstStrides[0];
-    const size_t dst_channel_stride = dstStrides[ndims-2];
+    const size_t dst_channel_stride = dstStrides[ndims - 2];
     const size_t stride1 = DIM2 * DIM3 * DIM4;
     const size_t stride2 = DIM2 * DIM3;
 
@@ -398,9 +410,15 @@ void Reorder::execute(dnnl::stream strm) {
 #endif
 
     if (isOptimized) {
-        DEBUG_LOG("#", getExecIndex(), " Reorder ", getName(), "  is Optimized.",
-                   " input @", getSrcDataAtPort(0),
-                   " output @", getDstDataAtPort(0));
+        DEBUG_LOG("#",
+                  getExecIndex(),
+                  " Reorder ",
+                  getName(),
+                  "  is Optimized.",
+                  " input @",
+                  getSrcDataAtPort(0),
+                  " output @",
+                  getDstDataAtPort(0));
         return;
     }
 
@@ -417,7 +435,7 @@ void Reorder::execute(dnnl::stream strm) {
     }
 }
 
-std::string Reorder::getReorderArgs(const MemoryDesc &parentDesc, const MemoryDesc &childDesc) {
+std::string Reorder::getReorderArgs(const MemoryDesc& parentDesc, const MemoryDesc& childDesc) {
     std::string inArgs, outArgs;
     if (parentDesc.getPrecision() != childDesc.getPrecision()) {
         inArgs += (inArgs.empty() ? "" : "_") + std::string(parentDesc.getPrecision().get_type_name());
@@ -432,7 +450,7 @@ std::string Reorder::getReorderArgs(const MemoryDesc &parentDesc, const MemoryDe
     return inArgs + "_" + outArgs;
 }
 
-void Reorder::reorderData(const IMemory &input, const IMemory &output, MultiCachePtr cache) {
+void Reorder::reorderData(const IMemory& input, const IMemory& output, MultiCachePtr cache) {
     if (!input.getDesc().isDefined() || !output.getDesc().isDefined())
         OPENVINO_THROW("Can't reorder data with dynamic shapes");
 
@@ -465,7 +483,7 @@ void Reorder::reorderData(const IMemory &input, const IMemory &output, MultiCach
         auto engine = dstMemory.get_engine();
 
         if (srcMemoryDesc.get_ndims() != dstMemoryDesc.get_ndims()) {
-            //rank mismatch, try to reshape source mem descriptor
+            // rank mismatch, try to reshape source mem descriptor
             constexpr bool allowEmpty = true;
             auto reshapedSrcMemDesc = srcMemoryDesc.reshape(dstMemoryDesc.get_dims(), allowEmpty);
             if (reshapedSrcMemDesc) {
@@ -480,14 +498,17 @@ void Reorder::reorderData(const IMemory &input, const IMemory &output, MultiCach
             // try precision conversion then do the reorder
             if (output.getDataType() != input.getDataType() && Convert::isSupportedDesc(input.getDesc()) &&
                 Convert::isSupportedDesc(output.getDesc())) {
-                //we probably could not make the reorder because there is no one supporting this precision conversion
-                //lets try to convert data first using cpu_convert
-                auto data = static_cast<const uint8_t *>(input.getData());
+                // we probably could not make the reorder because there is no one supporting this precision conversion
+                // lets try to convert data first using cpu_convert
+                auto data = static_cast<const uint8_t*>(input.getData());
                 tmpBuff.resize(output.getSize());
 
                 const auto outPrc = DnnlExtensionUtils::DataTypeToElementType(output.getDataType());
-                cpu_convert(data, tmpBuff.data(), DnnlExtensionUtils::DataTypeToElementType(input.getDataType()),
-                            outPrc, input.getSize() / input.getDesc().getPrecision().size());
+                cpu_convert(data,
+                            tmpBuff.data(),
+                            DnnlExtensionUtils::DataTypeToElementType(input.getDataType()),
+                            outPrc,
+                            input.getSize() / input.getDesc().getPrecision().size());
 
                 auto tmpDesc = input.getDesc().cloneWithNewPrecision(outPrc);
                 Memory tmpMem(engine, std::move(tmpDesc), tmpBuff.data());
@@ -511,6 +532,6 @@ void Reorder::reorderData(const IMemory &input, const IMemory &output, MultiCach
     }
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/reorder.h b/src/plugins/intel_cpu/src/nodes/reorder.h
index ab94b60b6a4a18..6f83a59f5b0d1f 100644
--- a/src/plugins/intel_cpu/src/nodes/reorder.h
+++ b/src/plugins/intel_cpu/src/nodes/reorder.h
@@ -15,7 +15,10 @@ namespace node {
 class Reorder : public Node {
 public:
     Reorder(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
-    Reorder(const MemoryDesc& input, const MemoryDesc& output, const std::string& name, const GraphContext::CPtr context);
+    Reorder(const MemoryDesc& input,
+            const MemoryDesc& output,
+            const std::string& name,
+            const GraphContext::CPtr context);
 
     void getSupportedDescriptors() override;
     void initSupportedPrimitiveDescriptors() override;
@@ -31,7 +34,7 @@ class Reorder : public Node {
 
     void executeDynamicImpl(dnnl::stream strm) override;
 
-    void setSrcPermutation(const std::vector<int> & src_perm) {
+    void setSrcPermutation(const std::vector<int>& src_perm) {
         this->src_permutation = src_perm;
     }
 
@@ -47,12 +50,16 @@ class Reorder : public Node {
         return false;
     }
 
-    const MemoryDesc& getInput() { return *input; }
-    const MemoryDesc& getOutput() { return *output; }
+    const MemoryDesc& getInput() {
+        return *input;
+    }
+    const MemoryDesc& getOutput() {
+        return *output;
+    }
 
-    static std::string getReorderArgs(const MemoryDesc &parentDesc, const MemoryDesc &childDesc);
+    static std::string getReorderArgs(const MemoryDesc& parentDesc, const MemoryDesc& childDesc);
 
-    static void reorderData(const IMemory &input, const IMemory &output, MultiCachePtr cache = nullptr);
+    static void reorderData(const IMemory& input, const IMemory& output, MultiCachePtr cache = nullptr);
 
 private:
     dnnl::reorder::primitive prim;
@@ -76,6 +83,6 @@ class Reorder : public Node {
     TransposeExecutorPtr transposeExecutor;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/reorg_yolo.cpp b/src/plugins/intel_cpu/src/nodes/reorg_yolo.cpp
index 49ad9b9cec5777..54824f6f12a0b4 100644
--- a/src/plugins/intel_cpu/src/nodes/reorg_yolo.cpp
+++ b/src/plugins/intel_cpu/src/nodes/reorg_yolo.cpp
@@ -2,11 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <string>
+#include "reorg_yolo.h"
 
 #include <openvino/opsets/opset2.hpp>
+#include <string>
+
 #include "openvino/core/parallel.hpp"
-#include "reorg_yolo.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -57,14 +58,14 @@ void ReorgYolo::executeDynamicImpl(dnnl::stream strm) {
 }
 
 void ReorgYolo::execute(dnnl::stream strm) {
-    const auto *src_data = getSrcDataAtPortAs<const float>(0);
-    auto *dst_data = getDstDataAtPortAs<float>(0);
+    const auto* src_data = getSrcDataAtPortAs<const float>(0);
+    auto* dst_data = getDstDataAtPortAs<float>(0);
 
-    const auto &inDims = getParentEdgeAt(0)->getMemory().getStaticDims();
+    const auto& inDims = getParentEdgeAt(0)->getMemory().getStaticDims();
     int IW = (inDims.size() > 3) ? inDims[3] : 1;
     int IH = (inDims.size() > 2) ? inDims[2] : 1;
     int IC = (inDims.size() > 1) ? inDims[1] : 1;
-    int B  = (inDims.size() > 0) ? inDims[0] : 1;
+    int B = (inDims.size() > 0) ? inDims[0] : 1;
 
     int ic_off = IC / (stride * stride);
     int ih_off = IH * stride;
@@ -94,6 +95,6 @@ bool ReorgYolo::created() const {
     return getType() == Type::ReorgYolo;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/reorg_yolo.h b/src/plugins/intel_cpu/src/nodes/reorg_yolo.h
index 190291ff06a4a9..d402b2d18a8a42 100644
--- a/src/plugins/intel_cpu/src/nodes/reorg_yolo.h
+++ b/src/plugins/intel_cpu/src/nodes/reorg_yolo.h
@@ -14,11 +14,13 @@ class ReorgYolo : public Node {
 public:
     ReorgYolo(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
-    bool needPrepareParams() const override { return false; }
+    bool needPrepareParams() const override {
+        return false;
+    }
     void executeDynamicImpl(dnnl::stream strm) override;
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
@@ -29,6 +31,6 @@ class ReorgYolo : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/reshape.cpp b/src/plugins/intel_cpu/src/nodes/reshape.cpp
index 6e3dea09db2a2f..a5ce68c886931d 100644
--- a/src/plugins/intel_cpu/src/nodes/reshape.cpp
+++ b/src/plugins/intel_cpu/src/nodes/reshape.cpp
@@ -21,7 +21,7 @@ bool Reshape::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, st
     try {
         if (!std::dynamic_pointer_cast<const ov::opset1::Reshape>(op) &&
             !std::dynamic_pointer_cast<const ov::opset1::Squeeze>(op) &&
-                !std::dynamic_pointer_cast<const ov::opset1::Unsqueeze>(op)) {
+            !std::dynamic_pointer_cast<const ov::opset1::Unsqueeze>(op)) {
             errorMessage = "Only opset1 Reshape, Squeeze, Unsqueeze operations are supported";
             return false;
         }
@@ -31,8 +31,8 @@ bool Reshape::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, st
     return true;
 }
 
-Reshape::Reshape(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) :
-        Node(op, context, ReshapeShapeInferFactory(op)) {
+Reshape::Reshape(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, ReshapeShapeInferFactory(op)) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
@@ -66,7 +66,7 @@ bool Reshape::needShapeInfer() const {
     if (lastSecondInputValues.empty()) {
         lastSecondInputValues.resize(mem.getStaticDims()[0], 0);
     }
-    const int32_t *sndInput = mem.getDataAs<const int32_t>();
+    const int32_t* sndInput = mem.getDataAs<const int32_t>();
     for (size_t i = 0; i < lastSecondInputValues.size(); i++) {
         if (lastSecondInputValues[i] != sndInput[i]) {
             for (size_t i = 0; i < lastSecondInputValues.size(); i++) {
@@ -113,7 +113,8 @@ void Reshape::initSupportedPrimitiveDescriptors() {
     for (size_t i = 0; i < getParentEdges().size(); i++) {
         config.inConfs[i].inPlace(0 == i && canBeInPlace ? 0 : -1);
         config.inConfs[i].constant(false);
-        config.inConfs[i].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc((i > 0 ? secondInPrc : inPrec), getInputShapeAtPort(i)));
+        config.inConfs[i].setMemDesc(
+            creatorsMap.at(LayoutType::ncsp)->createSharedDesc((i > 0 ? secondInPrc : inPrec), getInputShapeAtPort(i)));
     }
     config.outConfs.resize(1);
     config.outConfs[0].inPlace(canBeInPlace ? 0 : -1);
@@ -142,8 +143,7 @@ bool Reshape::isExecutable() const {
     bool inPlaceEnabled = false;
     if (auto prim_desc = getSelectedPrimitiveDescriptor()) {
         auto& config = prim_desc->getConfig();
-        if (config.inConfs[0].inPlace() >= 0 ||
-            config.outConfs[0].inPlace() >= 0) {
+        if (config.inConfs[0].inPlace() >= 0 || config.outConfs[0].inPlace() >= 0) {
             inPlaceEnabled = true;
         }
     }
@@ -154,6 +154,6 @@ bool Reshape::created() const {
     return getType() == Type::Reshape;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/reshape.h b/src/plugins/intel_cpu/src/nodes/reshape.h
index 887fc6f739bd80..40577eea451551 100644
--- a/src/plugins/intel_cpu/src/nodes/reshape.h
+++ b/src/plugins/intel_cpu/src/nodes/reshape.h
@@ -21,7 +21,9 @@ class Reshape : public Node {
     bool isExecutable() const override;
 
     bool needShapeInfer() const override;
-    bool needPrepareParams() const override { return false; }
+    bool needPrepareParams() const override {
+        return false;
+    }
     void executeDynamicImpl(dnnl::stream strm) override;
     void execute(dnnl::stream strm) override;
 
@@ -33,6 +35,6 @@ class Reshape : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/reverse_sequence.cpp b/src/plugins/intel_cpu/src/nodes/reverse_sequence.cpp
index 66139415588a10..51fc1868951181 100644
--- a/src/plugins/intel_cpu/src/nodes/reverse_sequence.cpp
+++ b/src/plugins/intel_cpu/src/nodes/reverse_sequence.cpp
@@ -2,18 +2,20 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "reverse_sequence.h"
+
 #include <string>
 #include <vector>
 
-#include "openvino/opsets/opset1.hpp"
 #include "openvino/core/parallel.hpp"
-#include "reverse_sequence.h"
+#include "openvino/opsets/opset1.hpp"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-bool ReverseSequence::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool ReverseSequence::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                           std::string& errorMessage) noexcept {
     try {
         const auto revSeq = std::dynamic_pointer_cast<const ov::opset1::ReverseSequence>(op);
         if (!revSeq) {
@@ -40,7 +42,7 @@ ReverseSequence::ReverseSequence(const std::shared_ptr<ov::Node>& op, const Grap
                        op->get_friendly_name(),
                        "' is not an instance of ReverseSequence from opset1.");
 
-    if (inputShapes.size() != 2  || outputShapes.size() != 1)
+    if (inputShapes.size() != 2 || outputShapes.size() != 1)
         OPENVINO_THROW(errorPrefix, " has incorrect number of input/output edges!");
 
     const auto dataRank = getInputShapeAtPort(REVERSESEQUENCE_DATA).getRank();
@@ -73,8 +75,7 @@ void ReverseSequence::initSupportedPrimitiveDescriptors() {
     if (lengthsPrecision != ov::element::i32 && lengthsPrecision != ov::element::f32)
         lengthsPrecision = ov::element::i32;
 
-    addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32},
-                          {LayoutType::ncsp, lengthsPrecision}},
+    addSupportedPrimDesc({{LayoutType::ncsp, ov::element::f32}, {LayoutType::ncsp, lengthsPrecision}},
                          {{LayoutType::ncsp, ov::element::f32}},
                          impl_desc_type::ref_any);
 }
@@ -105,9 +106,12 @@ void ReverseSequence::executeDynamicImpl(dnnl::stream strm) {
 }
 
 ReverseSequence::ReverseSequenceExecutor::ReverseSequenceExecutor(const VectorDims& dataDims,
-    const VectorDims& seqLengthsDims, const VectorDims& dstDims, int batchAxis, int seqAxis)
-        : batchAxis{batchAxis}
-        , seqAxis{seqAxis} {
+                                                                  const VectorDims& seqLengthsDims,
+                                                                  const VectorDims& dstDims,
+                                                                  int batchAxis,
+                                                                  int seqAxis)
+    : batchAxis{batchAxis},
+      seqAxis{seqAxis} {
     for (size_t i = 0; i < dataDims.size(); ++i) {
         if (dataDims[i] != dstDims[i])
             OPENVINO_THROW("Input/output tensors dimensions mismatch");
@@ -125,12 +129,14 @@ ReverseSequence::ReverseSequenceExecutor::ReverseSequenceExecutor(const VectorDi
     workAmountDst = srcStrides[0] * dataDims[0];
 }
 
-template<typename T>
-void ReverseSequence::ReverseSequenceExecutor::exec(const MemoryPtr& dataMemPtr, const MemoryPtr& seqLengthsMemPtr, const MemoryPtr& dstMemPtr) {
+template <typename T>
+void ReverseSequence::ReverseSequenceExecutor::exec(const MemoryPtr& dataMemPtr,
+                                                    const MemoryPtr& seqLengthsMemPtr,
+                                                    const MemoryPtr& dstMemPtr) {
     const VectorDims& srcDims = dataMemPtr->getStaticDims();
-    const auto *srcData = dataMemPtr->getDataAs<const float>();
-    auto *dstData = dstMemPtr->getDataAs<float>();
-    auto *seqLengthsData = seqLengthsMemPtr->getDataAs<T>();
+    const auto* srcData = dataMemPtr->getDataAs<const float>();
+    auto* dstData = dstMemPtr->getDataAs<float>();
+    auto* seqLengthsData = seqLengthsMemPtr->getDataAs<T>();
 
     for (size_t i = 0; i < srcDims[batchAxis]; ++i) {
         if (static_cast<int32_t>(seqLengthsData[i]) > static_cast<int>(srcDims[seqAxis])) {
@@ -159,7 +165,8 @@ void ReverseSequence::ReverseSequenceExecutor::exec(const MemoryPtr& dataMemPtr,
             dstData[iwork] = srcData[srcIdx];
             for (int j = srcDims.size() - 1; j >= 0; --j) {
                 counters[j] = (counters[j] + 1) % srcDims[j];
-                if (counters[j] != 0) break;
+                if (counters[j] != 0)
+                    break;
             }
         }
     });
@@ -171,7 +178,7 @@ void ReverseSequence::execute(dnnl::stream strm) {
 
     const auto precision = getParentEdgeAt(REVERSESEQUENCE_LENGTHS)->getMemory().getDesc().getPrecision();
     if (!one_of(precision, ov::element::f32, ov::element::i32))
-        OPENVINO_THROW("ReverseSequence layer does not support ", precision , " precision");
+        OPENVINO_THROW("ReverseSequence layer does not support ", precision, " precision");
 
     if (precision == ov::element::f32)
         execPtr->exec<float>(getSrcMemoryAtPort(REVERSESEQUENCE_DATA),
@@ -187,6 +194,6 @@ bool ReverseSequence::created() const {
     return getType() == Type::ReverseSequence;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/reverse_sequence.h b/src/plugins/intel_cpu/src/nodes/reverse_sequence.h
index 7260b73e3c6266..1e625fc934fbaa 100644
--- a/src/plugins/intel_cpu/src/nodes/reverse_sequence.h
+++ b/src/plugins/intel_cpu/src/nodes/reverse_sequence.h
@@ -14,7 +14,7 @@ class ReverseSequence : public Node {
 public:
     ReverseSequence(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
@@ -29,10 +29,11 @@ class ReverseSequence : public Node {
         ReverseSequenceExecutor(const VectorDims& dataDims,
                                 const VectorDims& seqLengthsDims,
                                 const VectorDims& dstDims,
-                                int batchAxis, int seqAxis);
+                                int batchAxis,
+                                int seqAxis);
         ~ReverseSequenceExecutor() = default;
 
-        template<typename T>
+        template <typename T>
         void exec(const MemoryPtr& dataMemPtr, const MemoryPtr& seqLengthsMemPtr, const MemoryPtr& dstMemPtr);
 
     private:
@@ -55,6 +56,6 @@ class ReverseSequence : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/rms_norm.cpp b/src/plugins/intel_cpu/src/nodes/rms_norm.cpp
index fe28c25af5ea1c..92e88c36333d3a 100644
--- a/src/plugins/intel_cpu/src/nodes/rms_norm.cpp
+++ b/src/plugins/intel_cpu/src/nodes/rms_norm.cpp
@@ -12,12 +12,12 @@
 #include "memory_desc/dnnl_blocked_memory_desc.h"
 #include "onednn/dnnl.h"
 #include "openvino/core/parallel.hpp"
+#include "openvino/opsets/opset6.hpp"
 #include "openvino/util/common_util.hpp"
 #include "ov_ops/rms.hpp"
 #include "shape_inference/custom/rms_norm.hpp"
-#include "openvino/opsets/opset6.hpp"
 #ifdef OPENVINO_ARCH_X86_64
-#include "kernels/x64/rms_kernel.hpp"
+#    include "kernels/x64/rms_kernel.hpp"
 #endif
 
 #include <algorithm>
@@ -51,10 +51,8 @@ size_t RMSNormKey::hash() const {
 }
 
 bool RMSNormKey::operator==(const RMSNormKey& rhs) const {
-    auto retVal = precision == rhs.precision &&
-                  data_size == rhs.data_size &&
-                  scale_size == rhs.scale_size &&
-                  eps == rhs.eps;
+    auto retVal =
+        precision == rhs.precision && data_size == rhs.data_size && scale_size == rhs.scale_size && eps == rhs.eps;
 
     return retVal;
 }
@@ -75,7 +73,10 @@ static std::shared_ptr<kernel::JitKernelBase> createJitKernel(const kernel::jit_
     return res;
 }
 
-static void execJitKernel(const std::shared_ptr<kernel::JitKernelBase>& ker, const uint8_t* src, uint8_t* dst, const float* scale) {
+static void execJitKernel(const std::shared_ptr<kernel::JitKernelBase>& ker,
+                          const uint8_t* src,
+                          uint8_t* dst,
+                          const float* scale) {
     kernel::jit_rms_call_args call_args;
     call_args.src = src;
     call_args.dst = dst;
@@ -84,7 +85,8 @@ static void execJitKernel(const std::shared_ptr<kernel::JitKernelBase>& ker, con
 }
 
 struct RMSNorm::RMSNormExecutor : public RMSNorm::Executor {
-    RMSNormExecutor(ov::element::Type precision, size_t data_size, size_t scale_size, float eps) : m_precision(precision) {
+    RMSNormExecutor(ov::element::Type precision, size_t data_size, size_t scale_size, float eps)
+        : m_precision(precision) {
         kernel::jit_rms_compile_params jcp;
         jcp.src_prc = precision;
         jcp.dst_prc = precision;
@@ -104,7 +106,7 @@ struct RMSNorm::RMSNormExecutor : public RMSNorm::Executor {
         const auto src_stride = src_strides[src_strides.size() - 2] * m_precision.size();
         const auto dst_stride = dst_strides[dst_strides.size() - 2] * m_precision.size();
         auto n = shape_size(shape) / shape[shape.size() - 1];
-        parallel_for(n, [&] (size_t i) {
+        parallel_for(n, [&](size_t i) {
             execJitKernel(m_kernel, src + i * src_stride, dst + i * dst_stride, scale);
         });
     }
@@ -113,7 +115,7 @@ struct RMSNorm::RMSNormExecutor : public RMSNorm::Executor {
     ov::element::Type m_precision;
     std::shared_ptr<kernel::JitKernelBase> m_kernel;
 };
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
 RMSNorm::RMSNorm(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
     : Node(op, context, RMSNormShapeInferFactory(op)) {
@@ -142,8 +144,8 @@ void RMSNorm::initSupportedPrimitiveDescriptors() {
     }
 
     addSupportedPrimDesc({{LayoutType::ncsp, precision}, {LayoutType::ncsp, ov::element::f32}},
-                        {{LayoutType::ncsp, precision}},
-                        impl_type);
+                         {{LayoutType::ncsp, precision}},
+                         impl_type);
 }
 
 void RMSNorm::createPrimitive() {
diff --git a/src/plugins/intel_cpu/src/nodes/rnn.cpp b/src/plugins/intel_cpu/src/nodes/rnn.cpp
index 108123fc3fe620..a1f6d60e289491 100644
--- a/src/plugins/intel_cpu/src/nodes/rnn.cpp
+++ b/src/plugins/intel_cpu/src/nodes/rnn.cpp
@@ -23,7 +23,6 @@
 
 using namespace dnnl;
 
-
 namespace ov {
 namespace intel_cpu {
 
@@ -38,37 +37,35 @@ static rnn_direction ieDirection2dnnl(const std::shared_ptr<const ov::Node>& op)
     } else if (ov::is_type<ov::op::v5::RNNSequence>(op)) {
         direction = ov::as_type_ptr<const ov::op::v5::RNNSequence>(op)->get_direction();
     }
-    return direction == ov::op::RecurrentSequenceDirection::FORWARD ? rnn_direction::unidirectional_left2right
-         : direction == ov::op::RecurrentSequenceDirection::REVERSE ? rnn_direction::unidirectional_right2left
-         : direction == ov::op::RecurrentSequenceDirection::BIDIRECTIONAL ? rnn_direction::bidirectional_concat
-         : rnn_direction::unidirectional_left2right;
+    return direction == ov::op::RecurrentSequenceDirection::FORWARD         ? rnn_direction::unidirectional_left2right
+           : direction == ov::op::RecurrentSequenceDirection::REVERSE       ? rnn_direction::unidirectional_right2left
+           : direction == ov::op::RecurrentSequenceDirection::BIDIRECTIONAL ? rnn_direction::bidirectional_concat
+                                                                            : rnn_direction::unidirectional_left2right;
 }
 
 static dnnl::algorithm ie2dnnl(const std::string& act_type) {
     return act_type == "sigmoid" ? dnnl::algorithm::eltwise_logistic
-         : act_type == "tanh"    ? dnnl::algorithm::eltwise_tanh
-         : act_type == "relu"    ? dnnl::algorithm::eltwise_relu
-         : dnnl::algorithm::undef;
+           : act_type == "tanh"  ? dnnl::algorithm::eltwise_tanh
+           : act_type == "relu"  ? dnnl::algorithm::eltwise_relu
+                                 : dnnl::algorithm::undef;
 }
 
 static dnnl::algorithm ie2dnnl(const std::shared_ptr<const ov::Node>& op) {
     if (one_of(op->get_type_info(),
-            ov::op::v3::GRUCell::get_type_info_static(),
-            ov::op::v5::GRUSequence::get_type_info_static())) {
+               ov::op::v3::GRUCell::get_type_info_static(),
+               ov::op::v5::GRUSequence::get_type_info_static())) {
         auto gruCellOp = ov::as_type_ptr<const ov::op::v3::GRUCell>(op);
         auto gruSeqOp = ov::as_type_ptr<const ov::op::v5::GRUSequence>(op);
-        if ((gruCellOp && gruCellOp->get_linear_before_reset()) ||
-                (gruSeqOp && gruSeqOp->get_linear_before_reset()))
+        if ((gruCellOp && gruCellOp->get_linear_before_reset()) || (gruSeqOp && gruSeqOp->get_linear_before_reset()))
             return dnnl::algorithm::lbr_gru;
         else
             return dnnl::algorithm::vanilla_gru;
     } else if (one_of(op->get_type_info(),
-            ov::op::internal::AUGRUCell::get_type_info_static(),
-            ov::op::internal::AUGRUSequence::get_type_info_static())) {
+                      ov::op::internal::AUGRUCell::get_type_info_static(),
+                      ov::op::internal::AUGRUSequence::get_type_info_static())) {
         auto gruCellOp = ov::as_type_ptr<const ov::op::internal::AUGRUCell>(op);
         auto gruSeqOp = ov::as_type_ptr<const ov::op::internal::AUGRUSequence>(op);
-        if ((gruCellOp && gruCellOp->get_linear_before_reset()) ||
-                (gruSeqOp && gruSeqOp->get_linear_before_reset()))
+        if ((gruCellOp && gruCellOp->get_linear_before_reset()) || (gruSeqOp && gruSeqOp->get_linear_before_reset()))
             return dnnl::algorithm::lbr_augru;
         else
             return dnnl::algorithm::vanilla_augru;
@@ -92,29 +89,34 @@ static dnnl::algorithm ie2dnnl(const std::shared_ptr<const ov::Node>& op) {
 
 inline size_t gatesCount(const algorithm& alg) {
     switch (alg) {
-        case algorithm::vanilla_rnn:     return 1;
-        case algorithm::vanilla_gru:
-        case algorithm::vanilla_augru:
-        case algorithm::lbr_augru:
-        case algorithm::lbr_gru:         return 3;
-        case algorithm::vanilla_lstm:    return 4;
-        default:
-            OPENVINO_THROW("Unsupported cell type");
-            return 0;
+    case algorithm::vanilla_rnn:
+        return 1;
+    case algorithm::vanilla_gru:
+    case algorithm::vanilla_augru:
+    case algorithm::lbr_augru:
+    case algorithm::lbr_gru:
+        return 3;
+    case algorithm::vanilla_lstm:
+        return 4;
+    default:
+        OPENVINO_THROW("Unsupported cell type");
+        return 0;
     }
 }
 
 inline size_t statesCount(const dnnl::algorithm& alg) {
     switch (alg) {
-        case dnnl::algorithm::vanilla_rnn:
-        case dnnl::algorithm::vanilla_gru:
-        case dnnl::algorithm::vanilla_augru:
-        case dnnl::algorithm::lbr_augru:
-        case dnnl::algorithm::lbr_gru:         return 1;
-        case dnnl::algorithm::vanilla_lstm:    return 2;
-        default:
-            OPENVINO_THROW("Unsupported cell type");
-            return 0;
+    case dnnl::algorithm::vanilla_rnn:
+    case dnnl::algorithm::vanilla_gru:
+    case dnnl::algorithm::vanilla_augru:
+    case dnnl::algorithm::lbr_augru:
+    case dnnl::algorithm::lbr_gru:
+        return 1;
+    case dnnl::algorithm::vanilla_lstm:
+        return 2;
+    default:
+        OPENVINO_THROW("Unsupported cell type");
+        return 0;
     }
 }
 
@@ -126,16 +128,15 @@ inline bool haveAttention(const dnnl::algorithm& alg) {
 }
 
 // what weight data type should be used for particular input data type
-const std::map<memory::data_type, memory::data_type> RNN::weightsByinputDataType {
+const std::map<memory::data_type, memory::data_type> RNN::weightsByinputDataType{
     // layer data type        weights data type
-    {memory::data_type::f32,  memory::data_type::f32},
-    {memory::data_type::f16,  memory::data_type::f16},
+    {memory::data_type::f32, memory::data_type::f32},
+    {memory::data_type::f16, memory::data_type::f16},
     {memory::data_type::bf16, memory::data_type::bf16},
-    {memory::data_type::u8,   memory::data_type::s8},
-    {memory::data_type::s8,   memory::data_type::s8},
+    {memory::data_type::u8, memory::data_type::s8},
+    {memory::data_type::s8, memory::data_type::s8},
 };
 
-
 struct RNNKey {
     const std::vector<DnnlBlockedMemoryDescPtr> inDataDescs;
     const std::vector<DnnlBlockedMemoryDescPtr> outDataDescs;
@@ -172,19 +173,22 @@ size_t RNNKey::hash() const {
 }
 
 bool RNNKey::operator==(const RNNKey& rhs) const {
-    if (inDataDescs.size() != rhs.inDataDescs.size() || outDataDescs.size() != rhs.outDataDescs.size() || wDescs.size() != rhs.wDescs.size() ||
-            cellType != rhs.cellType || cellAct != rhs.cellAct || direction != rhs.direction) {
+    if (inDataDescs.size() != rhs.inDataDescs.size() || outDataDescs.size() != rhs.outDataDescs.size() ||
+        wDescs.size() != rhs.wDescs.size() || cellType != rhs.cellType || cellAct != rhs.cellAct ||
+        direction != rhs.direction) {
         return false;
     }
 
     for (size_t i = 0lu; i < inDataDescs.size(); i++) {
-        if (inDataDescs[i] != rhs.inDataDescs[i] && (inDataDescs[i] == nullptr || rhs.inDataDescs[i] == nullptr ||
-                inDataDescs[i]->getDnnlDesc() != rhs.inDataDescs[i]->getDnnlDesc()))
+        if (inDataDescs[i] != rhs.inDataDescs[i] &&
+            (inDataDescs[i] == nullptr || rhs.inDataDescs[i] == nullptr ||
+             inDataDescs[i]->getDnnlDesc() != rhs.inDataDescs[i]->getDnnlDesc()))
             return false;
     }
     for (size_t i = 0lu; i < outDataDescs.size(); i++) {
-        if (outDataDescs[i] != rhs.outDataDescs[i] && (outDataDescs[i] == nullptr || rhs.outDataDescs[i] == nullptr ||
-                outDataDescs[i]->getDnnlDesc() != rhs.outDataDescs[i]->getDnnlDesc()))
+        if (outDataDescs[i] != rhs.outDataDescs[i] &&
+            (outDataDescs[i] == nullptr || rhs.outDataDescs[i] == nullptr ||
+             outDataDescs[i]->getDnnlDesc() != rhs.outDataDescs[i]->getDnnlDesc()))
             return false;
     }
     for (size_t i = 0lu; i < wDescs.size(); i++) {
@@ -211,7 +215,9 @@ bool RNN::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::s
             return false;
         }
 
-        if (one_of(op->get_type_info(), ov::op::v0::RNNCell::get_type_info_static(), ov::op::v3::GRUCell::get_type_info_static())) {
+        if (one_of(op->get_type_info(),
+                   ov::op::v0::RNNCell::get_type_info_static(),
+                   ov::op::v3::GRUCell::get_type_info_static())) {
             // Plug-in does not support dynamism on weights.
             if (!ov::op::util::is_on_constant_path(op->input_value(2)) ||
                 !ov::op::util::is_on_constant_path(op->input_value(3)) ||
@@ -220,10 +226,10 @@ bool RNN::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::s
                 return false;
             }
         } else if (one_of(op->get_type_info(),
-                ov::op::v0::LSTMCell::get_type_info_static(),
-                ov::op::v4::LSTMCell::get_type_info_static(),
-                ov::op::v5::GRUSequence::get_type_info_static(),
-                ov::op::v5::RNNSequence::get_type_info_static())) {
+                          ov::op::v0::LSTMCell::get_type_info_static(),
+                          ov::op::v4::LSTMCell::get_type_info_static(),
+                          ov::op::v5::GRUSequence::get_type_info_static(),
+                          ov::op::v5::RNNSequence::get_type_info_static())) {
             // Plug-in does not support dynamism on weights.
             if (!ov::op::util::is_on_constant_path(op->input_value(3)) ||
                 !ov::op::util::is_on_constant_path(op->input_value(4)) ||
@@ -275,7 +281,8 @@ bool RNN::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::s
             } else if (one_of(rnnCellBase->get_type_info(),
                               ov::op::v5::RNNSequence::get_type_info_static(),
                               ov::op::v0::RNNCell::get_type_info_static())) {
-                if (rnnCellBase->get_activations().empty() || !one_of(rnnCellBase->get_activations().front(), "sigmoid", "tanh", "relu")) {
+                if (rnnCellBase->get_activations().empty() ||
+                    !one_of(rnnCellBase->get_activations().front(), "sigmoid", "tanh", "relu")) {
                     errorMessage = "Not supported activation functions";
                     return false;
                 }
@@ -298,7 +305,9 @@ bool RNN::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::s
             seqLenIdx = 2;
         }
 
-        if (!one_of(direction, ov::op::RecurrentSequenceDirection::FORWARD, ov::op::RecurrentSequenceDirection::REVERSE)) {
+        if (!one_of(direction,
+                    ov::op::RecurrentSequenceDirection::FORWARD,
+                    ov::op::RecurrentSequenceDirection::REVERSE)) {
             errorMessage = "Unsupported sequence direction.";
             return false;
         }
@@ -313,7 +322,8 @@ bool RNN::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::s
 
             const int64_t maxSeqLenDimIdx = 1;
 
-            if (data_pshape.rank().is_static() && data_pshape.rank().get_length() > maxSeqLenDimIdx && !data_pshape[maxSeqLenDimIdx].is_static()) {
+            if (data_pshape.rank().is_static() && data_pshape.rank().get_length() > maxSeqLenDimIdx &&
+                !data_pshape[maxSeqLenDimIdx].is_static()) {
                 errorMessage = "Max sequence length dimension is dynamic";
                 return false;
             }
@@ -332,11 +342,11 @@ bool RNN::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::s
 
 bool RNN::isCell(const std::shared_ptr<const ov::Node>& op) {
     return one_of(op->get_type_info(),
-            ov::op::v0::RNNCell::get_type_info_static(),
-            ov::op::v3::GRUCell::get_type_info_static(),
-            ov::op::internal::AUGRUCell::get_type_info_static(),
-            ov::op::v0::LSTMCell::get_type_info_static(),
-            ov::op::v4::LSTMCell::get_type_info_static());
+                  ov::op::v0::RNNCell::get_type_info_static(),
+                  ov::op::v3::GRUCell::get_type_info_static(),
+                  ov::op::internal::AUGRUCell::get_type_info_static(),
+                  ov::op::v0::LSTMCell::get_type_info_static(),
+                  ov::op::v4::LSTMCell::get_type_info_static());
 }
 
 bool RNN::testNativeOrder(const std::shared_ptr<const ov::Node>& op) {
@@ -363,9 +373,8 @@ class RnnShapeInfer : public IShapeInfer {
           native_order(RNN::testNativeOrder(op)),
           m_shape_infer(make_shape_inference(std::move(op))) {}
 
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override {
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override {
         auto result = m_shape_infer->infer(input_shapes, data_dependency);
         if (ShapeInferStatus::success != result.status) {
             OPENVINO_THROW("Unexpected: Unexpected shape inference result status");
@@ -404,48 +413,71 @@ class RnnShapeInferFactory final : public ShapeInferFactory {
     ShapeInferPtr makeShapeInfer() const override {
         return std::make_shared<RnnShapeInfer>(m_op);
     }
+
 private:
     std::shared_ptr<ov::Node> m_op;
 };
 
-} // namespace
+}  // namespace
 
-RNN::RNN(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) :
-        Node(op, context, RnnShapeInferFactory(op)) {
+RNN::RNN(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, RnnShapeInferFactory(op)) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
     }
 
     is_augru = one_of(op->get_type_info(),
-            ov::op::internal::AUGRUCell::get_type_info_static(),
-            ov::op::internal::AUGRUSequence::get_type_info_static());
+                      ov::op::internal::AUGRUCell::get_type_info_static(),
+                      ov::op::internal::AUGRUSequence::get_type_info_static());
 
     is_cell = isCell(op);
 
     if (one_of(op->get_type_info(),
                ov::op::v0::RNNCell::get_type_info_static(),
                ov::op::v3::GRUCell::get_type_info_static())) {
-        wIdx = 2; rIdx = 3; bIdx = 4;
+        wIdx = 2;
+        rIdx = 3;
+        bIdx = 4;
         hoIdx = 0;
     } else if (op->get_type_info() == ov::op::internal::AUGRUCell::get_type_info_static()) {
-        wIdx = 2; rIdx = 3; bIdx = 4; aIdx = 5;
+        wIdx = 2;
+        rIdx = 3;
+        bIdx = 4;
+        aIdx = 5;
     } else if (one_of(op->get_type_info(),
                       ov::op::v0::LSTMCell::get_type_info_static(),
                       ov::op::v4::LSTMCell::get_type_info_static())) {
-        wIdx = 3; rIdx = 4; bIdx = 5;
-        yIdx = hoIdx = 0; coIdx = 1;
+        wIdx = 3;
+        rIdx = 4;
+        bIdx = 5;
+        yIdx = hoIdx = 0;
+        coIdx = 1;
     } else if (one_of(op->get_type_info(),
                       ov::op::v5::RNNSequence::get_type_info_static(),
                       ov::op::v5::GRUSequence::get_type_info_static())) {
-        sIdx = 2; wIdx = 3; rIdx = 4; bIdx = 5;
-        yIdx = 0; hoIdx = 1;
+        sIdx = 2;
+        wIdx = 3;
+        rIdx = 4;
+        bIdx = 5;
+        yIdx = 0;
+        hoIdx = 1;
     } else if (op->get_type_info() == ov::op::internal::AUGRUSequence::get_type_info_static()) {
-        sIdx = 2; wIdx = 3; rIdx = 4; bIdx = 5; aIdx = 6;
-        yIdx = 0; hoIdx = 1;
+        sIdx = 2;
+        wIdx = 3;
+        rIdx = 4;
+        bIdx = 5;
+        aIdx = 6;
+        yIdx = 0;
+        hoIdx = 1;
     } else if (one_of(op->get_type_info(), ov::op::v5::LSTMSequence::get_type_info_static())) {
-        sIdx = 3; wIdx = 4; rIdx = 5; bIdx = 6;
-        yIdx = 0; hoIdx = 1; coIdx = 2;
+        sIdx = 3;
+        wIdx = 4;
+        rIdx = 5;
+        bIdx = 6;
+        yIdx = 0;
+        hoIdx = 1;
+        coIdx = 2;
     }
 
     auto rnnCellBase = std::dynamic_pointer_cast<ov::op::util::RNNCellBase>(op);
@@ -497,37 +529,42 @@ void RNN::configurePortDataTypes() {
     inDataTypes[xIdx] = DnnlExtensionUtils::ElementTypeToDataType(getOriginalInputPrecisionAtPort(0));
     inDataTypes[hIdx] = DnnlExtensionUtils::ElementTypeToDataType(getOriginalInputPrecisionAtPort(1));
     if (haveCellState(cell_type))
-        inDataTypes[cIdx] = memory::data_type::f32; // @todo bf16 is also allowed, should be tried out
+        inDataTypes[cIdx] = memory::data_type::f32;  // @todo bf16 is also allowed, should be tried out
     if (!is_cell)
         inDataTypes[sIdx] = memory::data_type::s32;
     inDataTypes[wIdx] = DnnlExtensionUtils::ElementTypeToDataType(getOriginalInputPrecisionAtPort(wIdx));
     inDataTypes[rIdx] = DnnlExtensionUtils::ElementTypeToDataType(getOriginalInputPrecisionAtPort(rIdx));
 
-    inDataTypes[bIdx] = memory::data_type::f32; // @todo bf16 is also allowed, should be tried out
+    inDataTypes[bIdx] = memory::data_type::f32;  // @todo bf16 is also allowed, should be tried out
     if (haveAttention(cell_type))
         inDataTypes[aIdx] = DnnlExtensionUtils::ElementTypeToDataType(getOriginalInputPrecisionAtPort(aIdx));
 
     if (!is_cell)
         outDataTypes[yIdx] = DnnlExtensionUtils::ElementTypeToDataType(getOriginalOutputPrecisionAtPort(0));
 
-    outDataTypes[hoIdx] = inDataTypes[hIdx]; // required by oneDNN. Output hidden state is a input hidden state for the next iteration
+    outDataTypes[hoIdx] =
+        inDataTypes[hIdx];  // required by oneDNN. Output hidden state is a input hidden state for the next iteration
 
     if (haveCellState(cell_type))
-        outDataTypes[coIdx] = inDataTypes[cIdx]; // required by oneDNN.
+        outDataTypes[coIdx] = inDataTypes[cIdx];  // required by oneDNN.
 
     if (one_of(memory::data_type::bf16, inDataTypes[xIdx], inDataTypes[hIdx]))
-        inDataTypes[xIdx] = outDataTypes[yIdx] = outDataTypes[hoIdx] = inDataTypes[hIdx] = memory::data_type::bf16; // required by oneDNN.
+        inDataTypes[xIdx] = outDataTypes[yIdx] = outDataTypes[hoIdx] = inDataTypes[hIdx] =
+            memory::data_type::bf16;  // required by oneDNN.
 
     if (one_of(memory::data_type::f16, inDataTypes[xIdx], inDataTypes[hIdx]))
         // onednn doesn't have fp16 instance
-        inDataTypes[xIdx] = outDataTypes[yIdx] = outDataTypes[hoIdx] = inDataTypes[hIdx] = memory::data_type::f32; // required by oneDNN.
+        inDataTypes[xIdx] = outDataTypes[yIdx] = outDataTypes[hoIdx] = inDataTypes[hIdx] =
+            memory::data_type::f32;  // required by oneDNN.
 
     // OneDNN unsupported fp16 precision for this layer
     if (cell_type == dnnl::algorithm::vanilla_augru && inDataTypes[aIdx] == memory::data_type::f16)
         inDataTypes[aIdx] = memory::data_type::f32;
 
-    if (outDataTypes[yIdx] == memory::data_type::bf16 && one_of(inDataTypes[xIdx], memory::data_type::s8, memory::data_type::u8))
-        outDataTypes[yIdx] = memory::data_type::f32; // oneDNN does not support bf16 output precision for quantized rnn primitive yet
+    if (outDataTypes[yIdx] == memory::data_type::bf16 &&
+        one_of(inDataTypes[xIdx], memory::data_type::s8, memory::data_type::u8))
+        outDataTypes[yIdx] =
+            memory::data_type::f32;  // oneDNN does not support bf16 output precision for quantized rnn primitive yet
 }
 
 void RNN::getSupportedDescriptors() {
@@ -542,9 +579,9 @@ void RNN::getSupportedDescriptors() {
 void RNN::initCell() {
     if (getInputShapeAtPort(0).getRank() != 2lu || getInputShapeAtPort(1).getRank() != 2lu)
         THROW_CPU_NODE_ERR("has incorrect input ranks. Data rank: ",
-                    getInputShapeAtPort(0).getRank(),
-                    "; Hidden state rank: ",
-                    getInputShapeAtPort(1).getRank());
+                           getInputShapeAtPort(0).getRank(),
+                           "; Hidden state rank: ",
+                           getInputShapeAtPort(1).getRank());
     if (is_augru && getInputShapeAtPort(5).getRank() != 2lu)
         THROW_CPU_NODE_ERR("has incorrect input ranks. Attention rank: ", getInputShapeAtPort(2).getRank());
 
@@ -560,23 +597,23 @@ void RNN::initCell() {
         const Shape shapeD{B, DC}, shapeS{B, SC};
 
         if ((getInputShapeAtPort(0).isStatic() && getInputShapeAtPort(0) != shapeD) ||
-                (getInputShapeAtPort(1).isStatic() && getInputShapeAtPort(1) != shapeS) ||
-                (getOutputShapeAtPort(0).isStatic() && getOutputShapeAtPort(0) != shapeS)) {
+            (getInputShapeAtPort(1).isStatic() && getInputShapeAtPort(1) != shapeS) ||
+            (getOutputShapeAtPort(0).isStatic() && getOutputShapeAtPort(0) != shapeS)) {
             THROW_CPU_NODE_ERR("has incorrect input/output shapes. Data shape: ",
-                        getInputShapeAtPort(0).toString(),
-                        "; Hidden state input: ",
-                        getInputShapeAtPort(1).toString(),
-                        "; Hidden state output: ",
-                        getOutputShapeAtPort(0).toString());
+                               getInputShapeAtPort(0).toString(),
+                               "; Hidden state input: ",
+                               getInputShapeAtPort(1).toString(),
+                               "; Hidden state output: ",
+                               getOutputShapeAtPort(0).toString());
         }
 
         if (S == 2) {
             if ((getInputShapeAtPort(2).isStatic() && getInputShapeAtPort(2) != shapeS) ||
                 (getOutputShapeAtPort(1).isStatic() && getOutputShapeAtPort(1) != shapeS))
                 THROW_CPU_NODE_ERR("has incorrect input/output shapes. Cell state input: ",
-                            getInputShapeAtPort(2).toString(),
-                            "; Cell state output: ",
-                            getOutputShapeAtPort(1).toString());
+                                   getInputShapeAtPort(2).toString(),
+                                   "; Cell state output: ",
+                                   getOutputShapeAtPort(1).toString());
         }
 
         if (is_augru) {
@@ -590,8 +627,9 @@ void RNN::initCell() {
 
 void RNN::fillCellDesc() {
     const Shape shapeS_4D = MemoryDescUtils::makeDummyShape({{L, D, N.minVal, SC}, {L, D, N.maxVal, SC}});
-    const Shape inShape   = MemoryDescUtils::makeDummyShape({{T.minVal, N.minVal, DC}, {T.maxVal, N.maxVal, DC}});
-    const Shape outShape  = MemoryDescUtils::makeDummyShape({{T.minVal, N.minVal, D * SC}, {T.maxVal, N.maxVal, D * SC}});
+    const Shape inShape = MemoryDescUtils::makeDummyShape({{T.minVal, N.minVal, DC}, {T.maxVal, N.maxVal, DC}});
+    const Shape outShape =
+        MemoryDescUtils::makeDummyShape({{T.minVal, N.minVal, D * SC}, {T.maxVal, N.maxVal, D * SC}});
 
     // layer input plus states
     if (haveAttention(cell_type)) {
@@ -602,18 +640,25 @@ void RNN::fillCellDesc() {
     outDataDescs.reserve(S + 1);
 
     // @todo use indexies instead of emplacing back, since order matters
-    inDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(inShape, inDataTypes[xIdx], memory::format_tag::tnc));
-    outDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(outShape, outDataTypes[yIdx], memory::format_tag::tnc));
+    inDataDescs.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(inShape, inDataTypes[xIdx], memory::format_tag::tnc));
+    outDataDescs.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(outShape, outDataTypes[yIdx], memory::format_tag::tnc));
 
-    inDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, inDataTypes[hIdx], memory::format_tag::ldnc));
-    outDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, outDataTypes[hoIdx], memory::format_tag::ldnc));
+    inDataDescs.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, inDataTypes[hIdx], memory::format_tag::ldnc));
+    outDataDescs.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, outDataTypes[hoIdx], memory::format_tag::ldnc));
 
     if (haveCellState(cell_type)) {
-        inDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, inDataTypes[cIdx], memory::format_tag::ldnc));
-        outDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, outDataTypes[coIdx], memory::format_tag::ldnc));
+        inDataDescs.emplace_back(
+            std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, inDataTypes[cIdx], memory::format_tag::ldnc));
+        outDataDescs.emplace_back(
+            std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, outDataTypes[coIdx], memory::format_tag::ldnc));
     } else if (haveAttention(cell_type)) {
         const Shape attnShape = MemoryDescUtils::makeDummyShape({{T.minVal, N.minVal, 1}, {T.maxVal, N.maxVal, 1}});
-        inDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(attnShape, inDataTypes[aIdx], memory::format_tag::tnc));
+        inDataDescs.emplace_back(
+            std::make_shared<DnnlBlockedMemoryDesc>(attnShape, inDataTypes[aIdx], memory::format_tag::tnc));
     }
 
     copyWeightsData();
@@ -630,25 +675,33 @@ void RNN::fillCellDesc() {
     inCandidate.reserve(getOriginalInputsNumber());
     outCandidate.reserve(getOriginalOutputsNumber());
 
-    inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeD, inDataTypes[xIdx], memory::format_tag::nc));
+    inCandidate.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(shapeD, inDataTypes[xIdx], memory::format_tag::nc));
 
-    inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeS, inDataTypes[hIdx], memory::format_tag::nc));
-    outCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeS, outDataTypes[hoIdx], memory::format_tag::nc));
+    inCandidate.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(shapeS, inDataTypes[hIdx], memory::format_tag::nc));
+    outCandidate.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(shapeS, outDataTypes[hoIdx], memory::format_tag::nc));
 
     if (haveCellState(cell_type)) {
-        inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeS, inDataTypes[cIdx], memory::format_tag::nc));
-        outCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeS, outDataTypes[coIdx], memory::format_tag::nc));
+        inCandidate.emplace_back(
+            std::make_shared<DnnlBlockedMemoryDesc>(shapeS, inDataTypes[cIdx], memory::format_tag::nc));
+        outCandidate.emplace_back(
+            std::make_shared<DnnlBlockedMemoryDesc>(shapeS, outDataTypes[coIdx], memory::format_tag::nc));
     }
     // The weight and weights_iter would expose nc layout to avoid unnecessary reorder.
     // The onednn would determine the final layout when prepareParams.
-    inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(WShape, inDataTypes[wIdx], memory::format_tag::nc));
-    inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(RShape, inDataTypes[rIdx], memory::format_tag::nc));
+    inCandidate.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(WShape, inDataTypes[wIdx], memory::format_tag::nc));
+    inCandidate.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(RShape, inDataTypes[rIdx], memory::format_tag::nc));
 
     inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(BShape, inDataTypes[bIdx], memory::format_tag::x));
 
     if (haveAttention(cell_type)) {
         Shape shapeAttn{{N.minVal, 1}, {N.maxVal, 1}};
-        inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeAttn, inDataTypes[aIdx], memory::format_tag::nc));
+        inCandidate.emplace_back(
+            std::make_shared<DnnlBlockedMemoryDesc>(shapeAttn, inDataTypes[aIdx], memory::format_tag::nc));
     }
 
     createDescriptor(inCandidate, outCandidate);
@@ -659,8 +712,10 @@ void RNN::initSequence() {
     const auto& outDataShape = getOutputShapeAtPort(0);
 
     if (inDataShape.getRank() != 3lu || outDataShape.getRank() != 4lu)
-        THROW_CPU_NODE_ERR("has incorrect input/output shapes. Input data shape: " , inDataShape.toString() ,
-                " Output shape: " , outDataShape.toString());
+        THROW_CPU_NODE_ERR("has incorrect input/output shapes. Input data shape: ",
+                           inDataShape.toString(),
+                           " Output shape: ",
+                           outDataShape.toString());
 
     if (!one_of(getOriginalInputsNumber(), 6u, 7u))
         THROW_CPU_NODE_ERR("has incorrect number of input ports: ", getOriginalInputsNumber());
@@ -685,33 +740,41 @@ void RNN::initSequence() {
 
 void RNN::fillSequenceDesc() {
     const Shape shapeS_4D = MemoryDescUtils::makeDummyShape({{L, D, N.minVal, SC}, {L, D, N.maxVal, SC}});
-    const Shape inShape   = MemoryDescUtils::makeDummyShape({{T.minVal, N.minVal, DC}, {T.maxVal, N.maxVal, DC}});
-    const Shape outShape  = MemoryDescUtils::makeDummyShape({{T.minVal, N.minVal, D * SC}, {T.maxVal, N.maxVal, D * SC}});
+    const Shape inShape = MemoryDescUtils::makeDummyShape({{T.minVal, N.minVal, DC}, {T.maxVal, N.maxVal, DC}});
+    const Shape outShape =
+        MemoryDescUtils::makeDummyShape({{T.minVal, N.minVal, D * SC}, {T.maxVal, N.maxVal, D * SC}});
 
     // Try to create descriptor and corresponding configuration
-    inDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(inShape,  inDataTypes[xIdx], memory::format_tag::tnc));
-    outDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(outShape, outDataTypes[yIdx], memory::format_tag::tnc));
+    inDataDescs.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(inShape, inDataTypes[xIdx], memory::format_tag::tnc));
+    outDataDescs.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(outShape, outDataTypes[yIdx], memory::format_tag::tnc));
 
-    inDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, inDataTypes[hIdx], memory::format_tag::ldnc));
-    outDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, outDataTypes[hoIdx], memory::format_tag::ldnc));
+    inDataDescs.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, inDataTypes[hIdx], memory::format_tag::ldnc));
+    outDataDescs.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, outDataTypes[hoIdx], memory::format_tag::ldnc));
 
     if (haveCellState(cell_type)) {
-        inDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, inDataTypes[cIdx], memory::format_tag::ldnc));
-        outDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, outDataTypes[coIdx], memory::format_tag::ldnc));
+        inDataDescs.emplace_back(
+            std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, inDataTypes[cIdx], memory::format_tag::ldnc));
+        outDataDescs.emplace_back(
+            std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, outDataTypes[coIdx], memory::format_tag::ldnc));
     } else if (haveAttention(cell_type)) {
         const Shape attnShape = MemoryDescUtils::makeDummyShape({{T.minVal, N.minVal, 1}, {T.maxVal, N.maxVal, 1}});
-        inDataDescs.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(attnShape, inDataTypes[aIdx], memory::format_tag::tnc));
+        inDataDescs.emplace_back(
+            std::make_shared<DnnlBlockedMemoryDesc>(attnShape, inDataTypes[aIdx], memory::format_tag::tnc));
     }
 
     copyWeightsData();
 
-    const Shape shapeNDSC {{N.minVal, D, SC}, {N.maxVal, D, SC}};
-    Shape shapeNTSC {{N.minVal, T.minVal, SC}, {N.maxVal, T.maxVal, SC}};
-    const Shape shapeNTDC {{N.minVal, T.minVal, DC}, {N.maxVal, T.maxVal, DC}};
-    const Shape TShape {VectorDims{N_SEQ.minVal}, VectorDims{N_SEQ.maxVal}};
-    const Shape WShape {D, G * SC, DC};
-    const Shape RShape {D, G * SC, SC};
-    const Shape BShape {D, Gb * SC};
+    const Shape shapeNDSC{{N.minVal, D, SC}, {N.maxVal, D, SC}};
+    Shape shapeNTSC{{N.minVal, T.minVal, SC}, {N.maxVal, T.maxVal, SC}};
+    const Shape shapeNTDC{{N.minVal, T.minVal, DC}, {N.maxVal, T.maxVal, DC}};
+    const Shape TShape{VectorDims{N_SEQ.minVal}, VectorDims{N_SEQ.maxVal}};
+    const Shape WShape{D, G * SC, DC};
+    const Shape RShape{D, G * SC, SC};
+    const Shape BShape{D, Gb * SC};
 
     std::vector<MemoryDescPtr> inCandidate, outCandidate;
 
@@ -733,29 +796,40 @@ void RNN::fillSequenceDesc() {
         dstLayerMemoryFormat = memory::format_tag::ntc;
     }
 
-    inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeNTDC, inDataTypes[xIdx], srcLayerMemoryFormat));
-    outCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeNTSC, outDataTypes[yIdx], dstLayerMemoryFormat));
+    inCandidate.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(shapeNTDC, inDataTypes[xIdx], srcLayerMemoryFormat));
+    outCandidate.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(shapeNTSC, outDataTypes[yIdx], dstLayerMemoryFormat));
 
-    inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeNDSC,  inDataTypes[hIdx],    memory::format_tag::tnc));
-    outCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeNDSC, outDataTypes[hoIdx], memory::format_tag::tnc));
+    inCandidate.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(shapeNDSC, inDataTypes[hIdx], memory::format_tag::tnc));
+    outCandidate.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(shapeNDSC, outDataTypes[hoIdx], memory::format_tag::tnc));
 
     // initial cell state
     if (haveCellState(cell_type)) {
-        inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeNDSC, inDataTypes[cIdx], memory::format_tag::tnc));
-        outCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeNDSC, outDataTypes[coIdx], memory::format_tag::tnc));
+        inCandidate.emplace_back(
+            std::make_shared<DnnlBlockedMemoryDesc>(shapeNDSC, inDataTypes[cIdx], memory::format_tag::tnc));
+        outCandidate.emplace_back(
+            std::make_shared<DnnlBlockedMemoryDesc>(shapeNDSC, outDataTypes[coIdx], memory::format_tag::tnc));
     }
 
-    inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(TShape, inDataTypes[sIdx], memory::format_tag::x)); // sequence lengths
+    inCandidate.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(TShape, inDataTypes[sIdx], memory::format_tag::x));  // sequence lengths
     // The weight and weights_iter would expose tnc layout to avoid unnecessary reorder.
     // The onednn would determine the final layout when prepareParams.
-    inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(WShape, inDataTypes[wIdx], memory::format_tag::tnc)); // W
-    inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(RShape, inDataTypes[rIdx], memory::format_tag::tnc)); // R
+    inCandidate.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(WShape, inDataTypes[wIdx], memory::format_tag::tnc));  // W
+    inCandidate.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(RShape, inDataTypes[rIdx], memory::format_tag::tnc));  // R
 
-    inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(BShape, inDataTypes[bIdx], memory::format_tag::nc)); // B
+    inCandidate.emplace_back(
+        std::make_shared<DnnlBlockedMemoryDesc>(BShape, inDataTypes[bIdx], memory::format_tag::nc));  // B
 
     if (haveAttention(cell_type)) {
         Shape shapeAttn{{N.minVal, T.minVal, 1}, {N.maxVal, T.maxVal, 1}};
-        inCandidate.emplace_back(std::make_shared<DnnlBlockedMemoryDesc>(shapeAttn, inDataTypes[aIdx], memory::format_tag::ntc));
+        inCandidate.emplace_back(
+            std::make_shared<DnnlBlockedMemoryDesc>(shapeAttn, inDataTypes[aIdx], memory::format_tag::ntc));
     }
 
     createDescriptor(inCandidate, outCandidate);
@@ -767,18 +841,19 @@ void RNN::fillWeights() {
     if (getParentEdgeAt(wIdx)->getParent()->getType() != Type::Input) {
         THROW_CPU_NODE_ERR("expects Constant for port ", wIdx);
     }
-    auto w_const_blob = static_cast<Input *>(getParentEdgeAt(wIdx)->getParent().get())->getMemoryPtr();
+    auto w_const_blob = static_cast<Input*>(getParentEdgeAt(wIdx)->getParent().get())->getMemoryPtr();
     if (getParentEdgeAt(rIdx)->getParent()->getType() != Type::Input) {
         THROW_CPU_NODE_ERR("expects Constant for port ", rIdx);
     }
-    auto r_const_blob = static_cast<Input *>(getParentEdgeAt(rIdx)->getParent().get())->getMemoryPtr();
+    auto r_const_blob = static_cast<Input*>(getParentEdgeAt(rIdx)->getParent().get())->getMemoryPtr();
 
     const auto& weightPrec = DnnlExtensionUtils::DataTypeToElementType(inDataTypes[wIdx]);
     const auto& targetWeightDataType = weightsByinputDataType.at(inDataTypes[xIdx]);
     const auto& targetWeightPrec = DnnlExtensionUtils::DataTypeToElementType(targetWeightDataType);
 
     const VectorDims dims_w = {L, D, DC, G, SC};
-    auto w_data_desc = std::make_shared<DnnlBlockedMemoryDesc>(Shape(dims_w), targetWeightDataType, getWeightsFormatTagByDims(dims_w));
+    auto w_data_desc =
+        std::make_shared<DnnlBlockedMemoryDesc>(Shape(dims_w), targetWeightDataType, getWeightsFormatTagByDims(dims_w));
 
     auto create_w = [&]() {
         MemoryPtr w_data_mem = std::make_shared<Memory>(getEngine(), w_data_desc);
@@ -815,7 +890,8 @@ void RNN::fillWeights() {
     };
 
     const VectorDims dims_s = {L, D, SC, G, SC};
-    auto w_state_desc = std::make_shared<DnnlBlockedMemoryDesc>(Shape(dims_s), targetWeightDataType, getWeightsFormatTagByDims(dims_s));
+    auto w_state_desc =
+        std::make_shared<DnnlBlockedMemoryDesc>(Shape(dims_s), targetWeightDataType, getWeightsFormatTagByDims(dims_s));
 
     auto create_r = [&]() {
         MemoryPtr w_state_mem = std::make_shared<Memory>(getEngine(), w_state_desc);
@@ -852,10 +928,14 @@ void RNN::fillWeights() {
     };
 
     if (auto weight_cache = context->getWeightsCache()) {
-        const std::string hash_w = getName() + "_0_" + std::to_string(dnnl::impl::primitive_hashing::get_md_hash(*w_data_desc->getDnnlDesc().get()));
+        const std::string hash_w =
+            getName() + "_0_" +
+            std::to_string(dnnl::impl::primitive_hashing::get_md_hash(*w_data_desc->getDnnlDesc().get()));
         m_initial_weights[0] = *weight_cache->findOrCreate(hash_w, create_w);
 
-        const std::string hash_r = getName() + "_1_" + std::to_string(dnnl::impl::primitive_hashing::get_md_hash(*w_state_desc->getDnnlDesc().get()));
+        const std::string hash_r =
+            getName() + "_1_" +
+            std::to_string(dnnl::impl::primitive_hashing::get_md_hash(*w_state_desc->getDnnlDesc().get()));
         m_initial_weights[1] = *weight_cache->findOrCreate(hash_r, create_r);
     } else {
         m_initial_weights[0] = create_w();
@@ -870,16 +950,18 @@ void RNN::fillBiases() {
     if (getParentEdgeAt(bIdx)->getParent()->getType() != Type::Input) {
         THROW_CPU_NODE_ERR("expects Constant for port ", bIdx);
     }
-    auto b_const_blob = static_cast<Input *>(getParentEdgeAt(bIdx)->getParent().get())->getMemoryPtr();
+    auto b_const_blob = static_cast<Input*>(getParentEdgeAt(bIdx)->getParent().get())->getMemoryPtr();
 
     if (inDataTypes[bIdx] != memory::data_type::f32) {
-        THROW_CPU_NODE_ERR("doesn't support bias data type: ", DnnlExtensionUtils::DataTypeToElementType(inDataTypes[bIdx]));
+        THROW_CPU_NODE_ERR("doesn't support bias data type: ",
+                           DnnlExtensionUtils::DataTypeToElementType(inDataTypes[bIdx]));
     }
 
-    VectorDims dims_b = { L, D, Gb, SC };
+    VectorDims dims_b = {L, D, Gb, SC};
 
     auto dnnl_type = DnnlExtensionUtils::ElementTypeToDataType(ET);
-    auto w_bias_data_desc = std::make_shared<DnnlBlockedMemoryDesc>(Shape(dims_b), dnnl_type, getWeightsFormatTagByDims(dims_b));
+    auto w_bias_data_desc =
+        std::make_shared<DnnlBlockedMemoryDesc>(Shape(dims_b), dnnl_type, getWeightsFormatTagByDims(dims_b));
 
     auto create = [&]() {
         MemoryPtr w_bias_data_mem = std::make_shared<Memory>(getEngine(), w_bias_data_desc);
@@ -896,7 +978,11 @@ void RNN::fillBiases() {
             ie_b_vec.resize(ie_b_vec_size);
             ie_b_ptr = ie_b_vec.data();
 
-            cpu_convert(b_const_blob->getData(), ie_b_ptr, DnnlExtensionUtils::DataTypeToElementType(b_const_blob->getDataType()), ET, ie_b_vec_size);
+            cpu_convert(b_const_blob->getData(),
+                        ie_b_ptr,
+                        DnnlExtensionUtils::DataTypeToElementType(b_const_blob->getDataType()),
+                        ET,
+                        ie_b_vec_size);
         } else {
             ie_b_ptr = reinterpret_cast<DataType*>(b_const_blob->getData());
         }
@@ -912,7 +998,9 @@ void RNN::fillBiases() {
     };
 
     if (auto weight_cache = context->getWeightsCache()) {
-        const std::string hash_str = getName() + "_2_" + std::to_string(dnnl::impl::primitive_hashing::get_md_hash(*w_bias_data_desc->getDnnlDesc().get()));
+        const std::string hash_str =
+            getName() + "_2_" +
+            std::to_string(dnnl::impl::primitive_hashing::get_md_hash(*w_bias_data_desc->getDnnlDesc().get()));
         m_initial_weights[2] = *weight_cache->findOrCreate(hash_str, create);
     } else {
         m_initial_weights[2] = create();
@@ -933,8 +1021,9 @@ void RNN::prepareMemory(const DnnlMemoryDescPtr& new_desc, size_t idx) {
 
     MemoryPtr res_ptr;
     if (auto weight_cache = context->getWeightsCache()) {
-        const std::string hash_str = getName() + "_" + std::to_string(idx) + "_"
-            + std::to_string(dnnl::impl::primitive_hashing::get_md_hash(*new_desc->getDnnlDesc().get()));
+        const std::string hash_str =
+            getName() + "_" + std::to_string(idx) + "_" +
+            std::to_string(dnnl::impl::primitive_hashing::get_md_hash(*new_desc->getDnnlDesc().get()));
         res_ptr = *weight_cache->findOrCreate(hash_str, create);
         m_weights_pull.insert(res_ptr);
     } else {
@@ -965,8 +1054,8 @@ void RNN::copyWeightsData() {
      *   OV - URO, onednn - URO
      */
     static const uint64_t gate_map_lstm[] = {1, 0, 2, 3};  // FICO -> IFCO
-    static const uint64_t gate_map_gru[]  = {0, 1, 2, 3};
-    static const uint64_t gate_map_rnn[]  = {0};
+    static const uint64_t gate_map_gru[] = {0, 1, 2, 3};
+    static const uint64_t gate_map_rnn[] = {0};
     const uint64_t gate_map_lstm_size = sizeof(gate_map_lstm) / sizeof(uint64_t);
     const uint64_t gate_map_gru_size = sizeof(gate_map_gru) / sizeof(uint64_t);
     const uint64_t gate_map_rnn_size = sizeof(gate_map_rnn) / sizeof(uint64_t);
@@ -998,19 +1087,19 @@ void RNN::copyWeightsData() {
     }
 
     switch (inDataTypes[xIdx]) {
-        case  memory::data_type::bf16:
-        case  memory::data_type::f16:
-            fillWeights<element::u16>();
-            break;
-        case  memory::data_type::f32:
-            fillWeights<element::f32>();
-            break;
-        case  memory::data_type::u8:
-        case  memory::data_type::s8:
-            fillWeights<element::i8>();
-            break;
-        default:
-            THROW_CPU_NODE_ERR("has unsupported data type: ", DnnlExtensionUtils::DataTypeToElementType(inDataTypes[xIdx]));
+    case memory::data_type::bf16:
+    case memory::data_type::f16:
+        fillWeights<element::u16>();
+        break;
+    case memory::data_type::f32:
+        fillWeights<element::f32>();
+        break;
+    case memory::data_type::u8:
+    case memory::data_type::s8:
+        fillWeights<element::i8>();
+        break;
+    default:
+        THROW_CPU_NODE_ERR("has unsupported data type: ", DnnlExtensionUtils::DataTypeToElementType(inDataTypes[xIdx]));
     }
 
     fillBiases<element::f32>();
@@ -1019,9 +1108,9 @@ void RNN::copyWeightsData() {
 }
 
 namespace {
-dnnl::primitive_desc createPrimitiveDescriptor(const dnnl::engine        engine,
-                                               const dnnl::algorithm     cellType,
-                                               const dnnl::algorithm     cellAct,
+dnnl::primitive_desc createPrimitiveDescriptor(const dnnl::engine engine,
+                                               const dnnl::algorithm cellType,
+                                               const dnnl::algorithm cellAct,
                                                const dnnl::rnn_direction direction,
                                                const std::vector<DnnlBlockedMemoryDescPtr>& inDataDescs,
                                                const std::vector<DnnlBlockedMemoryDescPtr>& outDataDescs,
@@ -1045,18 +1134,17 @@ dnnl::primitive_desc createPrimitiveDescriptor(const dnnl::engine        engine,
             outDataDescs[RNN::InOutKind::HiddenState]->getDnnlDesc(),  // Out State
             attr);
     case dnnl::algorithm::vanilla_gru:
-        return dnnl::gru_forward::primitive_desc(
-            engine,
-            propKind,
-            direction,
-            inDataDescs[RNN::InOutKind::Layer]->getDnnlDesc(),         // In Data
-            inDataDescs[RNN::InOutKind::HiddenState]->getDnnlDesc(),   // In State
-            wDescs[0],                                                 // Weights data
-            wDescs[1],                                                 // Weights state
-            wDescs[2],                                                 // Bias
-            outDataDescs[RNN::InOutKind::Layer]->getDnnlDesc(),        // Out Data
-            outDataDescs[RNN::InOutKind::HiddenState]->getDnnlDesc(),  // Out State
-            attr);
+        return dnnl::gru_forward::primitive_desc(engine,
+                                                 propKind,
+                                                 direction,
+                                                 inDataDescs[RNN::InOutKind::Layer]->getDnnlDesc(),        // In Data
+                                                 inDataDescs[RNN::InOutKind::HiddenState]->getDnnlDesc(),  // In State
+                                                 wDescs[0],                                           // Weights data
+                                                 wDescs[1],                                           // Weights state
+                                                 wDescs[2],                                           // Bias
+                                                 outDataDescs[RNN::InOutKind::Layer]->getDnnlDesc(),  // Out Data
+                                                 outDataDescs[RNN::InOutKind::HiddenState]->getDnnlDesc(),  // Out State
+                                                 attr);
     case dnnl::algorithm::lbr_gru:
         return dnnl::lbr_gru_forward::primitive_desc(
             engine,
@@ -1117,41 +1205,39 @@ dnnl::primitive_desc createPrimitiveDescriptor(const dnnl::engine        engine,
         OPENVINO_THROW("RNN. Unknown cell type");
     }
 }
-} // namespace
+}  // namespace
 
 void RNN::fillDescs() {
     descs.clear();
 
     const auto attr = initPrimitiveAttr();
 
-    auto desc = createPrimitiveDescriptor(
-        getEngine(),
-        cell_type,
-        cell_act,
-        direction,
-        inDataDescs,
-        outDataDescs,
-        wDescs,
-        *attr);
+    auto desc = createPrimitiveDescriptor(getEngine(),
+                                          cell_type,
+                                          cell_act,
+                                          direction,
+                                          inDataDescs,
+                                          outDataDescs,
+                                          wDescs,
+                                          *attr);
 
     descs.emplace_back(desc);
 }
 
-void RNN::createDescriptor(const std::vector<MemoryDescPtr> &inputDesc,
-                           const std::vector<MemoryDescPtr> &outputDesc) {
+void RNN::createDescriptor(const std::vector<MemoryDescPtr>& inputDesc, const std::vector<MemoryDescPtr>& outputDesc) {
     if (descs.empty()) {
         wDescs.resize(3);
 
         /* for descriptor configuration use the same type which is used for internalBlobs
            since internalBlobs are used for the execution, not the initial weights */
         const auto& targetWeightDataType = weightsByinputDataType.at(inDataTypes[xIdx]);
-        auto weightsDims = DnnlExtensionUtils::convertToDnnlDims(VectorDims{ L, D, DC, G, SC });
-        //onednn determines the preferred weight layout.
+        auto weightsDims = DnnlExtensionUtils::convertToDnnlDims(VectorDims{L, D, DC, G, SC});
+        // onednn determines the preferred weight layout.
         wDescs[0] = dnnl::memory::desc(weightsDims, targetWeightDataType, memory::format_tag::any);
-        auto statesDims = DnnlExtensionUtils::convertToDnnlDims(VectorDims{ L, D, SC, G, SC });
-        //onednn determines the preferred weights_iter layout.
+        auto statesDims = DnnlExtensionUtils::convertToDnnlDims(VectorDims{L, D, SC, G, SC});
+        // onednn determines the preferred weights_iter layout.
         wDescs[1] = dnnl::memory::desc(statesDims, targetWeightDataType, memory::format_tag::any);
-        auto biasDims = DnnlExtensionUtils::convertToDnnlDims(VectorDims{ L, D, Gb, SC });
+        auto biasDims = DnnlExtensionUtils::convertToDnnlDims(VectorDims{L, D, Gb, SC});
         wDescs[2] = dnnl::memory::desc(biasDims, inDataTypes[bIdx], memory::format_tag::ldgo);
 
         fillDescs();
@@ -1159,7 +1245,7 @@ void RNN::createDescriptor(const std::vector<MemoryDescPtr> &inputDesc,
 
     // Fill supported config
     NodeConfig config;
-    for (const auto &desc : inputDesc) {
+    for (const auto& desc : inputDesc) {
         PortConfig dataConfig;
         dataConfig.inPlace(-1);
         dataConfig.constant(false);
@@ -1167,7 +1253,7 @@ void RNN::createDescriptor(const std::vector<MemoryDescPtr> &inputDesc,
         config.inConfs.push_back(dataConfig);
     }
 
-    for (const auto &desc : outputDesc) {
+    for (const auto& desc : outputDesc) {
         PortConfig dataConfig;
         dataConfig.inPlace(-1);
         dataConfig.constant(false);
@@ -1183,12 +1269,18 @@ Node::AttrPtr RNN::initPrimitiveAttr() {
     attr->set_scratchpad_mode(dnnl::scratchpad_mode::user);
 
     if (one_of(inDataTypes[xIdx], memory::data_type::u8, memory::data_type::s8)) {
-        const int weightsScaleMask = 0
-            + (1 << 3) // bit, indicating the unique scales for `g` dim in `ldigo`
-            + (1 << 4); // bit, indicating the unique scales for `o` dim in `ldigo`
-
-        DEBUG_LOG(getName(), ": inputScale: ", inputScale, ", inputShift: ", inputShift,
-                  ", weightsScaleMask: ", weightsScaleMask, ", weightsScales[0]: ", weightsScales[0]);
+        const int weightsScaleMask = 0 + (1 << 3)  // bit, indicating the unique scales for `g` dim in `ldigo`
+                                     + (1 << 4);   // bit, indicating the unique scales for `o` dim in `ldigo`
+
+        DEBUG_LOG(getName(),
+                  ": inputScale: ",
+                  inputScale,
+                  ", inputShift: ",
+                  inputShift,
+                  ", weightsScaleMask: ",
+                  weightsScaleMask,
+                  ", weightsScales[0]: ",
+                  weightsScales[0]);
 
         attr->set_rnn_weights_qparams(weightsScaleMask, weightsScales);
         attr->set_rnn_data_qparams(inputScale, inputShift);
@@ -1205,28 +1297,33 @@ void RNN::prepareParams() {
     }
     if ((is_cell && DC != getParentEdgeAt(0)->getMemory().getDesc().getShape().getStaticDims()[1]) ||
         (!is_cell && DC != getParentEdgeAt(0)->getMemory().getDesc().getShape().getStaticDims()[2]))
-            THROW_CPU_NODE_ERR("has incorrect input size value in the first input.");
+        THROW_CPU_NODE_ERR("has incorrect input size value in the first input.");
 
     auto dataMemPtr = getSrcMemoryAtPort(0);
     const size_t B = dataMemPtr->getShape().getStaticDims()[0];
     const size_t SL = is_cell ? 1lu : dataMemPtr->getShape().getStaticDims()[1];
     const Shape shapeS_4D{L, D, B, SC};
 
-    inDataDescs[0] = std::make_shared<DnnlBlockedMemoryDesc>(Shape{SL, B, DC}, inDataTypes[xIdx], memory::format_tag::tnc);
-    outDataDescs[0] = std::make_shared<DnnlBlockedMemoryDesc>(Shape{SL, B, D * SC}, outDataTypes[yIdx], memory::format_tag::tnc);
+    inDataDescs[0] =
+        std::make_shared<DnnlBlockedMemoryDesc>(Shape{SL, B, DC}, inDataTypes[xIdx], memory::format_tag::tnc);
+    outDataDescs[0] =
+        std::make_shared<DnnlBlockedMemoryDesc>(Shape{SL, B, D * SC}, outDataTypes[yIdx], memory::format_tag::tnc);
 
     inDataDescs[1] = std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, inDataTypes[hIdx], memory::format_tag::ldnc);
     outDataDescs[1] = std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, outDataTypes[hoIdx], memory::format_tag::ldnc);
 
     if (haveCellState(cell_type)) {
-        inDataDescs[2] = std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, inDataTypes[cIdx], memory::format_tag::ldnc);
-        outDataDescs[2] = std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, outDataTypes[coIdx], memory::format_tag::ldnc);
+        inDataDescs[2] =
+            std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, inDataTypes[cIdx], memory::format_tag::ldnc);
+        outDataDescs[2] =
+            std::make_shared<DnnlBlockedMemoryDesc>(shapeS_4D, outDataTypes[coIdx], memory::format_tag::ldnc);
     } else if (haveAttention(cell_type)) {
-        inDataDescs[2] = std::make_shared<DnnlBlockedMemoryDesc>(Shape{SL, B, 1}, inDataTypes[aIdx], memory::format_tag::tnc);
+        inDataDescs[2] =
+            std::make_shared<DnnlBlockedMemoryDesc>(Shape{SL, B, 1}, inDataTypes[aIdx], memory::format_tag::tnc);
     }
 
     const auto attr = initPrimitiveAttr();
-    RNNKey key = { inDataDescs, outDataDescs, wDescs, cell_type, cell_act, direction, *attr };
+    RNNKey key = {inDataDescs, outDataDescs, wDescs, cell_type, cell_act, direction, *attr};
 
     auto engine = getEngine();
     auto builder = [&engine](const RNNKey& key) -> executorPtr {
@@ -1279,12 +1376,12 @@ void RNN::prepareParams() {
 }
 
 std::shared_ptr<MemoryDesc> RNN::getSrcMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const {
-    (void) prim_desc;
+    (void)prim_desc;
     return supportedPrimitiveDescriptors[0].getConfig().inConfs[idx].getMemDesc();
 }
 
 std::shared_ptr<MemoryDesc> RNN::getDstMemDesc(const dnnl::primitive_desc& prim_desc, size_t idx) const {
-    (void) prim_desc;
+    (void)prim_desc;
     return supportedPrimitiveDescriptors[0].getConfig().outConfs[idx].getMemDesc();
 }
 
@@ -1300,10 +1397,10 @@ void RNN::execute(dnnl::stream strm) {
     args[DNNL_ARG_SRC_LAYER] = src_data_mem->getPrimitive();
     args[DNNL_ARG_DST_LAYER] = dst_data_mem->getPrimitive();
 
-    int state_i_tags[] {DNNL_ARG_SRC_ITER, DNNL_ARG_SRC_ITER_C};
-    int state_o_tags[] {DNNL_ARG_DST_ITER, DNNL_ARG_DST_ITER_C};
+    int state_i_tags[]{DNNL_ARG_SRC_ITER, DNNL_ARG_SRC_ITER_C};
+    int state_o_tags[]{DNNL_ARG_DST_ITER, DNNL_ARG_DST_ITER_C};
     for (size_t s = 0; s < S; s++) {
-        args[state_i_tags[s]] = getSrcMemoryAtPort(s+1)->getPrimitive();
+        args[state_i_tags[s]] = getSrcMemoryAtPort(s + 1)->getPrimitive();
     }
     if (is_augru) {
         const auto atten_port = is_cell ? 5 : 6;
@@ -1315,10 +1412,10 @@ void RNN::execute(dnnl::stream strm) {
             args[state_o_tags[s]] = getDstMemoryAtPort(s)->getPrimitive();
         }
     } else {
-        size_t n_ports_with_init_states = outputShapes.size() - 1; // first is a sequence data
+        size_t n_ports_with_init_states = outputShapes.size() - 1;  // first is a sequence data
         for (size_t s = 0; s < std::min(S, n_ports_with_init_states); s++) {
             if (s < outputShapes.size()) {
-                args[state_o_tags[s]] = getDstMemoryAtPort(s+1)->getPrimitive();
+                args[state_o_tags[s]] = getDstMemoryAtPort(s + 1)->getPrimitive();
             }
         }
     }
@@ -1351,6 +1448,6 @@ RNN::RnnDnnlExecutor::RnnDnnlExecutor(const dnnl::primitive_desc& pd) : DnnlExec
     bias_md = DnnlExtensionUtils::makeDescriptor(pd.weights_desc(2));
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/rnn.h b/src/plugins/intel_cpu/src/nodes/rnn.h
index 937a67f5f1fd5a..840ac0b5bfe5fc 100644
--- a/src/plugins/intel_cpu/src/nodes/rnn.h
+++ b/src/plugins/intel_cpu/src/nodes/rnn.h
@@ -4,10 +4,9 @@
 
 #pragma once
 
-#include "node.h"
 #include "common/dnnl_executor.h"
 #include "memory_desc/dnnl_blocked_memory_desc.h"
-
+#include "node.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -36,12 +35,7 @@ class RNN : public Node {
 
     void cleanup() override;
 
-    enum InOutKind {
-        Layer       = 0,
-        HiddenState = 1,
-        CellState   = 2,
-        Attention   = 2
-    };
+    enum InOutKind { Layer = 0, HiddenState = 1, CellState = 2, Attention = 2 };
 
 protected:
     void prepareParams() override;
@@ -54,8 +48,7 @@ class RNN : public Node {
     void fillCellDesc();
     void fillSequenceDesc();
     void fillDescs();
-    bool verifyWeightsPrecision(const ov::element::Type& layerPrec,
-                                const ov::element::Type& weightsPrec);
+    bool verifyWeightsPrecision(const ov::element::Type& layerPrec, const ov::element::Type& weightsPrec);
 
     template <ov::element::Type_t ET>
     void fillWeights();
@@ -66,20 +59,20 @@ class RNN : public Node {
 
     void prepareMemory(const DnnlMemoryDescPtr& intDesc, size_t indx) override;
     class RnnDnnlExecutor : public DnnlExecutor {
-        public:
-            RnnDnnlExecutor(const dnnl::primitive_desc& pd);
+    public:
+        RnnDnnlExecutor(const dnnl::primitive_desc& pd);
 
-            DnnlMemoryDescPtr getWeightIterDesc() const {
-                return wghts_iter_md;
-            }
+        DnnlMemoryDescPtr getWeightIterDesc() const {
+            return wghts_iter_md;
+        }
 
-            DnnlMemoryDescPtr getBiasDesc() const {
-                return bias_md;
-            }
+        DnnlMemoryDescPtr getBiasDesc() const {
+            return bias_md;
+        }
 
-        private:
-            DnnlMemoryDescPtr wghts_iter_md;
-            DnnlMemoryDescPtr bias_md;
+    private:
+        DnnlMemoryDescPtr wghts_iter_md;
+        DnnlMemoryDescPtr bias_md;
     };
 
     using executorPtr = std::shared_ptr<RnnDnnlExecutor>;
@@ -118,16 +111,16 @@ class RNN : public Node {
         Dim maxVal = 0;
     };
     // Internal attributes
-    Interval N;     /**< Batch value */
-    Interval N_SEQ; /**< Batch value of the 'sequence_length' input */
-    Interval T;     /**< Sequence value */
-    size_t DC = 0;  /**< Input data channel size */
-    size_t SC = 0;  /**< State channel size value */
-    size_t G = 0;   /**< Gate size. LSTM - 4, GRU - 3, RNN - 1 */
-    size_t Gb = 0;  /**< Gate size for biases. Gb = GRU_lbr ? G+1 : G */
-    size_t S = 2;   /**< Num of state. LSTM - 2, GRU & RNN - 1 */
-    const size_t L = 1;   /**< What is it??. Constant for onednn impl */
-    const size_t D = 1;   /**< Num of direction. 1 or 2 */
+    Interval N;         /**< Batch value */
+    Interval N_SEQ;     /**< Batch value of the 'sequence_length' input */
+    Interval T;         /**< Sequence value */
+    size_t DC = 0;      /**< Input data channel size */
+    size_t SC = 0;      /**< State channel size value */
+    size_t G = 0;       /**< Gate size. LSTM - 4, GRU - 3, RNN - 1 */
+    size_t Gb = 0;      /**< Gate size for biases. Gb = GRU_lbr ? G+1 : G */
+    size_t S = 2;       /**< Num of state. LSTM - 2, GRU & RNN - 1 */
+    const size_t L = 1; /**< What is it??. Constant for onednn impl */
+    const size_t D = 1; /**< Num of direction. 1 or 2 */
 
     std::vector<DnnlBlockedMemoryDescPtr> inDataDescs;
     std::vector<DnnlBlockedMemoryDescPtr> outDataDescs;
@@ -136,36 +129,36 @@ class RNN : public Node {
     std::vector<dnnl::memory::data_type> inDataTypes;
     std::vector<dnnl::memory::data_type> outDataTypes;
 
-    const size_t xIdx = 0; // ov -> input X;              dnnl -> src_layer
-    const size_t hIdx = 1; // ov -> initial_hidden_state; dnnl -> src_iter_h
-    const size_t cIdx = 2; // ov -> initial_cell_state;   dnnl -> src_iter_c
-    size_t sIdx = 0;       // ov -> sequence_length;      dnnl -> additional input dimension 't'
-                           //                             oneDNN does not support unique t (seq_len) per batch
-    size_t wIdx = 0;       // ov -> W;                    dnnl -> weights_layer
-    size_t rIdx = 0;       // ov -> R;                    dnnl -> weights_iter
-    size_t bIdx = 0;       // ov -> B;                    dnnl -> bias
-    size_t aIdx = 0;       // ov -> A:                    dnnl -> attention
+    const size_t xIdx = 0;  // ov -> input X;              dnnl -> src_layer
+    const size_t hIdx = 1;  // ov -> initial_hidden_state; dnnl -> src_iter_h
+    const size_t cIdx = 2;  // ov -> initial_cell_state;   dnnl -> src_iter_c
+    size_t sIdx = 0;        // ov -> sequence_length;      dnnl -> additional input dimension 't'
+                            //                             oneDNN does not support unique t (seq_len) per batch
+    size_t wIdx = 0;        // ov -> W;                    dnnl -> weights_layer
+    size_t rIdx = 0;        // ov -> R;                    dnnl -> weights_iter
+    size_t bIdx = 0;        // ov -> B;                    dnnl -> bias
+    size_t aIdx = 0;        // ov -> A:                    dnnl -> attention
 
-    size_t yIdx = 0;       // ov -> Y;                    dnnl -> dst_layer
-    size_t hoIdx = 0;      // ov -> Ho;                   dnnl -> dst_iter_h
-    size_t coIdx = 0;      // ov -> Co;                   dnnl -> dst_iter_c
+    size_t yIdx = 0;   // ov -> Y;                    dnnl -> dst_layer
+    size_t hoIdx = 0;  // ov -> Ho;                   dnnl -> dst_iter_h
+    size_t coIdx = 0;  // ov -> Co;                   dnnl -> dst_iter_c
 
     static const std::map<dnnl::memory::data_type, dnnl::memory::data_type> weightsByinputDataType;
 
     static constexpr size_t optimalBatchSize = 16lu;
     static constexpr size_t batchDimDummyValue = 64lu;
 
-    float inputScale    = 0.f;
-    float inputShift    = 0.f;
+    float inputScale = 0.f;
+    float inputShift = 0.f;
     std::vector<float> weightsScales;
 
     const uint64_t* m_gate_map;
     // Need to reorder from the initial memory descs due to limited Reorders set.
-    MemoryPtr m_initial_weights[3] = { nullptr, nullptr, nullptr };
+    MemoryPtr m_initial_weights[3] = {nullptr, nullptr, nullptr};
     // Need to keep cache objects. Otherwise, they will be erased from the global cache.
     std::unordered_set<MemoryPtr> m_weights_pull;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/roi_align.cpp b/src/plugins/intel_cpu/src/nodes/roi_align.cpp
index 2190ebd9445df8..02d894439e5527 100644
--- a/src/plugins/intel_cpu/src/nodes/roi_align.cpp
+++ b/src/plugins/intel_cpu/src/nodes/roi_align.cpp
@@ -3,19 +3,21 @@
 //
 
 #include "roi_align.h"
-#include <string>
-#include <vector>
+
 #include <math.h>
-#include "onednn/dnnl.h"
-#include "dnnl_extension_utils.h"
-#include <utils/bfloat16.hpp>
-#include "cpu/x64/cpu_isa_traits.hpp"
-#include "openvino/core/parallel.hpp"
-#include "selective_build.h"
+
 #include <openvino/opsets/opset9.hpp>
+#include <string>
+#include <utils/bfloat16.hpp>
+#include <vector>
 
+#include "cpu/x64/cpu_isa_traits.hpp"
 #include "cpu/x64/jit_generator.hpp"
+#include "dnnl_extension_utils.h"
 #include "emitters/plugin/x64/jit_load_store_emitters.hpp"
+#include "onednn/dnnl.h"
+#include "openvino/core/parallel.hpp"
+#include "selective_build.h"
 
 using namespace dnnl;
 using namespace dnnl::impl;
@@ -31,13 +33,15 @@ namespace node {
 using ngPoolingMode = ov::opset9::ROIAlign::PoolingMode;
 using ngAlignedMode = ov::opset9::ROIAlign::AlignedMode;
 #if defined(OPENVINO_ARCH_X86_64)
-#define GET_OFF(field) offsetof(jit_roi_align_call_args, field)
+#    define GET_OFF(field) offsetof(jit_roi_align_call_args, field)
 
 template <cpu_isa_t isa>
 struct jit_uni_roi_align_kernel_f32 : public jit_uni_roi_align_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_roi_align_kernel_f32);
 
-    explicit jit_uni_roi_align_kernel_f32(jit_roi_align_params jcp) : jit_uni_roi_align_kernel(jcp), jit_generator(jit_name()) {}
+    explicit jit_uni_roi_align_kernel_f32(jit_roi_align_params jcp)
+        : jit_uni_roi_align_kernel(jcp),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -49,7 +53,8 @@ struct jit_uni_roi_align_kernel_f32 : public jit_uni_roi_align_kernel, public ji
 
         uni_vpxor(vmm_zero, vmm_zero, vmm_zero);
 
-        load_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx()), static_cast<size_t>(reg_load_table.getIdx())};
+        load_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx()),
+                              static_cast<size_t>(reg_load_table.getIdx())};
         store_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx())};
         store_pool_vec_idxs = {static_cast<size_t>(vmm_zero.getIdx())};
 
@@ -65,8 +70,8 @@ struct jit_uni_roi_align_kernel_f32 : public jit_uni_roi_align_kernel, public ji
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
 
     const int v_len = cpu_isa_traits<isa>::vlen;
     const int x_len = cpu_isa_traits<sse41>::vlen;
@@ -79,19 +84,19 @@ struct jit_uni_roi_align_kernel_f32 : public jit_uni_roi_align_kernel, public ji
 
     reg64_t reg_src_address = r8;
     // reg_srcx is used after abi parse finised
-    reg64_t reg_src0        = r11;
-    reg64_t reg_src1        = r12;
-    reg64_t reg_src2        = rcx;
-    reg64_t reg_src3        = rdi;
-    reg64_t reg_weights     = r13;
+    reg64_t reg_src0 = r11;
+    reg64_t reg_src1 = r12;
+    reg64_t reg_src2 = rcx;
+    reg64_t reg_src3 = rdi;
+    reg64_t reg_weights = r13;
 
-    reg64_t reg_buf  = r9;
-    reg64_t reg_src_stride  = r15;
+    reg64_t reg_buf = r9;
+    reg64_t reg_src_stride = r15;
 
     reg64_t reg_work_amount = r14;
     reg64_t reg_num_samples = r10;
 
-    reg64_t reg_load_table  = rax;
+    reg64_t reg_load_table = rax;
     reg64_t reg_load_store_mask = rbx;
 
     reg64_t reg_tmp_64 = rbp;
@@ -177,29 +182,44 @@ struct jit_uni_roi_align_kernel_f32 : public jit_uni_roi_align_kernel, public ji
         emit_store(vmm_dst, reg_dst, ov::element::f32, ov::element::f32, elt_num, offset);
     }
 
-    inline void emit_load(Xbyak::Reg64 reg_src, Vmm vmm_src, ov::element::Type src_prc, ov::element::Type dst_prc, const int elt_num, const int offset = 0) {
+    inline void emit_load(Xbyak::Reg64 reg_src,
+                          Vmm vmm_src,
+                          ov::element::Type src_prc,
+                          ov::element::Type dst_prc,
+                          const int elt_num,
+                          const int offset = 0) {
         const auto seed = load_emitter_params(src_prc, dst_prc, elt_num).hash();
         if (!emitters[seed]) {
             emitters[seed].reset(new jit_load_emitter(this, isa, src_prc, dst_prc, elt_num));
         }
 
         emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), static_cast<size_t>(offset)},
-                                  {static_cast<size_t>(vmm_src.getIdx())}, {}, {load_pool_gpr_idxs});
+                                  {static_cast<size_t>(vmm_src.getIdx())},
+                                  {},
+                                  {load_pool_gpr_idxs});
     }
 
-    inline void emit_store(Vmm vmm_dst, Xbyak::Reg64 reg_dst, ov::element::Type src_prc, ov::element::Type dst_prc, const int elt_num, const int offset = 0) {
+    inline void emit_store(Vmm vmm_dst,
+                           Xbyak::Reg64 reg_dst,
+                           ov::element::Type src_prc,
+                           ov::element::Type dst_prc,
+                           const int elt_num,
+                           const int offset = 0) {
         const auto seed = store_emitter_params(src_prc, dst_prc, elt_num).hash();
         if (!emitters[seed]) {
             emitters[seed].reset(new jit_store_emitter(this, isa, src_prc, dst_prc, elt_num));
         }
 
         // for cases when Store emitter need 2 aux vmm we can use vmm_dst as second aux vmm
-        std::vector<size_t> local_store_pool_vec_idxs = { static_cast<size_t>(vmm_dst.getIdx()) };
-        local_store_pool_vec_idxs.insert(local_store_pool_vec_idxs.begin(), store_pool_vec_idxs.begin(), store_pool_vec_idxs.end());
+        std::vector<size_t> local_store_pool_vec_idxs = {static_cast<size_t>(vmm_dst.getIdx())};
+        local_store_pool_vec_idxs.insert(local_store_pool_vec_idxs.begin(),
+                                         store_pool_vec_idxs.begin(),
+                                         store_pool_vec_idxs.end());
 
         emitters[seed]->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
                                   {static_cast<size_t>(reg_dst.getIdx()), static_cast<size_t>(offset)},
-                                  {local_store_pool_vec_idxs}, {store_pool_gpr_idxs});
+                                  {local_store_pool_vec_idxs},
+                                  {store_pool_gpr_idxs});
     }
 
     void roi_align_cgather() {
@@ -555,7 +575,7 @@ struct jit_uni_roi_align_kernel_f32 : public jit_uni_roi_align_kernel, public ji
     }
 
     // gather f32 data from reg_src with vmm_idx(data_size) to vmm_src with f32 precision
-    inline void gather_f32(Vmm &vmm_src, const reg64_t &reg_src, const Vmm &vmm_idx) {
+    inline void gather_f32(Vmm& vmm_src, const reg64_t& reg_src, const Vmm& vmm_idx) {
         constexpr bool is_ymm = std::is_same<Vmm, Xbyak::Ymm>::value;
         constexpr bool is_zmm = std::is_same<Vmm, Xbyak::Zmm>::value;
 
@@ -574,7 +594,7 @@ struct jit_uni_roi_align_kernel_f32 : public jit_uni_roi_align_kernel, public ji
         sub(rsp, x_len);
         uni_vmovdqu(ptr[rsp], xmm_idx);
         for (int i = 0; i < x_step; i++) {
-            mov(reg_tmp_32, ptr[rsp + i * sizeof(int)]);       // sizeof(int)  index_size
+            mov(reg_tmp_32, ptr[rsp + i * sizeof(int)]);                  // sizeof(int)  index_size
             mov(reg_tmp_32, ptr[reg_src + reg_tmp_64 * jcp_.data_size]);  // scale: sizeof(float)   value_size
             mov(ptr[rsp + i * sizeof(int)], reg_tmp_32);
         }
@@ -590,7 +610,7 @@ struct jit_uni_roi_align_kernel_f32 : public jit_uni_roi_align_kernel, public ji
         sub(rsp, v_len);
         uni_vmovdqu(ptr[rsp], vmm_idx);
         for (int i = 0; i < v_step; i++) {
-            mov(reg_tmp_32, ptr[rsp + i * sizeof(int)]);       // sizeof(int)  index_size
+            mov(reg_tmp_32, ptr[rsp + i * sizeof(int)]);                   // sizeof(int)  index_size
             mov(reg_tmp_16, word[reg_src + reg_tmp_64 * jcp_.data_size]);  // scale: sizeof(bf16)   value_size
             mov(ptr[rsp + i * sizeof(int)], reg_tmp_16);
         }
@@ -614,11 +634,11 @@ struct jit_uni_roi_align_kernel_f32 : public jit_uni_roi_align_kernel, public ji
         add(rsp, x_len);
     }
 
-    inline void horizontal_add_xmm(const Xbyak::Xmm &xmm_dst, const Xbyak::Xmm &xmm_aux) {
-        uni_vmovshdup(xmm_aux, xmm_dst);              //  dst:1,2,3,4; aux:2,2,4,4
-        uni_vaddps(xmm_dst, xmm_dst, xmm_aux);        //  dst:1+2,2+2,3+4,4+4
-        uni_vmovhlps(xmm_aux, xmm_aux, xmm_dst);      //  aux:3+4,4+4,4,4
-        uni_vaddps(xmm_dst, xmm_dst, xmm_aux);        //  dst:1+2+3+4,...
+    inline void horizontal_add_xmm(const Xbyak::Xmm& xmm_dst, const Xbyak::Xmm& xmm_aux) {
+        uni_vmovshdup(xmm_aux, xmm_dst);          //  dst:1,2,3,4; aux:2,2,4,4
+        uni_vaddps(xmm_dst, xmm_dst, xmm_aux);    //  dst:1+2,2+2,3+4,4+4
+        uni_vmovhlps(xmm_aux, xmm_aux, xmm_dst);  //  aux:3+4,4+4,4,4
+        uni_vaddps(xmm_dst, xmm_dst, xmm_aux);    //  dst:1+2+3+4,...
     }
 
     // horizontal add for vmm_dst, temp1 and temp2 as aux
@@ -663,7 +683,8 @@ bool ROIAlign::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, s
         }
 
         const ngAlignedMode alignedMode = roiAlign->get_aligned_mode();
-        if (alignedMode != ngAlignedMode::ASYMMETRIC && alignedMode != ngAlignedMode::HALF_PIXEL_FOR_NN && alignedMode != ngAlignedMode::HALF_PIXEL) {
+        if (alignedMode != ngAlignedMode::ASYMMETRIC && alignedMode != ngAlignedMode::HALF_PIXEL_FOR_NN &&
+            alignedMode != ngAlignedMode::HALF_PIXEL) {
             errorMessage = "Doesn't support mode: " + ov::as_string(alignedMode);
             return false;
         }
@@ -791,9 +812,7 @@ void ROIAlign::initSupportedPrimitiveDescriptors() {
     } else {
         impl_type = impl_desc_type::ref;
     }
-    std::vector<std::pair<LayoutType, LayoutType>> supportedFormats {
-            {LayoutType::ncsp, LayoutType::ncsp}
-    };
+    std::vector<std::pair<LayoutType, LayoutType>> supportedFormats{{LayoutType::ncsp, LayoutType::ncsp}};
 
     if (mayiuse(cpu::x64::sse41)) {
         supportedFormats.push_back(std::make_pair(LayoutType::nspc, LayoutType::nspc));
@@ -805,11 +824,10 @@ void ROIAlign::initSupportedPrimitiveDescriptors() {
     }
 
     for (auto fmts : supportedFormats) {
-        addSupportedPrimDesc({{fmts.first, inputPrec0},
-                              {LayoutType::ncsp, ov::element::f32},
-                              {LayoutType::ncsp, ov::element::i32}},
-                             {{fmts.second, outputPrec}},
-                              impl_type);
+        addSupportedPrimDesc(
+            {{fmts.first, inputPrec0}, {LayoutType::ncsp, ov::element::f32}, {LayoutType::ncsp, ov::element::i32}},
+            {{fmts.second, outputPrec}},
+            impl_type);
     }
 }
 
@@ -836,50 +854,50 @@ void ROIAlign::createPrimitive() {
 
 namespace {
 struct ROIAlignContext {
-    ROIAlign &node;
+    ROIAlign& node;
 };
-}
+}  // namespace
 
-template<typename T>
+template <typename T>
 struct ROIAlign::ROIAlignExecute {
     using srcT = typename std::tuple_element<0, T>::type;
     using dstT = typename std::tuple_element<1, T>::type;
 
-    void operator()(ROIAlignContext & ctx) {
+    void operator()(ROIAlignContext& ctx) {
         ctx.node.executeSpecified<srcT, dstT>();
     }
 };
 void ROIAlign::execute(dnnl::stream strm) {
     auto inputPrec = getParentEdgeAt(0)->getMemory().getDataType();
     auto outputPrec = getChildEdgeAt(0)->getMemory().getDataType();
-    if (!((inputPrec == dnnl_bf16 && outputPrec == dnnl_bf16) ||
-          (inputPrec == dnnl_f32 && outputPrec == dnnl_f32)))
+    if (!((inputPrec == dnnl_bf16 && outputPrec == dnnl_bf16) || (inputPrec == dnnl_f32 && outputPrec == dnnl_f32)))
         OPENVINO_THROW("ROIAlign doesn't support demanded precisions");
 
-    ROIAlignContext ctx = {
-            *this
-    };
+    ROIAlignContext ctx = {*this};
 
-    OV_SWITCH(intel_cpu, ROIAlignExecute, ctx, std::tie(inputPrec, outputPrec),
+    OV_SWITCH(intel_cpu,
+              ROIAlignExecute,
+              ctx,
+              std::tie(inputPrec, outputPrec),
               OV_CASE2(dnnl_f32, dnnl_f32, float, float),
               OV_CASE2(dnnl_bf16, dnnl_bf16, bfloat16_t, bfloat16_t))
 }
 
 template <typename inputType, typename outputType>
 void ROIAlign::executeSpecified() {
-    auto &srcMemory0 = getParentEdgeAt(0)->getMemory();
-    auto &srcMemory1 = getParentEdgeAt(1)->getMemory();
-    auto &dstMemory = getChildEdgeAt(0)->getMemory();
+    auto& srcMemory0 = getParentEdgeAt(0)->getMemory();
+    auto& srcMemory1 = getParentEdgeAt(1)->getMemory();
+    auto& dstMemory = getChildEdgeAt(0)->getMemory();
 
     auto srcBlockDesc = srcMemory0.getDescWithType<BlockedMemoryDesc>();
     auto dstBlockDesc = dstMemory.getDescWithType<BlockedMemoryDesc>();
 
     auto isPlainFmt = srcBlockDesc->hasLayoutType(LayoutType::ncsp);
 
-    const auto *srcData = getSrcDataAtPortAs<const inputType>(0);
-    const auto *srcRoi = getSrcDataAtPortAs<const float>(1);
-    const auto *srcRoiIdx = getSrcDataAtPortAs<const int>(2);
-    auto *dst = getDstDataAtPortAs<outputType>(0);
+    const auto* srcData = getSrcDataAtPortAs<const inputType>(0);
+    const auto* srcRoi = getSrcDataAtPortAs<const float>(1);
+    const auto* srcRoiIdx = getSrcDataAtPortAs<const int>(2);
+    auto* dst = getDstDataAtPortAs<outputType>(0);
 
     auto nominalRoiCount = static_cast<int>(srcMemory1.getStaticDims()[0]);
     int realRois = 0;
@@ -890,8 +908,8 @@ void ROIAlign::executeSpecified() {
 
     const int binCount = pooledH * pooledW;
 
-    const auto &srcStrides = srcBlockDesc->getStrides();
-    const auto &dstStrides = dstBlockDesc->getStrides();
+    const auto& srcStrides = srcBlockDesc->getStrides();
+    const auto& dstStrides = dstBlockDesc->getStrides();
 
     const int batchInputStride = srcStrides[0];
     const int batchOutputStride = dstStrides[0];
@@ -993,8 +1011,7 @@ void ROIAlign::executeSpecified() {
                     float sampleY = y1 + yBinInd * binHeight + sampleDistanceY * (0.5f + ySampleInd);
                     for (int xSampleInd = 0; xSampleInd < samplingRatioX; xSampleInd++) {
                         float sampleX = x1 + xBinInd * binWidth + sampleDistanceX * (0.5f + xSampleInd);
-                        if (sampleX < -1.0 || sampleX > W ||
-                            sampleY < -1.0 || sampleY > H) {
+                        if (sampleX < -1.0 || sampleX > W || sampleY < -1.0 || sampleY > H) {
                             // For this sample we save 4 index of (0,0) and 4 weight of 0
                             if (!isPlainFmt) {
                                 auto startPoint = reinterpret_cast<size_t>(&srcData[batchSrcOffset]);
@@ -1030,7 +1047,8 @@ void ROIAlign::executeSpecified() {
                         }
 
                         if (!isPlainFmt) {
-                            size_t srcOffset = batchSrcOffset + sampleYLow * W * lastBlockDim + sampleXLow * lastBlockDim;
+                            size_t srcOffset =
+                                batchSrcOffset + sampleYLow * W * lastBlockDim + sampleXLow * lastBlockDim;
                             srcAddressListTbl[n][idxIter] = reinterpret_cast<size_t>(&srcData[srcOffset]);
 
                             srcOffset = batchSrcOffset + sampleYLow * W * lastBlockDim + sampleXHigh * lastBlockDim;
@@ -1042,8 +1060,8 @@ void ROIAlign::executeSpecified() {
                             srcOffset = batchSrcOffset + sampleYHigh * W * lastBlockDim + sampleXHigh * lastBlockDim;
                             srcAddressListTbl[n][idxIter + 3] = reinterpret_cast<size_t>(&srcData[srcOffset]);
                         } else {
-                            srcIndexTbl[n][idxIter] = sampleYLow  * W + sampleXLow;
-                            srcIndexTbl[n][idxIter + 1] = sampleYLow  * W + sampleXHigh;
+                            srcIndexTbl[n][idxIter] = sampleYLow * W + sampleXLow;
+                            srcIndexTbl[n][idxIter + 1] = sampleYLow * W + sampleXHigh;
                             srcIndexTbl[n][idxIter + 2] = sampleYHigh * W + sampleXLow;
                             srcIndexTbl[n][idxIter + 3] = sampleYHigh * W + sampleXHigh;
                         }
@@ -1079,7 +1097,8 @@ void ROIAlign::executeSpecified() {
             auto rhw_loop = [&](int n, int yBinInd, int xBinInd) {
                 int numSamplesROI = numSamples[n];
                 // each sample have 4 values for srcAddressList and weight
-                size_t binOffset = numSamplesROI * BLIParamsNum * pooledW * yBinInd + numSamplesROI * BLIParamsNum * xBinInd;
+                size_t binOffset =
+                    numSamplesROI * BLIParamsNum * pooledW * yBinInd + numSamplesROI * BLIParamsNum * xBinInd;
 
                 auto arg = jit_roi_align_call_args();
                 arg.src = static_cast<const void*>(&srcAddressListTbl[n][binOffset]);
@@ -1088,12 +1107,13 @@ void ROIAlign::executeSpecified() {
                 arg.num_samples = numSamplesROI;
                 float numSamplesInBinInvert = 1.f / numSamplesROI;
                 arg.scale = static_cast<const float*>(&numSamplesInBinInvert);
-                float *threadBuf = static_cast<float*>(&workingBuf[static_cast<size_t>(parallel_get_thread_num()) * static_cast<size_t>(bufSize)]);
+                float* threadBuf = static_cast<float*>(
+                    &workingBuf[static_cast<size_t>(parallel_get_thread_num()) * static_cast<size_t>(bufSize)]);
                 memset(threadBuf, 0, bufSize * sizeof(float));
                 arg.buffer = threadBuf;
                 size_t dstOffset = n * batchOutputStride + yBinInd * pooledW * lastBlockDim + xBinInd * lastBlockDim;
                 arg.dst = static_cast<void*>(&dst[dstOffset]);
-                arg.src_stride = lastBlockDim * W * H; // only valid for blk, nspc generate inside
+                arg.src_stride = lastBlockDim * W * H;  // only valid for blk, nspc generate inside
                 (*roi_align_kernel)(&arg);
             };
 
@@ -1140,24 +1160,19 @@ void ROIAlign::executeSpecified() {
                 float src2 = srcData[channelSrcOffset + srcIndexTbl[n][paramOffset + 2]];
                 float src3 = srcData[channelSrcOffset + srcIndexTbl[n][paramOffset + 3]];
 
-                float sampleValue =
-                        weightsTbl[n][paramOffset] * src0 +
-                        weightsTbl[n][paramOffset + 1] * src1 +
-                        weightsTbl[n][paramOffset + 2] * src2 +
-                        weightsTbl[n][paramOffset + 3] * src3;
+                float sampleValue = weightsTbl[n][paramOffset] * src0 + weightsTbl[n][paramOffset + 1] * src1 +
+                                    weightsTbl[n][paramOffset + 2] * src2 + weightsTbl[n][paramOffset + 3] * src3;
                 paramOffset += BLIParamsNum;
 
                 switch (getAlgorithm()) {
-                    case Algorithm::ROIAlignMax:
-                    {
-                        pooledValue = sampleValue > pooledValue ? sampleValue : pooledValue;
-                        break;
-                    }
-                    case Algorithm::ROIAlignAvg:
-                    default:
-                    {
-                        pooledValue += sampleValue * numSamplesInBinInvert;
-                    }
+                case Algorithm::ROIAlignMax: {
+                    pooledValue = sampleValue > pooledValue ? sampleValue : pooledValue;
+                    break;
+                }
+                case Algorithm::ROIAlignAvg:
+                default: {
+                    pooledValue += sampleValue * numSamplesInBinInvert;
+                }
                 }
                 dst[binDstOffset] = pooledValue;
             }
@@ -1177,6 +1192,6 @@ void ROIAlign::executeDynamicImpl(dnnl::stream strm) {
     execute(strm);
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/roi_align.h b/src/plugins/intel_cpu/src/nodes/roi_align.h
index 7e3e6f42f95868..bde1ef2e3f1447 100644
--- a/src/plugins/intel_cpu/src/nodes/roi_align.h
+++ b/src/plugins/intel_cpu/src/nodes/roi_align.h
@@ -11,17 +11,9 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 
-enum ROIAlignLayoutType {
-    ncsp,
-    blk,
-    nspc
-};
+enum ROIAlignLayoutType { ncsp, blk, nspc };
 
-enum ROIAlignedMode {
-    ra_asymmetric,
-    ra_half_pixel_for_nn,
-    ra_half_pixel
-};
+enum ROIAlignedMode { ra_asymmetric, ra_half_pixel_for_nn, ra_half_pixel };
 
 struct jit_roi_align_params {
     Algorithm alg;
@@ -35,20 +27,20 @@ struct jit_roi_align_params {
 struct jit_roi_align_call_args {
     // point to srcData for planar
     // point to srcData address list for other layouts
-    const void *src;
-    const float *weights;
-    const float *scale;
-    void *buffer;
-    void *dst;
+    const void* src;
+    const float* weights;
+    const float* scale;
+    void* buffer;
+    void* dst;
     size_t num_samples;
     size_t work_amount;
     size_t src_stride;
 };
 
 struct jit_uni_roi_align_kernel {
-    void (*ker_)(const jit_roi_align_call_args *);
+    void (*ker_)(const jit_roi_align_call_args*);
 
-    void operator()(const jit_roi_align_call_args *args) {
+    void operator()(const jit_roi_align_call_args* args) {
         assert(ker_);
         ker_(args);
     }
@@ -84,7 +76,7 @@ class ROIAlign : public Node {
     ROIAlignedMode alignedMode;
     template <typename inputType, typename outputType>
     void executeSpecified();
-    template<typename T>
+    template <typename T>
     struct ROIAlignExecute;
 
     void createJitKernel(const ov::element::Type& dataPrec, const ROIAlignLayoutType& selectLayout);
@@ -93,6 +85,6 @@ class ROIAlign : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/roi_pooling.cpp b/src/plugins/intel_cpu/src/nodes/roi_pooling.cpp
index 816adb3ffa0666..5c389350893939 100644
--- a/src/plugins/intel_cpu/src/nodes/roi_pooling.cpp
+++ b/src/plugins/intel_cpu/src/nodes/roi_pooling.cpp
@@ -4,24 +4,21 @@
 
 #include "roi_pooling.h"
 
-#include "onednn/dnnl.h"
-#include "dnnl_extension_utils.h"
-#include "selective_build.h"
-
+#include <algorithm>
+#include <cmath>
+#include <memory>
 #include <openvino/opsets/opset2.hpp>
+#include <string>
+#include <vector>
 
+#include "common/primitive_hashing_utils.hpp"
+#include "cpu/x64/jit_generator.hpp"
+#include "dnnl_extension_utils.h"
+#include "emitters/plugin/x64/jit_load_store_emitters.hpp"
+#include "onednn/dnnl.h"
 #include "openvino/core/parallel.hpp"
+#include "selective_build.h"
 #include "utils/bfloat16.hpp"
-#include "emitters/plugin/x64/jit_load_store_emitters.hpp"
-
-#include "cpu/x64/jit_generator.hpp"
-#include "common/primitive_hashing_utils.hpp"
-
-#include <string>
-#include <vector>
-#include <memory>
-#include <algorithm>
-#include <cmath>
 
 using namespace dnnl;
 using namespace dnnl::impl;
@@ -40,7 +37,9 @@ template <cpu_isa_t isa>
 struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, public jit_generator {
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_roi_pooling_kernel_f32);
 
-    explicit jit_uni_roi_pooling_kernel_f32(jit_roi_pooling_params jcp) : jit_uni_roi_pooling_kernel(jcp), jit_generator(jit_name()) {}
+    explicit jit_uni_roi_pooling_kernel_f32(jit_roi_pooling_params jcp)
+        : jit_uni_roi_pooling_kernel(jcp),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -72,7 +71,8 @@ struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, publi
             mov(reg_xoff, ptr[this->param1 + GET_OFF(xoff)]);
         }
 
-        load_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx()), static_cast<size_t>(reg_load_table.getIdx())};
+        load_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx()),
+                              static_cast<size_t>(reg_load_table.getIdx())};
         store_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx())};
         store_pool_vec_idxs = {static_cast<size_t>(vmm_zero.getIdx())};
 
@@ -98,14 +98,14 @@ struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, publi
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
 
     const int vlen = cpu_isa_traits<isa>::vlen;
     const int step = vlen / sizeof(float);
 
     Vmm vmm_mask = Vmm(0);
-    Vmm vmm_zero = Vmm(2); // avoid using xmm0 (reserved as mask reg in sse41-instruction blendvps)
+    Vmm vmm_zero = Vmm(2);  // avoid using xmm0 (reserved as mask reg in sse41-instruction blendvps)
 
     Xmm xmm_yf = Xmm(0);
     Vmm vmm_yf = Vmm(0);
@@ -120,20 +120,24 @@ struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, publi
     std::vector<size_t> store_pool_gpr_idxs;
     std::vector<size_t> store_pool_vec_idxs;
 
-    Vmm get_acc_reg(int idx) { return Vmm(2*idx + 1); }
-    Vmm get_src_reg(int idx) { return Vmm(2*idx + 2); }
+    Vmm get_acc_reg(int idx) {
+        return Vmm(2 * idx + 1);
+    }
+    Vmm get_src_reg(int idx) {
+        return Vmm(2 * idx + 2);
+    }
 
     Opmask k_store_mask = Opmask(7);
 
     const unsigned char _cmp_lt_os = 1;
 
     using reg64_t = const Xbyak::Reg64;
-    reg64_t reg_input     = r8;
+    reg64_t reg_input = r8;
     reg64_t aux_reg_input = rax;
     reg64_t aux_reg_input1 = rdx;
-    reg64_t reg_output    = r9;
-    reg64_t reg_kh    = r10;
-    reg64_t reg_kw    = r11;
+    reg64_t reg_output = r9;
+    reg64_t reg_kh = r10;
+    reg64_t reg_kw = r11;
 
     reg64_t h_iter = r13;
     reg64_t w_iter = r14;
@@ -151,8 +155,10 @@ struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, publi
     Xbyak::Reg64 reg_load_store_mask = abi_param1;
 
     std::vector<size_t> get_local_store_pool_vec_idxs(Vmm vmm) const {
-        std::vector<size_t> local_store_pool_vec_idxs = { static_cast<size_t>(vmm.getIdx()) };
-        local_store_pool_vec_idxs.insert(local_store_pool_vec_idxs.begin(), store_pool_vec_idxs.begin(), store_pool_vec_idxs.end());
+        std::vector<size_t> local_store_pool_vec_idxs = {static_cast<size_t>(vmm.getIdx())};
+        local_store_pool_vec_idxs.insert(local_store_pool_vec_idxs.begin(),
+                                         store_pool_vec_idxs.begin(),
+                                         store_pool_vec_idxs.end());
         return local_store_pool_vec_idxs;
     }
 
@@ -166,21 +172,28 @@ struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, publi
         for (int i = 0; i < c_blocks; i++) {
             Vmm vmm_max = get_acc_reg(i);
 
-            load_emitter->emit_code({static_cast<size_t>(reg_input.getIdx()), static_cast<size_t>(i * src_c_off)}, {static_cast<size_t>(vmm_max.getIdx())},
-                                    {}, load_pool_gpr_idxs);
+            load_emitter->emit_code({static_cast<size_t>(reg_input.getIdx()), static_cast<size_t>(i * src_c_off)},
+                                    {static_cast<size_t>(vmm_max.getIdx())},
+                                    {},
+                                    load_pool_gpr_idxs);
         }
 
         xor_(h_iter, h_iter);
-        L(h_loop_label); {
+        L(h_loop_label);
+        {
             xor_(w_iter, w_iter);
             mov(aux_reg_input1, aux_reg_input);
-            L(w_loop_label); {
+            L(w_loop_label);
+            {
                 for (int i = 0; i < c_blocks; i++) {
                     Vmm vmm_max = get_acc_reg(i);
                     Vmm vmm_src = get_src_reg(i);
 
-                    load_emitter->emit_code({static_cast<size_t>(aux_reg_input1.getIdx()), static_cast<size_t>(i * src_c_off)},
-                                            {static_cast<size_t>(vmm_src.getIdx())}, {}, load_pool_gpr_idxs);
+                    load_emitter->emit_code(
+                        {static_cast<size_t>(aux_reg_input1.getIdx()), static_cast<size_t>(i * src_c_off)},
+                        {static_cast<size_t>(vmm_src.getIdx())},
+                        {},
+                        load_pool_gpr_idxs);
 
                     if (isa == cpu::x64::sse41) {
                         movups(vmm_mask, vmm_max);
@@ -190,8 +203,8 @@ struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, publi
                         vcmpps(vmm_mask, vmm_max, vmm_src, _cmp_lt_os);
                         vblendvps(vmm_max, vmm_max, vmm_src, vmm_mask);
                     } else if (isa == cpu::x64::avx512_core) {
-                        vcmpps(k_store_mask,  vmm_max,  vmm_src, _cmp_lt_os);
-                        vblendmps(vmm_max| k_store_mask, vmm_max, vmm_src);
+                        vcmpps(k_store_mask, vmm_max, vmm_src, _cmp_lt_os);
+                        vblendmps(vmm_max | k_store_mask, vmm_max, vmm_src);
                     }
                 }
 
@@ -215,7 +228,8 @@ struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, publi
 
             store_emitter->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
                                      {static_cast<size_t>(reg_output.getIdx()), static_cast<size_t>(i * dst_c_off)},
-                                     get_local_store_pool_vec_idxs(vmm_dst), store_pool_gpr_idxs);
+                                     get_local_store_pool_vec_idxs(vmm_dst),
+                                     store_pool_gpr_idxs);
         }
     }
 
@@ -235,20 +249,28 @@ struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, publi
 
             mov(aux_reg_input, reg_input);
 
-            load_emitter->emit_code({static_cast<size_t>(aux_reg_input.getIdx()), static_cast<size_t>(src_c_off)}, {static_cast<size_t>(vmm_src00.getIdx())},
-                                    {}, load_pool_gpr_idxs);
+            load_emitter->emit_code({static_cast<size_t>(aux_reg_input.getIdx()), static_cast<size_t>(src_c_off)},
+                                    {static_cast<size_t>(vmm_src00.getIdx())},
+                                    {},
+                                    load_pool_gpr_idxs);
             add(aux_reg_input, reg_xoff);
 
-            load_emitter->emit_code({static_cast<size_t>(aux_reg_input.getIdx()), static_cast<size_t>(src_c_off)}, {static_cast<size_t>(vmm_src01.getIdx())},
-                                    {}, load_pool_gpr_idxs);
+            load_emitter->emit_code({static_cast<size_t>(aux_reg_input.getIdx()), static_cast<size_t>(src_c_off)},
+                                    {static_cast<size_t>(vmm_src01.getIdx())},
+                                    {},
+                                    load_pool_gpr_idxs);
 
             add(aux_reg_input, reg_yoff);
-            load_emitter->emit_code({static_cast<size_t>(aux_reg_input.getIdx()), static_cast<size_t>(src_c_off)}, {static_cast<size_t>(vmm_src11.getIdx())},
-                                    {}, load_pool_gpr_idxs);
+            load_emitter->emit_code({static_cast<size_t>(aux_reg_input.getIdx()), static_cast<size_t>(src_c_off)},
+                                    {static_cast<size_t>(vmm_src11.getIdx())},
+                                    {},
+                                    load_pool_gpr_idxs);
             sub(aux_reg_input, reg_xoff);
 
-            load_emitter->emit_code({static_cast<size_t>(aux_reg_input.getIdx()), static_cast<size_t>(src_c_off)}, {static_cast<size_t>(vmm_src10.getIdx())},
-                                    {}, load_pool_gpr_idxs);
+            load_emitter->emit_code({static_cast<size_t>(aux_reg_input.getIdx()), static_cast<size_t>(src_c_off)},
+                                    {static_cast<size_t>(vmm_src10.getIdx())},
+                                    {},
+                                    load_pool_gpr_idxs);
 
             uni_vsubps(vmm_src01, vmm_src01, vmm_src00);
             uni_vfmadd213ps(vmm_src01, vmm_xf, vmm_src00);
@@ -263,7 +285,8 @@ struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, publi
 
             store_emitter->emit_code({static_cast<size_t>(vmm_src11.getIdx())},
                                      {static_cast<size_t>(reg_output.getIdx()), static_cast<size_t>(dst_c_off)},
-                                     get_local_store_pool_vec_idxs(vmm_src11), store_pool_gpr_idxs);
+                                     get_local_store_pool_vec_idxs(vmm_src11),
+                                     store_pool_gpr_idxs);
         }
     }
 
@@ -272,9 +295,11 @@ struct jit_uni_roi_pooling_kernel_f32 : public jit_uni_roi_pooling_kernel, publi
 
         const int dst_c_off = jpp_.oh * jpp_.ow * jpp_.c_block * jpp_.dst_prc.size();
         for (int i = 0; i < c_blocks; i++) {
-            store_empty_roi_emitter->emit_code({static_cast<size_t>(vmm_zero.getIdx())},
-                                               {static_cast<size_t>(reg_output.getIdx()), static_cast<size_t>(i * dst_c_off)},
-                                               store_pool_vec_idxs, store_pool_gpr_idxs);
+            store_empty_roi_emitter->emit_code(
+                {static_cast<size_t>(vmm_zero.getIdx())},
+                {static_cast<size_t>(reg_output.getIdx()), static_cast<size_t>(i * dst_c_off)},
+                store_pool_vec_idxs,
+                store_pool_gpr_idxs);
         }
     }
 
@@ -346,27 +371,16 @@ size_t RoiPoolingKey::hash() const {
     return seed;
 }
 
-bool RoiPoolingKey::operator==(const RoiPoolingKey &rhs) const {
+bool RoiPoolingKey::operator==(const RoiPoolingKey& rhs) const {
     return refParams == rhs.refParams;
 }
-} // namespace
-
-bool jit_roi_pooling_params::operator==(const jit_roi_pooling_params &rhs) const noexcept {
-    return mb == rhs.mb &&
-           c == rhs.c &&
-           ih == rhs.ih &&
-           iw == rhs.iw &&
-           oh == rhs.oh &&
-           ow == rhs.ow &&
-           c_block == rhs.c_block &&
-           nb_c == rhs.nb_c &&
-           nb_c_blocking == rhs.nb_c_blocking &&
-           spatial_scale == rhs.spatial_scale &&
-           pooled_h == rhs.pooled_h &&
-           pooled_w == rhs.pooled_w &&
-           src_prc == rhs.src_prc &&
-           dst_prc == rhs.dst_prc &&
-           alg == rhs.alg;
+}  // namespace
+
+bool jit_roi_pooling_params::operator==(const jit_roi_pooling_params& rhs) const noexcept {
+    return mb == rhs.mb && c == rhs.c && ih == rhs.ih && iw == rhs.iw && oh == rhs.oh && ow == rhs.ow &&
+           c_block == rhs.c_block && nb_c == rhs.nb_c && nb_c_blocking == rhs.nb_c_blocking &&
+           spatial_scale == rhs.spatial_scale && pooled_h == rhs.pooled_h && pooled_w == rhs.pooled_w &&
+           src_prc == rhs.src_prc && dst_prc == rhs.dst_prc && alg == rhs.alg;
 }
 
 bool ROIPooling::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
@@ -459,10 +473,9 @@ void ROIPooling::initSupportedPrimitiveDescriptors() {
         refParams.src_prc = ov::element::f32;
     }
 
-    addSupportedPrimDesc({{format, refParams.src_prc},
-                          {LayoutType::ncsp, refParams.src_prc}},
+    addSupportedPrimDesc({{format, refParams.src_prc}, {LayoutType::ncsp, refParams.src_prc}},
                          {{format, refParams.src_prc}},
-                          impl_type);
+                         impl_type);
 }
 
 void ROIPooling::createPrimitive() {
@@ -470,7 +483,8 @@ void ROIPooling::createPrimitive() {
     if (!selectedPD)
         OPENVINO_THROW("CPU ROI Pooling node with name '", getName(), "' doesn't have primitive descriptors.");
 
-    refParams.c_block = mayiuse(cpu::x64::avx512_core) ? 16 : 8;;
+    refParams.c_block = mayiuse(cpu::x64::avx512_core) ? 16 : 8;
+    ;
     refParams.nb_c_blocking = mayiuse(cpu::x64::avx512_core) ? 15 : 7;
     refParams.alg = getAlgorithm();
 
@@ -487,9 +501,9 @@ void ROIPooling::createPrimitive() {
 
 void ROIPooling::execute(dnnl::stream strm) {
     if (execPtr) {
-        const auto &srcMemory0 = getParentEdgeAt(0)->getMemory();
-        const auto &srcMemory1 = getParentEdgeAt(1)->getMemory();
-        const auto &dstMemory = getChildEdgeAt(0)->getMemory();
+        const auto& srcMemory0 = getParentEdgeAt(0)->getMemory();
+        const auto& srcMemory1 = getParentEdgeAt(1)->getMemory();
+        const auto& dstMemory = getChildEdgeAt(0)->getMemory();
         execPtr->exec(srcMemory0, srcMemory1, dstMemory);
     } else {
         OPENVINO_THROW("Can't execute ROI Pooling node. Primitive wasn't created");
@@ -536,7 +550,7 @@ void ROIPooling::prepareParams() {
 template <typename T>
 class ROIPooling::ROIPoolingJitExecutor : public ROIPooling::ROIPoolingExecutor {
 public:
-    ROIPoolingJitExecutor(const jit_roi_pooling_params &jpp) {
+    ROIPoolingJitExecutor(const jit_roi_pooling_params& jpp) {
 #if defined(OPENVINO_ARCH_X86_64)
         if (mayiuse(cpu::x64::avx512_core)) {
             roi_pooling_kernel.reset(new jit_uni_roi_pooling_kernel_f32<cpu::x64::avx512_core>(jpp));
@@ -553,10 +567,7 @@ class ROIPooling::ROIPoolingJitExecutor : public ROIPooling::ROIPoolingExecutor
 #endif
     }
 
-    void exec(
-        const IMemory& srcData,
-        const IMemory& srcRoi,
-        const IMemory& dst) override {
+    void exec(const IMemory& srcData, const IMemory& srcRoi, const IMemory& dst) override {
         if (!roi_pooling_kernel)
             OPENVINO_THROW("Could not execute. Kernel for RoiPooling node was not compiled.");
 
@@ -570,13 +581,12 @@ class ROIPooling::ROIPoolingJitExecutor : public ROIPooling::ROIPoolingExecutor
     }
 
 private:
-    void executeOptimizedGeneric(
-        const T* src_data,
-        const T* src_roi,
-        T* dst,
-        const VectorDims& src_strides,
-        const VectorDims& dst_strides,
-        const size_t src_roi_step) {
+    void executeOptimizedGeneric(const T* src_data,
+                                 const T* src_roi,
+                                 T* dst,
+                                 const VectorDims& src_strides,
+                                 const VectorDims& dst_strides,
+                                 const size_t src_roi_step) {
         const auto& jpp = roi_pooling_kernel->jpp_;
         int cb_work = impl::utils::div_up(jpp.nb_c, jpp.nb_c_blocking);
         int MB = jpp.mb;
@@ -585,7 +595,7 @@ class ROIPooling::ROIPoolingJitExecutor : public ROIPooling::ROIPoolingExecutor
         for (; real_rois < MB; real_rois++) {
             size_t roi_off = real_rois * src_roi_step;
 
-            const auto *src_roi_ptr = &src_roi[roi_off];
+            const auto* src_roi_ptr = &src_roi[roi_off];
             int roi_batch_ind = static_cast<int>(src_roi_ptr[0]);
             if (roi_batch_ind == -1) {
                 break;
@@ -604,7 +614,7 @@ class ROIPooling::ROIPoolingJitExecutor : public ROIPooling::ROIPoolingExecutor
                 (*roi_pooling_kernel)(&arg);
             } else {
                 size_t roi_off = n * src_roi_step;
-                const auto *src_roi_ptr = &src_roi[roi_off];
+                const auto* src_roi_ptr = &src_roi[roi_off];
 
                 int roi_batch_ind = static_cast<int>(src_roi_ptr[0]);
 
@@ -615,11 +625,21 @@ class ROIPooling::ROIPoolingJitExecutor : public ROIPooling::ROIPoolingExecutor
                     int roi_end_h = static_cast<int>(round(src_roi_ptr[4] * jpp.spatial_scale));
 
                     int hstart, hend, wstart, wend;
-                    std::tie(hstart, hend, wstart, wend) = getBordersForMaxMode(
-                        roi_start_h, roi_end_h, roi_start_w, roi_end_w, jpp.ih, oh, jpp.iw, ow, jpp.pooled_h, jpp.pooled_w);
-
-                    arg.src = &src_data[roi_batch_ind * src_strides[0] + cb * src_strides[1] + hstart * src_strides[2] + wstart * src_strides[3]];
-                    arg.dst = &dst[n * dst_strides[0] + cb * dst_strides[1] + oh * dst_strides[2] + ow * dst_strides[3]];
+                    std::tie(hstart, hend, wstart, wend) = getBordersForMaxMode(roi_start_h,
+                                                                                roi_end_h,
+                                                                                roi_start_w,
+                                                                                roi_end_w,
+                                                                                jpp.ih,
+                                                                                oh,
+                                                                                jpp.iw,
+                                                                                ow,
+                                                                                jpp.pooled_h,
+                                                                                jpp.pooled_w);
+
+                    arg.src = &src_data[roi_batch_ind * src_strides[0] + cb * src_strides[1] + hstart * src_strides[2] +
+                                        wstart * src_strides[3]];
+                    arg.dst =
+                        &dst[n * dst_strides[0] + cb * dst_strides[1] + oh * dst_strides[2] + ow * dst_strides[3]];
 
                     arg.bin_area = (hend - hstart) * (wend - wstart);
                     arg.kh = hend - hstart;
@@ -627,21 +647,30 @@ class ROIPooling::ROIPoolingJitExecutor : public ROIPooling::ROIPoolingExecutor
                 } else {
                     float roi_start_w_ = src_roi_ptr[1];
                     float roi_start_h_ = src_roi_ptr[2];
-                    float roi_end_w_   = src_roi_ptr[3];
-                    float roi_end_h_   = src_roi_ptr[4];
+                    float roi_end_w_ = src_roi_ptr[3];
+                    float roi_end_h_ = src_roi_ptr[4];
 
                     float in_x, in_y;
-                    std::tie(in_x, in_y) = getXYForBilinearMode(
-                        roi_start_h_, roi_end_h_, roi_start_w_, roi_end_w_, jpp.ih, oh, jpp.iw, ow, jpp.pooled_h, jpp.pooled_w);
+                    std::tie(in_x, in_y) = getXYForBilinearMode(roi_start_h_,
+                                                                roi_end_h_,
+                                                                roi_start_w_,
+                                                                roi_end_w_,
+                                                                jpp.ih,
+                                                                oh,
+                                                                jpp.iw,
+                                                                ow,
+                                                                jpp.pooled_h,
+                                                                jpp.pooled_w);
 
                     if (in_y < 0 || in_y > jpp.ih - 1 || in_x < 0 || in_x > jpp.iw - 1) {
                         arg.bin_area = 0;
-                        arg.dst = &dst[n * dst_strides[0] + cb * dst_strides[1] + oh * dst_strides[2] + ow * dst_strides[3]];
+                        arg.dst =
+                            &dst[n * dst_strides[0] + cb * dst_strides[1] + oh * dst_strides[2] + ow * dst_strides[3]];
                     } else {
-                        int top_y_index    = static_cast<int>(floorf(in_y));
+                        int top_y_index = static_cast<int>(floorf(in_y));
                         int bottom_y_index = static_cast<int>(ceilf(in_y));
-                        int left_x_index   = static_cast<int>(floorf(in_x));
-                        int right_x_index  = static_cast<int>(ceilf(in_x));
+                        int left_x_index = static_cast<int>(floorf(in_x));
+                        int right_x_index = static_cast<int>(ceilf(in_x));
 
                         if (right_x_index > jpp.iw - 1)
                             right_x_index = jpp.iw - 1;
@@ -649,7 +678,8 @@ class ROIPooling::ROIPoolingJitExecutor : public ROIPooling::ROIPoolingExecutor
                         if (bottom_y_index > jpp.ih - 1)
                             bottom_y_index = jpp.ih - 1;
 
-                        arg.dst = &dst[n * dst_strides[0] + cb * dst_strides[1] + oh * dst_strides[2] + ow * dst_strides[3]];
+                        arg.dst =
+                            &dst[n * dst_strides[0] + cb * dst_strides[1] + oh * dst_strides[2] + ow * dst_strides[3]];
 
                         arg.xf = in_x - left_x_index;
                         arg.yf = in_y - top_y_index;
@@ -675,11 +705,8 @@ class ROIPooling::ROIPoolingJitExecutor : public ROIPooling::ROIPoolingExecutor
 template <typename T>
 class ROIPooling::ROIPoolingRefExecutor : public ROIPooling::ROIPoolingExecutor {
 public:
-    ROIPoolingRefExecutor(const jit_roi_pooling_params &_jpp) : jpp(_jpp) {}
-    void exec(
-        const IMemory& srcData,
-        const IMemory& srcRoi,
-        const IMemory& dst) override {
+    ROIPoolingRefExecutor(const jit_roi_pooling_params& _jpp) : jpp(_jpp) {}
+    void exec(const IMemory& srcData, const IMemory& srcRoi, const IMemory& dst) override {
         auto src_strides = srcData.getDescWithType<BlockedMemoryDesc>()->getStrides();
         auto src_roi_step = srcRoi.getDescWithType<BlockedMemoryDesc>()->getStrides()[0];
         auto dst_strides = dst.getDescWithType<BlockedMemoryDesc>()->getStrides();
@@ -689,13 +716,12 @@ class ROIPooling::ROIPoolingRefExecutor : public ROIPooling::ROIPoolingExecutor
         executeReference(src_ptr, roi_ptr, dst_ptr, src_strides, dst_strides, src_roi_step);
     }
 
-    void executeReference(
-        const T* src_data,
-        const T* src_roi,
-        T* dst,
-        const VectorDims& src_strides,
-        const VectorDims& dst_strides,
-        const size_t src_roi_step) {
+    void executeReference(const T* src_data,
+                          const T* src_roi,
+                          T* dst,
+                          const VectorDims& src_strides,
+                          const VectorDims& dst_strides,
+                          const size_t src_roi_step) {
         int cb_work = impl::utils::div_up(jpp.nb_c, jpp.nb_c_blocking);
         int MB = jpp.mb;
 
@@ -703,7 +729,7 @@ class ROIPooling::ROIPoolingRefExecutor : public ROIPooling::ROIPoolingExecutor
         for (; real_rois < MB; real_rois++) {
             size_t roi_off = real_rois * src_roi_step;
 
-            const auto *src_roi_ptr = &src_roi[roi_off];
+            const auto* src_roi_ptr = &src_roi[roi_off];
             int roi_batch_ind = static_cast<int>(src_roi_ptr[0]);
             if (roi_batch_ind == -1) {
                 break;
@@ -718,15 +744,16 @@ class ROIPooling::ROIPoolingRefExecutor : public ROIPooling::ROIPoolingExecutor
                 for (int cbb_cur = 0; cbb_cur < cb_num; cbb_cur++) {
                     int ch_blk_cur = cbb * cb_num + cbb_cur;
                     if (ch_blk_cur >= jpp.nb_c) {
-                        break; // current block work is done
+                        break;  // current block work is done
                     }
                     for (int c = 0; c < c_block; c++) {
-                        dst[n * dst_strides[0] + ch_blk_cur * dst_strides[1] + oh * dst_strides[2] + ow * dst_strides[3] + c] = 0;
+                        dst[n * dst_strides[0] + ch_blk_cur * dst_strides[1] + oh * dst_strides[2] +
+                            ow * dst_strides[3] + c] = 0;
                     }
                 }
             } else {
                 size_t roi_off = n * src_roi_step;
-                const auto *src_roi_ptr = &src_roi[roi_off];
+                const auto* src_roi_ptr = &src_roi[roi_off];
 
                 int roi_batch_ind = static_cast<int>(src_roi_ptr[0]);
 
@@ -737,8 +764,16 @@ class ROIPooling::ROIPoolingRefExecutor : public ROIPooling::ROIPoolingExecutor
                     int roi_end_h = static_cast<int>(round(src_roi_ptr[4] * jpp.spatial_scale));
 
                     int hstart, hend, wstart, wend;
-                    std::tie(hstart, hend, wstart, wend) = getBordersForMaxMode(
-                        roi_start_h, roi_end_h, roi_start_w, roi_end_w, jpp.ih, oh, jpp.iw, ow, jpp.pooled_h, jpp.pooled_w);
+                    std::tie(hstart, hend, wstart, wend) = getBordersForMaxMode(roi_start_h,
+                                                                                roi_end_h,
+                                                                                roi_start_w,
+                                                                                roi_end_w,
+                                                                                jpp.ih,
+                                                                                oh,
+                                                                                jpp.iw,
+                                                                                ow,
+                                                                                jpp.pooled_h,
+                                                                                jpp.pooled_w);
 
                     for (int cbb_cur = 0; cbb_cur < cb_num; cbb_cur++) {
                         int ch_blk_cur = cbb * cb_num + cbb_cur;
@@ -746,16 +781,19 @@ class ROIPooling::ROIPoolingRefExecutor : public ROIPooling::ROIPoolingExecutor
                             break;  // current block work is done
                         }
                         for (int c = 0; c < c_block; c++) {
-                            const size_t pool_index = n * dst_strides[0] + ch_blk_cur * dst_strides[1] + oh * dst_strides[2] + ow * dst_strides[3] + c;
+                            const size_t pool_index = n * dst_strides[0] + ch_blk_cur * dst_strides[1] +
+                                                      oh * dst_strides[2] + ow * dst_strides[3] + c;
                             if ((hend <= hstart) || (wend <= wstart)) {
                                 dst[pool_index] = 0;
                             } else {
-                                dst[pool_index] =  src_data[roi_batch_ind * src_strides[0] + ch_blk_cur * src_strides[1] +
-                                                            hstart * src_strides[2] + wstart * src_strides[3] + c];
+                                dst[pool_index] =
+                                    src_data[roi_batch_ind * src_strides[0] + ch_blk_cur * src_strides[1] +
+                                             hstart * src_strides[2] + wstart * src_strides[3] + c];
                                 for (int h = hstart; h < hend; ++h) {
                                     for (int w = wstart; w < wend; ++w) {
-                                        float batch_data = src_data[roi_batch_ind * src_strides[0] + ch_blk_cur * src_strides[1] +
-                                                                    h * src_strides[2] + w * src_strides[3] + c];
+                                        float batch_data =
+                                            src_data[roi_batch_ind * src_strides[0] + ch_blk_cur * src_strides[1] +
+                                                     h * src_strides[2] + w * src_strides[3] + c];
                                         dst[pool_index] = std::fmax(batch_data, dst[pool_index]);
                                     }
                                 }
@@ -765,12 +803,20 @@ class ROIPooling::ROIPoolingRefExecutor : public ROIPooling::ROIPoolingExecutor
                 } else {
                     float roi_start_w_ = src_roi_ptr[1];
                     float roi_start_h_ = src_roi_ptr[2];
-                    float roi_end_w_   = src_roi_ptr[3];
-                    float roi_end_h_   = src_roi_ptr[4];
+                    float roi_end_w_ = src_roi_ptr[3];
+                    float roi_end_h_ = src_roi_ptr[4];
 
                     float in_x, in_y;
-                    std::tie(in_x, in_y) = getXYForBilinearMode(
-                        roi_start_h_, roi_end_h_, roi_start_w_, roi_end_w_, jpp.ih, oh, jpp.iw, ow, jpp.pooled_h, jpp.pooled_w);
+                    std::tie(in_x, in_y) = getXYForBilinearMode(roi_start_h_,
+                                                                roi_end_h_,
+                                                                roi_start_w_,
+                                                                roi_end_w_,
+                                                                jpp.ih,
+                                                                oh,
+                                                                jpp.iw,
+                                                                ow,
+                                                                jpp.pooled_h,
+                                                                jpp.pooled_w);
 
                     if (in_y < 0 || in_y > jpp.ih - 1 || in_x < 0 || in_x > jpp.iw - 1) {
                         for (int cbb_cur = 0; cbb_cur < cb_num; cbb_cur++) {
@@ -779,14 +825,15 @@ class ROIPooling::ROIPoolingRefExecutor : public ROIPooling::ROIPoolingExecutor
                                 break;  // current block work is done
                             }
                             for (int c = 0; c < c_block; c++) {
-                                dst[n * dst_strides[0] + ch_blk_cur * dst_strides[1] + oh * dst_strides[2] + ow * dst_strides[3] + c] = 0;
+                                dst[n * dst_strides[0] + ch_blk_cur * dst_strides[1] + oh * dst_strides[2] +
+                                    ow * dst_strides[3] + c] = 0;
                             }
                         }
                     } else {
-                        int top_y_index    = static_cast<int>(floorf(in_y));
+                        int top_y_index = static_cast<int>(floorf(in_y));
                         int bottom_y_index = static_cast<int>(ceilf(in_y));
-                        int left_x_index   = static_cast<int>(floorf(in_x));
-                        int right_x_index  = static_cast<int>(ceilf(in_x));
+                        int left_x_index = static_cast<int>(floorf(in_x));
+                        int right_x_index = static_cast<int>(ceilf(in_x));
 
                         if (right_x_index > jpp.iw - 1)
                             right_x_index = jpp.iw - 1;
@@ -800,20 +847,24 @@ class ROIPooling::ROIPoolingRefExecutor : public ROIPooling::ROIPoolingExecutor
                                 break;  // current block work is done
                             }
                             for (int c = 0; c < c_block; c++) {
-                                const float top_left     = src_data[roi_batch_ind * src_strides[0] + ch_blk_cur * src_strides[1] +
-                                                                    top_y_index * src_strides[2] + left_x_index * src_strides[3] + c];
-                                const float top_right    = src_data[roi_batch_ind * src_strides[0] + ch_blk_cur * src_strides[1] +
-                                                                    top_y_index * src_strides[2] + right_x_index * src_strides[3] + c];
-                                const float bottom_left  = src_data[roi_batch_ind * src_strides[0] + ch_blk_cur * src_strides[1] +
-                                                                    bottom_y_index * src_strides[2] + left_x_index * src_strides[3] + c];
-                                const float bottom_right = src_data[roi_batch_ind * src_strides[0] + ch_blk_cur * src_strides[1] +
-                                                                    bottom_y_index * src_strides[2] + right_x_index * src_strides[3] + c];
-
-                                const float top    = top_left + (top_right - top_left) * (in_x - left_x_index);
+                                const float top_left =
+                                    src_data[roi_batch_ind * src_strides[0] + ch_blk_cur * src_strides[1] +
+                                             top_y_index * src_strides[2] + left_x_index * src_strides[3] + c];
+                                const float top_right =
+                                    src_data[roi_batch_ind * src_strides[0] + ch_blk_cur * src_strides[1] +
+                                             top_y_index * src_strides[2] + right_x_index * src_strides[3] + c];
+                                const float bottom_left =
+                                    src_data[roi_batch_ind * src_strides[0] + ch_blk_cur * src_strides[1] +
+                                             bottom_y_index * src_strides[2] + left_x_index * src_strides[3] + c];
+                                const float bottom_right =
+                                    src_data[roi_batch_ind * src_strides[0] + ch_blk_cur * src_strides[1] +
+                                             bottom_y_index * src_strides[2] + right_x_index * src_strides[3] + c];
+
+                                const float top = top_left + (top_right - top_left) * (in_x - left_x_index);
                                 const float bottom = bottom_left + (bottom_right - bottom_left) * (in_x - left_x_index);
 
-                                dst[n * dst_strides[0] + ch_blk_cur * dst_strides[1] + oh * dst_strides[2] + ow * dst_strides[3] + c] =
-                                        top + (bottom - top) * (in_y - top_y_index);
+                                dst[n * dst_strides[0] + ch_blk_cur * dst_strides[1] + oh * dst_strides[2] +
+                                    ow * dst_strides[3] + c] = top + (bottom - top) * (in_y - top_y_index);
                             }
                         }
                     }
@@ -828,9 +879,12 @@ class ROIPooling::ROIPoolingRefExecutor : public ROIPooling::ROIPoolingExecutor
 
 std::shared_ptr<ROIPooling::ROIPoolingExecutor> ROIPooling::ROIPoolingExecutor::createROIPoolingNewExecutor(
     const jit_roi_pooling_params& jpp) {
-    ROIPoolingContext ctx = { nullptr, jpp };
+    ROIPoolingContext ctx = {nullptr, jpp};
 
-    OV_SWITCH(intel_cpu, ROIPoolingExecutorCreation, ctx, jpp.src_prc,
+    OV_SWITCH(intel_cpu,
+              ROIPoolingExecutorCreation,
+              ctx,
+              jpp.src_prc,
               OV_CASE(ov::element::f32, float),
               OV_CASE(ov::element::bf16, bfloat16_t),
               OV_CASE(ov::element::f16, dnnl::impl::float16_t))
@@ -838,9 +892,16 @@ std::shared_ptr<ROIPooling::ROIPoolingExecutor> ROIPooling::ROIPoolingExecutor::
     return ctx.executor;
 }
 
-std::tuple<int, int, int, int> ROIPooling::ROIPoolingExecutor::getBordersForMaxMode(
-    const int roi_start_h, const int roi_end_h, const int roi_start_w, const int roi_end_w,
-    const int ih, const int oh, const int iw, const int ow, const int pooled_h, const int pooled_w) {
+std::tuple<int, int, int, int> ROIPooling::ROIPoolingExecutor::getBordersForMaxMode(const int roi_start_h,
+                                                                                    const int roi_end_h,
+                                                                                    const int roi_start_w,
+                                                                                    const int roi_end_w,
+                                                                                    const int ih,
+                                                                                    const int oh,
+                                                                                    const int iw,
+                                                                                    const int ow,
+                                                                                    const int pooled_h,
+                                                                                    const int pooled_w) {
     int roi_height = std::max(roi_end_h - roi_start_h + 1, 1);
     int roi_width = std::max(roi_end_w - roi_start_w + 1, 1);
 
@@ -871,11 +932,18 @@ std::tuple<int, int, int, int> ROIPooling::ROIPoolingExecutor::getBordersForMaxM
     return std::make_tuple(hstart, hend, wstart, wend);
 }
 
-std::pair<float, float> ROIPooling::ROIPoolingExecutor::getXYForBilinearMode(
-    const float roi_start_h, const float roi_end_h, const float roi_start_w, const float roi_end_w,
-    const int ih, const int oh, const int iw, const int ow, const int pooled_h, const int pooled_w) {
+std::pair<float, float> ROIPooling::ROIPoolingExecutor::getXYForBilinearMode(const float roi_start_h,
+                                                                             const float roi_end_h,
+                                                                             const float roi_start_w,
+                                                                             const float roi_end_w,
+                                                                             const int ih,
+                                                                             const int oh,
+                                                                             const int iw,
+                                                                             const int ow,
+                                                                             const int pooled_h,
+                                                                             const int pooled_w) {
     float height_scale = (pooled_h > 1 ? ((roi_end_h - roi_start_h) * (ih - 1)) / (pooled_h - 1) : 0);
-    float width_scale  = (pooled_w > 1 ? ((roi_end_w - roi_start_w) * (iw - 1)) / (pooled_w - 1) : 0);
+    float width_scale = (pooled_w > 1 ? ((roi_end_w - roi_start_w) * (iw - 1)) / (pooled_w - 1) : 0);
 
     float in_y, in_x;
     // because of nonalgebraic character of floating point operation, some proposals can cause violation of inequality:
@@ -888,7 +956,7 @@ std::pair<float, float> ROIPooling::ROIPoolingExecutor::getXYForBilinearMode(
         in_y = 0.5 * (roi_start_h + roi_end_h) * (ih - 1);
     }
     if (pooled_w > 1) {
-        in_x = (ow == pooled_w - 1 ? roi_end_w * (iw - 1) : (ow * width_scale  + roi_start_w * (iw - 1)));
+        in_x = (ow == pooled_w - 1 ? roi_end_w * (iw - 1) : (ow * width_scale + roi_start_w * (iw - 1)));
     } else {
         in_x = 0.5 * (roi_start_w + roi_end_w) * (iw - 1);
     }
@@ -911,6 +979,6 @@ bool ROIPooling::created() const {
     return getType() == Type::ROIPooling;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/roi_pooling.h b/src/plugins/intel_cpu/src/nodes/roi_pooling.h
index 466a2b4ad970cd..5a846dc0236d95 100644
--- a/src/plugins/intel_cpu/src/nodes/roi_pooling.h
+++ b/src/plugins/intel_cpu/src/nodes/roi_pooling.h
@@ -29,8 +29,8 @@ struct jit_roi_pooling_params {
 };
 
 struct jit_roi_pooling_call_args {
-    const void *src;
-    void *dst;
+    const void* src;
+    void* dst;
 
     size_t kh;
     size_t kw;
@@ -46,9 +46,9 @@ struct jit_roi_pooling_call_args {
 };
 
 struct jit_uni_roi_pooling_kernel {
-    void (*ker_)(const jit_roi_pooling_call_args *);
+    void (*ker_)(const jit_roi_pooling_call_args*);
 
-    void operator()(const jit_roi_pooling_call_args *args) {
+    void operator()(const jit_roi_pooling_call_args* args) {
         assert(ker_);
         ker_(args);
     }
@@ -77,8 +77,10 @@ class ROIPooling : public Node {
 private:
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
-    template<typename T> void execute();
-    template<typename T> struct ROIPoolingExecute;
+    template <typename T>
+    void execute();
+    template <typename T>
+    struct ROIPoolingExecute;
 
     jit_roi_pooling_params refParams = {};
 
@@ -87,21 +89,34 @@ class ROIPooling : public Node {
     class ROIPoolingExecutor {
     public:
         ROIPoolingExecutor() = default;
-        virtual void exec(
-            const ov::intel_cpu::IMemory& srcData,
-            const ov::intel_cpu::IMemory& srcRoi,
-            const ov::intel_cpu::IMemory& dst) = 0;
+        virtual void exec(const ov::intel_cpu::IMemory& srcData,
+                          const ov::intel_cpu::IMemory& srcRoi,
+                          const ov::intel_cpu::IMemory& dst) = 0;
         virtual ~ROIPoolingExecutor() = default;
 
         static std::shared_ptr<ROIPoolingExecutor> createROIPoolingNewExecutor(const jit_roi_pooling_params& jpp);
 
     protected:
-        std::tuple<int, int, int, int> getBordersForMaxMode(
-            const int roi_start_h, const int roi_end_h, const int roi_start_w, const int roi_end_w,
-            const int ih, const int oh, const int iw, const int ow, const int pooled_h, const int pooled_w);
-        std::pair<float, float> getXYForBilinearMode(
-            const float roi_start_h, const float roi_end_h, const float roi_start_w, const float roi_end_w,
-            const int ih, const int oh, const int iw, const int ow, const int pooled_h, const int pooled_w);
+        std::tuple<int, int, int, int> getBordersForMaxMode(const int roi_start_h,
+                                                            const int roi_end_h,
+                                                            const int roi_start_w,
+                                                            const int roi_end_w,
+                                                            const int ih,
+                                                            const int oh,
+                                                            const int iw,
+                                                            const int ow,
+                                                            const int pooled_h,
+                                                            const int pooled_w);
+        std::pair<float, float> getXYForBilinearMode(const float roi_start_h,
+                                                     const float roi_end_h,
+                                                     const float roi_start_w,
+                                                     const float roi_end_w,
+                                                     const int ih,
+                                                     const int oh,
+                                                     const int iw,
+                                                     const int ow,
+                                                     const int pooled_h,
+                                                     const int pooled_w);
 
     private:
         template <typename T>
@@ -112,7 +127,7 @@ class ROIPooling : public Node {
             jit_roi_pooling_params jpp;
         };
 
-        template<typename T>
+        template <typename T>
         struct ROIPoolingExecutorCreation {
             void operator()(ROIPoolingContext& ctx) {
                 ctx.executor = ROIPoolingExecutor::makeExecutor<T>(ctx.jpp);
@@ -120,13 +135,15 @@ class ROIPooling : public Node {
         };
     };
 
-    template <typename T> class ROIPoolingJitExecutor;
-    template <typename T> class ROIPoolingRefExecutor;
+    template <typename T>
+    class ROIPoolingJitExecutor;
+    template <typename T>
+    class ROIPoolingRefExecutor;
 
     using executorPtr = std::shared_ptr<ROIPoolingExecutor>;
     executorPtr execPtr = nullptr;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/roll.cpp b/src/plugins/intel_cpu/src/nodes/roll.cpp
index 7b17dff9746666..6ab01a4486d018 100644
--- a/src/plugins/intel_cpu/src/nodes/roll.cpp
+++ b/src/plugins/intel_cpu/src/nodes/roll.cpp
@@ -2,17 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "roll.h"
+
+#include <cmath>
+#include <openvino/opsets/opset7.hpp>
 #include <string>
 #include <vector>
-#include <cmath>
-#include "dnnl_extension_utils.h"
 
-#include "roll.h"
-#include "openvino/core/parallel.hpp"
+#include "common/cpu_memcpy.h"
+#include "dnnl_extension_utils.h"
 #include "onednn/dnnl.h"
+#include "openvino/core/parallel.hpp"
 #include "utils/general_utils.h"
-#include "common/cpu_memcpy.h"
-#include <openvino/opsets/opset7.hpp>
 
 using namespace dnnl;
 
@@ -42,9 +43,10 @@ Roll::Roll(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context
             OPENVINO_THROW(layerErrorPrefix, " has incorrect number of input/output edges!");
         }
 
-        const auto &dataPrecision = getOriginalInputPrecisionAtPort(DATA_INDEX);
+        const auto& dataPrecision = getOriginalInputPrecisionAtPort(DATA_INDEX);
 
-        if (std::find(supportedPrecisionSizes.begin(), supportedPrecisionSizes.end(), dataPrecision.size()) == supportedPrecisionSizes.end())
+        if (std::find(supportedPrecisionSizes.begin(), supportedPrecisionSizes.end(), dataPrecision.size()) ==
+            supportedPrecisionSizes.end())
             OPENVINO_THROW(layerErrorPrefix, "has unsupported precision: ", dataPrecision.get_type_name());
 
         const auto dataRank = getInputShapeAtPort(DATA_INDEX).getRank();
@@ -58,7 +60,9 @@ Roll::Roll(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context
         /* Axes */
         const auto& axesTensorPrec = getOriginalInputPrecisionAtPort(AXES_INDEX);
         if (axesTensorPrec != ov::element::i32 && axesTensorPrec != ov::element::i64) {
-            OPENVINO_THROW(layerErrorPrefix, " has unsupported 'axes' input precision: ", axesTensorPrec.get_type_name());
+            OPENVINO_THROW(layerErrorPrefix,
+                           " has unsupported 'axes' input precision: ",
+                           axesTensorPrec.get_type_name());
         }
 
         const auto axesTensorRank = getInputShapeAtPort(AXES_INDEX).getRank();
@@ -69,7 +73,9 @@ Roll::Roll(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context
         /* Shift */
         const auto& shiftTensorPrec = getOriginalInputPrecisionAtPort(SHIFT_INDEX);
         if (shiftTensorPrec != ov::element::i32 && shiftTensorPrec != ov::element::i64) {
-            OPENVINO_THROW(layerErrorPrefix, " has unsupported 'shift' input precision: ", shiftTensorPrec.get_type_name());
+            OPENVINO_THROW(layerErrorPrefix,
+                           " has unsupported 'shift' input precision: ",
+                           shiftTensorPrec.get_type_name());
         }
 
         const auto shiftTensorRank = getInputShapeAtPort(SHIFT_INDEX).getRank();
@@ -89,11 +95,10 @@ void Roll::initSupportedPrimitiveDescriptors() {
 
     ov::element::Type precision = getOriginalInputPrecisionAtPort(0);
 
-    addSupportedPrimDesc({{LayoutType::ncsp, precision},
-                          {LayoutType::ncsp, ov::element::i32},
-                          {LayoutType::ncsp, ov::element::i32}},
-                         {{LayoutType::ncsp, precision}},
-                         impl_desc_type::ref);
+    addSupportedPrimDesc(
+        {{LayoutType::ncsp, precision}, {LayoutType::ncsp, ov::element::i32}, {LayoutType::ncsp, ov::element::i32}},
+        {{LayoutType::ncsp, precision}},
+        impl_desc_type::ref);
 }
 
 void Roll::prepareParams() {
@@ -132,38 +137,40 @@ void Roll::execute(dnnl::stream strm) {
     const auto dataPrecision = getParentEdgeAt(DATA_INDEX)->getMemory().getDesc().getPrecision();
     const auto& dataTypeSize = dataPrecision.size();
     switch (dataTypeSize) {
-        case sizeof(element_type_traits<ov::element::i8>::value_type): {
-            execPtr->exec<element_type_traits<ov::element::i8>::value_type>(getSrcMemoryAtPort(DATA_INDEX),
-                                                                     getSrcMemoryAtPort(SHIFT_INDEX),
-                                                                     getSrcMemoryAtPort(AXES_INDEX),
-                                                                     getDstMemoryAtPort(0));
-            break;
-        }
-        case sizeof(element_type_traits<ov::element::i16>::value_type): {
-            execPtr->exec<element_type_traits<ov::element::i16>::value_type>(getSrcMemoryAtPort(DATA_INDEX),
-                                                                     getSrcMemoryAtPort(SHIFT_INDEX),
-                                                                     getSrcMemoryAtPort(AXES_INDEX),
-                                                                     getDstMemoryAtPort(0));
-            break;
-        }
-        case sizeof(element_type_traits<ov::element::i32>::value_type): {
-            execPtr->exec<element_type_traits<ov::element::i32>::value_type>(getSrcMemoryAtPort(DATA_INDEX),
-                                                                     getSrcMemoryAtPort(SHIFT_INDEX),
-                                                                     getSrcMemoryAtPort(AXES_INDEX),
-                                                                     getDstMemoryAtPort(0));
-            break;
-        }
-        default:
-            OPENVINO_THROW(layerErrorPrefix,  "has unsupported 'data' input precision: ", dataPrecision.get_type_name());
+    case sizeof(element_type_traits<ov::element::i8>::value_type): {
+        execPtr->exec<element_type_traits<ov::element::i8>::value_type>(getSrcMemoryAtPort(DATA_INDEX),
+                                                                        getSrcMemoryAtPort(SHIFT_INDEX),
+                                                                        getSrcMemoryAtPort(AXES_INDEX),
+                                                                        getDstMemoryAtPort(0));
+        break;
+    }
+    case sizeof(element_type_traits<ov::element::i16>::value_type): {
+        execPtr->exec<element_type_traits<ov::element::i16>::value_type>(getSrcMemoryAtPort(DATA_INDEX),
+                                                                         getSrcMemoryAtPort(SHIFT_INDEX),
+                                                                         getSrcMemoryAtPort(AXES_INDEX),
+                                                                         getDstMemoryAtPort(0));
+        break;
+    }
+    case sizeof(element_type_traits<ov::element::i32>::value_type): {
+        execPtr->exec<element_type_traits<ov::element::i32>::value_type>(getSrcMemoryAtPort(DATA_INDEX),
+                                                                         getSrcMemoryAtPort(SHIFT_INDEX),
+                                                                         getSrcMemoryAtPort(AXES_INDEX),
+                                                                         getDstMemoryAtPort(0));
+        break;
+    }
+    default:
+        OPENVINO_THROW(layerErrorPrefix, "has unsupported 'data' input precision: ", dataPrecision.get_type_name());
     }
 }
 
-Roll::RollExecutor::RollExecutor(const VectorDims& dataDims, const VectorDims& shiftDims, const VectorDims& axesDims,
-    const VectorDims& dstDims)
-        : numOfDims{dataDims.size()}
-        , blockSize{dataDims.back()}
-        , numOfIterations{std::accumulate(dataDims.cbegin(), dataDims.cend(), 1ul, std::multiplies<size_t>()) / blockSize}
-        , axesLength{axesDims[0]} {
+Roll::RollExecutor::RollExecutor(const VectorDims& dataDims,
+                                 const VectorDims& shiftDims,
+                                 const VectorDims& axesDims,
+                                 const VectorDims& dstDims)
+    : numOfDims{dataDims.size()},
+      blockSize{dataDims.back()},
+      numOfIterations{std::accumulate(dataDims.cbegin(), dataDims.cend(), 1ul, std::multiplies<size_t>()) / blockSize},
+      axesLength{axesDims[0]} {
     for (size_t i = 0; i < dataDims.size(); ++i) {
         if (dataDims[i] != dstDims[i])
             OPENVINO_THROW("Input/output tensors dimensions mismatch");
@@ -173,18 +180,20 @@ Roll::RollExecutor::RollExecutor(const VectorDims& dataDims, const VectorDims& s
         OPENVINO_THROW("'shift' and 'axes' dimensions mismatch");
 }
 
-template<typename T>
-void Roll::RollExecutor::exec(const MemoryPtr& dataMemPtr, const MemoryPtr& shiftMemPtr, const MemoryPtr& axesMemPtr,
-    const MemoryPtr& dstMemPtr) {
-    const auto *data = dataMemPtr->getDataAs<const T>();
-    const auto *shift = shiftMemPtr->getDataAs<const int32_t>();
-    const auto *axes = axesMemPtr->getDataAs<const int32_t>();
-    auto *dst = dstMemPtr->getDataAs<T>();
+template <typename T>
+void Roll::RollExecutor::exec(const MemoryPtr& dataMemPtr,
+                              const MemoryPtr& shiftMemPtr,
+                              const MemoryPtr& axesMemPtr,
+                              const MemoryPtr& dstMemPtr) {
+    const auto* data = dataMemPtr->getDataAs<const T>();
+    const auto* shift = shiftMemPtr->getDataAs<const int32_t>();
+    const auto* axes = axesMemPtr->getDataAs<const int32_t>();
+    auto* dst = dstMemPtr->getDataAs<T>();
 
     std::vector<size_t> shiftsVector(numOfDims, 0ul);
     const VectorDims& dataDims = dataMemPtr->getStaticDims();
 
-    for (size_t dim = 0; dim < axesLength ; ++dim) {
+    for (size_t dim = 0; dim < axesLength; ++dim) {
         int32_t currentAxis = axes[dim] < 0 ? axes[dim] + numOfDims : axes[dim];
         int32_t shiftSum = shiftsVector[currentAxis] + shift[dim];
         int32_t dimSize = dataDims[currentAxis];
@@ -196,7 +205,7 @@ void Roll::RollExecutor::exec(const MemoryPtr& dataMemPtr, const MemoryPtr& shif
     const size_t elementSize = sizeof(T);
 
     const auto strides = dataMemPtr->getDescWithType<BlockedMemoryDesc>()->getStrides();
-    const auto calculateShiftOffset = [](size_t dataOffset, size_t dimShift, size_t segmentSize, size_t dimSize){
+    const auto calculateShiftOffset = [](size_t dataOffset, size_t dimShift, size_t segmentSize, size_t dimSize) {
         size_t pos = dataOffset / segmentSize % dimSize;
         size_t shift = (pos + dimShift) % dimSize - pos;
 
@@ -209,20 +218,17 @@ void Roll::RollExecutor::exec(const MemoryPtr& dataMemPtr, const MemoryPtr& shif
         size_t rightBlockStartOffset = start + leftBlockSize;
 
         for (int dim = numOfDims - 1; dim >= 0; --dim) {
-            leftBlockStartOffset = calculateShiftOffset(leftBlockStartOffset, shiftsVector[dim], strides[dim], dataDims[dim]);
-            rightBlockStartOffset = calculateShiftOffset(rightBlockStartOffset, shiftsVector[dim], strides[dim], dataDims[dim]);
+            leftBlockStartOffset =
+                calculateShiftOffset(leftBlockStartOffset, shiftsVector[dim], strides[dim], dataDims[dim]);
+            rightBlockStartOffset =
+                calculateShiftOffset(rightBlockStartOffset, shiftsVector[dim], strides[dim], dataDims[dim]);
         }
 
         if (leftBlockSize > 0)
-            cpu_memcpy(dst + leftBlockStartOffset,
-                       data + start,
-                       leftBlockSize * elementSize);
-
+            cpu_memcpy(dst + leftBlockStartOffset, data + start, leftBlockSize * elementSize);
 
         if (rightBlockSize > 0)
-            cpu_memcpy(dst + rightBlockStartOffset,
-                       data + (start + leftBlockSize),
-                       rightBlockSize * elementSize);
+            cpu_memcpy(dst + rightBlockStartOffset, data + (start + leftBlockSize), rightBlockSize * elementSize);
     });
 }
 
@@ -232,6 +238,6 @@ bool Roll::created() const {
 
 constexpr std::array<size_t, 3> Roll::supportedPrecisionSizes;
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/roll.h b/src/plugins/intel_cpu/src/nodes/roll.h
index 058b8eb26bc27f..d01ba90851ea69 100644
--- a/src/plugins/intel_cpu/src/nodes/roll.h
+++ b/src/plugins/intel_cpu/src/nodes/roll.h
@@ -26,12 +26,16 @@ class Roll : public Node {
 
 private:
     struct RollExecutor {
-        RollExecutor(const VectorDims& dataDims, const VectorDims& shiftDims, const VectorDims& axesDims,
+        RollExecutor(const VectorDims& dataDims,
+                     const VectorDims& shiftDims,
+                     const VectorDims& axesDims,
                      const VectorDims& dstDims);
         ~RollExecutor() = default;
 
-        template<typename T>
-        void exec(const MemoryPtr& dataMemPtr, const MemoryPtr& shiftMemPtr, const MemoryPtr& axesMemPtr,
+        template <typename T>
+        void exec(const MemoryPtr& dataMemPtr,
+                  const MemoryPtr& shiftMemPtr,
+                  const MemoryPtr& axesMemPtr,
                   const MemoryPtr& dstMemPtr);
 
     private:
@@ -52,6 +56,6 @@ class Roll : public Node {
     static constexpr size_t AXES_INDEX = 2ul;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/rope.cpp b/src/plugins/intel_cpu/src/nodes/rope.cpp
index 9144eaaae846bd..3edf4cb52a841a 100644
--- a/src/plugins/intel_cpu/src/nodes/rope.cpp
+++ b/src/plugins/intel_cpu/src/nodes/rope.cpp
@@ -4,16 +4,16 @@
 
 #include "rope.h"
 
+#include <chrono>
+#include <string>
+#include <vector>
+
 #include "common/bfloat16.hpp"
 #include "common/cpu_memcpy.h"
 #include "cpu/x64/cpu_isa_traits.hpp"
+#include "kernels/x64/rope_kernel.hpp"
 #include "shape_inference/shape_inference_internal_dyn.hpp"
 #include "utils/plain_tensor.hpp"
-#include "kernels/x64/rope_kernel.hpp"
-
-#include <chrono>
-#include <string>
-#include <vector>
 
 using namespace ov::intel_cpu::kernel;
 
@@ -32,7 +32,8 @@ RoPE::RoPE(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context
     m_config = node->get_config();
 }
 
-static std::shared_ptr<kernel::JitKernelBase> createJitKernel(const jit_rotary_compile_params& param, bool check_vec_size2 = false) {
+static std::shared_ptr<kernel::JitKernelBase> createJitKernel(const jit_rotary_compile_params& param,
+                                                              bool check_vec_size2 = false) {
     std::shared_ptr<kernel::JitKernelBase> res;
 
     MAYBE_UNUSED(param);
@@ -63,12 +64,16 @@ static std::shared_ptr<kernel::JitKernelBase> createJitKernel(const jit_rotary_c
     if (res)
         res->create_kernel();
 
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
     return res;
 }
 
-static void execJitKernel(const std::shared_ptr<kernel::JitKernelBase>& ker, const void* src, void* dst, const float* cos, const float* sin) {
+static void execJitKernel(const std::shared_ptr<kernel::JitKernelBase>& ker,
+                          const void* src,
+                          void* dst,
+                          const float* cos,
+                          const float* sin) {
     MAYBE_UNUSED(ker);
     MAYBE_UNUSED(src);
     MAYBE_UNUSED(dst);
@@ -84,7 +89,7 @@ static void execJitKernel(const std::shared_ptr<kernel::JitKernelBase>& ker, con
     call_args.dst = dst;
     (*ker)(&call_args);
 
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 }
 
 template <typename T>
@@ -325,10 +330,10 @@ struct RoPE::RoPEExecutorQwen : public RoPE::Executor {
     void execute(dnnl::stream strm,
                  const std::vector<MemoryPtr>& inputs,
                  const std::vector<MemoryPtr>& outputs) override {
-        ov::intel_cpu::PlainTensor t_src(inputs[0]);    // [batch, length, head_cnt*head_size * 3]
-        ov::intel_cpu::PlainTensor t_cos(inputs[1]);    // [1, present-kv-length, 1, rotary_dims]
-        ov::intel_cpu::PlainTensor t_sin(inputs[2]);    // [1, present-kv-length, 1, rotary_dims]
-        ov::intel_cpu::PlainTensor t_dst(outputs[0]);   // [batch, length, head_cnt, head_size]>
+        ov::intel_cpu::PlainTensor t_src(inputs[0]);   // [batch, length, head_cnt*head_size * 3]
+        ov::intel_cpu::PlainTensor t_cos(inputs[1]);   // [1, present-kv-length, 1, rotary_dims]
+        ov::intel_cpu::PlainTensor t_sin(inputs[2]);   // [1, present-kv-length, 1, rotary_dims]
+        ov::intel_cpu::PlainTensor t_dst(outputs[0]);  // [batch, length, head_cnt, head_size]>
         auto rotary_dims = t_cos.size(3);
 
         if (m_config.slice_stop - m_config.slice_start > 0) {
diff --git a/src/plugins/intel_cpu/src/nodes/scaled_attn.cpp b/src/plugins/intel_cpu/src/nodes/scaled_attn.cpp
index 837991ba068d08..9449f57e2d5f5c 100644
--- a/src/plugins/intel_cpu/src/nodes/scaled_attn.cpp
+++ b/src/plugins/intel_cpu/src/nodes/scaled_attn.cpp
@@ -24,22 +24,22 @@
 #endif
 
 #ifdef OV_CPU_WITH_ACL
-#     include "kernels/acl/gemm_kernel.hpp"
+#    include "kernels/acl/gemm_kernel.hpp"
 #endif
 
-#include "utils/plain_tensor.hpp"
-#include "kernels/scaled_attn/softmax.hpp"
-#include "kernels/scaled_attn/mha_single_token.hpp"
+#include <algorithm>
+#include <string>
+#include <vector>
+
 #include "kernels/scaled_attn/attn_memcpy.hpp"
 #include "kernels/scaled_attn/attn_quant.hpp"
+#include "kernels/scaled_attn/mha_single_token.hpp"
+#include "kernels/scaled_attn/softmax.hpp"
 #include "kernels/x64/brgemm_kernel.hpp"
 #include "nodes/common/cpu_convert.h"
+#include "utils/plain_tensor.hpp"
 #include "utils/precision_support.h"
 
-#include <algorithm>
-#include <string>
-#include <vector>
-
 using namespace ov::Extensions::Cpu::XARCH;
 using namespace dnnl::impl;
 using namespace dnnl::impl::cpu::x64;
@@ -193,7 +193,8 @@ struct MHAKernel {
                 }
 
                 // output [B, L1, H*head_size]
-                auto* out = has_out_transpose ? &output_emb.at<T>({b, m, h * head_size_v}) : &output_emb.at<T>({b, h, m});
+                auto* out =
+                    has_out_transpose ? &output_emb.at<T>({b, m, h * head_size_v}) : &output_emb.at<T>({b, h, m});
                 std::copy(word_vec.begin(), word_vec.end(), out);
             }
         });
@@ -251,8 +252,7 @@ struct MHAKernel<ScaledDotProductAttention::KT_ONEDNN, T> {
     std::shared_ptr<BrgemmKernel> wv_gemm_ptr = nullptr;
 
     MHAKernel() = delete;
-    explicit MHAKernel(GraphContext::CPtr ctx)
-        : context(ctx) {}
+    explicit MHAKernel(GraphContext::CPtr ctx) : context(ctx) {}
 
     dnnl::memory::dims make_dnnl_dims(const std::vector<size_t>& dims) {
         dnnl::memory::dims dnnl_dims(dims.size());
@@ -261,7 +261,11 @@ struct MHAKernel<ScaledDotProductAttention::KT_ONEDNN, T> {
         return dnnl_dims;
     }
 
-    void prepare_brgemm_prim(dnnl::stream strm, PlainTensor& query, PlainTensor& present_key, PlainTensor& present_value, bool has_out_transpose) {
+    void prepare_brgemm_prim(dnnl::stream strm,
+                             PlainTensor& query,
+                             PlainTensor& present_key,
+                             PlainTensor& present_value,
+                             bool has_out_transpose) {
         auto in_type = precision_of<T>::value;
         auto qkv_dt = DnnlExtensionUtils::ElementTypeToDataType(in_type);
         auto B = query.size(0);
@@ -409,24 +413,26 @@ struct MHAKernel<ScaledDotProductAttention::KT_ONEDNN, T> {
                 auto ncausal = auto_causal ? (kv_len - q_len + m + 1) : kv_len;
                 auto score = weight_score.ptr<float>(ithr, h, m - m_start);
                 attn_softmax(reinterpret_cast<void*>(score),
-                            reinterpret_cast<T*>(score),
-                            d_scale,
-                            reinterpret_cast<void*>(alibi_ptr + m * alibi_stride),
-                            attn_mask_ptr + m * attn_mask_stride,
-                            cmask_ptr + m * cmask_stride,
-                            select_nfltmax_at_0,
-                            ncausal,
-                            kv_len,
-                            precision_of<T>::value,
-                            precision_of<T>::value,
-                            precision_of<T>::value);
+                             reinterpret_cast<T*>(score),
+                             d_scale,
+                             reinterpret_cast<void*>(alibi_ptr + m * alibi_stride),
+                             attn_mask_ptr + m * attn_mask_stride,
+                             cmask_ptr + m * cmask_stride,
+                             select_nfltmax_at_0,
+                             ncausal,
+                             kv_len,
+                             precision_of<T>::value,
+                             precision_of<T>::value,
+                             precision_of<T>::value);
             }
             auto* w_ptr = reinterpret_cast<T*>(weight_score.ptr<float>(ithr, h, 0, 0));
             float* fp32_out_ptr;
             if (is_xf16) {
-                fp32_out_ptr = has_out_transpose ? &fp32_out.at<float>({b, m_start, h, 0}) : &fp32_out.at<float>({b, h, m_start, 0});
+                fp32_out_ptr = has_out_transpose ? &fp32_out.at<float>({b, m_start, h, 0})
+                                                 : &fp32_out.at<float>({b, h, m_start, 0});
             } else {
-                fp32_out_ptr = has_out_transpose ? &output_emb.at<float>({b, m_start, h * head_size_v}) : &output_emb.at<float>({b, h, m_start, 0});
+                fp32_out_ptr = has_out_transpose ? &output_emb.at<float>({b, m_start, h * head_size_v})
+                                                 : &output_emb.at<float>({b, h, m_start, 0});
             }
             T* v_ptr = is_xf16 ? &wv_scratch_b.at<T>({b, h / h_each_group_len, 0})
                                : &present_value.at<T>({b, h / h_each_group_len, 0, 0});
@@ -513,7 +519,7 @@ struct MHAKernel<ScaledDotProductAttention::KT_ACL, T> {
     ov::element::Type precision;
 
     MHAKernel() = delete;
-    explicit MHAKernel(GraphContext::CPtr ctx): context(ctx) {
+    explicit MHAKernel(GraphContext::CPtr ctx) : context(ctx) {
         m_block_size = 512;
         select_nfltmax_at_0 = false;
         precision = ov::element::from<T>();
@@ -599,8 +605,8 @@ struct MHAKernel<ScaledDotProductAttention::KT_ACL, T> {
 
             arm_compute::Strides qStrides({query.stride_bytes(3), query.stride_bytes(2)});
             arm_compute::Strides kStrides({present_key.stride_bytes(3), present_key.stride_bytes(2)});
-            qk_gemm.executeGemm(reinterpret_cast<void *>(q_ptr),
-                                reinterpret_cast<void *>(k_ptr),
+            qk_gemm.executeGemm(reinterpret_cast<void*>(q_ptr),
+                                reinterpret_cast<void*>(k_ptr),
                                 qkInfo,
                                 qkTensor,
                                 qStrides,
@@ -608,7 +614,6 @@ struct MHAKernel<ScaledDotProductAttention::KT_ACL, T> {
 
             auto qk = reinterpret_cast<T*>(qkTensor.buffer());
 
-
             for (size_t m = m_start; m < m_end; m++) {
                 // apply attention mask & sofmax
                 auto ncausal = auto_causal ? (kv_len - q_len + m + 1) : kv_len;
@@ -628,13 +633,14 @@ struct MHAKernel<ScaledDotProductAttention::KT_ACL, T> {
             arm_compute::TensorInfo outInfo;
             arm_compute::Tensor outTensor;
 
-            auto out = has_out_transpose ? &output_emb.at<T>({b, m_start, h * head_size_v}) : &output_emb.at<T>({b, h, m_start});
+            auto out = has_out_transpose ? &output_emb.at<T>({b, m_start, h * head_size_v})
+                                         : &output_emb.at<T>({b, h, m_start});
             auto strides = arm_compute::Strides({output_emb.stride_bytes(1), output_emb.stride_bytes(2)});
             GemmKernel out_gemm(m_cnt, kv_len, head_size_v, false, precision);
 
             arm_compute::Strides vStrides({present_value.stride_bytes(3), present_value.stride_bytes(2)});
             out_gemm.executeGemm(qkTensor.buffer(),
-                                 reinterpret_cast<void *>(v_ptr),
+                                 reinterpret_cast<void*>(v_ptr),
                                  outInfo,
                                  outTensor,
                                  qkInfo.strides_in_bytes(),
@@ -660,7 +666,7 @@ struct MHAKernel<ScaledDotProductAttention::KT_MLAS, float> {
     size_t m_threads_num = 0lu;
 
     MHAKernel() = delete;
-    explicit MHAKernel(GraphContext::CPtr ctx): context(ctx) {
+    explicit MHAKernel(GraphContext::CPtr ctx) : context(ctx) {
         m_block_size = 4;
         select_nfltmax_at_0 = false;
         m_threads_num = parallel_get_max_threads();
@@ -782,17 +788,17 @@ struct MHAKernel<ScaledDotProductAttention::KT_MLAS, float> {
                 // apply attention mask & sofmax
                 auto ncausal = auto_causal ? (kv_len - q_len + m + 1) : kv_len;
                 attn_softmax(reinterpret_cast<void*>(qk + (m - m_start) * qk_m_stride),
-                            qk + (m - m_start) * qk_m_stride,
-                            d_scale,
-                            reinterpret_cast<void*>(alibi_ptr + m * alibi_stride),
-                            attn_mask_ptr + m * attn_mask_stride,
-                            cmask_ptr + m * cmask_stride,
-                            select_nfltmax_at_0,
-                            ncausal,
-                            kv_len,
-                            ov::element::f32,
-                            ov::element::f32,
-                            ov::element::f32);
+                             qk + (m - m_start) * qk_m_stride,
+                             d_scale,
+                             reinterpret_cast<void*>(alibi_ptr + m * alibi_stride),
+                             attn_mask_ptr + m * attn_mask_stride,
+                             cmask_ptr + m * cmask_stride,
+                             select_nfltmax_at_0,
+                             ncausal,
+                             kv_len,
+                             ov::element::f32,
+                             ov::element::f32,
+                             ov::element::f32);
             }
             mlas_sgemm("N",
                        "N",
@@ -805,7 +811,8 @@ struct MHAKernel<ScaledDotProductAttention::KT_MLAS, float> {
                        v_ptr,
                        present_value.stride(2),
                        0.f,
-                       has_out_transpose ? &output_emb.at<float>({b, m_start, h * head_size_v}) : &output_emb.at<float>({b, h, m_start}),
+                       has_out_transpose ? &output_emb.at<float>({b, m_start, h * head_size_v})
+                                         : &output_emb.at<float>({b, h, m_start}),
                        has_out_transpose ? output_emb.stride(1) : output_emb.stride(2),
                        1);
         };
@@ -852,15 +859,28 @@ struct MHASingleToken {
 
         // aligned to cache line (64bytes=16*sizeof(float)) to avoid false sharing
         m_attn_w.resize<float>({B, H, q_len, (kv_len + 15) / 16 * 16});
-        mha_single_token(query, present_key, present_value, alibi_mask, attention_mask, beams,
-            output_emb, m_attn_w, m_temp, has_out_transpose, auto_causal, d_scale, k_scale_zp, v_scale_zp, m_head_sum);
+        mha_single_token(query,
+                         present_key,
+                         present_value,
+                         alibi_mask,
+                         attention_mask,
+                         beams,
+                         output_emb,
+                         m_attn_w,
+                         m_temp,
+                         has_out_transpose,
+                         auto_causal,
+                         d_scale,
+                         k_scale_zp,
+                         v_scale_zp,
+                         m_head_sum);
     }
 };
 
 template <ScaledDotProductAttention::KernelTypes KType, typename T>
 struct ScaledDotProductAttention::AttentionExecutor : public ScaledDotProductAttention::Executor {
     GraphContext::CPtr context;
-    PlainTensor attn_buf;          // f32[[B|1],[H|1], L1|1, L0+L1]
+    PlainTensor attn_buf;  // f32[[B|1],[H|1], L1|1, L0+L1]
 
     MHAKernel<KType, T> kernel;
     MHASingleToken kernel_single_token;
@@ -874,9 +894,15 @@ struct ScaledDotProductAttention::AttentionExecutor : public ScaledDotProductAtt
             attn_buf.ptr<float>()[i] = p[i] ? 0.0f : -FLT_MAX;
     }
 
-    void execute(dnnl::stream strm, const Config& config, const std::vector<MemoryPtr>& inputs, const MemoryPtr output,
-                 const MemoryPtr presentk_input, const MemoryPtr presentv_input, const MemoryPtr beam_input,
-                 const PlainTensor& k_scale_zp, const PlainTensor& v_scale_zp) override {
+    void execute(dnnl::stream strm,
+                 const Config& config,
+                 const std::vector<MemoryPtr>& inputs,
+                 const MemoryPtr output,
+                 const MemoryPtr presentk_input,
+                 const MemoryPtr presentv_input,
+                 const MemoryPtr beam_input,
+                 const PlainTensor& k_scale_zp,
+                 const PlainTensor& v_scale_zp) override {
         bool has_in_reshape = config.config.input_BLHxS;
         bool has_out_transpose = config.config.output_BLHxS;
         bool fuse_causal_attn = config.config.fuse_causal_attn;
@@ -884,10 +910,10 @@ struct ScaledDotProductAttention::AttentionExecutor : public ScaledDotProductAtt
         bool fuse_concat = config.config.fuse_concat;
         auto input_num = inputs.size();
         PlainTensor present_key, present_value;
-        PlainTensor q_input;           // f32[B, H, L1, S]
-        PlainTensor k_input;           // f32[B, H|1, L1, S] / [B, H|1, L0+L1, S]
-        PlainTensor v_input;           // f32[B, H|1, L1, S] / [B, H|1, L0+L1, S]
-        PlainTensor beam_table;        // i32[B, max_kvLen]
+        PlainTensor q_input;     // f32[B, H, L1, S]
+        PlainTensor k_input;     // f32[B, H|1, L1, S] / [B, H|1, L0+L1, S]
+        PlainTensor v_input;     // f32[B, H|1, L1, S] / [B, H|1, L0+L1, S]
+        PlainTensor beam_table;  // i32[B, max_kvLen]
         PlainTensor attn_mask;
         PlainTensor output_emb(output);
         float scale_input = 0.0f;
@@ -933,7 +959,7 @@ struct ScaledDotProductAttention::AttentionExecutor : public ScaledDotProductAtt
         }
 
         // q: [B, H, L1, S]
-        const auto & permute_axes = config.config.permute_axes;
+        const auto& permute_axes = config.config.permute_axes;
         if (!permute_axes.empty()) {
             q_input = q_input.permute(permute_axes);
             k_input = k_input.permute(permute_axes);
@@ -979,7 +1005,8 @@ struct ScaledDotProductAttention::AttentionExecutor : public ScaledDotProductAtt
                     if (attn_mask.m_rank == 2)
                         attn_mask = attn_mask.reshape({1, 1, attn_mask.m_dims[0], attn_mask.m_dims[1]});
                     else if (attn_mask.m_rank == 3)
-                        attn_mask = attn_mask.reshape({1, attn_mask.m_dims[0], attn_mask.m_dims[1], attn_mask.m_dims[2]});
+                        attn_mask =
+                            attn_mask.reshape({1, attn_mask.m_dims[0], attn_mask.m_dims[1], attn_mask.m_dims[2]});
                     auto_causal = false;
                     use_attn_mask = true;
                 } else {
@@ -993,21 +1020,40 @@ struct ScaledDotProductAttention::AttentionExecutor : public ScaledDotProductAtt
         bool use_one_token = L1 == 1 || (fuse_concat && L0 > 0);
         if (!use_one_token) {
             // multi-token version
-            kernel(strm, q_input, k_input, v_input, {}, use_attn_mask ? attn_mask : PlainTensor(),
-                   output_emb, has_out_transpose, auto_causal, scale_input);
+            kernel(strm,
+                   q_input,
+                   k_input,
+                   v_input,
+                   {},
+                   use_attn_mask ? attn_mask : PlainTensor(),
+                   output_emb,
+                   has_out_transpose,
+                   auto_causal,
+                   scale_input);
         } else {
             // 1-token version
             // for second token, using a special AVX2/AVX512 float path:
             //  1, in matrix mutiply, using AMX is not efficency because the M dimension of A will alway be 1
             //  2, using float will save the repack cost which typically is required for bf16/int8 opt
             //  3, using dot product can leverage the SIMD while easily adapt to indirect kv cache
-            kernel_single_token(q_input, present_key, present_value, {}, use_attn_mask ? attn_mask : PlainTensor(),
-                output_emb, beam_table, has_out_transpose, auto_causal, scale_input, k_scale_zp, v_scale_zp);
+            kernel_single_token(q_input,
+                                present_key,
+                                present_value,
+                                {},
+                                use_attn_mask ? attn_mask : PlainTensor(),
+                                output_emb,
+                                beam_table,
+                                has_out_transpose,
+                                auto_causal,
+                                scale_input,
+                                k_scale_zp,
+                                v_scale_zp);
         }
     }
 };
 
-ScaledDotProductAttention::ScaledDotProductAttention(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+ScaledDotProductAttention::ScaledDotProductAttention(const std::shared_ptr<ov::Node>& op,
+                                                     const GraphContext::CPtr context)
     : Node(op, context, SDPAShapeInferFactory(op)) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
@@ -1033,59 +1079,64 @@ void ScaledDotProductAttention::initSupportedPrimitiveDescriptors() {
     auto& creatorsMap = BlockedDescCreator::getCommonCreators();
     config.inConfs.resize(getOriginalInputsNumber());
     config.outConfs.resize(getOriginalOutputsNumber());
-    config.inConfs[0].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        rtPrecision, getInputShapeAtPort(0)));
-    config.inConfs[1].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        rtPrecision, getInputShapeAtPort(1)));
-    config.inConfs[2].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        rtPrecision, getInputShapeAtPort(2)));
+    config.inConfs[0].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)->createSharedDesc(rtPrecision, getInputShapeAtPort(0)));
+    config.inConfs[1].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)->createSharedDesc(rtPrecision, getInputShapeAtPort(1)));
+    config.inConfs[2].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)->createSharedDesc(rtPrecision, getInputShapeAtPort(2)));
     auto nextPortIdx = 3;
     if (orginSDPInputNumber > 3) {
         // attn_mask
         if (getOriginalInputPrecisionAtPort(nextPortIdx) == ov::element::u8) {
-            config.inConfs[nextPortIdx].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-                ov::element::u8, getInputShapeAtPort(nextPortIdx)));
+            config.inConfs[nextPortIdx].setMemDesc(
+                creatorsMap.at(LayoutType::ncsp)->createSharedDesc(ov::element::u8, getInputShapeAtPort(nextPortIdx)));
         } else {
-            config.inConfs[nextPortIdx].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-                rtPrecision, getInputShapeAtPort(nextPortIdx)));
+            config.inConfs[nextPortIdx].setMemDesc(
+                creatorsMap.at(LayoutType::ncsp)->createSharedDesc(rtPrecision, getInputShapeAtPort(nextPortIdx)));
         }
         nextPortIdx++;
     }
     if (orginSDPInputNumber > 4) {
-        config.inConfs[nextPortIdx].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-            ov::element::f32, getInputShapeAtPort(nextPortIdx)));
+        config.inConfs[nextPortIdx].setMemDesc(
+            creatorsMap.at(LayoutType::ncsp)->createSharedDesc(ov::element::f32, getInputShapeAtPort(nextPortIdx)));
     }
 
     if (m_config.config.fuse_concat) {
         // beam_idx
-        config.inConfs[orginSDPInputNumber + 0].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-            ov::element::i32, getInputShapeAtPort(orginSDPInputNumber + 0)));
+        config.inConfs[orginSDPInputNumber + 0].setMemDesc(
+            creatorsMap.at(LayoutType::ncsp)
+                ->createSharedDesc(ov::element::i32, getInputShapeAtPort(orginSDPInputNumber + 0)));
 
         // Since the InputMemory nodes are simple proxy for the state memory as well as the init subgraph memory,
         // it doesn't make sense to set the real KV cache precision, since we don't need any precision conversions
         // provided by the common graph logic. We set precisions equal to the precisions of the state nodes to avoid
         // reorder insertion in between MemoryInputSDPA and SDPA nodes.
 
-        auto past_k_input_mem_precision = getParentEdgeAt(orginSDPInputNumber + 1)->getParent()->getOriginalOutputPrecisionAtPort(0);
+        auto past_k_input_mem_precision =
+            getParentEdgeAt(orginSDPInputNumber + 1)->getParent()->getOriginalOutputPrecisionAtPort(0);
         // pastk
-        config.inConfs[orginSDPInputNumber + 1].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-            past_k_input_mem_precision, getInputShapeAtPort(orginSDPInputNumber + 1)));
+        config.inConfs[orginSDPInputNumber + 1].setMemDesc(
+            creatorsMap.at(LayoutType::ncsp)
+                ->createSharedDesc(past_k_input_mem_precision, getInputShapeAtPort(orginSDPInputNumber + 1)));
 
-        auto past_v_input_mem_precision = getParentEdgeAt(orginSDPInputNumber + 2)->getParent()->getOriginalOutputPrecisionAtPort(0);
+        auto past_v_input_mem_precision =
+            getParentEdgeAt(orginSDPInputNumber + 2)->getParent()->getOriginalOutputPrecisionAtPort(0);
         // pastv
-        config.inConfs[orginSDPInputNumber + 2].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-            past_v_input_mem_precision, getInputShapeAtPort(orginSDPInputNumber + 2)));
+        config.inConfs[orginSDPInputNumber + 2].setMemDesc(
+            creatorsMap.at(LayoutType::ncsp)
+                ->createSharedDesc(past_v_input_mem_precision, getInputShapeAtPort(orginSDPInputNumber + 2)));
 
-        config.outConfs[1].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-            past_k_input_mem_precision, getOutputShapeAtPort(1)));
+        config.outConfs[1].setMemDesc(
+            creatorsMap.at(LayoutType::ncsp)->createSharedDesc(past_k_input_mem_precision, getOutputShapeAtPort(1)));
         config.outConfs[1].inPlace(-1);
-        config.outConfs[2].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-            past_v_input_mem_precision, getOutputShapeAtPort(2)));
+        config.outConfs[2].setMemDesc(
+            creatorsMap.at(LayoutType::ncsp)->createSharedDesc(past_v_input_mem_precision, getOutputShapeAtPort(2)));
         config.outConfs[2].inPlace(-1);
     }
 
-    config.outConfs[0].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-        rtPrecision, getOutputShapeAtPort(0)));
+    config.outConfs[0].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)->createSharedDesc(rtPrecision, getOutputShapeAtPort(0)));
 
     supportedPrimitiveDescriptors.emplace_back(config, impl_desc_type::ref_any);
 }
@@ -1112,15 +1163,15 @@ void ScaledDotProductAttention::createPrimitive() {
                 executor = std::make_shared<AttentionExecutor<KT_REF, ov::float16>>(context);
             }
         } else {
-#ifdef OV_CPU_WITH_MLAS
+#    ifdef OV_CPU_WITH_MLAS
             executor = std::make_shared<AttentionExecutor<KT_MLAS, float>>(context);
-#else
+#    else
             if (with_cpu_x86_avx512_core()) {
                 executor = std::make_shared<AttentionExecutor<KT_ONEDNN, float>>(context);
             } else {
                 executor = std::make_shared<AttentionExecutor<KT_REF, float>>(context);
             }
-#endif
+#    endif
         }
 #elif defined(OV_CPU_WITH_ACL)
         if (rtPrecision == ov::element::f16) {
@@ -1137,7 +1188,8 @@ void ScaledDotProductAttention::createPrimitive() {
     auto cache = context->getParamsCache();
     auto result = cache->getOrCreate(key, builder);
     if (!result.first) {
-        OPENVINO_THROW("ScaledDotProductAttention AttentionExecutor creation fails with precision " + rtPrecision.to_string());
+        OPENVINO_THROW("ScaledDotProductAttention AttentionExecutor creation fails with precision " +
+                       rtPrecision.to_string());
     }
     m_executor = result.first;
 }
@@ -1166,10 +1218,12 @@ void ScaledDotProductAttention::execute(dnnl::stream strm) {
         presentk_input = inputs[1];
         presentv_input = inputs[2];
     }
-    m_executor->execute(strm, m_config, inputs, output, presentk_input, presentv_input, beam_input, k_scale_zp, v_scale_zp);
+    m_executor
+        ->execute(strm, m_config, inputs, output, presentk_input, presentv_input, beam_input, k_scale_zp, v_scale_zp);
 }
 
-bool ScaledDotProductAttention::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool ScaledDotProductAttention::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                                     std::string& errorMessage) noexcept {
     try {
         auto sdpaWithTransposeReshapeOp = std::dynamic_pointer_cast<const SDPAWithTransposeReshape>(op);
         if (!std::dynamic_pointer_cast<const ov::op::v13::ScaledDotProductAttention>(op) &&
@@ -1225,8 +1279,12 @@ void ScaledDotProductAttention::assignState(const std::shared_ptr<VariableStateK
     } else if (inputNumber - 1 == static_cast<size_t>(idx)) {
         m_v_state = state;
     } else {
-        OPENVINO_THROW(
-            "Unexpected idx ", idx , " for a state in a node with type: ", getTypeStr(), " and name ", getName());
+        OPENVINO_THROW("Unexpected idx ",
+                       idx,
+                       " for a state in a node with type: ",
+                       getTypeStr(),
+                       " and name ",
+                       getName());
     }
 }
 
@@ -1239,7 +1297,9 @@ std::vector<T> permute_axes(const std::vector<T>& shape, const std::vector<size_
     return results;
 }
 
-void ScaledDotProductAttention::resetBeamTablePastkv(const MemoryPtr& mem_cur_k, const MemoryPtr& mem_cur_v, const MemoryPtr& mem_beam_idx) {
+void ScaledDotProductAttention::resetBeamTablePastkv(const MemoryPtr& mem_cur_k,
+                                                     const MemoryPtr& mem_cur_v,
+                                                     const MemoryPtr& mem_beam_idx) {
     std::vector<size_t> order = {0, 1, 2, 3};
     if (!m_config.config.permute_axes.empty()) {
         order = m_config.config.permute_axes;
@@ -1268,7 +1328,7 @@ void ScaledDotProductAttention::resetBeamTablePastkv(const MemoryPtr& mem_cur_k,
     auto L1 = cur_k.size(2);
     auto S = cur_k.size(3);
     auto SV = cur_v.size(3);
-    auto reverse = [&order] (const std::vector<size_t>& cur) {
+    auto reverse = [&order](const std::vector<size_t>& cur) {
         std::vector<size_t> result(cur.size());
         for (size_t i = 0; i < cur.size(); i++) {
             result[order[i]] = cur[i];
@@ -1279,16 +1339,21 @@ void ScaledDotProductAttention::resetBeamTablePastkv(const MemoryPtr& mem_cur_k,
     // 1. check beam idx if it's valid
     auto* table = beam_idx.ptr<int32_t>();
     for (size_t i = 0; i < B; i++) {
-        OPENVINO_ASSERT(static_cast<size_t>(table[i]) < B_state, "beam_idx[", i, "]=", table[i],
-            " should less than batch of previous pastkv: ", B_state);
+        OPENVINO_ASSERT(static_cast<size_t>(table[i]) < B_state,
+                        "beam_idx[",
+                        i,
+                        "]=",
+                        table[i],
+                        " should less than batch of previous pastkv: ",
+                        B_state);
     }
 
     // 2. resize pastkv
     ov::element::Type kvcache_precision = m_k_state->internal_desc()->getPrecision();
     {
-        // shape is the shape used by the original model which maybe different from BHLS, reverse here is to permute BHLS to original model shape.
-        // BHLS is the stated input shape of SDPA, however internally we use LBHS for KV-cache storage.
-        // real_order is used to permute the original shape to LBHS
+        // shape is the shape used by the original model which maybe different from BHLS, reverse here is to permute
+        // BHLS to original model shape. BHLS is the stated input shape of SDPA, however internally we use LBHS for
+        // KV-cache storage. real_order is used to permute the original shape to LBHS
         std::vector<size_t> shape = reverse({B, H, (L0 + L1) * 2, S});
         auto mem_desc_k = std::make_shared<CpuBlockedMemoryDesc>(kvcache_precision,
                                                                  Shape(shape),
@@ -1375,9 +1440,12 @@ void ScaledDotProductAttention::resetBeamTablePastkv(const MemoryPtr& mem_cur_k,
         if (kvcache_precision == ov::element::u8) {
             // past_k's shape is BHLS, internal layout LBHS
             // scale_zp's shape is LBHS, internal layout LBHS
-            attn_quantkv(cur_k, cur_v,
-                new_pastk.slice(2, L0, L0 + L1), new_pastv.slice(2, L0, L0 + L1),
-                m_k_state->get_scale_zp().slice(0, L0, L0 + L1), m_v_state->get_scale_zp().slice(0, L0, L0 + L1));
+            attn_quantkv(cur_k,
+                         cur_v,
+                         new_pastk.slice(2, L0, L0 + L1),
+                         new_pastv.slice(2, L0, L0 + L1),
+                         m_k_state->get_scale_zp().slice(0, L0, L0 + L1),
+                         m_v_state->get_scale_zp().slice(0, L0, L0 + L1));
         } else {
             attn_memcpy(cur_k, cur_v, new_pastk.slice(2, L0, L0 + L1), new_pastv.slice(2, L0, L0 + L1));
         }
@@ -1406,12 +1474,12 @@ void ScaledDotProductAttention::resetBeamTablePastkv(const MemoryPtr& mem_cur_k,
 
         std::vector<size_t> new_shape{B, (L0 + L1)};
         mem_desc = std::make_shared<CpuBlockedMemoryDesc>(ov::element::i32,
-            Shape(new_shape),
-            new_shape,
-            VectorDims{0, 1},
-            0,
-            VectorDims{},
-            mem_desc->getStrides());
+                                                          Shape(new_shape),
+                                                          new_shape,
+                                                          VectorDims{0, 1},
+                                                          0,
+                                                          VectorDims{},
+                                                          mem_desc->getStrides());
         new_hidden_state_k->redefineDesc(mem_desc);
         new_hidden_state_v->redefineDesc(mem_desc);
 
@@ -1422,7 +1490,9 @@ void ScaledDotProductAttention::resetBeamTablePastkv(const MemoryPtr& mem_cur_k,
     }
 }
 
-void ScaledDotProductAttention::gatherConcatPastkv(const MemoryPtr& mem_cur_k, const MemoryPtr& mem_cur_v, const MemoryPtr& mem_beam_idx) {
+void ScaledDotProductAttention::gatherConcatPastkv(const MemoryPtr& mem_cur_k,
+                                                   const MemoryPtr& mem_cur_v,
+                                                   const MemoryPtr& mem_beam_idx) {
     PlainTensor cur_k;
     cur_k.reset(mem_cur_k);
     auto inputNumber = getOriginalInputsNumber();
@@ -1447,7 +1517,8 @@ void ScaledDotProductAttention::gatherConcatPastkv(const MemoryPtr& mem_cur_k, c
 }
 
 // Update beam table using beam_idx. For first token, beam table is like [[0, 0, 0, ...], [1, 1, 1, ...], ...],
-//   for second token, beam table is updated using gather(beam_table, beam_idx) then appending [0, 1, 2, ...] to the end for itself.
+//   for second token, beam table is updated using gather(beam_table, beam_idx) then appending [0, 1, 2, ...] to the end
+//   for itself.
 void ScaledDotProductAttention::updateBeamTable(const MemoryPtr& mem_beam_idx, size_t L1) {
     std::vector<size_t> order = {0, 1, 2, 3};
     if (!m_config.config.permute_axes.empty()) {
@@ -1465,8 +1536,8 @@ void ScaledDotProductAttention::updateBeamTable(const MemoryPtr& mem_beam_idx, s
     size_t L0 = v_dims.at(order[2]);
     auto B_state = v_dims.at(order[0]);
     OPENVINO_ASSERT(m_k_state->is_reset_state() == m_v_state->is_reset_state(),
-        "KV state must be reset simultaneously, please also reset state for ",
-        (m_k_state->is_reset_state() ? m_v_state->get_name() : m_k_state->get_name()));
+                    "KV state must be reset simultaneously, please also reset state for ",
+                    (m_k_state->is_reset_state() ? m_v_state->get_name() : m_k_state->get_name()));
     OPENVINO_ASSERT(B == B_state, "beam idx batch: ", B, " is not equal to batch of state: ", B_state);
     OPENVINO_ASSERT(B * (L0 + L1) > 0, "B or (L0+L1) is zero, B: ", B, ", L0: ", L0, ", L1: ", L1);
     // resize buffer
@@ -1495,7 +1566,7 @@ void ScaledDotProductAttention::updateBeamTable(const MemoryPtr& mem_beam_idx, s
         hidden_state_v = new_hidden_state_v;
         beam_table_k = new_beam_table_k;
         beam_table_v = new_beam_table_v;
-    }  else if (is_reset) {
+    } else if (is_reset) {
         // when reset and not resize, just reset the desc
         need_redefine = false;
         auto size = m_k_state->hidden_state_max_size();
@@ -1505,24 +1576,25 @@ void ScaledDotProductAttention::updateBeamTable(const MemoryPtr& mem_beam_idx, s
         strides[1] = 1;
         std::vector<size_t> new_shape{B, (L0 + L1)};
         auto mem_desc = std::make_shared<CpuBlockedMemoryDesc>(ov::element::i32,
-            Shape(new_shape),
-            new_shape,
-            VectorDims{0, 1},
-            0,
-            VectorDims{},
-            strides);
+                                                               Shape(new_shape),
+                                                               new_shape,
+                                                               VectorDims{0, 1},
+                                                               0,
+                                                               VectorDims{},
+                                                               strides);
         hidden_state_k->redefineDesc(mem_desc);
         hidden_state_v->redefineDesc(mem_desc);
     }
     if (need_redefine) {
         std::vector<size_t> new_shape{B, (L0 + L1)};
-        auto mem_desc = std::make_shared<CpuBlockedMemoryDesc>(ov::element::i32,
-            Shape(new_shape),
-            new_shape,
-            VectorDims{0, 1},
-            0,
-            VectorDims{},
-            hidden_state_k->getDescWithType<BlockedMemoryDesc>()->getStrides());
+        auto mem_desc =
+            std::make_shared<CpuBlockedMemoryDesc>(ov::element::i32,
+                                                   Shape(new_shape),
+                                                   new_shape,
+                                                   VectorDims{0, 1},
+                                                   0,
+                                                   VectorDims{},
+                                                   hidden_state_k->getDescWithType<BlockedMemoryDesc>()->getStrides());
         hidden_state_k->redefineDesc(mem_desc);
         hidden_state_v->redefineDesc(mem_desc);
     }
@@ -1557,14 +1629,10 @@ void ScaledDotProductAttention::updateBeamTable(const MemoryPtr& mem_beam_idx, s
         auto* table = beam_idx.ptr<int32_t>();
         // beam table is same for both k,v state
         for (size_t i = 0; i < B; i++) {
-            std::memcpy(beam_table_k.ptr<int32_t>(i),
-                        beam_table_v.ptr<int32_t>(table[i]),
-                        sizeof(int32_t) * L0);
+            std::memcpy(beam_table_k.ptr<int32_t>(i), beam_table_v.ptr<int32_t>(table[i]), sizeof(int32_t) * L0);
         }
         for (size_t i = 0; i < B; i++) {
-            std::memcpy(beam_table_v.ptr<int32_t>(i),
-                        beam_table_k.ptr<int32_t>(i),
-                        sizeof(int32_t) * L0);
+            std::memcpy(beam_table_v.ptr<int32_t>(i), beam_table_k.ptr<int32_t>(i), sizeof(int32_t) * L0);
         }
     }
     // second token itself
@@ -1596,7 +1664,7 @@ void ScaledDotProductAttention::updatePastkv(const MemoryPtr& mem_cur_k, const M
     auto L1 = cur_k.size(2);
     auto S = cur_k.size(3);
     auto SV = cur_v.size(3);
-    auto reverse = [&order] (const std::vector<size_t>& cur) {
+    auto reverse = [&order](const std::vector<size_t>& cur) {
         std::vector<size_t> result(cur.size());
         for (size_t i = 0; i < cur.size(); i++) {
             result[order[i]] = cur[i];
@@ -1617,13 +1685,14 @@ void ScaledDotProductAttention::updatePastkv(const MemoryPtr& mem_cur_k, const M
     ov::element::Type kvcache_precision = m_k_state->internal_desc()->getPrecision();
     bool need_redefine = true;
     if (B * H * (L0 + L1) * S > m_k_state->internal_state_max_size()) {
-        // new_shape is the shape used by the original model which maybe different from BHLS, reverse here is to permute BHLS to original model shape.
-        // BHLS is the stated input shape of SDPA, however internally we use LBHS for KV-cache storage.
-        // real_order is used to permute the original shape to LBHS
-        auto new_memory = [&] (size_t new_S) {
+        // new_shape is the shape used by the original model which maybe different from BHLS, reverse here is to permute
+        // BHLS to original model shape. BHLS is the stated input shape of SDPA, however internally we use LBHS for
+        // KV-cache storage. real_order is used to permute the original shape to LBHS
+        auto new_memory = [&](size_t new_S) {
             std::vector<size_t> new_shape = reverse({B, H, (L0 + L1) * 2, new_S});
             auto real_shape = permute_axes(new_shape, real_order);
-            auto mem_desc = std::make_shared<CpuBlockedMemoryDesc>(kvcache_precision, Shape(new_shape), real_shape, real_order);
+            auto mem_desc =
+                std::make_shared<CpuBlockedMemoryDesc>(kvcache_precision, Shape(new_shape), real_shape, real_order);
             return std::make_shared<Memory>(getEngine(), mem_desc);
         };
 
@@ -1671,23 +1740,24 @@ void ScaledDotProductAttention::updatePastkv(const MemoryPtr& mem_cur_k, const M
     } else if (is_reset) {
         // when reset and not resize, just reset the desc
         need_redefine = false;
-        // new_shape is the shape used by the original model which maybe different from BHLS, reverse here is to permute BHLS to original model shape.
-        // BHLS is the stated input shape of SDPA, however internally we use LBHS for KV-cache storage.
-        // real_order is used to permute the original shape to LBHS
-        auto reset_desc = [&] (size_t new_S) {
+        // new_shape is the shape used by the original model which maybe different from BHLS, reverse here is to permute
+        // BHLS to original model shape. BHLS is the stated input shape of SDPA, however internally we use LBHS for
+        // KV-cache storage. real_order is used to permute the original shape to LBHS
+        auto reset_desc = [&](size_t new_S) {
             std::vector<size_t> new_shape = reverse({B, H, (L0 + L1), new_S});
             VectorDims strides(new_shape.size(), 1);
             auto real_shape = permute_axes(new_shape, real_order);
             for (size_t i = 2; i <= real_shape.size(); i++) {
-                strides[real_shape.size() - i] = strides[real_shape.size() - (i-1)] * real_shape[real_shape.size() - (i-1)];
+                strides[real_shape.size() - i] =
+                    strides[real_shape.size() - (i - 1)] * real_shape[real_shape.size() - (i - 1)];
             }
             return std::make_shared<CpuBlockedMemoryDesc>(kvcache_precision,
-                Shape(new_shape),
-                real_shape,
-                real_order,
-                0,
-                VectorDims{},
-                strides);
+                                                          Shape(new_shape),
+                                                          real_shape,
+                                                          real_order,
+                                                          0,
+                                                          VectorDims{},
+                                                          strides);
         };
         internal_mem_k->redefineDesc(reset_desc(S));
         internal_mem_v->redefineDesc(reset_desc(SV));
@@ -1703,19 +1773,19 @@ void ScaledDotProductAttention::updatePastkv(const MemoryPtr& mem_cur_k, const M
         }
     }
     if (need_redefine) {
-        // new_shape is the shape used by the original model which maybe different from BHLS, reverse here is to permute BHLS to original model shape.
-        // BHLS is the stated input shape of SDPA, however internally we use LBHS for KV-cache storage.
-        // real_order is used to permute the original shape to LBHS
-        auto redefine_desc = [&] (MemoryPtr& mem, size_t new_S) {
+        // new_shape is the shape used by the original model which maybe different from BHLS, reverse here is to permute
+        // BHLS to original model shape. BHLS is the stated input shape of SDPA, however internally we use LBHS for
+        // KV-cache storage. real_order is used to permute the original shape to LBHS
+        auto redefine_desc = [&](MemoryPtr& mem, size_t new_S) {
             std::vector<size_t> new_shape = reverse({B, H, (L0 + L1), new_S});
             auto real_shape = permute_axes(new_shape, real_order);
             return std::make_shared<CpuBlockedMemoryDesc>(kvcache_precision,
-                                                    Shape(new_shape),
-                                                    real_shape,
-                                                    real_order,
-                                                    0,
-                                                    VectorDims{},
-                                                    mem->getDescWithType<BlockedMemoryDesc>()->getStrides());
+                                                          Shape(new_shape),
+                                                          real_shape,
+                                                          real_order,
+                                                          0,
+                                                          VectorDims{},
+                                                          mem->getDescWithType<BlockedMemoryDesc>()->getStrides());
         };
         internal_mem_k->redefineDesc(redefine_desc(internal_mem_k, S));
         internal_mem_v->redefineDesc(redefine_desc(internal_mem_v, SV));
@@ -1750,9 +1820,12 @@ void ScaledDotProductAttention::updatePastkv(const MemoryPtr& mem_cur_k, const M
     if (kvcache_precision == ov::element::u8) {
         // past_k's shape is BHLS, internal layout LBHS
         // scale_zp's shape is LBHS, internal layout LBHS
-        attn_quantkv(cur_k, cur_v,
-            past_k.slice(2, L0, L0 + L1), past_v.slice(2, L0, L0 + L1),
-            m_k_state->get_scale_zp().slice(0, L0, L0 + L1), m_v_state->get_scale_zp().slice(0, L0, L0 + L1));
+        attn_quantkv(cur_k,
+                     cur_v,
+                     past_k.slice(2, L0, L0 + L1),
+                     past_v.slice(2, L0, L0 + L1),
+                     m_k_state->get_scale_zp().slice(0, L0, L0 + L1),
+                     m_v_state->get_scale_zp().slice(0, L0, L0 + L1));
     } else {
         attn_memcpy(cur_k, cur_v, past_k.slice(2, L0, L0 + L1), past_v.slice(2, L0, L0 + L1));
     }
@@ -1763,7 +1836,7 @@ ov::element::Type ScaledDotProductAttention::getKVCachePrecision() {
     auto rtPrecision = getRuntimePrecision();
     auto kvCachePrecisionHint = context->getConfig().kvCachePrecision;
     bool enableKVCacheFP16 = m_config.config.fuse_concat && mayiuse(cpu_isa_t::avx2) &&
-        rtPrecision != ov::element::bf16 && kvCachePrecisionHint == ov::element::f16;
+                             rtPrecision != ov::element::bf16 && kvCachePrecisionHint == ov::element::f16;
     kvcache_precision = enableKVCacheFP16 ? ov::element::f16 : rtPrecision;
     bool use_int8_kv_cache_precision = kvCachePrecisionHint == ov::element::u8;
     if (use_int8_kv_cache_precision)
diff --git a/src/plugins/intel_cpu/src/nodes/scaled_attn.h b/src/plugins/intel_cpu/src/nodes/scaled_attn.h
index bbf12727478e43..21b9056ba9517c 100644
--- a/src/plugins/intel_cpu/src/nodes/scaled_attn.h
+++ b/src/plugins/intel_cpu/src/nodes/scaled_attn.h
@@ -36,7 +36,7 @@ class ScaledDotProductAttention : public Node {
     void createPrimitive() override;
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
-    enum KernelTypes { KT_REF, KT_ONEDNN, KT_MLAS, KT_ACL};
+    enum KernelTypes { KT_REF, KT_ONEDNN, KT_MLAS, KT_ACL };
 
     void assignState(const std::shared_ptr<VariableStateKVcache>& state, int idx);
 
@@ -62,15 +62,22 @@ class ScaledDotProductAttention : public Node {
     };
 
     struct Executor {
-        virtual void execute(dnnl::stream strm, const Config& config, const std::vector<MemoryPtr>& inputs, const MemoryPtr output,
-                             const MemoryPtr presentk_input, const MemoryPtr presentv_input, const MemoryPtr beam_input,
-                             const PlainTensor& k_scale_zp, const PlainTensor& v_scale_zp) = 0;
+        virtual void execute(dnnl::stream strm,
+                             const Config& config,
+                             const std::vector<MemoryPtr>& inputs,
+                             const MemoryPtr output,
+                             const MemoryPtr presentk_input,
+                             const MemoryPtr presentv_input,
+                             const MemoryPtr beam_input,
+                             const PlainTensor& k_scale_zp,
+                             const PlainTensor& v_scale_zp) = 0;
         virtual ~Executor() = default;
     };
 
     Config m_config;
     std::shared_ptr<Executor> m_executor;
-    template <KernelTypes KType, typename T> struct AttentionExecutor;
+    template <KernelTypes KType, typename T>
+    struct AttentionExecutor;
     friend struct ScaledDotProductAttentionKey;
 
     std::shared_ptr<VariableStateKVcache> m_k_state;
diff --git a/src/plugins/intel_cpu/src/nodes/scatter_update.cpp b/src/plugins/intel_cpu/src/nodes/scatter_update.cpp
index 3934f4f5bc0120..5b96d2fec2e2bc 100644
--- a/src/plugins/intel_cpu/src/nodes/scatter_update.cpp
+++ b/src/plugins/intel_cpu/src/nodes/scatter_update.cpp
@@ -4,6 +4,10 @@
 
 #include "scatter_update.h"
 
+#include <algorithm>
+#include <string>
+#include <vector>
+
 #include "common/cpu_memcpy.h"
 #include "dnnl_extension_utils.h"
 #include "onednn/dnnl.h"
@@ -12,9 +16,6 @@
 #include "openvino/op/scatter_nd_update.hpp"
 #include "openvino/op/scatter_update.hpp"
 #include "selective_build.h"
-#include <algorithm>
-#include <string>
-#include <vector>
 
 using namespace dnnl;
 
@@ -22,7 +23,8 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 
-bool ScatterUpdate::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool ScatterUpdate::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                         std::string& errorMessage) noexcept {
     try {
         if (!one_of(op->get_type_info(),
                     ov::op::v3::ScatterElementsUpdate::get_type_info_static(),
@@ -36,14 +38,28 @@ bool ScatterUpdate::isSupportedOperation(const std::shared_ptr<const ov::Node>&
         }
         if (const auto node_element = ov::as_type_ptr<const ov::op::v12::ScatterElementsUpdate>(op)) {
             using Reduction = ov::op::v12::ScatterElementsUpdate::Reduction;
-            if (!one_of(node_element->get_reduction(), Reduction::MAX, Reduction::MEAN, Reduction::MIN, Reduction::NONE, Reduction::PROD, Reduction::SUM)) {
-                errorMessage = "ScatterElementsUpdate CPU does not support reduction mode: " + ov::as_string(node_element->get_reduction());
+            if (!one_of(node_element->get_reduction(),
+                        Reduction::MAX,
+                        Reduction::MEAN,
+                        Reduction::MIN,
+                        Reduction::NONE,
+                        Reduction::PROD,
+                        Reduction::SUM)) {
+                errorMessage = "ScatterElementsUpdate CPU does not support reduction mode: " +
+                               ov::as_string(node_element->get_reduction());
                 return false;
             }
         } else if (const auto node_element = ov::as_type_ptr<const ov::op::v15::ScatterNDUpdate>(op)) {
             using Reduction = ov::op::v15::ScatterNDUpdate::Reduction;
-            if (!one_of(node_element->get_reduction(), Reduction::MAX, Reduction::MIN, Reduction::NONE, Reduction::PROD, Reduction::SUM, Reduction::SUB)) {
-                errorMessage = "ScatterNDUpdate CPU does not support reduction mode: " + ov::as_string(node_element->get_reduction());
+            if (!one_of(node_element->get_reduction(),
+                        Reduction::MAX,
+                        Reduction::MIN,
+                        Reduction::NONE,
+                        Reduction::PROD,
+                        Reduction::SUM,
+                        Reduction::SUB)) {
+                errorMessage = "ScatterNDUpdate CPU does not support reduction mode: " +
+                               ov::as_string(node_element->get_reduction());
                 return false;
             }
         }
@@ -99,51 +115,53 @@ ScatterUpdate::ScatterUpdate(const std::shared_ptr<ov::Node>& op, const GraphCon
     if (const auto node_element = ov::as_type_ptr<const ov::op::v12::ScatterElementsUpdate>(op)) {
         using OpReduction = ov::op::v12::ScatterElementsUpdate::Reduction;
         switch (node_element->get_reduction()) {
-            case OpReduction::SUM:
-                reduction_type = ScatterUpdate::Reduction::SUM;
-                break;
-            case OpReduction::PROD:
-                reduction_type = ScatterUpdate::Reduction::PROD;
-                break;
-            case OpReduction::MEAN:
-                reduction_type = ScatterUpdate::Reduction::MEAN;
-                break;
-            case OpReduction::MAX:
-                reduction_type = ScatterUpdate::Reduction::MAX;
-                break;
-            case OpReduction::MIN:
-                reduction_type = ScatterUpdate::Reduction::MIN;
-                break;
-            case OpReduction::NONE:
-                reduction_type = ScatterUpdate::Reduction::NONE;
-                break;
-            default:
-                THROW_CPU_NODE_ERR("ScatterElementsUpdate CPU does not support reduction mode: ", ov::as_string(node_element->get_reduction()));
+        case OpReduction::SUM:
+            reduction_type = ScatterUpdate::Reduction::SUM;
+            break;
+        case OpReduction::PROD:
+            reduction_type = ScatterUpdate::Reduction::PROD;
+            break;
+        case OpReduction::MEAN:
+            reduction_type = ScatterUpdate::Reduction::MEAN;
+            break;
+        case OpReduction::MAX:
+            reduction_type = ScatterUpdate::Reduction::MAX;
+            break;
+        case OpReduction::MIN:
+            reduction_type = ScatterUpdate::Reduction::MIN;
+            break;
+        case OpReduction::NONE:
+            reduction_type = ScatterUpdate::Reduction::NONE;
+            break;
+        default:
+            THROW_CPU_NODE_ERR("ScatterElementsUpdate CPU does not support reduction mode: ",
+                               ov::as_string(node_element->get_reduction()));
         }
         use_init_val = node_element->get_use_init_val();
     } else if (const auto node_element = ov::as_type_ptr<const ov::op::v15::ScatterNDUpdate>(op)) {
         using OpReduction = ov::op::v15::ScatterNDUpdate::Reduction;
         switch (node_element->get_reduction()) {
-            case OpReduction::SUM:
-                reduction_type = ScatterUpdate::Reduction::SUM;
-                break;
-            case OpReduction::PROD:
-                reduction_type = ScatterUpdate::Reduction::PROD;
-                break;
-            case OpReduction::SUB:
-                reduction_type = ScatterUpdate::Reduction::SUB;
-                break;
-            case OpReduction::MAX:
-                reduction_type = ScatterUpdate::Reduction::MAX;
-                break;
-            case OpReduction::MIN:
-                reduction_type = ScatterUpdate::Reduction::MIN;
-                break;
-            case OpReduction::NONE:
-                reduction_type = ScatterUpdate::Reduction::NONE;
-                break;
-            default:
-                THROW_CPU_NODE_ERR("ScatterNDUpdate CPU does not support reduction mode: ", ov::as_string(node_element->get_reduction()));
+        case OpReduction::SUM:
+            reduction_type = ScatterUpdate::Reduction::SUM;
+            break;
+        case OpReduction::PROD:
+            reduction_type = ScatterUpdate::Reduction::PROD;
+            break;
+        case OpReduction::SUB:
+            reduction_type = ScatterUpdate::Reduction::SUB;
+            break;
+        case OpReduction::MAX:
+            reduction_type = ScatterUpdate::Reduction::MAX;
+            break;
+        case OpReduction::MIN:
+            reduction_type = ScatterUpdate::Reduction::MIN;
+            break;
+        case OpReduction::NONE:
+            reduction_type = ScatterUpdate::Reduction::NONE;
+            break;
+        default:
+            THROW_CPU_NODE_ERR("ScatterNDUpdate CPU does not support reduction mode: ",
+                               ov::as_string(node_element->get_reduction()));
         }
     }
 }
@@ -161,7 +179,7 @@ void ScatterUpdate::initSupportedPrimitiveDescriptors() {
 
     const auto& srcDataDim = getInputShapeAtPort(DATA_ID).getDims();
     const auto& indicesDim = getInputShapeAtPort(INDICES_ID).getDims();
-    const auto& updateDim =  getInputShapeAtPort(UPDATE_ID).getDims();
+    const auto& updateDim = getInputShapeAtPort(UPDATE_ID).getDims();
     const auto& dstDataDim = getOutputShapeAtPort(0).getDims();
 
     size_t srcRank = srcDataDim.size();
@@ -188,64 +206,64 @@ void ScatterUpdate::initSupportedPrimitiveDescriptors() {
     }
     // specific check
     switch (scatterUpdateMode) {
-        case ScatterUpdateMode::ScatterUpdate: {
-            if (updateRank != (srcRank + indicesRank - 1)) {
+    case ScatterUpdateMode::ScatterUpdate: {
+        if (updateRank != (srcRank + indicesRank - 1)) {
+            THROW_CPU_NODE_ERR(errorPrefix,
+                               " do not have matched tensor rank relationship for input, indices and update");
+        }
+        break;
+    }
+    case ScatterUpdateMode::ScatterNDUpdate: {
+        if (indicesDim[indicesRank - 1] != Shape::UNDEFINED_DIM) {
+            size_t k = indicesDim[indicesRank - 1];
+            if (k > srcRank) {
                 THROW_CPU_NODE_ERR(errorPrefix,
-                                   " do not have matched tensor rank relationship for input, indices and update");
+                                   "' do not have an correct indices' last dimension value, ",
+                                   "which should be smaller than or equal to input tensor rank");
             }
-            break;
-        }
-        case ScatterUpdateMode::ScatterNDUpdate: {
-            if (indicesDim[indicesRank - 1] != Shape::UNDEFINED_DIM) {
-                size_t k = indicesDim[indicesRank - 1];
-                if (k > srcRank) {
-                    THROW_CPU_NODE_ERR(errorPrefix,
-                                       "' do not have an correct indices' last dimension value, ",
-                                       "which should be smaller than or equal to input tensor rank");
-                }
 
-                size_t tupleRank = indicesRank - 1;
-                VectorDims expectUpdateShape(tupleRank + srcRank - k, 0);
-                if (isUpdateScalar) {
-                    // Workaround to properly identify rank of scalar
-                    updateRank = 0;
-                }
-                int updateAxisIter = 0;
-                for (size_t ri = 0; ri < tupleRank; ri++) {
-                    expectUpdateShape[updateAxisIter] = indicesDim[ri];
-                    updateAxisIter++;
-                }
-                for (size_t rd = k; rd < srcRank; rd++) {
-                    expectUpdateShape[updateAxisIter] = srcDataDim[rd];
-                    updateAxisIter++;
-                }
-                if (expectUpdateShape.size() != updateRank) {
-                    THROW_CPU_NODE_ERR(errorPrefix,
-                                       " do not have matched tensor rank relationship for input, indices and update");
-                }
-                for (size_t ru = 0; ru < updateRank; ru++) {
-                    if (!dimsEqualWeak(updateDim[ru], expectUpdateShape[ru])) {
-                        THROW_CPU_NODE_ERR(errorPrefix,
-                                           " do not have matched tensor shape relationship for input, indices and update");
-                    }
-                }
+            size_t tupleRank = indicesRank - 1;
+            VectorDims expectUpdateShape(tupleRank + srcRank - k, 0);
+            if (isUpdateScalar) {
+                // Workaround to properly identify rank of scalar
+                updateRank = 0;
             }
-            break;
-        }
-        case ScatterUpdateMode::ScatterElementsUpdate: {
-            if (srcRank != indicesRank || srcRank != updateRank) {
-                THROW_CPU_NODE_ERR(errorPrefix, " do not have the same tensor rank for input, indices and update");
+            int updateAxisIter = 0;
+            for (size_t ri = 0; ri < tupleRank; ri++) {
+                expectUpdateShape[updateAxisIter] = indicesDim[ri];
+                updateAxisIter++;
             }
-            for (size_t ri = 0; ri < indicesRank; ri++) {
-                if (!dimsEqualWeak(indicesDim[ri], updateDim[ri])) {
-                    THROW_CPU_NODE_ERR(errorPrefix, " do not have the same tensor shape for indices and update");
+            for (size_t rd = k; rd < srcRank; rd++) {
+                expectUpdateShape[updateAxisIter] = srcDataDim[rd];
+                updateAxisIter++;
+            }
+            if (expectUpdateShape.size() != updateRank) {
+                THROW_CPU_NODE_ERR(errorPrefix,
+                                   " do not have matched tensor rank relationship for input, indices and update");
+            }
+            for (size_t ru = 0; ru < updateRank; ru++) {
+                if (!dimsEqualWeak(updateDim[ru], expectUpdateShape[ru])) {
+                    THROW_CPU_NODE_ERR(errorPrefix,
+                                       " do not have matched tensor shape relationship for input, indices and update");
                 }
             }
-            break;
         }
-        default: {
-            THROW_CPU_NODE_ERR(errorPrefix, " is not supported");
+        break;
+    }
+    case ScatterUpdateMode::ScatterElementsUpdate: {
+        if (srcRank != indicesRank || srcRank != updateRank) {
+            THROW_CPU_NODE_ERR(errorPrefix, " do not have the same tensor rank for input, indices and update");
+        }
+        for (size_t ri = 0; ri < indicesRank; ri++) {
+            if (!dimsEqualWeak(indicesDim[ri], updateDim[ri])) {
+                THROW_CPU_NODE_ERR(errorPrefix, " do not have the same tensor shape for indices and update");
+            }
         }
+        break;
+    }
+    default: {
+        THROW_CPU_NODE_ERR(errorPrefix, " is not supported");
+    }
     }
 
     indicesPrec = getOriginalInputPrecisionAtPort(INDICES_ID);
@@ -294,7 +312,7 @@ void ScatterUpdate::initSupportedPrimitiveDescriptors() {
         inPortConfig.emplace_back(LayoutType::ncsp, axisPrec);
     addSupportedPrimDesc(inPortConfig,
                          {{LayoutType::ncsp, dataPrec, false, canBeInplace ? 0 : -1}},
-                          impl_desc_type::unknown);
+                         impl_desc_type::unknown);
 }
 
 bool ScatterUpdate::needPrepareParams() const {
@@ -305,14 +323,14 @@ void ScatterUpdate::executeDynamicImpl(dnnl::stream strm) {
     execute(strm);
 }
 
-int64_t ScatterUpdate::getIndicesValue(uint8_t *indices, size_t offset) {
-    auto *indicesPtr = indices + offset * indicesSize;
+int64_t ScatterUpdate::getIndicesValue(uint8_t* indices, size_t offset) {
+    auto* indicesPtr = indices + offset * indicesSize;
     int64_t ret = 0;
     if (indicesSize == 4) {
-        auto *indicesPtr32 = reinterpret_cast<int32_t*>(indicesPtr);
+        auto* indicesPtr32 = reinterpret_cast<int32_t*>(indicesPtr);
         ret = *indicesPtr32;
     } else {
-        auto *indicesPtr64 = reinterpret_cast<int64_t*>(indicesPtr);
+        auto* indicesPtr64 = reinterpret_cast<int64_t*>(indicesPtr);
         ret = *indicesPtr64;
     }
     return ret;
@@ -326,7 +344,7 @@ static std::vector<size_t> getBlockND(const VectorDims& shape) {
     size_t shapeRank = shape.size();
     std::vector<size_t> blockND(shapeRank + 1, 1);
     for (int i = shapeRank - 1; i >= 0; i--) {
-        blockND[i] = shape[i] * blockND[i+1];
+        blockND[i] = shape[i] * blockND[i + 1];
     }
     return blockND;
 }
@@ -360,11 +378,15 @@ static inline void getCoordinate(VectorDims& coordinate, size_t offset, const Ve
 }
 
 struct TensorIterator {
-    TensorIterator(const VectorDims& squashed_shape, const int64_t squashed_axis) : m_squashed_shape(squashed_shape), m_squashed_axis(squashed_axis) {
+    TensorIterator(const VectorDims& squashed_shape, const int64_t squashed_axis)
+        : m_squashed_shape(squashed_shape),
+          m_squashed_axis(squashed_axis) {
         OPENVINO_ASSERT(m_squashed_shape[m_squashed_axis] == 1);
     }
 
-    std::array<size_t, 2> startover(const size_t start, const std::vector<size_t>& dataBlockND, const std::vector<size_t>& indicesBlockND) {
+    std::array<size_t, 2> startover(const size_t start,
+                                    const std::vector<size_t>& dataBlockND,
+                                    const std::vector<size_t>& indicesBlockND) {
         m_tensorIter.resize(m_squashed_shape.size(), 0);
         getCoordinate(m_tensorIter, start, m_squashed_shape);
 
@@ -381,10 +403,12 @@ struct TensorIterator {
         return {dst_idx, indices_idx};
     }
 
-    void increment(std::array<size_t, 2>& offsets, const std::vector<size_t>& dataBlockND, const std::vector<size_t>& indicesBlockND) {
+    void increment(std::array<size_t, 2>& offsets,
+                   const std::vector<size_t>& dataBlockND,
+                   const std::vector<size_t>& indicesBlockND) {
         for (int64_t j = m_squashed_shape.size() - 1; j >= 0; j--) {
             m_tensorIter[j]++;
-            if (m_tensorIter[j] < m_squashed_shape[j]) { // no need check if (j != axis) as it is squashed
+            if (m_tensorIter[j] < m_squashed_shape[j]) {  // no need check if (j != axis) as it is squashed
                 offsets[0] += dataBlockND[j + 1];
                 offsets[1] += indicesBlockND[j + 1];
                 break;
@@ -418,18 +442,21 @@ struct ScatterElementsUpdateContext {
 };
 
 // tier 2 dispatcher with Reduce which follows up DataType.
-template<typename PT>
+template <typename PT>
 struct ScatterElementsUpdateReduceDispatcher {
     void operator()(ScatterElementsUpdateContext& ctx) {
         using kernel_t = typename PT::second_type;
         using data_t = typename PT::first_type;
-        ctx.node->scatterElementsUpdate<data_t>(ctx.dstMemPtr, ctx.indicesMemPtr, ctx.updateMemPtr, ctx.axis,
+        ctx.node->scatterElementsUpdate<data_t>(ctx.dstMemPtr,
+                                                ctx.indicesMemPtr,
+                                                ctx.updateMemPtr,
+                                                ctx.axis,
                                                 kernel_t{});
     }
 };
 
 // tier 1 dispatcher with DataType
-template<typename DataType>
+template <typename DataType>
 struct ScatterElementsUpdateDispatcher {
     void operator()(ScatterElementsUpdateContext& ctx) {
         scatterElementsUpdate_dispatch(ctx);
@@ -445,18 +472,18 @@ struct ScatterElementsUpdateDispatcher {
         using DT_MUL = std::pair<DataType, ReduceMultiply>;
         using DT_MEAN = std::pair<DataType, ReduceMean>;
         OV_SWITCH(intel_cpu,
-                ScatterElementsUpdateReduceDispatcher,
-                ctx,
-                ctx.reduction_type,
-                OV_CASE(ScatterUpdate::Reduction::NONE, DT_NONE),
-                OV_CASE(ScatterUpdate::Reduction::SUM,  DT_SUM),
-                OV_CASE(ScatterUpdate::Reduction::MAX,  DT_MAX),
-                OV_CASE(ScatterUpdate::Reduction::MIN,  DT_MIN),
-                OV_CASE(ScatterUpdate::Reduction::PROD, DT_MUL),
-                OV_CASE(ScatterUpdate::Reduction::MEAN, DT_MEAN));
+                  ScatterElementsUpdateReduceDispatcher,
+                  ctx,
+                  ctx.reduction_type,
+                  OV_CASE(ScatterUpdate::Reduction::NONE, DT_NONE),
+                  OV_CASE(ScatterUpdate::Reduction::SUM, DT_SUM),
+                  OV_CASE(ScatterUpdate::Reduction::MAX, DT_MAX),
+                  OV_CASE(ScatterUpdate::Reduction::MIN, DT_MIN),
+                  OV_CASE(ScatterUpdate::Reduction::PROD, DT_MUL),
+                  OV_CASE(ScatterUpdate::Reduction::MEAN, DT_MEAN));
     }
 };
-};   // namespace scatter_elements_update
+};  // namespace scatter_elements_update
 
 namespace scatter_nd_update {
 struct ScatterNDUpdateContext {
@@ -468,27 +495,25 @@ struct ScatterNDUpdateContext {
 };
 
 // tier 2 dispatcher with Reduce which follows up DataType.
-template<typename PT>
+template <typename PT>
 struct ScatterNDUpdateReduceDispatcher {
     void operator()(ScatterNDUpdateContext& ctx) {
         using kernel_t = typename PT::second_type;
         using data_t = typename PT::first_type;
-        ctx.node->scatterNDUpdate<data_t>(ctx.dstMemPtr, ctx.indicesMemPtr, ctx.updateMemPtr,
-                                                kernel_t{});
+        ctx.node->scatterNDUpdate<data_t>(ctx.dstMemPtr, ctx.indicesMemPtr, ctx.updateMemPtr, kernel_t{});
     }
 };
 
 // tier 2 dispatcher with ReduceNone that does not depend on DatType
-template<>
+template <>
 struct ScatterNDUpdateReduceDispatcher<scatter_reductions::ReduceNone> {
     void operator()(ScatterNDUpdateContext& ctx) {
-        ctx.node->scatterNDUpdate(ctx.dstMemPtr, ctx.indicesMemPtr, ctx.updateMemPtr,
-                                  scatter_reductions::ReduceNone{});
+        ctx.node->scatterNDUpdate(ctx.dstMemPtr, ctx.indicesMemPtr, ctx.updateMemPtr, scatter_reductions::ReduceNone{});
     }
 };
 
 // tier 1 dispatcher with DataType
-template<typename DataType>
+template <typename DataType>
 struct ScatterNDUpdateDispatcher {
     void operator()(ScatterNDUpdateContext& ctx) {
         scatterNDUpdate_dispatch(ctx);
@@ -505,29 +530,32 @@ struct ScatterNDUpdateDispatcher {
         using DT_MIN = std::pair<DataType, ReduceMinimum>;
         using DT_MUL = std::pair<DataType, ReduceMultiply>;
         OV_SWITCH(intel_cpu,
-                ScatterNDUpdateReduceDispatcher,
-                ctx,
-                ctx.reduction_type,
-                OV_CASE(ScatterUpdate::Reduction::NONE, DT_NONE),
-                OV_CASE(ScatterUpdate::Reduction::SUM,  DT_SUM),
-                OV_CASE(ScatterUpdate::Reduction::SUB,  DT_SUB),
-                OV_CASE(ScatterUpdate::Reduction::MAX,  DT_MAX),
-                OV_CASE(ScatterUpdate::Reduction::MIN,  DT_MIN),
-                OV_CASE(ScatterUpdate::Reduction::PROD, DT_MUL));
+                  ScatterNDUpdateReduceDispatcher,
+                  ctx,
+                  ctx.reduction_type,
+                  OV_CASE(ScatterUpdate::Reduction::NONE, DT_NONE),
+                  OV_CASE(ScatterUpdate::Reduction::SUM, DT_SUM),
+                  OV_CASE(ScatterUpdate::Reduction::SUB, DT_SUB),
+                  OV_CASE(ScatterUpdate::Reduction::MAX, DT_MAX),
+                  OV_CASE(ScatterUpdate::Reduction::MIN, DT_MIN),
+                  OV_CASE(ScatterUpdate::Reduction::PROD, DT_MUL));
     }
 };
-};   // namespace scatter_nd_update
+};  // namespace scatter_nd_update
 
 // output[indices[i][j][k]][j][k] = updates[i][j][k] if axis = 0,
 // output[i][indices[i][j][k]][k] = updates[i][j][k] if axis = 1,
 // output[i][j][indices[i][j][k]] = updates[i][j][k] if axis = 2.
 template <typename DataType, typename KernelType>
-void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data, const MemoryPtr& mem_indices, const MemoryPtr& mem_updates,
-                            int axis, const KernelType& kernel) {
+void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data,
+                                          const MemoryPtr& mem_indices,
+                                          const MemoryPtr& mem_updates,
+                                          int axis,
+                                          const KernelType& kernel) {
     using namespace scatter_elements_update;
-    DataType *dataPtr = mem_data->getDataAs<DataType>();
-    DataType *updatePtr = mem_updates->getDataAs<DataType>();
-    uint8_t *indicesPtr = mem_indices->getDataAs<uint8_t>();
+    DataType* dataPtr = mem_data->getDataAs<DataType>();
+    DataType* updatePtr = mem_updates->getDataAs<DataType>();
+    uint8_t* indicesPtr = mem_indices->getDataAs<uint8_t>();
 
     const auto& data_shape = mem_data->getStaticDims();
     const auto& indices_shape = mem_indices->getStaticDims();
@@ -554,16 +582,17 @@ void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data, const Memor
         splitter(shape_size(squashed_indices_shape), nthr, ithr, start, end);
         scatter_elements_update::TensorIterator tensorItr(squashed_indices_shape, axis);
 
-        // When *use_init_val* attribute is false, we need to substitute the copied values at target locations with values that
-        // will not affect the particular reduction algorithms.
+        // When *use_init_val* attribute is false, we need to substitute the copied values at target locations with
+        // values that will not affect the particular reduction algorithms.
         if (!use_init_val) {
             const auto value = reduction_neutral_value<DataType>(reduction_type);
             auto offsets = tensorItr.startover(start, dataBlockND, indicesBlockND);
             for (size_t worker = start; worker < end; worker++) {
                 auto indices_offset = offsets[1];
                 for (size_t idx = 0; idx < index_dim_size; idx++) {
-                    int64_t idxValue =  getIndicesValue(indicesPtr, indices_offset);
-                    if (idxValue < 0) idxValue += data_dim_size;
+                    int64_t idxValue = getIndicesValue(indicesPtr, indices_offset);
+                    if (idxValue < 0)
+                        idxValue += data_dim_size;
                     assert(idxValue < data_dim_size && idxValue >= 0);
                     dataPtr[offsets[0] + idxValue * dataBlock_axisplus1] = value;
                     indices_offset += indicesBlock_axisplus1;
@@ -582,8 +611,9 @@ void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data, const Memor
             for (size_t worker = start; worker < end; worker++) {
                 auto indices_offset = offsets[1];
                 for (size_t idx = 0; idx < index_dim_size; idx++) {
-                    int64_t idxValue =  getIndicesValue(indicesPtr, indices_offset);
-                    if (idxValue < 0) idxValue += data_dim_size;
+                    int64_t idxValue = getIndicesValue(indicesPtr, indices_offset);
+                    if (idxValue < 0)
+                        idxValue += data_dim_size;
                     assert(idxValue < data_dim_size && idxValue >= 0);
                     auto dst = &dataPtr[offsets[0] + idxValue * dataBlock_axisplus1];
                     auto src = &updatePtr[indices_offset];
@@ -594,15 +624,18 @@ void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data, const Memor
                 tensorItr.increment(offsets, dataBlockND, indicesBlockND);
             }
         } else {
-            // For better performance, the offsets of dst and indices are cached in the first iteration of outer loop, and reused
-            // in the remaining iterations.
-            std::vector<size_t> dst_offsets(end-start+1, offsets[0]);  // one extra to avoid overflow at the last iteration of inner loop
-            std::vector<size_t> indices_offsets(end-start+1, offsets[1]);
-            size_t *ptr_dst_offset = &dst_offsets[0];
-            size_t *ptr_indices_offset = &indices_offsets[0];
-            for (size_t worker = start; worker < end; worker++) { // idx = 0
-                int64_t idxValue =  getIndicesValue(indicesPtr, *ptr_indices_offset);
-                if (idxValue < 0) idxValue += data_dim_size;
+            // For better performance, the offsets of dst and indices are cached in the first iteration of outer loop,
+            // and reused in the remaining iterations.
+            std::vector<size_t> dst_offsets(
+                end - start + 1,
+                offsets[0]);  // one extra to avoid overflow at the last iteration of inner loop
+            std::vector<size_t> indices_offsets(end - start + 1, offsets[1]);
+            size_t* ptr_dst_offset = &dst_offsets[0];
+            size_t* ptr_indices_offset = &indices_offsets[0];
+            for (size_t worker = start; worker < end; worker++) {  // idx = 0
+                int64_t idxValue = getIndicesValue(indicesPtr, *ptr_indices_offset);
+                if (idxValue < 0)
+                    idxValue += data_dim_size;
                 assert(idxValue < data_dim_size && idxValue >= 0);
                 auto dst = &dataPtr[ptr_dst_offset[0] + idxValue * dataBlock_axisplus1];
                 auto src = &updatePtr[ptr_indices_offset[0]];
@@ -618,8 +651,9 @@ void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data, const Memor
                 ptr_dst_offset = &dst_offsets[0];
                 for (size_t worker = start; worker < end; worker++) {
                     auto indices_offset = *ptr_indices_offset + idx * indicesBlock_axisplus1;
-                    int64_t idxValue =  getIndicesValue(indicesPtr, indices_offset);
-                    if (idxValue < 0) idxValue += data_dim_size;
+                    int64_t idxValue = getIndicesValue(indicesPtr, indices_offset);
+                    if (idxValue < 0)
+                        idxValue += data_dim_size;
                     assert(idxValue < data_dim_size && idxValue >= 0);
                     auto dst = &dataPtr[ptr_dst_offset[0] + idxValue * dataBlock_axisplus1];
                     auto src = &updatePtr[indices_offset];
@@ -635,13 +669,16 @@ void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data, const Memor
 // We specialize ReduceMean to avoid spoil performance of other reduce methods, as otherwise condition branch
 // were used in loops.
 template <typename DataType>
-void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data, const MemoryPtr& mem_indices, const MemoryPtr& mem_updates,
-                                          int axis, const scatter_reductions::ReduceMean& kernel) {
+void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data,
+                                          const MemoryPtr& mem_indices,
+                                          const MemoryPtr& mem_updates,
+                                          int axis,
+                                          const scatter_reductions::ReduceMean& kernel) {
     using namespace scatter_elements_update;
     OPENVINO_ASSERT(reduction_type == ScatterUpdate::Reduction::MEAN, "The reduction type should be MEAN here.");
-    DataType *dataPtr = mem_data->getDataAs<DataType>();
-    DataType *updatePtr = mem_updates->getDataAs<DataType>();
-    uint8_t *indicesPtr = mem_indices->getDataAs<uint8_t>();
+    DataType* dataPtr = mem_data->getDataAs<DataType>();
+    DataType* updatePtr = mem_updates->getDataAs<DataType>();
+    uint8_t* indicesPtr = mem_indices->getDataAs<uint8_t>();
 
     const auto& data_shape = mem_data->getStaticDims();
     const auto& indices_shape = mem_indices->getStaticDims();
@@ -668,16 +705,17 @@ void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data, const Memor
         splitter(shape_size(squashed_indices_shape), nthr, ithr, start, end);
         scatter_elements_update::TensorIterator tensorItr(squashed_indices_shape, axis);
 
-        // When *use_init_val* attribute is false, we need to substitute the copied values at target locations with values that
-        // will not affect the particular reduction algorithms.
+        // When *use_init_val* attribute is false, we need to substitute the copied values at target locations with
+        // values that will not affect the particular reduction algorithms.
         if (!use_init_val) {
             const auto value = reduction_neutral_value<DataType>(reduction_type);
             auto offsets = tensorItr.startover(start, dataBlockND, indicesBlockND);
             for (size_t worker = start; worker < end; worker++) {
                 auto indices_offset = offsets[1];
                 for (size_t idx = 0; idx < index_dim_size; idx++) {
-                    int64_t idxValue =  getIndicesValue(indicesPtr, indices_offset);
-                    if (idxValue < 0) idxValue += data_dim_size;
+                    int64_t idxValue = getIndicesValue(indicesPtr, indices_offset);
+                    if (idxValue < 0)
+                        idxValue += data_dim_size;
                     assert(idxValue < data_dim_size && idxValue >= 0);
                     dataPtr[offsets[0] + idxValue * dataBlock_axisplus1] = value;
                     indices_offset += indicesBlock_axisplus1;
@@ -698,8 +736,9 @@ void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data, const Memor
 
                 auto indices_offset = offsets[1];
                 for (size_t idx = 0; idx < index_dim_size; idx++) {
-                    int64_t idxValue =  getIndicesValue(indicesPtr, indices_offset);
-                    if (idxValue < 0) idxValue += data_dim_size;
+                    int64_t idxValue = getIndicesValue(indicesPtr, indices_offset);
+                    if (idxValue < 0)
+                        idxValue += data_dim_size;
                     assert(idxValue < data_dim_size && idxValue >= 0);
                     auto dst = &dataPtr[offsets[0] + idxValue * dataBlock_axisplus1];
                     auto src = &updatePtr[indices_offset];
@@ -720,17 +759,20 @@ void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data, const Memor
                 tensorItr.increment(offsets, dataBlockND, indicesBlockND);
             }
         } else {
-            // For better performance, the offsets of dst and indices are cached in the first iteration of outer loop, and reused
-            // in the remaining iterations.
-            std::unordered_map<DataType*, int64_t> mean_reduction_counters;     // (dst_addr, num_sums) for all workers
-
-            std::vector<size_t> dst_offsets(end-start+1, offsets[0]);  // one extra to avoid overflow at the last iteration of inner loop
-            std::vector<size_t> indices_offsets(end-start+1, offsets[1]);
-            size_t *ptr_dst_offset = &dst_offsets[0];
-            size_t *ptr_indices_offset = &indices_offsets[0];
-            for (size_t worker = start; worker < end; worker++) { // idx = 0
-                int64_t idxValue =  getIndicesValue(indicesPtr, *ptr_indices_offset);
-                if (idxValue < 0) idxValue += data_dim_size;
+            // For better performance, the offsets of dst and indices are cached in the first iteration of outer loop,
+            // and reused in the remaining iterations.
+            std::unordered_map<DataType*, int64_t> mean_reduction_counters;  // (dst_addr, num_sums) for all workers
+
+            std::vector<size_t> dst_offsets(
+                end - start + 1,
+                offsets[0]);  // one extra to avoid overflow at the last iteration of inner loop
+            std::vector<size_t> indices_offsets(end - start + 1, offsets[1]);
+            size_t* ptr_dst_offset = &dst_offsets[0];
+            size_t* ptr_indices_offset = &indices_offsets[0];
+            for (size_t worker = start; worker < end; worker++) {  // idx = 0
+                int64_t idxValue = getIndicesValue(indicesPtr, *ptr_indices_offset);
+                if (idxValue < 0)
+                    idxValue += data_dim_size;
                 assert(idxValue < data_dim_size && idxValue >= 0);
                 auto dst = &dataPtr[ptr_dst_offset[0] + idxValue * dataBlock_axisplus1];
                 auto src = &updatePtr[ptr_indices_offset[0]];
@@ -748,8 +790,9 @@ void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data, const Memor
                 ptr_dst_offset = &dst_offsets[0];
                 for (size_t worker = start; worker < end; worker++) {
                     auto indices_offset = *ptr_indices_offset + idx * indicesBlock_axisplus1;
-                    int64_t idxValue =  getIndicesValue(indicesPtr, indices_offset);
-                    if (idxValue < 0) idxValue += data_dim_size;
+                    int64_t idxValue = getIndicesValue(indicesPtr, indices_offset);
+                    if (idxValue < 0)
+                        idxValue += data_dim_size;
                     assert(idxValue < data_dim_size && idxValue >= 0);
                     auto dst = &dataPtr[ptr_dst_offset[0] + idxValue * dataBlock_axisplus1];
                     auto src = &updatePtr[indices_offset];
@@ -770,7 +813,10 @@ void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& mem_data, const Memor
     });
 }
 
-void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& dstMemPtr, const MemoryPtr& indicesMemPtr, const MemoryPtr& updateMemPtr, int axis) {
+void ScatterUpdate::scatterElementsUpdate(const MemoryPtr& dstMemPtr,
+                                          const MemoryPtr& indicesMemPtr,
+                                          const MemoryPtr& updateMemPtr,
+                                          int axis) {
     using namespace scatter_elements_update;
     ScatterElementsUpdateContext ctx{this, dstMemPtr, indicesMemPtr, updateMemPtr, axis, reduction_type};
     OV_SWITCH(intel_cpu,
@@ -791,10 +837,10 @@ void ScatterUpdate::execute(dnnl::stream strm) {
     auto indicesMemPtr = getSrcMemoryAtPort(INDICES_ID);
     auto updateMemPtr = getSrcMemoryAtPort(UPDATE_ID);
 
-    uint8_t *dstPtr = dstMemPtr->getDataAs<uint8_t>();
-    uint8_t *srcPtr = srcMemPtr->getDataAs<uint8_t>();
-    uint8_t *indicesPtr = indicesMemPtr->getDataAs<uint8_t>();
-    uint8_t *updatePtr = updateMemPtr->getDataAs<uint8_t>();
+    uint8_t* dstPtr = dstMemPtr->getDataAs<uint8_t>();
+    uint8_t* srcPtr = srcMemPtr->getDataAs<uint8_t>();
+    uint8_t* indicesPtr = indicesMemPtr->getDataAs<uint8_t>();
+    uint8_t* updatePtr = updateMemPtr->getDataAs<uint8_t>();
 
     const auto& srcDataDim = getParentEdgeAt(DATA_ID)->getMemory().getStaticDims();
     const auto& indicesDim = getParentEdgeAt(INDICES_ID)->getMemory().getStaticDims();
@@ -825,18 +871,18 @@ void ScatterUpdate::execute(dnnl::stream strm) {
     int axis = 0;
     if (axisRelaxed) {
         auto axisMemPtr = getSrcMemoryAtPort(AXIS_ID);
-        uint8_t *axisPtr = axisMemPtr->getDataAs<uint8_t>();
+        uint8_t* axisPtr = axisMemPtr->getDataAs<uint8_t>();
         if (axisSize == 4) {
-            auto *axisPtr32 = reinterpret_cast<int32_t*>(axisPtr);
+            auto* axisPtr32 = reinterpret_cast<int32_t*>(axisPtr);
             axis = *axisPtr32;
         } else {
-            auto *axisPtr64 = reinterpret_cast<int64_t*>(axisPtr);
+            auto* axisPtr64 = reinterpret_cast<int64_t*>(axisPtr);
             axis = *axisPtr64;
         }
 
-        if (axis >= static_cast<int>(srcRank) || axis < (static_cast<int>(srcRank) * - 1)) {
+        if (axis >= static_cast<int>(srcRank) || axis < (static_cast<int>(srcRank) * -1)) {
             THROW_CPU_NODE_ERR(errorPrefix,
-            " should have axis value in range [-r, r - 1], where r is the rank of input data");
+                               " should have axis value in range [-r, r - 1], where r is the rank of input data");
         }
         axis = axis < 0 ? (axis + srcRank) : axis;
 
@@ -846,11 +892,11 @@ void ScatterUpdate::execute(dnnl::stream strm) {
             size_t start = 0, end = 0;
             splitter(indicesBlockND[0], nthr, ithr, start, end);
             for (size_t i = start; i < end; i++) {
-                int64_t idxValue =  getIndicesValue(indicesPtr, i);
+                int64_t idxValue = getIndicesValue(indicesPtr, i);
                 if (idxValue >= static_cast<int64_t>(srcDimAxis) ||
                     (idxValue < 0 && scatterUpdateMode != ScatterUpdateMode::ScatterElementsUpdate)) {
                     THROW_CPU_NODE_ERR(errorPrefix,
-                    " have indices value that points to non-existing output tensor element");
+                                       " have indices value that points to non-existing output tensor element");
                 }
             }
         });
@@ -875,14 +921,14 @@ void ScatterUpdate::execute(dnnl::stream strm) {
             }
             if (updateRank > expectUpdateShape.size())
                 THROW_CPU_NODE_ERR(errorPrefix,
-                               " cannot update shape. New rank: ",
-                               updateRank,
-                               ", expected: ",
-                               expectUpdateShape.size());
+                                   " cannot update shape. New rank: ",
+                                   updateRank,
+                                   ", expected: ",
+                                   expectUpdateShape.size());
             for (size_t ru = 0; ru < updateRank; ru++) {
                 if (updateDim[ru] != expectUpdateShape[ru]) {
                     THROW_CPU_NODE_ERR(errorPrefix,
-                    " do not have matched tensor shape relationship for input, indices and update");
+                                       " do not have matched tensor shape relationship for input, indices and update");
                 }
             }
         }
@@ -904,28 +950,28 @@ void ScatterUpdate::execute(dnnl::stream strm) {
     }
 
     switch (scatterUpdateMode) {
-        case ScatterUpdateMode::ScatterUpdate: {
-            scatterUpdate(indicesPtr, updatePtr, axis, dstPtr);
-            break;
-        }
-        case ScatterUpdateMode::ScatterNDUpdate: {
-            scatterNDUpdate(dstMemPtr, indicesMemPtr, updateMemPtr);
-            break;
-        }
-        case ScatterUpdateMode::ScatterElementsUpdate: {
-            scatterElementsUpdate(dstMemPtr, indicesMemPtr, updateMemPtr, axis);
-            break;
-        }
-        default: {
-            THROW_CPU_NODE_ERR(errorPrefix, " is not supported");
-        }
+    case ScatterUpdateMode::ScatterUpdate: {
+        scatterUpdate(indicesPtr, updatePtr, axis, dstPtr);
+        break;
+    }
+    case ScatterUpdateMode::ScatterNDUpdate: {
+        scatterNDUpdate(dstMemPtr, indicesMemPtr, updateMemPtr);
+        break;
+    }
+    case ScatterUpdateMode::ScatterElementsUpdate: {
+        scatterElementsUpdate(dstMemPtr, indicesMemPtr, updateMemPtr, axis);
+        break;
+    }
+    default: {
+        THROW_CPU_NODE_ERR(errorPrefix, " is not supported");
+    }
     }
 }
 
 // For the data tensor of shape [d_0, d_1, ..., d_n],
 // and indices tensor of shape [i_0, i_1, ..., i_k].
 // Updates tensor shape should be [d_0, d_1, ... d_(axis - 1), i_0, i_1, ..., i_k, d_(axis + 1), ..., d_n].
-void ScatterUpdate::scatterUpdate(uint8_t *indices, uint8_t *update, int axis, uint8_t *dstData) {
+void ScatterUpdate::scatterUpdate(uint8_t* indices, uint8_t* update, int axis, uint8_t* dstData) {
     const auto& srcDataDim = getParentEdgeAt(DATA_ID)->getMemory().getStaticDims();
     const auto& indicesDim = getParentEdgeAt(INDICES_ID)->getMemory().getStaticDims();
     const auto& updateDim = getParentEdgeAt(UPDATE_ID)->getMemory().getStaticDims();
@@ -949,13 +995,15 @@ void ScatterUpdate::scatterUpdate(uint8_t *indices, uint8_t *update, int axis, u
 
     parallel_for2d(batchToUpdate, idxLength, [&](size_t b, size_t idx) {
         int64_t idxValue = getIndicesValue(indices, idx);
-        uint8_t *dstEntry = dstData + (b * srcBlockND[axis] + idxValue * blockToUpdate) * dataSize;
-        uint8_t *updateEntry = update + (b * updateBlockND[axis] + idx * blockToUpdate) * dataSize;
+        uint8_t* dstEntry = dstData + (b * srcBlockND[axis] + idxValue * blockToUpdate) * dataSize;
+        uint8_t* updateEntry = update + (b * updateBlockND[axis] + idx * blockToUpdate) * dataSize;
         cpu_memcpy(dstEntry, updateEntry, blockToUpdateSize);
     });
 }
 
-void ScatterUpdate::scatterNDUpdate(const MemoryPtr& dstMemPtr, const MemoryPtr& indicesMemPtr, const MemoryPtr& updateMemPtr) {
+void ScatterUpdate::scatterNDUpdate(const MemoryPtr& dstMemPtr,
+                                    const MemoryPtr& indicesMemPtr,
+                                    const MemoryPtr& updateMemPtr) {
     using namespace scatter_nd_update;
     ScatterNDUpdateContext ctx{this, dstMemPtr, indicesMemPtr, updateMemPtr, reduction_type};
     OV_SWITCH(intel_cpu,
@@ -1064,11 +1112,10 @@ void ScatterUpdate::scatterNDUpdate(const MemoryPtr& mem_data,
 }
 
 bool ScatterUpdate::created() const {
-    return getType() == Type::ScatterUpdate
-            || getType() == Type::ScatterElementsUpdate
-            || getType() == Type::ScatterNDUpdate;
+    return getType() == Type::ScatterUpdate || getType() == Type::ScatterElementsUpdate ||
+           getType() == Type::ScatterNDUpdate;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/scatter_update.h b/src/plugins/intel_cpu/src/nodes/scatter_update.h
index 87604efe745332..e667bf58bae99a 100644
--- a/src/plugins/intel_cpu/src/nodes/scatter_update.h
+++ b/src/plugins/intel_cpu/src/nodes/scatter_update.h
@@ -4,26 +4,23 @@
 
 #pragma once
 
+#include <utility>
+
 #include "node.h"
 #include "openvino/op/scatter_elements_update.hpp"
-#include <utility>
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-enum class ScatterUpdateMode {
-    ScatterUpdate,
-    ScatterNDUpdate,
-    ScatterElementsUpdate
-};
+enum class ScatterUpdateMode { ScatterUpdate, ScatterNDUpdate, ScatterElementsUpdate };
 
 namespace scatter_reductions {
 enum class CommonReduction { NONE, SUM, SUB, PROD, MIN, MAX, MEAN };
 class ReduceMultiply {
 public:
     template <typename DT>
-    void operator() (DT* dst_data, const DT* src_data) const {
+    void operator()(DT* dst_data, const DT* src_data) const {
         *dst_data *= *src_data;
     }
 };
@@ -31,7 +28,7 @@ class ReduceMultiply {
 class ReduceAdd {
 public:
     template <typename DT>
-    void operator() (DT* dst_data, const DT* src_data) const {
+    void operator()(DT* dst_data, const DT* src_data) const {
         *dst_data += *src_data;
     }
 };
@@ -39,7 +36,7 @@ class ReduceAdd {
 class ReduceSub {
 public:
     template <typename DT>
-    void operator() (DT* dst_data, const DT* src_data) const {
+    void operator()(DT* dst_data, const DT* src_data) const {
         *dst_data -= *src_data;
     }
 };
@@ -47,7 +44,7 @@ class ReduceSub {
 class ReduceMean {
 public:
     template <typename DT>
-    void operator() (DT* dst_data, const DT* src_data) const {
+    void operator()(DT* dst_data, const DT* src_data) const {
         *dst_data += *src_data;
     }
 };
@@ -55,7 +52,7 @@ class ReduceMean {
 class ReduceMaximum {
 public:
     template <typename DT>
-    void operator() (DT* dst_data, const DT* src_data) const {
+    void operator()(DT* dst_data, const DT* src_data) const {
         *dst_data = std::max(*dst_data, *src_data);
     }
 };
@@ -63,7 +60,7 @@ class ReduceMaximum {
 class ReduceMinimum {
 public:
     template <typename DT>
-    void operator() (DT* dst_data, const DT* src_data) const {
+    void operator()(DT* dst_data, const DT* src_data) const {
         *dst_data = std::min(*dst_data, *src_data);
     }
 };
@@ -71,7 +68,7 @@ class ReduceMinimum {
 class ReduceNone {
 public:
     template <typename DT>
-    void operator() (DT* dst_data, const DT* src_data) const {
+    void operator()(DT* dst_data, const DT* src_data) const {
         *dst_data = *src_data;
     }
 };
@@ -97,20 +94,35 @@ class ScatterUpdate : public Node {
 
     using Reduction = scatter_reductions::CommonReduction;
     template <typename DataType, typename KernelType>
-    void scatterElementsUpdate(const MemoryPtr& mem_data, const MemoryPtr& mem_indices, const MemoryPtr& mem_updates, int axis, const KernelType& kernel);
+    void scatterElementsUpdate(const MemoryPtr& mem_data,
+                               const MemoryPtr& mem_indices,
+                               const MemoryPtr& mem_updates,
+                               int axis,
+                               const KernelType& kernel);
     template <typename DataType>
-    void scatterElementsUpdate(const MemoryPtr& mem_data, const MemoryPtr& mem_indices, const MemoryPtr& mem_updates,
-                                int axis, const scatter_reductions::ReduceMean& kernel);
+    void scatterElementsUpdate(const MemoryPtr& mem_data,
+                               const MemoryPtr& mem_indices,
+                               const MemoryPtr& mem_updates,
+                               int axis,
+                               const scatter_reductions::ReduceMean& kernel);
     template <typename DataType, typename KernelType>
-    void scatterNDUpdate(const MemoryPtr& mem_data, const MemoryPtr& mem_indices, const MemoryPtr& mem_updates, const KernelType& kernel);
-    void scatterNDUpdate(const MemoryPtr& mem_data, const MemoryPtr& mem_indices, const MemoryPtr& mem_updates,
+    void scatterNDUpdate(const MemoryPtr& mem_data,
+                         const MemoryPtr& mem_indices,
+                         const MemoryPtr& mem_updates,
+                         const KernelType& kernel);
+    void scatterNDUpdate(const MemoryPtr& mem_data,
+                         const MemoryPtr& mem_indices,
+                         const MemoryPtr& mem_updates,
                          const scatter_reductions::ReduceNone& kernel);
 
 private:
-    void scatterUpdate(uint8_t *indicesPtr, uint8_t *updatePtr, int axis, uint8_t *dstDataPtr);
+    void scatterUpdate(uint8_t* indicesPtr, uint8_t* updatePtr, int axis, uint8_t* dstDataPtr);
     void scatterNDUpdate(const MemoryPtr& dstMemPtr, const MemoryPtr& indicesMemPtr, const MemoryPtr& updateMemPtr);
-    void scatterElementsUpdate(const MemoryPtr& dstMemPtr, const MemoryPtr& indicesMemPtr, const MemoryPtr& updateMemPtr, int axis);
-    inline int64_t getIndicesValue(uint8_t *indices, size_t offset);
+    void scatterElementsUpdate(const MemoryPtr& dstMemPtr,
+                               const MemoryPtr& indicesMemPtr,
+                               const MemoryPtr& updateMemPtr,
+                               int axis);
+    inline int64_t getIndicesValue(uint8_t* indices, size_t offset);
 
     ScatterUpdateMode scatterUpdateMode = ScatterUpdateMode::ScatterUpdate;
     enum { DATA_ID, INDICES_ID, UPDATE_ID, AXIS_ID };
@@ -129,6 +141,6 @@ class ScatterUpdate : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/search_sorted.cpp b/src/plugins/intel_cpu/src/nodes/search_sorted.cpp
index 69e57398bd327d..613b4df64d19fa 100644
--- a/src/plugins/intel_cpu/src/nodes/search_sorted.cpp
+++ b/src/plugins/intel_cpu/src/nodes/search_sorted.cpp
@@ -107,7 +107,7 @@ void SearchSorted::execute(dnnl::stream strm) {
 
 #define CASE(OV_TYPE)                                                                           \
     OV_CASE2(OV_TYPE, ov::element::i64, ov::element_type_traits<OV_TYPE>::value_type, int64_t), \
-    OV_CASE2(OV_TYPE, ov::element::i32, ov::element_type_traits<OV_TYPE>::value_type, int32_t)
+        OV_CASE2(OV_TYPE, ov::element::i32, ov::element_type_traits<OV_TYPE>::value_type, int32_t)
 
     OV_SWITCH(intel_cpu,
               SearchSortedExecute,
diff --git a/src/plugins/intel_cpu/src/nodes/shapeof.cpp b/src/plugins/intel_cpu/src/nodes/shapeof.cpp
index af5df8e2878b18..5d16d2e2a80878 100644
--- a/src/plugins/intel_cpu/src/nodes/shapeof.cpp
+++ b/src/plugins/intel_cpu/src/nodes/shapeof.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "shapeof.h"
+
 #include "openvino/opsets/opset1.hpp"
 #include "shape_inference/custom/shapeof.hpp"
 
@@ -49,9 +50,7 @@ void ShapeOf::initSupportedPrimitiveDescriptors() {
 
     ov::element::Type precision = getOriginalInputPrecisionAtPort(0);
 
-    addSupportedPrimDesc({{LayoutType::ncsp, precision}},
-                        {{LayoutType::ncsp, ov::element::i32}},
-                        impl_desc_type::ref);
+    addSupportedPrimDesc({{LayoutType::ncsp, precision}}, {{LayoutType::ncsp, ov::element::i32}}, impl_desc_type::ref);
 }
 
 void ShapeOf::initOptimalPrimitiveDescriptor() {
@@ -60,22 +59,23 @@ void ShapeOf::initOptimalPrimitiveDescriptor() {
     auto parent = parentEdge->getParent();
     auto parentPd = parent->getSelectedPrimitiveDescriptor();
     OPENVINO_ASSERT(parentPd,
-        parent->getTypeStr(), " ",
-        parent->getName(),
-        "failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
+                    parent->getTypeStr(),
+                    " ",
+                    parent->getName(),
+                    "failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
 
     const auto& parentConfig = parentPd->getConfig();
     auto mem_desc = parentConfig.outConfs[parentEdge->getInputNum()].getMemDesc();
 
     auto selected_pd = getSelectedPrimitiveDescriptor();
     OPENVINO_ASSERT(selected_pd,
-        "ShapeOf ",
-        getName(),
-        " failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
+                    "ShapeOf ",
+                    getName(),
+                    " failed getSelectedPrimitiveDescriptor() call, preferable primitive descriptor is not set");
 
     auto config = selected_pd->getConfig();
     config.inConfs.front().setMemDesc(mem_desc);
-    //bypass any checks, we enforce the parent descriptor
+    // bypass any checks, we enforce the parent descriptor
     selected_pd->setConfig(config);
 }
 
@@ -102,6 +102,6 @@ bool ShapeOf::created() const {
     return getType() == Type::ShapeOf;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/shapeof.h b/src/plugins/intel_cpu/src/nodes/shapeof.h
index fbdb689ed08cec..bc1474075a225c 100644
--- a/src/plugins/intel_cpu/src/nodes/shapeof.h
+++ b/src/plugins/intel_cpu/src/nodes/shapeof.h
@@ -5,9 +5,11 @@
 #pragma once
 
 #include <node.h>
-#include <string>
+
 #include <memory>
+#include <string>
 #include <vector>
+
 #include "dnnl_extension_utils.h"
 
 namespace ov {
@@ -23,8 +25,12 @@ class ShapeOf : public Node {
     void initOptimalPrimitiveDescriptor() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
-    bool needPrepareParams() const override {return false;};
-    void executeDynamicImpl(dnnl::stream strm) override { execute(strm); }
+    bool needPrepareParams() const override {
+        return false;
+    };
+    void executeDynamicImpl(dnnl::stream strm) override {
+        execute(strm);
+    }
 
     bool isExecutable() const override;
 
@@ -34,6 +40,6 @@ class ShapeOf : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/shuffle_channels.cpp b/src/plugins/intel_cpu/src/nodes/shuffle_channels.cpp
index 974001a78c994a..31d5c4764d5317 100644
--- a/src/plugins/intel_cpu/src/nodes/shuffle_channels.cpp
+++ b/src/plugins/intel_cpu/src/nodes/shuffle_channels.cpp
@@ -4,18 +4,16 @@
 
 #include "shuffle_channels.h"
 
+#include <cmath>
 #include <openvino/op/shuffle_channels.hpp>
+#include <string>
 
-#include "openvino/core/parallel.hpp"
-#include "dnnl_extension_utils.h"
-#include "cpu/x64/jit_generator.hpp"
 #include "common/blocked_desc_creator.h"
-
-#include "utils/general_utils.h"
-
-#include <string>
-#include <cmath>
 #include "common/primitive_hashing_utils.hpp"
+#include "cpu/x64/jit_generator.hpp"
+#include "dnnl_extension_utils.h"
+#include "openvino/core/parallel.hpp"
+#include "utils/general_utils.h"
 
 #define THROW_SHCH_ERROR(...) OPENVINO_THROW("ShuffleChannels layer with name '", getName(), "' ", __VA_ARGS__)
 
@@ -46,14 +44,14 @@ size_t ShuffleChannels::ShuffleChannelsAttributes::hash() const {
 }
 
 bool ShuffleChannels::ShuffleChannelsAttributes::operator==(const ShuffleChannelsAttributes& rhs) const {
-    bool result = layoutType == rhs.layoutType && dataRank == rhs.dataRank &&
-                  axis == rhs.axis && spatialRank == rhs.spatialRank &&
-                  group == rhs.group && dataSize == rhs.dataSize && srcDims == rhs.srcDims &&
-                  srcBlockedDims == rhs.srcBlockedDims;
+    bool result = layoutType == rhs.layoutType && dataRank == rhs.dataRank && axis == rhs.axis &&
+                  spatialRank == rhs.spatialRank && group == rhs.group && dataSize == rhs.dataSize &&
+                  srcDims == rhs.srcDims && srcBlockedDims == rhs.srcBlockedDims;
     return result;
 }
 
-bool ShuffleChannels::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool ShuffleChannels::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                           std::string& errorMessage) noexcept {
     try {
         auto shuffleChannels = ov::as_type_ptr<const ov::op::v0::ShuffleChannels>(op);
         if (!shuffleChannels) {
@@ -108,20 +106,12 @@ void ShuffleChannels::initSupportedPrimitiveDescriptors() {
     auto firstCreatorType = context->isGraphQuantized() ? LayoutType::nspc : LayoutType::ncsp;
     auto secondCreatorType = context->isGraphQuantized() ? LayoutType::ncsp : LayoutType::nspc;
 
-    addSupportedPrimDesc({{firstCreatorType, precision}},
-                         {{firstCreatorType, precision}},
-                         impl_type);
-    addSupportedPrimDesc({{secondCreatorType, precision}},
-                         {{secondCreatorType, precision}},
-                         impl_type);
+    addSupportedPrimDesc({{firstCreatorType, precision}}, {{firstCreatorType, precision}}, impl_type);
+    addSupportedPrimDesc({{secondCreatorType, precision}}, {{secondCreatorType, precision}}, impl_type);
     // canUseBlocked
     if (attrs.axis != 1) {
-        addSupportedPrimDesc({{LayoutType::nCsp8c, precision}},
-                             {{LayoutType::nCsp8c, precision}},
-                             impl_type);
-        addSupportedPrimDesc({{LayoutType::nCsp16c, precision}},
-                             {{LayoutType::nCsp16c, precision}},
-                             impl_type);
+        addSupportedPrimDesc({{LayoutType::nCsp8c, precision}}, {{LayoutType::nCsp8c, precision}}, impl_type);
+        addSupportedPrimDesc({{LayoutType::nCsp16c, precision}}, {{LayoutType::nCsp16c, precision}}, impl_type);
     }
 }
 
@@ -138,9 +128,10 @@ void ShuffleChannels::createPrimitive() {
     const auto& memoryDesc = srcMemPtr->getDesc();
     attrs.spatialRank = attrs.dataRank - attrs.axis - 1;
     attrs.dataSize = memoryDesc.getPrecision().size();
-    attrs.layoutType = memoryDesc.hasLayoutType(LayoutType::nCsp16c) ? LayoutType::nCsp16c :
-                       memoryDesc.hasLayoutType(LayoutType::nCsp8c) ? LayoutType::nCsp8c :
-                       memoryDesc.hasLayoutType(LayoutType::nspc) ? LayoutType::nspc : LayoutType::ncsp;
+    attrs.layoutType = memoryDesc.hasLayoutType(LayoutType::nCsp16c)  ? LayoutType::nCsp16c
+                       : memoryDesc.hasLayoutType(LayoutType::nCsp8c) ? LayoutType::nCsp8c
+                       : memoryDesc.hasLayoutType(LayoutType::nspc)   ? LayoutType::nspc
+                                                                      : LayoutType::ncsp;
 
     if (inputShapesDefined() && isExecutable()) {
         if (needPrepareParams())
@@ -177,7 +168,8 @@ ShuffleChannels::ShuffleChannelsExecutor::ShuffleChannelsExecutor(const ShuffleC
 
     // 2 for decomposed axis dim, 1 for composed spatial dim
     const int batchRank = attrs.axis;
-    const int reshapedRank = batchRank + 2 + static_cast<int>(attrs.spatialRank != 0) + static_cast<int>(isBlocked && (attrs.spatialRank == 0));
+    const int reshapedRank = batchRank + 2 + static_cast<int>(attrs.spatialRank != 0) +
+                             static_cast<int>(isBlocked && (attrs.spatialRank == 0));
     PermuteParams params;
     params.data_size = attrs.dataSize;
     params.order.resize(reshapedRank, 0);
@@ -214,7 +206,7 @@ ShuffleChannels::ShuffleChannelsExecutor::ShuffleChannelsExecutor(const ShuffleC
 
             params.order[batchRank + 2] = batchRank + 2;
             params.src_block_dims[batchRank + 2] = spatialShapeSize * blkSize;
-        } else { // axis on batch
+        } else {  // axis on batch
             decomposeAndTranpose(0);
             spatialShapeSize = CB * blkSize;
             for (int i = 2; i < attrs.dataRank; i++) {
@@ -249,7 +241,7 @@ ShuffleChannels::ShuffleChannelsExecutor::ShuffleChannelsExecutor(const ShuffleC
                 params.order[batchRank + 1] = batchRank + 1;
                 params.src_block_dims[batchRank + 1] = spatialShapeSize;
             }
-        } else { // axis on batch
+        } else {  // axis on batch
             decomposeAndTranpose(0);
             params.order[2] = 2;
             params.src_block_dims[2] = spatialShapeSize;
@@ -304,6 +296,6 @@ bool ShuffleChannels::created() const {
     return getType() == Type::ShuffleChannels;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/shuffle_channels.h b/src/plugins/intel_cpu/src/nodes/shuffle_channels.h
index f5e7d9e8cd3b2a..86a25c2cd8368e 100644
--- a/src/plugins/intel_cpu/src/nodes/shuffle_channels.h
+++ b/src/plugins/intel_cpu/src/nodes/shuffle_channels.h
@@ -4,8 +4,8 @@
 
 #pragma once
 
-#include "node.h"
 #include "common/permute_kernel.h"
+#include "node.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -17,7 +17,7 @@ class ShuffleChannels : public Node {
     ~ShuffleChannels() override = default;
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void createPrimitive() override;
     void execute(dnnl::stream strm) override;
@@ -55,6 +55,6 @@ class ShuffleChannels : public Node {
     executorPtr execPtr = nullptr;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/softmax.cpp b/src/plugins/intel_cpu/src/nodes/softmax.cpp
index 7da1e733c9511d..72e6b602bcf9b1 100644
--- a/src/plugins/intel_cpu/src/nodes/softmax.cpp
+++ b/src/plugins/intel_cpu/src/nodes/softmax.cpp
@@ -4,14 +4,16 @@
 
 #include "softmax.h"
 
+#include <memory_desc/cpu_memory_desc_utils.h>
+
+#include <shape_inference/shape_inference_pass_through.hpp>
 #include <string>
-#include "dnnl_types.h"
+
+#include "common/primitive_hashing_utils.hpp"
 #include "dnnl_extension_utils.h"
-#include <memory_desc/cpu_memory_desc_utils.h>
-#include "openvino/opsets/opset1.hpp"
+#include "dnnl_types.h"
 #include "memory_desc/dnnl_blocked_memory_desc.h"
-#include "common/primitive_hashing_utils.hpp"
-#include <shape_inference/shape_inference_pass_through.hpp>
+#include "openvino/opsets/opset1.hpp"
 
 using namespace dnnl;
 
@@ -66,8 +68,8 @@ bool SoftMax::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, st
     return true;
 }
 
-SoftMax::SoftMax(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) :
-        Node(op, context, PassThroughShapeInferFactory()) {
+SoftMax::SoftMax(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, PassThroughShapeInferFactory()) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
@@ -80,10 +82,7 @@ void SoftMax::getSupportedDescriptors() {
         return;
 
     ov::element::Type precision = getOriginalInputPrecisionAtPort(0);
-    if (!one_of(precision,
-                ov::element::f32,
-                ov::element::bf16,
-                ov::element::f16))
+    if (!one_of(precision, ov::element::f32, ov::element::bf16, ov::element::f16))
         precision = ov::element::f32;
     auto inputDataType = DnnlExtensionUtils::ElementTypeToDataType(precision);
 
@@ -92,7 +91,7 @@ void SoftMax::getSupportedDescriptors() {
     if (!getChildEdges().size())
         OPENVINO_THROW("Incorrect number of output edges for layer ", getName());
 
-    const auto &inShape = getInputShapeAtPort(0);
+    const auto& inShape = getInputShapeAtPort(0);
     if (inShape.getRank() == 3) {
         auto in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(inShape, inputDataType, memory::format_tag::abc);
         createDescriptor({in_candidate}, {});
@@ -126,11 +125,12 @@ void SoftMax::initOptimalPrimitiveDescriptor() {
     auto config = selected_pd->getConfig();
     if (isDynamicNode()) {
         auto outMemDesc = config.outConfs[0].getMemDesc();
-        config.outConfs[0].setMemDesc(std::dynamic_pointer_cast<BlockedMemoryDesc>(outMemDesc), BlockedMemoryDesc::FULL_MASK);
+        config.outConfs[0].setMemDesc(std::dynamic_pointer_cast<BlockedMemoryDesc>(outMemDesc),
+                                      BlockedMemoryDesc::FULL_MASK);
     } else {
         if (config.inConfs.size() != 1 || config.outConfs.size() != 1 ||
-            (config.inConfs[0].getMemDesc()->isDefined() &&
-             config.outConfs[0].getMemDesc()->isDefined() && !config.outConfs[0].getPortDesc()->isCompatible(*config.inConfs[0].getPortDesc())))
+            (config.inConfs[0].getMemDesc()->isDefined() && config.outConfs[0].getMemDesc()->isDefined() &&
+             !config.outConfs[0].getPortDesc()->isCompatible(*config.inConfs[0].getPortDesc())))
             OPENVINO_THROW("Layer ", getName(), " has incorrect selected config!");
 
         config.inConfs[0].setMemDesc(getConsistentInputDesc(config, 0)->getMemDesc());
@@ -139,23 +139,22 @@ void SoftMax::initOptimalPrimitiveDescriptor() {
     initDescriptor(config);
 }
 
-void SoftMax::createDescriptor(const std::vector<MemoryDescPtr> &inputDesc,
-                               const std::vector<MemoryDescPtr> &outputDesc) {
+void SoftMax::createDescriptor(const std::vector<MemoryDescPtr>& inputDesc,
+                               const std::vector<MemoryDescPtr>& outputDesc) {
     auto inpDesc = inputDesc[0]->isDefined() ? inputDesc[0] : MemoryDescUtils::makeDummyDesc(*inputDesc[0]);
     DnnlMemoryDescPtr definedInpMemDesc = MemoryDescUtils::convertToDnnlMemoryDesc(inpDesc);
     auto in_candidate = definedInpMemDesc->getDnnlDesc();
 
     auto attr = initPrimitiveAttr();
 
-    auto desc = softmax_forward::primitive_desc(
-        getEngine(),
-        prop_kind::forward_inference,
-        algorithm::softmax_accurate,
-        in_candidate,
-        in_candidate,
-        axis,
-        *attr,
-        true);
+    auto desc = softmax_forward::primitive_desc(getEngine(),
+                                                prop_kind::forward_inference,
+                                                algorithm::softmax_accurate,
+                                                in_candidate,
+                                                in_candidate,
+                                                axis,
+                                                *attr,
+                                                true);
 
     if (desc)
         descs.emplace_back(desc);
@@ -174,15 +173,14 @@ void SoftMax::prepareParams() {
     auto engine = getEngine();
 
     auto builder = [&engine](const SoftmaxKey& key) -> executorPtr {
-        auto prim_desc = softmax_forward::primitive_desc(
-            engine,
-            prop_kind::forward_inference,
-            algorithm::softmax_accurate,
-            key.inp0->getDnnlDesc(),
-            key.inp0->getDnnlDesc(),
-            key.axis,
-            key.attr,
-            true);
+        auto prim_desc = softmax_forward::primitive_desc(engine,
+                                                         prop_kind::forward_inference,
+                                                         algorithm::softmax_accurate,
+                                                         key.inp0->getDnnlDesc(),
+                                                         key.inp0->getDnnlDesc(),
+                                                         key.axis,
+                                                         key.attr,
+                                                         true);
 
         primitive_desc_iterator itpd = prim_desc;
 
@@ -237,6 +235,6 @@ void SoftMax::executeDynamicImpl(dnnl::stream strm) {
     execute(strm);
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/softmax.h b/src/plugins/intel_cpu/src/nodes/softmax.h
index c98c7cb331a6c3..b11d43f2896795 100644
--- a/src/plugins/intel_cpu/src/nodes/softmax.h
+++ b/src/plugins/intel_cpu/src/nodes/softmax.h
@@ -4,8 +4,8 @@
 
 #pragma once
 
-#include "node.h"
 #include "common/dnnl_executor.h"
+#include "node.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -33,6 +33,6 @@ class SoftMax : public Node {
     size_t axis = 0;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/space_to_batch.cpp b/src/plugins/intel_cpu/src/nodes/space_to_batch.cpp
index 044200ba183e4f..763ade2294d660 100644
--- a/src/plugins/intel_cpu/src/nodes/space_to_batch.cpp
+++ b/src/plugins/intel_cpu/src/nodes/space_to_batch.cpp
@@ -4,9 +4,10 @@
 
 #include "space_to_batch.h"
 
-#include "openvino/core/parallel.hpp"
 #include <openvino/op/space_to_batch.hpp>
 
+#include "openvino/core/parallel.hpp"
+
 namespace ov {
 namespace intel_cpu {
 namespace node {
@@ -48,7 +49,7 @@ void SpaceToBatch::initSupportedPrimitiveDescriptors() {
     if (!supportedPrimitiveDescriptors.empty())
         return;
 
-    const auto &inDims = getInputShapeAtPort(0).getDims();
+    const auto& inDims = getInputShapeAtPort(0).getDims();
     const auto precision = getOriginalInputPrecisionAtPort(0);
     const std::set<size_t> supported_precision_sizes = {1, 2, 4, 8};
     if (supported_precision_sizes.find(precision.size()) == supported_precision_sizes.end())
@@ -84,7 +85,7 @@ void SpaceToBatch::initSupportedPrimitiveDescriptors() {
     }
 }
 
-static std::vector<int64_t> getShape5D(const VectorDims &shape) {
+static std::vector<int64_t> getShape5D(const VectorDims& shape) {
     std::vector<int64_t> shape5D(5, 1);
     for (int i = 0; i < 2; i++) {
         shape5D[i] = shape[i];
@@ -94,38 +95,38 @@ static std::vector<int64_t> getShape5D(const VectorDims &shape) {
     return shape5D;
 }
 
-template<typename T>
+template <typename T>
 void SpaceToBatch::SpaceToBatchKernel() {
     const auto& srcMem = getSrcMemoryAtPort(0);
     const auto& dstMem = getDstMemoryAtPort(0);
 
-    const auto *blockShapesPtr = getSrcDataAtPortAs<int>(1);
+    const auto* blockShapesPtr = getSrcDataAtPortAs<int>(1);
     size_t dataRank = srcMem->getShape().getRank();
     blockShapeIn.clear();
     for (size_t i = 0; i < dataRank; i++) {
         blockShapeIn.push_back(*(blockShapesPtr + i));
     }
 
-    const auto *padsBeginPtr = getSrcDataAtPortAs<int>(2);
+    const auto* padsBeginPtr = getSrcDataAtPortAs<int>(2);
     padsBeginIn.clear();
     for (size_t i = 0; i < dataRank; i++) {
         padsBeginIn.push_back(*(padsBeginPtr + i));
     }
 
-    const auto *srcData = srcMem->getDataAs<const T>();
-    auto *dstData = dstMem->getDataAs<T>();
+    const auto* srcData = srcMem->getDataAs<const T>();
+    auto* dstData = dstMem->getDataAs<T>();
 
     const int64_t srcLen = srcMem->getSize() / sizeof(T);
     const int64_t dstLen = dstMem->getSize() / sizeof(T);
 
-    const auto &inDims = srcMem->getStaticDims();
-    const auto &outDims = dstMem->getStaticDims();
+    const auto& inDims = srcMem->getStaticDims();
+    const auto& outDims = dstMem->getStaticDims();
 
-    const bool blocked = srcMem->getDesc().hasLayoutType(LayoutType::nCsp16c) ||
-                         srcMem->getDesc().hasLayoutType(LayoutType::nCsp8c);
+    const bool blocked =
+        srcMem->getDesc().hasLayoutType(LayoutType::nCsp16c) || srcMem->getDesc().hasLayoutType(LayoutType::nCsp8c);
     const auto dimsSize = inDims.size();
 
-    auto inShape5D  = getShape5D(outDims);
+    auto inShape5D = getShape5D(outDims);
     auto outShape5D = getShape5D(inDims);
     auto blockShape = getShape5D(blockShapeIn);
 
@@ -216,11 +217,14 @@ void SpaceToBatch::SpaceToBatchKernel() {
                             const int64_t srcIdx4 = srcIdx3 + tmpOw * blockSize;
                             const int64_t dstIdx4 = dstIdx3 + i4 * blockSize;
                             for (int64_t it = 0; it < itEnd + 1; ++it) {
-                                const int64_t i5Begin = it == 0 ? 0 : (it * blockSize - 1 - oAdd[1]) / blockShape[1] + 1;
-                                const int64_t i5End = it == itEnd ? (block - 1) : ((it + 1) * blockSize - 1 - oAdd[1]) / blockShape[1];
+                                const int64_t i5Begin =
+                                    it == 0 ? 0 : (it * blockSize - 1 - oAdd[1]) / blockShape[1] + 1;
+                                const int64_t i5End =
+                                    it == itEnd ? (block - 1) : ((it + 1) * blockSize - 1 - oAdd[1]) / blockShape[1];
                                 for (int64_t i5 = i5Begin; i5 < i5End + 1; ++i5) {
                                     const int64_t tmpOc = i5 * blockShape[1] + addTmpOc;
-                                    const int64_t srcIdx5 = srcIdx4 + it * outSpatialStep * blockSize + (tmpOc - it * blockSize);
+                                    const int64_t srcIdx5 =
+                                        srcIdx4 + it * outSpatialStep * blockSize + (tmpOc - it * blockSize);
                                     const int64_t dstIdx5 = dstIdx4 + i5;
                                     if (srcIdx5 >= srcLen || dstIdx5 >= dstLen) {
                                         continue;
@@ -254,7 +258,7 @@ void SpaceToBatch::execute(dnnl::stream strm) {
         break;
     default:
         OPENVINO_THROW("SpaceToBatch layer does not support precision '" +
-                           std::string(getParentEdgeAt(0)->getMemory().getDesc().getPrecision().get_type_name()) + "'");
+                       std::string(getParentEdgeAt(0)->getMemory().getDesc().getPrecision().get_type_name()) + "'");
     }
 }
 
@@ -262,6 +266,6 @@ bool SpaceToBatch::created() const {
     return getType() == Type::SpaceToBatch;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/space_to_batch.h b/src/plugins/intel_cpu/src/nodes/space_to_batch.h
index d9126764e5d923..76f6c369a5e501 100644
--- a/src/plugins/intel_cpu/src/nodes/space_to_batch.h
+++ b/src/plugins/intel_cpu/src/nodes/space_to_batch.h
@@ -18,13 +18,17 @@ class SpaceToBatch : public Node {
 public:
     SpaceToBatch(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void execute(dnnl::stream strm) override;
     bool created() const override;
 
-    bool needPrepareParams() const override { return false; };
-    bool needShapeInfer() const override {return true;};
+    bool needPrepareParams() const override {
+        return false;
+    };
+    bool needShapeInfer() const override {
+        return true;
+    };
     void executeDynamicImpl(dnnl::stream strm) override;
 
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
@@ -35,10 +39,10 @@ class SpaceToBatch : public Node {
 
     std::string errorPrefix;
 
-    template<typename T>
+    template <typename T>
     void SpaceToBatchKernel();
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/space_to_depth.cpp b/src/plugins/intel_cpu/src/nodes/space_to_depth.cpp
index 0fcb190035537c..554aae5c96bca6 100644
--- a/src/plugins/intel_cpu/src/nodes/space_to_depth.cpp
+++ b/src/plugins/intel_cpu/src/nodes/space_to_depth.cpp
@@ -4,17 +4,16 @@
 
 #include "space_to_depth.h"
 
-#include "dnnl_extension_utils.h"
-#include "utils/general_utils.h"
-
 #include <cmath>
+#include <string>
+
+#include "common/blocked_desc_creator.h"
 #include "common/primitive_hashing_utils.hpp"
 #include "cpu/x64/jit_generator.hpp"
+#include "dnnl_extension_utils.h"
 #include "openvino/opsets/opset1.hpp"
-#include <string>
 #include "openvino/util/pp.hpp"
-
-#include "common/blocked_desc_creator.h"
+#include "utils/general_utils.h"
 
 #define THROW_ERROR(...) OPENVINO_THROW("SpaceToDepth layer with name '", getName(), "' ", __VA_ARGS__)
 
@@ -43,16 +42,14 @@ size_t SpaceToDepth::SpaceToDepthAttrs::hash() const {
 }
 
 bool SpaceToDepth::SpaceToDepthAttrs::operator==(const SpaceToDepthAttrs& rhs) const {
-    bool result = layoutType == rhs.layoutType && mode == rhs.mode &&
-                  blockSize == rhs.blockSize && blockStep == rhs.blockStep &&
-                  dataSize == rhs.dataSize && nSpatialDims == rhs.nSpatialDims &&
+    bool result = layoutType == rhs.layoutType && mode == rhs.mode && blockSize == rhs.blockSize &&
+                  blockStep == rhs.blockStep && dataSize == rhs.dataSize && nSpatialDims == rhs.nSpatialDims &&
                   srcBlockedDims == rhs.srcBlockedDims && destBlockedDims == rhs.destBlockedDims;
 
     return result;
 }
 
-bool SpaceToDepth::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
-                                                  std::string& errorMessage) noexcept {
+bool SpaceToDepth::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
         const auto spaceToDepth = ov::as_type_ptr<const ov::opset1::SpaceToDepth>(op);
         if (!spaceToDepth) {
@@ -175,11 +172,10 @@ void SpaceToDepth::createPrimitive() {
 
     const auto& memoryDesc = srcMemPtr->getDesc();
     attrs.dataSize = memoryDesc.getPrecision().size();
-    attrs.layoutType = memoryDesc.hasLayoutType(LayoutType::nCsp16c)
-                           ? LayoutType::nCsp16c
-                           : memoryDesc.hasLayoutType(LayoutType::nCsp8c)
-                                 ? LayoutType::nCsp8c
-                                 : memoryDesc.hasLayoutType(LayoutType::nspc) ? LayoutType::nspc : LayoutType::ncsp;
+    attrs.layoutType = memoryDesc.hasLayoutType(LayoutType::nCsp16c)  ? LayoutType::nCsp16c
+                       : memoryDesc.hasLayoutType(LayoutType::nCsp8c) ? LayoutType::nCsp8c
+                       : memoryDesc.hasLayoutType(LayoutType::nspc)   ? LayoutType::nspc
+                                                                      : LayoutType::ncsp;
 
     if (inputShapesDefined() && isExecutable()) {
         if (needPrepareParams())
@@ -189,10 +185,8 @@ void SpaceToDepth::createPrimitive() {
 }
 
 void SpaceToDepth::prepareParams() {
-    attrs.srcBlockedDims =
-        getSrcMemoryAtPort(0)->getDescWithType<BlockedMemoryDesc>()->getBlockDims();
-    attrs.destBlockedDims =
-        getDstMemoryAtPort(0)->getDescWithType<BlockedMemoryDesc>()->getBlockDims();
+    attrs.srcBlockedDims = getSrcMemoryAtPort(0)->getDescWithType<BlockedMemoryDesc>()->getBlockDims();
+    attrs.destBlockedDims = getDstMemoryAtPort(0)->getDescWithType<BlockedMemoryDesc>()->getBlockDims();
     auto builder = [](const SpaceToDepthAttrs& key) -> std::shared_ptr<SpaceToDepthExecutor> {
         return std::make_shared<SpaceToDepthExecutor>(key);
     };
@@ -207,11 +201,7 @@ void SpaceToDepth::prepareParams() {
 }
 
 SpaceToDepth::SpaceToDepthExecutor::SpaceToDepthExecutor(const SpaceToDepthAttrs& attrs) {
-    if (!one_of(attrs.layoutType,
-                LayoutType::nCsp16c,
-                LayoutType::nCsp8c,
-                LayoutType::nspc,
-                LayoutType::ncsp))
+    if (!one_of(attrs.layoutType, LayoutType::nCsp16c, LayoutType::nCsp8c, LayoutType::nspc, LayoutType::ncsp))
         OPENVINO_THROW("SpaceToDepth executor supports only 'nCsp16c', 'nCsp8c', "
                        "'nspc' or 'ncsp' layouts.");
 
@@ -327,6 +317,6 @@ bool SpaceToDepth::created() const {
     return getType() == Type::SpaceToDepth;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/space_to_depth.h b/src/plugins/intel_cpu/src/nodes/space_to_depth.h
index 18bc2feb4391fd..9529949b6fb4c0 100644
--- a/src/plugins/intel_cpu/src/nodes/space_to_depth.h
+++ b/src/plugins/intel_cpu/src/nodes/space_to_depth.h
@@ -57,6 +57,6 @@ class SpaceToDepth : public Node {
     executorPtr execPtr = nullptr;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/split.cpp b/src/plugins/intel_cpu/src/nodes/split.cpp
index aca963536d8059..751ced5b1b0a59 100644
--- a/src/plugins/intel_cpu/src/nodes/split.cpp
+++ b/src/plugins/intel_cpu/src/nodes/split.cpp
@@ -3,18 +3,21 @@
 //
 
 #include "split.h"
-#include "common/cpu_memcpy.h"
-#include "common/blocked_desc_creator.h"
+
+#include <memory_desc/cpu_memory_desc_utils.h>
+#include <partitioned_mem_blk.h>
+
 #include <vector>
-#include "dnnl_types.h"
+
+#include "common/blocked_desc_creator.h"
+#include "common/cpu_memcpy.h"
 #include "dnnl_extension_utils.h"
+#include "dnnl_types.h"
 #include "openvino/core/parallel.hpp"
-#include "utils/general_utils.h"
-#include <memory_desc/cpu_memory_desc_utils.h>
-#include "utils/ngraph_utils.hpp"
-#include <partitioned_mem_blk.h>
 #include "openvino/op/split.hpp"
 #include "openvino/op/variadic_split.hpp"
+#include "utils/general_utils.h"
+#include "utils/ngraph_utils.hpp"
 
 #define THROW_ERROR(...) OPENVINO_THROW("Split layer with name '", getName(), "' ", __VA_ARGS__)
 
@@ -26,7 +29,9 @@ namespace node {
 
 bool Split::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
-        if (!one_of(op->get_type_info(), ov::op::v1::Split::get_type_info_static(), ov::op::v1::VariadicSplit::get_type_info_static())) {
+        if (!one_of(op->get_type_info(),
+                    ov::op::v1::Split::get_type_info_static(),
+                    ov::op::v1::VariadicSplit::get_type_info_static())) {
             errorMessage = "Only opset1 Split and VariadicSplit operations are supported";
             return false;
         }
@@ -74,8 +79,7 @@ Split::Split(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr conte
     this->axis = axis;
 }
 
-void Split::getSupportedDescriptors() {
-}
+void Split::getSupportedDescriptors() {}
 
 void Split::initSupportedPrimitiveDescriptors() {
     constexpr size_t channelsPos = 1lu;
@@ -83,10 +87,10 @@ void Split::initSupportedPrimitiveDescriptors() {
     if (!supportedPrimitiveDescriptors.empty())
         return;
 
-    const auto &srcShape = getInputShapeAtPort(0);
-    const auto &dstFirstDims = getOutputShapeAtPort(0).getDims();
+    const auto& srcShape = getInputShapeAtPort(0);
+    const auto& dstFirstDims = getOutputShapeAtPort(0).getDims();
     for (size_t i = 0; i < outputShapes.size(); i++) {
-        const auto &o_Dims = outputShapes[i].getDims();
+        const auto& o_Dims = outputShapes[i].getDims();
         if (dstFirstDims.size() != o_Dims.size()) {
             THROW_ERROR("only supports output blobs with equal number of dimensions");
         }
@@ -103,18 +107,18 @@ void Split::initSupportedPrimitiveDescriptors() {
     const auto axisPrecision = ov::element::i32;
 
     // Set plain and tailC formats
-    std::vector<LayoutType> tdCreatorTypes{ LayoutType::ncsp, LayoutType::nspc };
+    std::vector<LayoutType> tdCreatorTypes{LayoutType::ncsp, LayoutType::nspc};
 
     // Support channel blocked format only if we manipulate complete blocks
     if (srcShape.getRank() > 2) {
-        for (auto item : { std::make_pair(8lu, LayoutType::nCsp8c), std::make_pair(16lu, LayoutType::nCsp16c) }) {
-            const auto &blkDims = srcShape.getDims();
+        for (auto item : {std::make_pair(8lu, LayoutType::nCsp8c), std::make_pair(16lu, LayoutType::nCsp16c)}) {
+            const auto& blkDims = srcShape.getDims();
             if (blkDims[channelsPos] == Shape::UNDEFINED_DIM || blkDims[channelsPos] % item.first != 0)
                 continue;
 
             bool blocked = true;
             for (size_t i = 0; i < outputShapes.size(); i++) {
-                const auto &outBlkDims = getOutputShapeAtPort(i).getDims();
+                const auto& outBlkDims = getOutputShapeAtPort(i).getDims();
                 if (outBlkDims[channelsPos] == Shape::UNDEFINED_DIM || outBlkDims[channelsPos] % item.first != 0) {
                     blocked = false;
                     break;
@@ -129,19 +133,22 @@ void Split::initSupportedPrimitiveDescriptors() {
     std::vector<size_t> pdIndexesToReuse;
 
     auto& creatorsMap = BlockedDescCreator::getCommonCreators();
-    auto itrRange = BlockedDescCreator::makeFilteredRange(creatorsMap, static_cast<unsigned>(srcShape.getRank()), tdCreatorTypes);
+    auto itrRange =
+        BlockedDescCreator::makeFilteredRange(creatorsMap, static_cast<unsigned>(srcShape.getRank()), tdCreatorTypes);
     for (auto itr = itrRange.first; itr != itrRange.second; ++itr) {
         NodeConfig config;
 
         config.inConfs.resize(INPUTS_NUM);
         config.inConfs[0].inPlace(-1);
         config.inConfs[0].constant(false);
-        config.inConfs[0].setMemDesc(std::make_shared<CpuBlockedMemoryDesc>(itr->second->createDesc(inpPrecision, srcShape)));
+        config.inConfs[0].setMemDesc(
+            std::make_shared<CpuBlockedMemoryDesc>(itr->second->createDesc(inpPrecision, srcShape)));
         config.inConfs[1].inPlace(-1);
         config.inConfs[1].constant(true);
         config.inConfs[1].setMemDesc(std::make_shared<CpuBlockedMemoryDesc>(axisPrecision, Shape(VectorDims{1})));
         if (INPUTS_NUM == 3) {
-            config.inConfs[2].setMemDesc(std::make_shared<CpuBlockedMemoryDesc>(axisPrecision, Shape(VectorDims{outputShapes.size()})));
+            config.inConfs[2].setMemDesc(
+                std::make_shared<CpuBlockedMemoryDesc>(axisPrecision, Shape(VectorDims{outputShapes.size()})));
             config.inConfs[2].constant(constSplitLengths);
         }
 
@@ -150,7 +157,8 @@ void Split::initSupportedPrimitiveDescriptors() {
         for (size_t i = 0; i < outputShapes.size(); i++) {
             config.outConfs[i].inPlace(-1);
             config.outConfs[i].constant(false);
-            config.outConfs[i].setMemDesc(std::make_shared<CpuBlockedMemoryDesc>(itr->second->createDesc(inpPrecision, outputShapes[i])));
+            config.outConfs[i].setMemDesc(
+                std::make_shared<CpuBlockedMemoryDesc>(itr->second->createDesc(inpPrecision, outputShapes[i])));
         }
         supportedPrimitiveDescriptors.emplace_back(config, impl_desc_type::ref);
 
@@ -167,9 +175,14 @@ void Split::initSupportedPrimitiveDescriptors() {
     // in place only makes sense when we split by dense blocks since strided tensors are not supported by most nodes.
     const auto& parentdDims = inputShapes[0].getDims();
     if (parentdDims[axis] != Shape::UNDEFINED_DIM &&
-        std::all_of(parentdDims.begin(), parentdDims.begin() + axis, [](size_t dim) { return  dim == 1; }) &&
-        std::all_of(outputShapes.begin(), outputShapes.end(),
-            [OV_CAPTURE_CPY_AND_THIS](const Shape& shape){ return shape.getDims()[axis] != Shape::UNDEFINED_DIM; })) {
+        std::all_of(parentdDims.begin(),
+                    parentdDims.begin() + axis,
+                    [](size_t dim) {
+                        return dim == 1;
+                    }) &&
+        std::all_of(outputShapes.begin(), outputShapes.end(), [OV_CAPTURE_CPY_AND_THIS](const Shape& shape) {
+            return shape.getDims()[axis] != Shape::UNDEFINED_DIM;
+        })) {
         for (auto refPdIndex : pdIndexesToReuse) {
             auto config = supportedPrimitiveDescriptors[refPdIndex].getConfig();
 
@@ -192,7 +205,8 @@ void Split::initSupportedPrimitiveDescriptors() {
         config.inConfs[1].constant(true);
         config.inConfs[1].setMemDesc(std::make_shared<CpuBlockedMemoryDesc>(axisPrecision, Shape(VectorDims{1})));
         if (INPUTS_NUM == 3) {
-            config.inConfs[2].setMemDesc(std::make_shared<CpuBlockedMemoryDesc>(axisPrecision, Shape(VectorDims{outputShapes.size()})));
+            config.inConfs[2].setMemDesc(
+                std::make_shared<CpuBlockedMemoryDesc>(axisPrecision, Shape(VectorDims{outputShapes.size()})));
             config.inConfs[2].constant(constSplitLengths);
         }
         config.outConfs.resize(outputShapes.size());
@@ -200,7 +214,8 @@ void Split::initSupportedPrimitiveDescriptors() {
         for (size_t i = 0; i < outputShapes.size(); i++) {
             config.outConfs[i].inPlace(-1);
             config.outConfs[i].constant(false);
-            config.outConfs[i].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(inpPrecision, outputShapes[i]));
+            config.outConfs[i].setMemDesc(
+                creatorsMap.at(LayoutType::ncsp)->createSharedDesc(inpPrecision, outputShapes[i]));
         }
         supportedPrimitiveDescriptors.emplace_back(config, impl_desc_type::ref);
     }
@@ -239,7 +254,7 @@ void Split::createPrimitive() {
 }
 
 void Split::prepareParams() {
-    const auto &srcMemPtr = getSrcMemoryAtPort(0);
+    const auto& srcMemPtr = getSrcMemoryAtPort(0);
     if (!srcMemPtr || !srcMemPtr->isDefined()) {
         THROW_ERROR("has undefined input memory");
     }
@@ -254,7 +269,7 @@ void Split::prepareParams() {
     dstMemPtrs.clear();
     std::vector<BlockedMemoryDescCPtr> outDescs;
     for (size_t port = 0; port < outputShapes.size(); ++port) {
-        const auto &outMemPtr = this->getDstMemoryAtPort(port);
+        const auto& outMemPtr = this->getDstMemoryAtPort(port);
         if (!outMemPtr || !outMemPtr->isDefined()) {
             THROW_ERROR("has undefined destination memory");
         }
@@ -288,7 +303,7 @@ void Split::execute(dnnl::stream strm) {
     if (dstMemPtrs.empty())
         THROW_ERROR("Output data pointers have not been initialized.");
 
-    const auto &srcMem = getParentEdgeAt(0)->getMemory();
+    const auto& srcMem = getParentEdgeAt(0)->getMemory();
 
     if (canUseOptimizedNspc2Ncsp) {
         optimizedNspc2Ncsp(srcMem.getStaticDims()[0]);
@@ -325,14 +340,14 @@ void Split::initOptimalPrimitiveDescriptor() {
 
 void Split::selectOptimalPrimitiveDescriptor() {
     // Enforce the reference implementation for the planar layout if the implementation is in the impl priorities list.
-    // This is needed mostly for the testing purposes, since for the planar layout Split works always in place, we need to enforce
-    // the reference implementation when it is selected in a test to test that piece of code.
+    // This is needed mostly for the testing purposes, since for the planar layout Split works always in place, we need
+    // to enforce the reference implementation when it is selected in a test to test that piece of code.
     if (!customImplPriorities.empty() && customImplPriorities[0] == impl_desc_type::ref) {
         for (size_t i = 0; i < supportedPrimitiveDescriptors.size(); ++i) {
             auto& pd = supportedPrimitiveDescriptors[i];
             if (pd.getConfig().inConfs[0].getMemDesc()->hasLayoutType(LayoutType::ncsp) &&
                 impl_desc_type::ref == pd.getImplementationType()) {
-                    selectPrimitiveDescriptorByIndex(static_cast<int>(i));
+                selectPrimitiveDescriptorByIndex(static_cast<int>(i));
                 return;
             }
         }
@@ -350,7 +365,8 @@ void Split::selectOptimalPrimitiveDescriptor() {
             if (inNum < 0 || static_cast<size_t>(inNum) >= parent_spd->getConfig().outConfs.size()) {
                 inNum = 0;
             }
-            if (supportedPrimitiveDescriptors[i].getConfig().inConfs[0].getMemDesc()->isCompatible(*parent_spd->getConfig().outConfs[inNum].getMemDesc())) {
+            if (supportedPrimitiveDescriptors[i].getConfig().inConfs[0].getMemDesc()->isCompatible(
+                    *parent_spd->getConfig().outConfs[inNum].getMemDesc())) {
                 canSelectPrimitive.push_back(i);
             }
         }
@@ -375,7 +391,8 @@ void Split::selectOptimalPrimitiveDescriptor() {
             auto childEdge = getChildEdgeAt(i);
             auto childPtr = childEdge->getChild();
             auto& vecChildSpd = childPtr->getSupportedPrimitiveDescriptors();
-            const auto& outputDesc = supportedPrimitiveDescriptors[indx].getConfig().outConfs[childEdge->getInputNum()].getMemDesc();
+            const auto& outputDesc =
+                supportedPrimitiveDescriptors[indx].getConfig().outConfs[childEdge->getInputNum()].getMemDesc();
 
             if (!vecChildSpd.empty()) {
                 int inNum = childEdge->getOutputNum();
@@ -432,9 +449,9 @@ void Split::optimizedNspc2Ncsp(size_t MB) {
     auto srcData = srcMem.getDataAs<const uint8_t>();
     const auto dataSize = srcMem.getDesc().getPrecision().size();
 
-    const size_t DHW = D*H*W;
+    const size_t DHW = D * H * W;
     const size_t strideIB = DHW * IC * dataSize;
-    const size_t strideIW = IC*dataSize;
+    const size_t strideIW = IC * dataSize;
     const size_t strideOC = DHW * dataSize;
 
     for (size_t i = 0, sIdx = 0; i < dstMemPtrs.size(); i++) {
@@ -452,8 +469,8 @@ void Split::optimizedNspc2Ncsp(size_t MB) {
         const size_t strideOB = OC * strideOC;
 
         parallel_for2d(MB, DHW, [&](size_t b, size_t j) {
-            auto localSrcPtr = srcPtr + b*strideIB + j*strideIW;
-            auto localDstPtr = dstData + b*strideOB + j*dataSize;
+            auto localSrcPtr = srcPtr + b * strideIB + j * strideIW;
+            auto localDstPtr = dstData + b * strideOB + j * dataSize;
             for (size_t c = 0; c < OC; c++) {
                 cpu_memcpy(localDstPtr, localSrcPtr, dataSize);
                 localSrcPtr += dataSize;
@@ -476,8 +493,9 @@ std::vector<uint8_t*> Split::getRawDstMemPtrs() const {
     return result;
 }
 
-Split::SplitOptimizedExecutor::SplitOptimizedExecutor(BlockedMemoryDescCPtr inDesc, const std::vector<BlockedMemoryDescCPtr> &outDescs,
-                                                                const size_t axis) {
+Split::SplitOptimizedExecutor::SplitOptimizedExecutor(BlockedMemoryDescCPtr inDesc,
+                                                      const std::vector<BlockedMemoryDescCPtr>& outDescs,
+                                                      const size_t axis) {
     // find axis order position
     const auto& order = inDesc->getOrder();
     unsigned axisOrderPos = std::numeric_limits<unsigned>::max();
@@ -525,9 +543,7 @@ void Split::SplitOptimizedExecutor::exec(const uint8_t* srcData, const std::vect
     parallel_for2d(dstRawMemPtrs.size(), execCountStrides, [&](size_t i, size_t j) {
         uint8_t* dstData = dstRawMemPtrs[i];
 
-        cpu_memcpy(&dstData[j * dataSize[i]],
-                   &srcData[srcDataOffsets[i] + j * srcDataStride],
-                   dataSize[i]);
+        cpu_memcpy(&dstData[j * dataSize[i]], &srcData[srcDataOffsets[i] + j * srcDataStride], dataSize[i]);
     });
 }
 
@@ -579,6 +595,6 @@ void Split::resolveInPlaceEdges(Edge::LOOK look) {
     }
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/split.h b/src/plugins/intel_cpu/src/nodes/split.h
index 0782594bcf9989..d93e414c788851 100644
--- a/src/plugins/intel_cpu/src/nodes/split.h
+++ b/src/plugins/intel_cpu/src/nodes/split.h
@@ -42,15 +42,17 @@ class Split : public Node {
     std::shared_ptr<SplitExecutor> execPtr = nullptr;
 
     struct SplitOptimizedExecutor : public SplitExecutor {
-        public:
-            SplitOptimizedExecutor(BlockedMemoryDescCPtr inDesc, const std::vector<BlockedMemoryDescCPtr> &outDescs, const size_t axis);
-            void exec(const uint8_t* srcData, const std::vector<uint8_t*>& dstRawMemPtrs) override;
-
-        private:
-            std::vector<size_t> dataSize;
-            std::vector<size_t> srcDataOffsets;
-            size_t srcDataStride;
-            size_t countStrides;
+    public:
+        SplitOptimizedExecutor(BlockedMemoryDescCPtr inDesc,
+                               const std::vector<BlockedMemoryDescCPtr>& outDescs,
+                               const size_t axis);
+        void exec(const uint8_t* srcData, const std::vector<uint8_t*>& dstRawMemPtrs) override;
+
+    private:
+        std::vector<size_t> dataSize;
+        std::vector<size_t> srcDataOffsets;
+        size_t srcDataStride;
+        size_t countStrides;
     };
 
     void optimizedNspc2Ncsp(size_t MB);
@@ -66,6 +68,6 @@ class Split : public Node {
     std::vector<int> splitLengths;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/strided_slice.cpp b/src/plugins/intel_cpu/src/nodes/strided_slice.cpp
index 81a5825c99afc0..7f7d4983a31e5a 100644
--- a/src/plugins/intel_cpu/src/nodes/strided_slice.cpp
+++ b/src/plugins/intel_cpu/src/nodes/strided_slice.cpp
@@ -4,14 +4,14 @@
 
 #include "strided_slice.h"
 
-#include "openvino/core/parallel.hpp"
+#include <string>
+
 #include "common/cpu_memcpy.h"
 #include "input.h"
+#include "openvino/core/parallel.hpp"
 #include "openvino/opsets/opset1.hpp"
-#include "slice_shape_inference_utils.hpp"
 #include "shape_inference/custom/strided_slice.hpp"
-
-#include <string>
+#include "slice_shape_inference_utils.hpp"
 
 using namespace dnnl;
 
@@ -21,10 +21,10 @@ namespace node {
 
 bool StridedSlice::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
-        if (!ov::is_type<ov::op::v1::StridedSlice>(op) &&
-            !ov::is_type<ov::op::v8::Slice>(op) &&
+        if (!ov::is_type<ov::op::v1::StridedSlice>(op) && !ov::is_type<ov::op::v8::Slice>(op) &&
             !ov::is_type<ov::op::v15::SliceScatter>(op)) {
-            errorMessage = "Only StridedSlice from opset1, Slice from opset8 and SliceScatter from opset15 operations are supported.";
+            errorMessage = "Only StridedSlice from opset1, Slice from opset8 and SliceScatter from opset15 operations "
+                           "are supported.";
             return false;
         }
     } catch (...) {
@@ -33,8 +33,8 @@ bool StridedSlice::isSupportedOperation(const std::shared_ptr<const ov::Node>& o
     return true;
 }
 
-StridedSlice::StridedSlice(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) :
-        Node(op, context, StridedSliceShapeInferFactory(op)) {
+StridedSlice::StridedSlice(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, StridedSliceShapeInferFactory(op)) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
@@ -56,7 +56,8 @@ StridedSlice::StridedSlice(const std::shared_ptr<ov::Node>& op, const GraphConte
     }
 
     if ((attrs.isStridedSliceOp && (inputShapes.size() < 3 || inputShapes.size() > 4)) ||
-            (!attrs.isStridedSliceOp && (inputShapes.size() < (attrs.STRIDE_ID + 1) || inputShapes.size() > (attrs.AXES_ID + 1)))) {
+        (!attrs.isStridedSliceOp &&
+         (inputShapes.size() < (attrs.STRIDE_ID + 1) || inputShapes.size() > (attrs.AXES_ID + 1)))) {
         OPENVINO_THROW(errorPrefix, "has incorrect number of input edges");
     }
     if (outputShapes.size() != 1) {
@@ -73,7 +74,8 @@ StridedSlice::StridedSlice(const std::shared_ptr<ov::Node>& op, const GraphConte
 
     for (size_t i = 0lu; i < op->get_input_size(); i++) {
         isConstantInput[i] = ov::is_type<ov::op::v0::Constant>(op->get_input_node_shared_ptr(i));
-        if (!isConstantInput[i] && one_of(i, attrs.BEGIN_ID, attrs.END_ID, attrs.STRIDE_ID) && !attrs.isSliceScatterOp) {
+        if (!isConstantInput[i] && one_of(i, attrs.BEGIN_ID, attrs.END_ID, attrs.STRIDE_ID) &&
+            !attrs.isSliceScatterOp) {
             shapeHasDataDependency = true;
         }
     }
@@ -88,7 +90,7 @@ StridedSlice::StridedSlice(const std::shared_ptr<ov::Node>& op, const GraphConte
     if (attrs.isStridedSliceOp) {
         auto ss = ov::as_type_ptr<const ov::op::v1::StridedSlice>(op);
 
-        auto createMask = [&](const std::vector<int64_t> &origMask, const int bit = 0, bool needReverse = false) {
+        auto createMask = [&](const std::vector<int64_t>& origMask, const int bit = 0, bool needReverse = false) {
             std::vector<int> mask(origMask.size());
             for (size_t i = 0; i < mask.size(); i++) {
                 mask[i] = static_cast<int>(origMask[i]);
@@ -96,7 +98,8 @@ StridedSlice::StridedSlice(const std::shared_ptr<ov::Node>& op, const GraphConte
                     mask[i] = 1 - mask[i];
                 }
             }
-            for (size_t i = mask.size(); i < nDims; ++i) mask.push_back(bit);
+            for (size_t i = mask.size(); i < nDims; ++i)
+                mask.push_back(bit);
             return mask;
         };
 
@@ -134,7 +137,7 @@ StridedSlice::StridedSlice(const std::shared_ptr<ov::Node>& op, const GraphConte
         attrs.equalDims = true;
     }
 
-    auto fillingInParameters = [&](std::vector<int> &parameter, const size_t type, const int value) {
+    auto fillingInParameters = [&](std::vector<int>& parameter, const size_t type, const int value) {
         if (!isConstantInput[type])
             return;
 
@@ -143,7 +146,8 @@ StridedSlice::StridedSlice(const std::shared_ptr<ov::Node>& op, const GraphConte
 
         auto size = constNode->get_shape()[0];
         if (type != attrs.AXES_ID && attrs.ellipsisMaskCounter == 0 && size < nDims) {
-            for (size_t i = size; i < nDims; i++) parameter.push_back(value);
+            for (size_t i = size; i < nDims; i++)
+                parameter.push_back(value);
         }
     };
 
@@ -155,10 +159,12 @@ StridedSlice::StridedSlice(const std::shared_ptr<ov::Node>& op, const GraphConte
         fillingInParameters(attrs.axes, attrs.AXES_ID, 0);
 }
 
-void StridedSlice::getSupportedDescriptors() {
-}
+void StridedSlice::getSupportedDescriptors() {}
 
-static void addHiddenDims(StridedSlice::StridedSliceAttributes& attrs, const size_t inputRank, const size_t outputRank, bool withAxis) {
+static void addHiddenDims(StridedSlice::StridedSliceAttributes& attrs,
+                          const size_t inputRank,
+                          const size_t outputRank,
+                          bool withAxis) {
     if (withAxis) {
         std::vector<int> beginTmp(outputRank, 0);
         std::vector<int> endTmp(outputRank, -1);
@@ -180,8 +186,9 @@ static void addHiddenDims(StridedSlice::StridedSliceAttributes& attrs, const siz
 
     if (inputRank > 3 && attrs.equalDims && attrs.ellipsisMaskCounter == 1) {
         // all masks and input parameters are for planar layouts. So if we use blocked or per channel layout and
-        // there is ellipsis should to add default values in hidden dimensions to know real order of mask or parameter values
-        size_t afterDims =  attrs.begin.size() - attrs.ellipsisPos1 - 1;
+        // there is ellipsis should to add default values in hidden dimensions to know real order of mask or parameter
+        // values
+        size_t afterDims = attrs.begin.size() - attrs.ellipsisPos1 - 1;
         size_t ellipsisPos2 = inputRank - afterDims - 1;
 
         auto addHiddenDims = [&](std::vector<int>& data, const int bit = 0) {
@@ -248,7 +255,8 @@ void StridedSlice::initSupportedPrimitiveDescriptors() {
             const auto& srcDims = getInputShapeAtPort(attrs.DATA_ID).getDims();
             if (srcDims[1] == Shape::UNDEFINED_DIM)
                 return false;
-            auto channelBeginNormalized = tmpAttrs.begin[1] > 0 ? tmpAttrs.begin[1] : tmpAttrs.begin[1] + static_cast<std::int64_t>(srcDims[1]);
+            auto channelBeginNormalized =
+                tmpAttrs.begin[1] > 0 ? tmpAttrs.begin[1] : tmpAttrs.begin[1] + static_cast<std::int64_t>(srcDims[1]);
             return srcDims[1] % blockSize == 0 && abs(tmpAttrs.stride[1]) == 1 &&
                    (channelBeginNormalized > static_cast<long>(srcDims[1]) || channelBeginNormalized % blockSize == 0 ||
                     channelBeginNormalized < 0 || tmpAttrs.beginMask[1] == 0);
@@ -258,7 +266,10 @@ void StridedSlice::initSupportedPrimitiveDescriptors() {
 
         if (hasConstAttrInputs) {
             auto tmpAttrs = attrs;
-            addHiddenDims(tmpAttrs, getInputShapeAtPort(attrs.DATA_ID).getRank(), getOutputShapeAtPort(0).getRank(), isAxesSpecified);
+            addHiddenDims(tmpAttrs,
+                          getInputShapeAtPort(attrs.DATA_ID).getRank(),
+                          getOutputShapeAtPort(0).getRank(),
+                          isAxesSpecified);
             if (canUseBlocked(tmpAttrs, 8lu))
                 supportedTypes.push_back(LayoutType::nCsp8c);
             if (canUseBlocked(tmpAttrs, 16lu))
@@ -270,18 +281,25 @@ void StridedSlice::initSupportedPrimitiveDescriptors() {
     auto range = BlockedDescCreator::makeFilteredRange(creators, nDims, supportedTypes);
 
     for (auto itr = range.first; itr != range.second; ++itr) {
-        config.inConfs[attrs.DATA_ID].setMemDesc(itr->second->createSharedDesc(dataPrecision, getInputShapeAtPort(attrs.DATA_ID)));
-        config.inConfs[attrs.BEGIN_ID].setMemDesc(creators.at(LayoutType::ncsp)->createSharedDesc(iPrecision, getInputShapeAtPort(attrs.BEGIN_ID)));
-        config.inConfs[attrs.END_ID].setMemDesc(creators.at(LayoutType::ncsp)->createSharedDesc(iPrecision, getInputShapeAtPort(attrs.END_ID)));
+        config.inConfs[attrs.DATA_ID].setMemDesc(
+            itr->second->createSharedDesc(dataPrecision, getInputShapeAtPort(attrs.DATA_ID)));
+        config.inConfs[attrs.BEGIN_ID].setMemDesc(
+            creators.at(LayoutType::ncsp)->createSharedDesc(iPrecision, getInputShapeAtPort(attrs.BEGIN_ID)));
+        config.inConfs[attrs.END_ID].setMemDesc(
+            creators.at(LayoutType::ncsp)->createSharedDesc(iPrecision, getInputShapeAtPort(attrs.END_ID)));
         if (isStrideSpecified)
-            config.inConfs[attrs.STRIDE_ID].setMemDesc(creators.at(LayoutType::ncsp)->createSharedDesc(iPrecision, getInputShapeAtPort(attrs.STRIDE_ID)));
+            config.inConfs[attrs.STRIDE_ID].setMemDesc(
+                creators.at(LayoutType::ncsp)->createSharedDesc(iPrecision, getInputShapeAtPort(attrs.STRIDE_ID)));
         if (isAxesSpecified)
-            config.inConfs[attrs.AXES_ID].setMemDesc(creators.at(LayoutType::ncsp)->createSharedDesc(iPrecision, getInputShapeAtPort(attrs.AXES_ID)));
+            config.inConfs[attrs.AXES_ID].setMemDesc(
+                creators.at(LayoutType::ncsp)->createSharedDesc(iPrecision, getInputShapeAtPort(attrs.AXES_ID)));
         if (attrs.isSliceScatterOp) {
-            config.inConfs[attrs.UPDATES_ID].setMemDesc(itr->second->createSharedDesc(dataPrecision, getInputShapeAtPort(attrs.UPDATES_ID)));
+            config.inConfs[attrs.UPDATES_ID].setMemDesc(
+                itr->second->createSharedDesc(dataPrecision, getInputShapeAtPort(attrs.UPDATES_ID)));
         }
 
-        config.outConfs[0].setMemDesc(itr->second->createSharedDesc(dataPrecision, getOutputShapeAtPort(attrs.DATA_ID)));
+        config.outConfs[0].setMemDesc(
+            itr->second->createSharedDesc(dataPrecision, getOutputShapeAtPort(attrs.DATA_ID)));
         supportedPrimitiveDescriptors.emplace_back(config, impl_desc_type::ref);
     }
 }
@@ -342,7 +360,7 @@ StridedSlice::StridedSliceCommonExecutor::StridedSliceCommonExecutor(const Strid
                                                                      const std::vector<MemoryCPtr>& srcMemory,
                                                                      const std::vector<MemoryCPtr>& dstMemory,
                                                                      const std::string& errorPrefix)
-                                                                    : StridedSliceExecutor(attrs, srcMemory, dstMemory, errorPrefix) {
+    : StridedSliceExecutor(attrs, srcMemory, dstMemory, errorPrefix) {
     paramsInitialization(attrs, srcMemory, dstMemory);
     dimsNormalization();
     dimsGluing();
@@ -350,7 +368,8 @@ StridedSlice::StridedSliceCommonExecutor::StridedSliceCommonExecutor(const Strid
     m_threads_num = parallel_get_max_threads();
 }
 
-void StridedSlice::StridedSliceCommonExecutor::orderParametersByLayouts(const BlockedMemoryDescCPtr& blockedMemoryDesc) {
+void StridedSlice::StridedSliceCommonExecutor::orderParametersByLayouts(
+    const BlockedMemoryDescCPtr& blockedMemoryDesc) {
     size_t blk = 1;
     bool isBlockedLayout = false;
     if (blockedMemoryDesc->hasLayoutType(LayoutType::nCsp16c)) {
@@ -410,12 +429,13 @@ void StridedSlice::StridedSliceCommonExecutor::paramsInitialization(const Stride
     const size_t outputRank = dstMemory[0]->getShape().getRank();
     const size_t nDims = std::max(inputRank, outputRank);
 
-    auto fillingInParameters = [&](std::vector<int> &parameter, const size_t type, const size_t size, const int value) {
-        const int *ptr = srcMemory[type]->getDataAs<const int32_t>();
+    auto fillingInParameters = [&](std::vector<int>& parameter, const size_t type, const size_t size, const int value) {
+        const int* ptr = srcMemory[type]->getDataAs<const int32_t>();
         parameter.assign(ptr, ptr + size);
 
         if (type != attrs.AXES_ID && params.attrs.ellipsisMaskCounter == 0 && size < nDims) {
-            for (size_t i = size; i < nDims; i++) parameter.push_back(value);
+            for (size_t i = size; i < nDims; i++)
+                parameter.push_back(value);
         }
     };
 
@@ -465,18 +485,20 @@ void StridedSlice::StridedSliceCommonExecutor::dimsNormalization() {
     // creating new src and dst dimensions and parameters of the same size using masks
     //
     // example 1: before srcDims = [5, 6, 8, 3, 2], begin = [1, 0], end = [4, 0], stride = [1, 1]
-    //            beginMask = [0, 1], endMask = [0, 1], ellipsisMask = [1, 0], newAxisMas = [0, 0], shrinkAxisMask = [0, 0]
-    //            after srcDims = [5, 6, 8, 3, 2], begin = [1, 0, 0, 0, 0], end = [4, 5, 7, 2, 1], stride = [1, 1, 1, 1, 1], dstDims = [4, 6, 8, 3, 2]
+    //            beginMask = [0, 1], endMask = [0, 1], ellipsisMask = [1, 0], newAxisMas = [0, 0], shrinkAxisMask = [0,
+    //            0] after srcDims = [5, 6, 8, 3, 2], begin = [1, 0, 0, 0, 0], end = [4, 5, 7, 2, 1], stride = [1, 1, 1,
+    //            1, 1], dstDims = [4, 6, 8, 3, 2]
     //
-    // example 2: before srcDims = [5, 6, 8, 3, 2], begin = [0, 3, 0, 0, 0], end = [0, 3, 0, 0, 0], stride = [1, 1, 1, 1, 1]
-    //            beginMask = [1, 0, 1, 1, 1], endMask = [1, 0, 1, 1, 1], ellipsisMask = [0, 0, 0, 0, 0], newAxisMask = [0, 0, 0, 0, 0],
-    //            shrinkAxisMask = [0, 1, 0, 0, 0]
-    //            after srcDims = [5, 6, 8, 3, 2], begin = [0, 3, 0, 0, 0], end = [4, 3, 7, 2, 1], stride = [1, 1, 1, 1, 1], dstDims = [5, 1, 8, 3, 2]
+    // example 2: before srcDims = [5, 6, 8, 3, 2], begin = [0, 3, 0, 0, 0], end = [0, 3, 0, 0, 0], stride = [1, 1, 1,
+    // 1, 1]
+    //            beginMask = [1, 0, 1, 1, 1], endMask = [1, 0, 1, 1, 1], ellipsisMask = [0, 0, 0, 0, 0], newAxisMask =
+    //            [0, 0, 0, 0, 0], shrinkAxisMask = [0, 1, 0, 0, 0] after srcDims = [5, 6, 8, 3, 2], begin = [0, 3, 0,
+    //            0, 0], end = [4, 3, 7, 2, 1], stride = [1, 1, 1, 1, 1], dstDims = [5, 1, 8, 3, 2]
     //
     // example 3: before srcDims = [5, 8, 3, 2], begin = [0, 0, 0, 0], end = [0, 0, 0, 0], stride = [1, 1, 1, 1]
-    //            beginMask = [1, 0, 1, 1, 1], endMask = [1, 0, 1, 1, 1], ellipsisMask = [0, 0, 0, 0, 0], newAxisMask = [0, 1, 0, 0, 0],
-    //            shrinkAxisMask = [0, 0, 0, 0, 0]
-    //            after srcDims = [5, 1, 8, 3, 2], begin = [0, 0, 0, 0, 0], end = [4, 0, 7, 2, 1], stride = [1, 1, 1, 1, 1], dstDims = [5, 1, 8, 3, 2]
+    //            beginMask = [1, 0, 1, 1, 1], endMask = [1, 0, 1, 1, 1], ellipsisMask = [0, 0, 0, 0, 0], newAxisMask =
+    //            [0, 1, 0, 0, 0], shrinkAxisMask = [0, 0, 0, 0, 0] after srcDims = [5, 1, 8, 3, 2], begin = [0, 0, 0,
+    //            0, 0], end = [4, 0, 7, 2, 1], stride = [1, 1, 1, 1, 1], dstDims = [5, 1, 8, 3, 2]
 
     auto clipping = [](int& idx, const int min, const int max) {
         idx = (idx > min) ? idx : min;
@@ -535,12 +557,14 @@ void StridedSlice::StridedSliceCommonExecutor::dimsNormalization() {
 
                 srcIdx++;
             } else {
-                int b = params.attrs.beginMask[axis] == 1 ? params.attrs.begin[axis] : (params.attrs.stride[axis] > 0 ? 0 : -1);
+                int b = params.attrs.beginMask[axis] == 1 ? params.attrs.begin[axis]
+                                                          : (params.attrs.stride[axis] > 0 ? 0 : -1);
                 correcting(b, params.srcBlockedDims[srcIdx]);
                 clipping(b, 0, params.srcBlockedDims[srcIdx]);
 
-                int e = params.attrs.endMask[axis] == 1 ? (params.attrs.stride[axis] > 0 ? params.attrs.end[axis] - 1 : params.attrs.end[axis] + 1) :
-                        (params.attrs.stride[axis] > 0 ? -1 : 0);
+                int e = params.attrs.endMask[axis] == 1
+                            ? (params.attrs.stride[axis] > 0 ? params.attrs.end[axis] - 1 : params.attrs.end[axis] + 1)
+                            : (params.attrs.stride[axis] > 0 ? -1 : 0);
                 correcting(e, params.srcBlockedDims[srcIdx]);
                 clipping(e, 0, params.srcBlockedDims[srcIdx]);
 
@@ -548,7 +572,8 @@ void StridedSlice::StridedSliceCommonExecutor::dimsNormalization() {
                 endTemp.push_back(e);
                 strideTemp.push_back(params.attrs.stride[axis]);
                 newSrcDims.push_back(params.srcBlockedDims[srcIdx]);
-                newDstDims.push_back(ceil(static_cast<float>(abs(e - b) + 1) / static_cast<float>(abs(strideTemp.back()))));
+                newDstDims.push_back(
+                    ceil(static_cast<float>(abs(e - b) + 1) / static_cast<float>(abs(strideTemp.back()))));
 
                 srcIdx++;
             }
@@ -572,12 +597,14 @@ void StridedSlice::StridedSliceCommonExecutor::dimsNormalization() {
 
 void StridedSlice::StridedSliceCommonExecutor::dimsGluing() {
     // gluing of dimensions if there aren't begin, end and stride != 1 on this axis
-    // example: before gluing srcDims = [5, 6, 8, 3, 2], begin = [1, 0, 0, 0, 0], stride = [1, 1, 2, 1, 1], dstDims = [4, 6, 4, 3, 2]
-    //          after gluing  srcDims = [30, 8, 6],      begin = [6, 0, 0],       stride = [1, 2, 1],       dstDims = [24, 4, 6]
+    // example: before gluing srcDims = [5, 6, 8, 3, 2], begin = [1, 0, 0, 0, 0], stride = [1, 1, 2, 1, 1], dstDims =
+    // [4, 6, 4, 3, 2]
+    //          after gluing  srcDims = [30, 8, 6],      begin = [6, 0, 0],       stride = [1, 2, 1],       dstDims =
+    //          [24, 4, 6]
 
     size_t realNDims = params.dstBlockedDims.size();
 
-    std::pair<size_t, size_t> secondDim = { 0, params.attrs.begin.size() };
+    std::pair<size_t, size_t> secondDim = {0, params.attrs.begin.size()};
     VectorDims indexes(1, 0);
     for (size_t idx = 0; idx < params.attrs.begin.size(); idx++) {
         if (params.attrs.begin[idx] != 0 ||
@@ -618,8 +645,10 @@ void StridedSlice::StridedSliceCommonExecutor::dimsGluing() {
             const size_t beginShift = indexes[idx - 1] + 1;
             const size_t endShift = indexes[idx] + 1;
 
-            params.dstBlockedDims.erase(params.dstBlockedDims.begin() + beginShift, params.dstBlockedDims.begin() + endShift);
-            params.srcBlockedDims.erase(params.srcBlockedDims.begin() + beginShift, params.srcBlockedDims.begin() + endShift);
+            params.dstBlockedDims.erase(params.dstBlockedDims.begin() + beginShift,
+                                        params.dstBlockedDims.begin() + endShift);
+            params.srcBlockedDims.erase(params.srcBlockedDims.begin() + beginShift,
+                                        params.srcBlockedDims.begin() + endShift);
             params.dstStrides.erase(params.dstStrides.begin() + beginShift, params.dstStrides.begin() + endShift);
             params.srcStrides.erase(params.srcStrides.begin() + beginShift, params.srcStrides.begin() + endShift);
 
@@ -660,10 +689,13 @@ void StridedSlice::StridedSliceCommonExecutor::dimsGluing() {
             params.dstBlockedDims[1] = 1;
 
         workAmount = params.dstBlockedDims[0] * params.dstBlockedDims[1];
-        srcShift = (params.attrs.begin[0] * params.srcStrides[0] + params.attrs.begin[1] * params.srcStrides[1]) * params.attrs.dataSize;
+        srcShift = (params.attrs.begin[0] * params.srcStrides[0] + params.attrs.begin[1] * params.srcStrides[1]) *
+                   params.attrs.dataSize;
     } else {
-        srcShift = params.attrs.stride.back() == 1 && params.attrs.stride.size() > 1 ?
-                          params.attrs.begin[params.nDimsForWork] * params.srcStrides[params.nDimsForWork] * params.attrs.dataSize : 0;
+        srcShift = params.attrs.stride.back() == 1 && params.attrs.stride.size() > 1
+                       ? params.attrs.begin[params.nDimsForWork] * params.srcStrides[params.nDimsForWork] *
+                             params.attrs.dataSize
+                       : 0;
     }
 }
 
@@ -688,7 +720,7 @@ void StridedSlice::StridedSliceCommonExecutor::indicesCalculation() {
         return;
     }
 
-    auto getSrcIdx = [&](const VectorDims& indexes){
+    auto getSrcIdx = [&](const VectorDims& indexes) {
         size_t srcIdx = 0;
         for (size_t i = 0; i < params.nDimsForWork; ++i)
             srcIdx += (params.attrs.begin[i] + indexes[i] * params.attrs.stride[i]) * params.srcStrides[i];
@@ -743,7 +775,8 @@ void StridedSlice::StridedSliceCommonExecutor::indicesCalculationForOptimized()
     }
 }
 
-void StridedSlice::StridedSliceCommonExecutor::execStridedSlice(const std::vector<MemoryCPtr>& srcMemory, const std::vector<MemoryCPtr>& dstMemory) {
+void StridedSlice::StridedSliceCommonExecutor::execStridedSlice(const std::vector<MemoryCPtr>& srcMemory,
+                                                                const std::vector<MemoryCPtr>& dstMemory) {
     const uint8_t* srcData = srcMemory[0]->getDataAs<const uint8_t>();
     uint8_t* dstData = dstMemory[0]->getDataAs<uint8_t>();
     const uint8_t* srcShiftedData = srcData + srcShift;
@@ -756,7 +789,8 @@ void StridedSlice::StridedSliceCommonExecutor::execStridedSlice(const std::vecto
     });
 }
 
-void StridedSlice::StridedSliceCommonExecutor::execSliceScatter(const std::vector<MemoryCPtr>& srcMemory, const std::vector<MemoryCPtr>& dstMemory) {
+void StridedSlice::StridedSliceCommonExecutor::execSliceScatter(const std::vector<MemoryCPtr>& srcMemory,
+                                                                const std::vector<MemoryCPtr>& dstMemory) {
     const uint8_t* srcData = srcMemory[0]->getDataAs<const uint8_t>();
     const uint8_t* srcUpdates = srcMemory[1]->getDataAs<const uint8_t>();
     uint8_t* dstData = dstMemory[0]->getDataAs<uint8_t>();
@@ -775,7 +809,8 @@ void StridedSlice::StridedSliceCommonExecutor::execSliceScatter(const std::vecto
     });
 }
 
-void StridedSlice::StridedSliceCommonExecutor::exec(const std::vector<MemoryCPtr>& srcMemory, const std::vector<MemoryCPtr>& dstMemory) {
+void StridedSlice::StridedSliceCommonExecutor::exec(const std::vector<MemoryCPtr>& srcMemory,
+                                                    const std::vector<MemoryCPtr>& dstMemory) {
     if (params.attrs.isSliceScatterOp) {
         execSliceScatter(srcMemory, dstMemory);
     } else {
@@ -783,6 +818,6 @@ void StridedSlice::StridedSliceCommonExecutor::exec(const std::vector<MemoryCPtr
     }
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/strided_slice.h b/src/plugins/intel_cpu/src/nodes/strided_slice.h
index bf698643271d7a..4f3b9c1c14434c 100644
--- a/src/plugins/intel_cpu/src/nodes/strided_slice.h
+++ b/src/plugins/intel_cpu/src/nodes/strided_slice.h
@@ -5,6 +5,7 @@
 #pragma once
 
 #include <node.h>
+
 #include <string>
 #include <vector>
 
@@ -72,9 +73,9 @@ class StridedSlice : public Node {
         StridedSliceExecutor(const StridedSliceAttributes& attrs,
                              const std::vector<MemoryCPtr>& srcMemory,
                              const std::vector<MemoryCPtr>& dstMemory,
-                             const std::string& errorPrefix) : errorPrefix(errorPrefix) {}
-        virtual void exec(const std::vector<MemoryCPtr>& srcMemory,
-                          const std::vector<MemoryCPtr>& dstMemory) = 0;
+                             const std::string& errorPrefix)
+            : errorPrefix(errorPrefix) {}
+        virtual void exec(const std::vector<MemoryCPtr>& srcMemory, const std::vector<MemoryCPtr>& dstMemory) = 0;
         virtual ~StridedSliceExecutor() = default;
 
     protected:
@@ -87,12 +88,9 @@ class StridedSlice : public Node {
                                    const std::vector<MemoryCPtr>& srcMemory,
                                    const std::vector<MemoryCPtr>& dstMemory,
                                    const std::string& errorPrefix);
-        void exec(const std::vector<MemoryCPtr>& srcMemory,
-                  const std::vector<MemoryCPtr>& dstMemory) override;
-        void execSliceScatter(const std::vector<MemoryCPtr>& srcMemory,
-                              const std::vector<MemoryCPtr>& dstMemory);
-        void execStridedSlice(const std::vector<MemoryCPtr>& srcMemory,
-                              const std::vector<MemoryCPtr>& dstMemory);
+        void exec(const std::vector<MemoryCPtr>& srcMemory, const std::vector<MemoryCPtr>& dstMemory) override;
+        void execSliceScatter(const std::vector<MemoryCPtr>& srcMemory, const std::vector<MemoryCPtr>& dstMemory);
+        void execStridedSlice(const std::vector<MemoryCPtr>& srcMemory, const std::vector<MemoryCPtr>& dstMemory);
 
     private:
         struct StridedSliceParams {
@@ -140,6 +138,6 @@ class StridedSlice : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/string_tensor_pack.cpp b/src/plugins/intel_cpu/src/nodes/string_tensor_pack.cpp
index f8d6c2c78fecf2..ff52cc32fe1cb1 100644
--- a/src/plugins/intel_cpu/src/nodes/string_tensor_pack.cpp
+++ b/src/plugins/intel_cpu/src/nodes/string_tensor_pack.cpp
@@ -3,8 +3,9 @@
 //
 
 #include "string_tensor_pack.h"
-#include "openvino/reference/string_tensor_pack.hpp"
+
 #include "openvino/op/string_tensor_pack.hpp"
+#include "openvino/reference/string_tensor_pack.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -17,7 +18,8 @@ StringTensorPack::StringTensorPack(const std::shared_ptr<ov::Node>& op, const Gr
     }
 }
 
-bool StringTensorPack::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool StringTensorPack::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                            std::string& errorMessage) noexcept {
     try {
         if (!ov::is_type<ov::op::v15::StringTensorPack>(op)) {
             errorMessage = "Only opset15 StringTensorPack operation is supported";
@@ -37,10 +39,11 @@ void StringTensorPack::initSupportedPrimitiveDescriptors() {
     if (!supportedPrimitiveDescriptors.empty())
         return;
     ov::element::Type indicesPrecision = getOriginalInputPrecisionAtPort(0);
-    addSupportedPrimDesc(
-        {{LayoutType::ncsp, indicesPrecision}, {LayoutType::ncsp, indicesPrecision}, {LayoutType::ncsp, ov::element::u8}},
-        {{LayoutType::ncsp, ov::element::string}},
-        impl_desc_type::ref);
+    addSupportedPrimDesc({{LayoutType::ncsp, indicesPrecision},
+                          {LayoutType::ncsp, indicesPrecision},
+                          {LayoutType::ncsp, ov::element::u8}},
+                         {{LayoutType::ncsp, ov::element::string}},
+                         impl_desc_type::ref);
 }
 
 bool StringTensorPack::created() const {
@@ -58,33 +61,33 @@ void StringTensorPack::executeDynamicImpl(dnnl::stream strm) {
 template <class T_idx>
 void StringTensorPack::executeImpl() {
     const auto& data_shape = getSrcMemoryAtPort(0)->getStaticDims();
-    ov::reference::string_tensor_pack(
-        getSrcDataAtPortAs<const T_idx>(0),
-        getSrcDataAtPortAs<const T_idx>(1),
-        getSrcDataAtPortAs<const uint8_t>(2),
-        getDstDataAtPortAs<std::string>(0),
-        ov::shape_size(data_shape));
+    ov::reference::string_tensor_pack(getSrcDataAtPortAs<const T_idx>(0),
+                                      getSrcDataAtPortAs<const T_idx>(1),
+                                      getSrcDataAtPortAs<const uint8_t>(2),
+                                      getDstDataAtPortAs<std::string>(0),
+                                      ov::shape_size(data_shape));
 }
 
 namespace {
 struct StringTensorPackContext {
-    StringTensorPack &node;
+    StringTensorPack& node;
 };
-}
+}  // namespace
 
-template<typename T_idx>
+template <typename T_idx>
 struct StringTensorPack::StringTensorPackExecute {
     void operator()(StringTensorPackContext& ctx) {
-            ctx.node.executeImpl<T_idx>();
-        }
+        ctx.node.executeImpl<T_idx>();
+    }
 };
 
 void StringTensorPack::execute(dnnl::stream strm) {
     auto indicesPrecision = getParentEdgeAt(0)->getMemory().getDesc().getPrecision();
-    StringTensorPackContext ctx = {
-            *this
-    };
-    OV_SWITCH(intel_cpu, StringTensorPackExecute, ctx, indicesPrecision,
+    StringTensorPackContext ctx = {*this};
+    OV_SWITCH(intel_cpu,
+              StringTensorPackExecute,
+              ctx,
+              indicesPrecision,
               OV_CASE(ov::element::i32, int32_t),
               OV_CASE(ov::element::i64, int64_t))
 }
diff --git a/src/plugins/intel_cpu/src/nodes/string_tensor_pack.h b/src/plugins/intel_cpu/src/nodes/string_tensor_pack.h
index 57ebe63721ed63..78eb86d0c5aa84 100644
--- a/src/plugins/intel_cpu/src/nodes/string_tensor_pack.h
+++ b/src/plugins/intel_cpu/src/nodes/string_tensor_pack.h
@@ -26,7 +26,7 @@ class StringTensorPack : public Node {
     template <class OV_INDEX_TYPE>
     void executeImpl();
 
-    template<typename T_idx>
+    template <typename T_idx>
     struct StringTensorPackExecute;
 };
 
diff --git a/src/plugins/intel_cpu/src/nodes/string_tensor_unpack.cpp b/src/plugins/intel_cpu/src/nodes/string_tensor_unpack.cpp
index 06eb2f149d0d4a..4d6b2c0135b912 100644
--- a/src/plugins/intel_cpu/src/nodes/string_tensor_unpack.cpp
+++ b/src/plugins/intel_cpu/src/nodes/string_tensor_unpack.cpp
@@ -3,8 +3,9 @@
 //
 
 #include "string_tensor_unpack.h"
-#include "openvino/reference/string_tensor_unpack.hpp"
+
 #include "openvino/op/string_tensor_unpack.hpp"
+#include "openvino/reference/string_tensor_unpack.hpp"
 #include "shape_inference/shape_inference_internal_dyn.hpp"
 
 namespace ov {
@@ -18,7 +19,8 @@ StringTensorUnpack::StringTensorUnpack(const std::shared_ptr<ov::Node>& op, cons
     }
 }
 
-bool StringTensorUnpack::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool StringTensorUnpack::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                              std::string& errorMessage) noexcept {
     try {
         if (!ov::is_type<ov::op::v15::StringTensorUnpack>(op)) {
             errorMessage = "Only opset15 StringTensorUnpack operation is supported";
@@ -37,10 +39,11 @@ void StringTensorUnpack::getSupportedDescriptors() {
 void StringTensorUnpack::initSupportedPrimitiveDescriptors() {
     if (!supportedPrimitiveDescriptors.empty())
         return;
-    addSupportedPrimDesc(
-        {{LayoutType::ncsp, ov::element::string}},
-        {{LayoutType::ncsp, ov::element::i32}, {LayoutType::ncsp, ov::element::i32}, {LayoutType::ncsp, ov::element::u8}},
-        impl_desc_type::ref);
+    addSupportedPrimDesc({{LayoutType::ncsp, ov::element::string}},
+                         {{LayoutType::ncsp, ov::element::i32},
+                          {LayoutType::ncsp, ov::element::i32},
+                          {LayoutType::ncsp, ov::element::u8}},
+                         impl_desc_type::ref);
 }
 
 bool StringTensorUnpack::created() const {
@@ -60,18 +63,17 @@ void StringTensorUnpack::executeDynamicImpl(dnnl::stream strm) {
     for (Dim i = 0; i < stringCount; ++i) {
         totalCharLength += srcData[i].length();
     }
-    redefineOutputMemory({ srcDataDims, srcDataDims, {totalCharLength}});
+    redefineOutputMemory({srcDataDims, srcDataDims, {totalCharLength}});
     execute(strm);
 }
 
 void StringTensorUnpack::execute(dnnl::stream strm) {
     const auto stringCount = ov::shape_size(getSrcMemoryAtPort(0)->getStaticDims());
-    ov::reference::string_tensor_unpack(
-        getSrcDataAtPortAs<const std::string>(0),
-        getDstDataAtPortAs<int32_t>(0),
-        getDstDataAtPortAs<int32_t>(1),
-        getDstDataAtPortAs<uint8_t>(2),
-        stringCount);
+    ov::reference::string_tensor_unpack(getSrcDataAtPortAs<const std::string>(0),
+                                        getDstDataAtPortAs<int32_t>(0),
+                                        getDstDataAtPortAs<int32_t>(1),
+                                        getDstDataAtPortAs<uint8_t>(2),
+                                        stringCount);
 }
 }  // namespace node
 }  // namespace intel_cpu
diff --git a/src/plugins/intel_cpu/src/nodes/subgraph.cpp b/src/plugins/intel_cpu/src/nodes/subgraph.cpp
index d5579fea23b6b1..94e01cd89a39fa 100644
--- a/src/plugins/intel_cpu/src/nodes/subgraph.cpp
+++ b/src/plugins/intel_cpu/src/nodes/subgraph.cpp
@@ -9,59 +9,60 @@
 #include "openvino/core/parallel.hpp"
 #include "openvino/core/rt_info.hpp"
 #include "shape_inference/custom/subgraph.hpp"
-#include "snippets/utils/utils.hpp"
+#include "snippets/lowered/pass/init_loops.hpp"
+#include "snippets/lowered/pass/insert_buffers.hpp"
+#include "snippets/lowered/pass/insert_loops.hpp"
+#include "snippets/lowered/pass/mark_loops.hpp"
 #include "snippets/op/subgraph.hpp"
+#include "snippets/pass/analyze_broadcastable_inputs.hpp"
+#include "snippets/pass/canonicalization.hpp"
 #include "snippets/pass/hash.hpp"
 #include "snippets/pass/matmul_to_brgemm.hpp"
-#include "snippets/pass/propagate_precision.hpp"
 #include "snippets/pass/positioned_pass.hpp"
-#include "snippets/pass/canonicalization.hpp"
-#include "snippets/pass/analyze_broadcastable_inputs.hpp"
-#include "snippets/lowered/pass/insert_loops.hpp"
-#include "snippets/lowered/pass/mark_loops.hpp"
-#include "snippets/lowered/pass/insert_buffers.hpp"
-#include "snippets/lowered/pass/init_loops.hpp"
-#include "transformations/defs.hpp"
+#include "snippets/pass/propagate_precision.hpp"
+#include "snippets/utils/utils.hpp"
 #include "transformations/cpu_opset/common/pass/convert_to_swish_cpu.hpp"
+#include "transformations/defs.hpp"
 #include "transformations/snippets/common/pass/mul_add_to_fma.hpp"
 
 #if defined(OPENVINO_ARCH_ARM64)
-#include "emitters/snippets/aarch64/cpu_generator.hpp"
-#include "transformations/snippets/aarch64/shape_inference.hpp"
+#    include "emitters/snippets/aarch64/cpu_generator.hpp"
+#    include "transformations/snippets/aarch64/shape_inference.hpp"
 #else
-#include "emitters/snippets/x64/cpu_generator.hpp"
-#include "transformations/snippets/x64/pass/lowered/brgemm_cpu_blocking.hpp"
-#include "transformations/snippets/x64/pass/lowered/fuse_load_store_and_convert.hpp"
-#include "transformations/snippets/x64/pass/lowered/insert_brgemm_copy_buffers.hpp"
-#include "transformations/snippets/x64/pass/remove_converts.hpp"
-#include "transformations/snippets/x64/pass/brgemm_to_brgemm_cpu.hpp"
-#include "transformations/snippets/x64/pass/eliminate_brgemm_copy_b.hpp"
-#include "transformations/snippets/x64/pass/enforce_precision.hpp"
-#include "transformations/snippets/x64/shape_inference.hpp"
-#include "transformations/snippets/x64/pass/lowered/adjust_brgemm_copy_b_loop_ports.hpp"
+#    include "emitters/snippets/x64/cpu_generator.hpp"
+#    include "transformations/snippets/x64/pass/brgemm_to_brgemm_cpu.hpp"
+#    include "transformations/snippets/x64/pass/eliminate_brgemm_copy_b.hpp"
+#    include "transformations/snippets/x64/pass/enforce_precision.hpp"
+#    include "transformations/snippets/x64/pass/lowered/adjust_brgemm_copy_b_loop_ports.hpp"
+#    include "transformations/snippets/x64/pass/lowered/brgemm_cpu_blocking.hpp"
+#    include "transformations/snippets/x64/pass/lowered/fuse_load_store_and_convert.hpp"
+#    include "transformations/snippets/x64/pass/lowered/insert_brgemm_copy_buffers.hpp"
+#    include "transformations/snippets/x64/pass/remove_converts.hpp"
+#    include "transformations/snippets/x64/shape_inference.hpp"
 #endif
 
-#include "utils/cpu_utils.hpp"
-#include "utils/ngraph_utils.hpp"
-
 #include <algorithm>
 #include <array>
 #include <vector>
 
+#include "utils/cpu_utils.hpp"
+#include "utils/ngraph_utils.hpp"
+
 #if defined(__linux__) && defined(OPENVINO_ARCH_X86_64) && defined(SNIPPETS_DEBUG_CAPS)
-#include "emitters/snippets/x64/jit_segfault_detector_emitter.hpp"
-#include <signal.h>
+#    include <signal.h>
+
+#    include "emitters/snippets/x64/jit_segfault_detector_emitter.hpp"
 std::mutex err_print_lock;
 #endif
 
 #ifdef SNIPPETS_LIBXSMM_TPP
-#include "snippets/lowered/pass/optimize_domain.hpp"
-#include "transformations/tpp/x64/pass/brgemm_to_brgemm_tpp.hpp"
-#include "transformations/tpp/x64/pass/eltwise_to_eltwise_tpp.hpp"
-#include "transformations/tpp/x64/pass/scalar_to_scalar_tpp.hpp"
-#include "transformations/tpp/x64/pass/lowered/set_tpp_leading_dim.hpp"
-#include "transformations/tpp/x64/pass/lowered/brgemm_tpp_blocking.hpp"
-#include "transformations/tpp/x64/pass/fuse_tpp_to_equations.hpp"
+#    include "snippets/lowered/pass/optimize_domain.hpp"
+#    include "transformations/tpp/x64/pass/brgemm_to_brgemm_tpp.hpp"
+#    include "transformations/tpp/x64/pass/eltwise_to_eltwise_tpp.hpp"
+#    include "transformations/tpp/x64/pass/fuse_tpp_to_equations.hpp"
+#    include "transformations/tpp/x64/pass/lowered/brgemm_tpp_blocking.hpp"
+#    include "transformations/tpp/x64/pass/lowered/set_tpp_leading_dim.hpp"
+#    include "transformations/tpp/x64/pass/scalar_to_scalar_tpp.hpp"
 #endif
 
 namespace ov {
@@ -78,9 +79,9 @@ class SubgraphStaticExecutor : public Subgraph::SubgraphExecutor {
                            const std::vector<ptrdiff_t>& start_offset_out,
                            const std::shared_ptr<CPURuntimeConfig>& snippet_config,
                            const BufferScratchpadAllocator& allocator)
-    : SubgraphExecutor(snippet_attrs, snippet, start_offset_in, start_offset_out, snippet_config, allocator) {}
+        : SubgraphExecutor(snippet_attrs, snippet, start_offset_in, start_offset_out, snippet_config, allocator) {}
 
-    void exec_impl(const std::vector<MemoryPtr>& inMemPtrs, const std::vector<MemoryPtr>& outMemPtrs) override  {
+    void exec_impl(const std::vector<MemoryPtr>& inMemPtrs, const std::vector<MemoryPtr>& outMemPtrs) override {
         const auto& callable = m_schedule->get_callable<kernel>();
 
         auto initializer = [&](jit_snippets_call_args& call_args, size_t ithr) {
@@ -100,8 +101,10 @@ class SubgraphStaticExecutor : public Subgraph::SubgraphExecutor {
 protected:
     typedef void (*kernel)(const void*, const void*);
 
-    inline void init_call_args(jit_snippets_call_args& call_args, const std::vector<MemoryPtr>& srcMemPtrs,
-                               const std::vector<MemoryPtr>& dstMemPtrs, size_t ithr) {
+    inline void init_call_args(jit_snippets_call_args& call_args,
+                               const std::vector<MemoryPtr>& srcMemPtrs,
+                               const std::vector<MemoryPtr>& dstMemPtrs,
+                               size_t ithr) {
         for (size_t i = 0; i < srcMemPtrs.size(); i++)
             call_args.src_ptrs[i] = srcMemPtrs[i]->getDataAs<const uint8_t>() + m_start_offset_in[i];
 
@@ -121,7 +124,7 @@ class SubgraphDynamicSpecializedExecutor : public Subgraph::SubgraphExecutor {
                                        const std::vector<ptrdiff_t>& start_offset_out,
                                        const std::shared_ptr<CPURuntimeConfig>& snippet_config,
                                        const BufferScratchpadAllocator& allocator)
-    : SubgraphExecutor(snippet_attrs, snippet, start_offset_in, start_offset_out, snippet_config, allocator) {
+        : SubgraphExecutor(snippet_attrs, snippet, start_offset_in, start_offset_out, snippet_config, allocator) {
         buffer_offsets = snippet_config->buffer_cluster_offsets;
         data_offsets = snippet_config->io_data_offsets;
         loop_args = snippet_config->loop_args;
@@ -132,10 +135,11 @@ class SubgraphDynamicSpecializedExecutor : public Subgraph::SubgraphExecutor {
         const auto& callable = m_schedule->get_callable<dynamic_kernel>();
 
         OPENVINO_ASSERT(data_offsets.size() == inMemPtrs.size() + outMemPtrs.size(), "Incorrect data offset count!");
-        OPENVINO_ASSERT(data_offsets.front().size() == m_parallel_exec_domain.size(), "Data offsets with invalid ranks detected");
+        OPENVINO_ASSERT(data_offsets.front().size() == m_parallel_exec_domain.size(),
+                        "Data offsets with invalid ranks detected");
 
-        // Note: we need to reset KernelExecutorTable to the state that was recorded in the SubgraphDynamicSpecializedExecutor
-        // constructor because the table might've been used for other shapes
+        // Note: we need to reset KernelExecutorTable to the state that was recorded in the
+        // SubgraphDynamicSpecializedExecutor constructor because the table might've been used for other shapes
         reset_exec_table_state();
 
         std::vector<const uint8_t*> src_ptrs;
@@ -158,7 +162,7 @@ class SubgraphDynamicSpecializedExecutor : public Subgraph::SubgraphExecutor {
     }
 
 protected:
-    typedef void (*dynamic_kernel)(const void *);
+    typedef void (*dynamic_kernel)(const void*);
 
     inline void init_call_args(jit_snippets_call_args& call_args, size_t ithr) {
         call_args.register_loops(loop_args);
@@ -167,8 +171,10 @@ class SubgraphDynamicSpecializedExecutor : public Subgraph::SubgraphExecutor {
         update_scratchpad_ptr(call_args.buffer_scratchpad_ptr, ithr);
     }
 
-    inline void init_original_ptrs(const std::vector<MemoryPtr>& srcMemPtrs, const std::vector<MemoryPtr>& dstMemPtrs,
-                                   std::vector<const uint8_t*>& src_ptrs, std::vector<uint8_t*>& dst_ptrs) {
+    inline void init_original_ptrs(const std::vector<MemoryPtr>& srcMemPtrs,
+                                   const std::vector<MemoryPtr>& dstMemPtrs,
+                                   std::vector<const uint8_t*>& src_ptrs,
+                                   std::vector<uint8_t*>& dst_ptrs) {
         const auto in_num = srcMemPtrs.size();
         const auto out_num = dstMemPtrs.size();
 
@@ -181,8 +187,10 @@ class SubgraphDynamicSpecializedExecutor : public Subgraph::SubgraphExecutor {
             dst_ptrs[i] = dstMemPtrs[i]->getDataAs<uint8_t>() + m_start_offset_out[i];
     }
 
-    inline void update_ptrs(jit_snippets_call_args& call_args, const std::vector<const uint8_t*>& src_ptrs,
-                            const std::vector<uint8_t*>& dst_ptrs, const std::vector<size_t>& indexes) const {
+    inline void update_ptrs(jit_snippets_call_args& call_args,
+                            const std::vector<const uint8_t*>& src_ptrs,
+                            const std::vector<uint8_t*>& dst_ptrs,
+                            const std::vector<size_t>& indexes) const {
         for (size_t i = 0; i < src_ptrs.size(); i++) {
             auto i_ptr = src_ptrs[i];
             for (size_t j = 0; j < indexes.size(); j++) {
@@ -208,7 +216,8 @@ class SubgraphDynamicSpecializedExecutor : public Subgraph::SubgraphExecutor {
 struct SubgraphKey {
     SubgraphKey() = default;
     SubgraphKey(const std::shared_ptr<Subgraph::SubgraphAttrs>& attrs_, const std::vector<VectorDims>& in_shapes_)
-        : attrs(attrs_), in_shapes(in_shapes_) {}
+        : attrs(attrs_),
+          in_shapes(in_shapes_) {}
     virtual ~SubgraphKey() = default;
 
     size_t hash() const;
@@ -220,7 +229,8 @@ struct SubgraphKey {
 
 struct SubgraphCodeGeneratorKey {
     SubgraphCodeGeneratorKey(const std::shared_ptr<Subgraph::SubgraphAttrs>& attrs_, uint8_t mask_)
-        : attrs(attrs_), broadcasting_mask(mask_) {}
+        : attrs(attrs_),
+          broadcasting_mask(mask_) {}
 
     size_t hash() const;
     bool operator==(const SubgraphCodeGeneratorKey& rhs) const;
@@ -231,7 +241,8 @@ struct SubgraphCodeGeneratorKey {
 
 struct SubgraphShapeInferResultKey {
     SubgraphShapeInferResultKey(std::vector<VectorDims> in_shapes_, uint64_t body_hash_)
-        : in_shapes(std::move(in_shapes_)), body_hash(body_hash_) {}
+        : in_shapes(std::move(in_shapes_)),
+          body_hash(body_hash_) {}
 
     size_t hash() const;
     bool operator==(const SubgraphShapeInferResultKey& rhs) const;
@@ -258,7 +269,6 @@ size_t get_attr_hash(size_t seed, const std::shared_ptr<Subgraph::SubgraphAttrs>
     return seed;
 }
 
-
 size_t SubgraphKey::hash() const {
     using namespace dnnl::impl;
     using namespace dnnl::impl::primitive_hashing;
@@ -296,17 +306,13 @@ bool operator==(const Subgraph::SubgraphAttrs& lhs, const Subgraph::SubgraphAttr
         return true;
     if (lhs.bodyHash != rhs.bodyHash)
         return false;
-    if (lhs.inMemOrders.size() != rhs.inMemOrders.size() ||
-        lhs.inMemPrecs.size() != rhs.inMemPrecs.size())
+    if (lhs.inMemOrders.size() != rhs.inMemOrders.size() || lhs.inMemPrecs.size() != rhs.inMemPrecs.size())
         return false;
-    if (lhs.outMemOrders.size() != rhs.outMemOrders.size() ||
-        lhs.outMemPrecs.size() != rhs.outMemPrecs.size())
+    if (lhs.outMemOrders.size() != rhs.outMemOrders.size() || lhs.outMemPrecs.size() != rhs.outMemPrecs.size())
         return false;
-    if (lhs.inMemOrders != rhs.inMemOrders ||
-        lhs.inMemPrecs != rhs.inMemPrecs)
+    if (lhs.inMemOrders != rhs.inMemOrders || lhs.inMemPrecs != rhs.inMemPrecs)
         return false;
-    if (lhs.outMemOrders != rhs.outMemOrders ||
-        lhs.outMemPrecs != rhs.outMemPrecs)
+    if (lhs.outMemOrders != rhs.outMemOrders || lhs.outMemPrecs != rhs.outMemPrecs)
         return false;
     return true;
 }
@@ -329,10 +335,11 @@ struct SubgraphShapeInferResult {
     IShapeInfer::Result result;
 };
 
-} // namespace
+}  // namespace
 
 Subgraph::Subgraph(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr& context)
-        : Node(op, context, SnippetShapeInferFactory(op)), subgraph_attrs(std::make_shared<SubgraphAttrs>()) {
+    : Node(op, context, SnippetShapeInferFactory(op)),
+      subgraph_attrs(std::make_shared<SubgraphAttrs>()) {
 #if defined(OPENVINO_ARCH_ARM64)
     host_isa = dnnl::impl::cpu::aarch64::asimd;
 #else
@@ -382,29 +389,29 @@ void Subgraph::initSupportedPrimitiveDescriptors() {
     const size_t ndims = outputShapes[0].getRank();
     // Domain sensitive operations and dynamic Subgraphs support only Planar layout
     const bool isOnlyPlanarApplicable = subgraph_attrs->snippet->has_domain_sensitive_ops();
-    const bool isChannelsFirstApplicable = dnnl::impl::utils::one_of(ndims, 1u, 2u, 3u, 4u, 5u) && dimRanksAreEqual && !isOnlyPlanarApplicable && !isDynamic;
+    const bool isChannelsFirstApplicable = dnnl::impl::utils::one_of(ndims, 1u, 2u, 3u, 4u, 5u) && dimRanksAreEqual &&
+                                           !isOnlyPlanarApplicable && !isDynamic;
     // Todo: Subgraphs currently don't support per-channel broadcasting of Blocked descriptors because
     //  canonicalization can't distinguish between <N, C, H, W, c> and <N, C, D, H, W> cases.
     //  See snippets::op::Subgraph::canonicalize for details.
 #if defined(OPENVINO_ARCH_ARM64)
     bool isBlockedApplicable = false;
 #else
-    bool isBlockedApplicable = dnnl::impl::utils::one_of(ndims,  3u, 4u, 5u) && dimRanksAreEqual && !isOnlyPlanarApplicable && !isDynamic;
+    bool isBlockedApplicable =
+        dnnl::impl::utils::one_of(ndims, 3u, 4u, 5u) && dimRanksAreEqual && !isOnlyPlanarApplicable && !isDynamic;
 
     for (const auto& inShape : inputShapes) {
         if (isDynamic && inShape.getRank() != 1)
-            isBlockedApplicable = isBlockedApplicable && inShape.getMinDims()[1] != Shape::UNDEFINED_DIM && inShape.getMinDims()[1] > 1;
+            isBlockedApplicable =
+                isBlockedApplicable && inShape.getMinDims()[1] != Shape::UNDEFINED_DIM && inShape.getMinDims()[1] > 1;
     }
 #endif
 
-    enum LayoutType {
-        Planar,
-        ChannelsFirst,
-        Blocked
-    };
-    auto initDesc = [&] (LayoutType lt) -> NodeDesc {
-        auto createMemoryDesc = [lt](const Shape &shape, ov::element::Type prc, size_t offset) -> std::shared_ptr<CpuBlockedMemoryDesc> {
-            const auto &dims = shape.getDims();
+    enum LayoutType { Planar, ChannelsFirst, Blocked };
+    auto initDesc = [&](LayoutType lt) -> NodeDesc {
+        auto createMemoryDesc =
+            [lt](const Shape& shape, ov::element::Type prc, size_t offset) -> std::shared_ptr<CpuBlockedMemoryDesc> {
+            const auto& dims = shape.getDims();
             if (lt == ChannelsFirst && shape.getRank() != 1) {
                 auto ndims = shape.getRank();
                 VectorDims order(ndims);
@@ -420,7 +427,8 @@ void Subgraph::initSupportedPrimitiveDescriptors() {
                 }
 
                 return std::make_shared<CpuBlockedMemoryDesc>(prc, shape, blocks, order, offset);
-            } else if (lt == Blocked && shape.getRank() != 1 && (shape.getMinDims()[1] != Shape::UNDEFINED_DIM && shape.getMinDims()[1] > 1)) {
+            } else if (lt == Blocked && shape.getRank() != 1 &&
+                       (shape.getMinDims()[1] != Shape::UNDEFINED_DIM && shape.getMinDims()[1] > 1)) {
 #if defined(OPENVINO_ARCH_ARM64)
                 size_t blockSize = 16;
 #else
@@ -451,22 +459,22 @@ void Subgraph::initSupportedPrimitiveDescriptors() {
         for (size_t i = 0; i < inputShapes.size(); i++) {
             const auto originalInputPrecision = getOriginalInputPrecisionAtPort(i);
             const auto precision = ((originalInputPrecision == ov::element::f32) &&
-                                     context->getConfig().inferencePrecision == ov::element::bf16 &&
-                                     subgraph_attrs->snippet->has_domain_sensitive_ops()) ?
-                static_cast<ov::element::Type>(ov::element::bf16) :
-                originalInputPrecision;
+                                    context->getConfig().inferencePrecision == ov::element::bf16 &&
+                                    subgraph_attrs->snippet->has_domain_sensitive_ops())
+                                       ? static_cast<ov::element::Type>(ov::element::bf16)
+                                       : originalInputPrecision;
             if (supportedPrecisions.count(precision) == 0)
                 OPENVINO_THROW("Subgraph node with name `", getName(), "` doesn't support ", precision, " precision.");
 
-            const auto equalPrecisions = getOriginalOutputPrecisions().size() == 1 &&
-                    precision == getOriginalOutputPrecisionAtPort(0);
+            const auto equalPrecisions =
+                getOriginalOutputPrecisions().size() == 1 && precision == getOriginalOutputPrecisionAtPort(0);
 
             BlockedMemoryDesc::CmpMask inputMask = BlockedMemoryDesc::SKIP_OFFSET_MASK;
             PortConfig portConfig;
             portConfig.inPlace((!i && canBeInPlace() && equalPrecisions) ? 0 : -1);
             portConfig.constant(false);
             if (inputShapes[i].getDims()[0] == 1) {
-                inputMask.reset(0); // accepts any stride on batch axis
+                inputMask.reset(0);  // accepts any stride on batch axis
             }
             portConfig.setMemDesc(createMemoryDesc(inputShapes[i], precision, offset), inputMask);
             config.inConfs[i] = portConfig;
@@ -482,7 +490,7 @@ void Subgraph::initSupportedPrimitiveDescriptors() {
             portConfig.inPlace(-1);
             portConfig.constant(false);
             if (outputShapes[i].getDims()[0] == 1) {
-                outputMask.reset(0); // accepts any stride on batch axis
+                outputMask.reset(0);  // accepts any stride on batch axis
             }
             portConfig.setMemDesc(createMemoryDesc(outputShapes[i], precision, offset), outputMask);
             config.outConfs[i] = portConfig;
@@ -518,8 +526,10 @@ ov::element::Type Subgraph::getRuntimePrecision() const {
     std::vector<ov::element::Type> inputPrecisions;
     for (size_t i = 0; i < getParentEdges().size(); i++) {
         auto parentEdge = getParentEdgeAt(i);
-        if (parentEdge && parentEdge->getStatus() == Edge::Status::Validated && !parentEdge->getParent()->isConstant()) {
-            inputPrecisions.emplace_back(DnnlExtensionUtils::DataTypeToElementType((parentEdge->getMemoryPtr()->getDataType())));
+        if (parentEdge && parentEdge->getStatus() == Edge::Status::Validated &&
+            !parentEdge->getParent()->isConstant()) {
+            inputPrecisions.emplace_back(
+                DnnlExtensionUtils::DataTypeToElementType((parentEdge->getMemoryPtr()->getDataType())));
         }
     }
 
@@ -621,47 +631,60 @@ Subgraph::DataFlowPasses Subgraph::getDataFlowPasses() {
     using PassPosition = ov::snippets::pass::PassPosition;
     using Place = PassPosition::Place;
 
-#   define SNIPPETS_REGISTER_PASS_ABSOLUTE_COMMON(PASS_PLACE, PASS, ...) \
-            backend_passes.emplace_back(PassPosition(PASS_PLACE), std::make_shared<PASS>(__VA_ARGS__))
-#   define SNIPPETS_REGISTER_PASS_RELATIVE_COMMON(PASS_PLACE, TARGET_PASS, PASS, ...) \
-            backend_passes.emplace_back(PassPosition(PASS_PLACE, TARGET_PASS::get_type_info_static()), std::make_shared<PASS>(__VA_ARGS__))
+#define SNIPPETS_REGISTER_PASS_ABSOLUTE_COMMON(PASS_PLACE, PASS, ...) \
+    backend_passes.emplace_back(PassPosition(PASS_PLACE), std::make_shared<PASS>(__VA_ARGS__))
+#define SNIPPETS_REGISTER_PASS_RELATIVE_COMMON(PASS_PLACE, TARGET_PASS, PASS, ...)             \
+    backend_passes.emplace_back(PassPosition(PASS_PLACE, TARGET_PASS::get_type_info_static()), \
+                                std::make_shared<PASS>(__VA_ARGS__))
 
 #if defined(OPENVINO_ARCH_X86_64)
-#   define SNIPPETS_REGISTER_PASS_ABSOLUTE_X86_64(PASS_PLACE, PASS, ...) \
-            backend_passes.emplace_back(PassPosition(PASS_PLACE), std::make_shared<PASS>(__VA_ARGS__))
-#   define SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(PASS_PLACE, TARGET_PASS, PASS, ...) \
-            backend_passes.emplace_back(PassPosition(PASS_PLACE, TARGET_PASS::get_type_info_static()), std::make_shared<PASS>(__VA_ARGS__))
+#    define SNIPPETS_REGISTER_PASS_ABSOLUTE_X86_64(PASS_PLACE, PASS, ...) \
+        backend_passes.emplace_back(PassPosition(PASS_PLACE), std::make_shared<PASS>(__VA_ARGS__))
+#    define SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(PASS_PLACE, TARGET_PASS, PASS, ...)             \
+        backend_passes.emplace_back(PassPosition(PASS_PLACE, TARGET_PASS::get_type_info_static()), \
+                                    std::make_shared<PASS>(__VA_ARGS__))
 #else
 #    define SNIPPETS_REGISTER_PASS_ABSOLUTE_X86_64(PASS_PLACE, PASS, ...)
 #    define SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(PASS_PLACE, TARGET_PASS, PASS, ...)
 #endif  // OPENVINO_ARCH_X86_64
 
     SNIPPETS_REGISTER_PASS_ABSOLUTE_COMMON(Place::PipelineStart, ConvertToSwishCPU);
-    SNIPPETS_REGISTER_PASS_RELATIVE_COMMON(Place::After, ov::snippets::pass::Canonicalization,
-                                           ov::snippets::pass::AnalyzeBroadcastableInputs, broadcastable_inputs);
-    if (context->getConfig().inferencePrecision == ov::element::bf16 && subgraph_attrs->snippet->has_domain_sensitive_ops()) {
+    SNIPPETS_REGISTER_PASS_RELATIVE_COMMON(Place::After,
+                                           ov::snippets::pass::Canonicalization,
+                                           ov::snippets::pass::AnalyzeBroadcastableInputs,
+                                           broadcastable_inputs);
+    if (context->getConfig().inferencePrecision == ov::element::bf16 &&
+        subgraph_attrs->snippet->has_domain_sensitive_ops()) {
         // enforce BF16 precisions to supported operations
         // MatMul has to be decomposed to Brgemm operations before enforcement
         // Note, MatMul decomposition will be run later again for case if BF16 enforcement is not happened
         SNIPPETS_REGISTER_PASS_ABSOLUTE_X86_64(Place::PipelineStart, ov::snippets::pass::MatMulToBrgemm);
-        SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(Place::After, ov::snippets::pass::MatMulToBrgemm,
-                                               pass::EnforcePrecision, element::f32, element::bf16);
+        SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(Place::After,
+                                               ov::snippets::pass::MatMulToBrgemm,
+                                               pass::EnforcePrecision,
+                                               element::f32,
+                                               element::bf16);
     }
-    SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(Place::Before, ov::snippets::pass::PropagatePrecision,
+    SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(Place::Before,
+                                           ov::snippets::pass::PropagatePrecision,
                                            ov::intel_cpu::pass::BrgemmToBrgemmCPU);
-    SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(Place::After, ov::intel_cpu::pass::BrgemmToBrgemmCPU,
+    SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(Place::After,
+                                           ov::intel_cpu::pass::BrgemmToBrgemmCPU,
                                            ov::intel_cpu::pass::EliminateBrgemmCopyB);
     SNIPPETS_REGISTER_PASS_ABSOLUTE_X86_64(Place::PipelineEnd, ov::intel_cpu::pass::RemoveConverts);
     SNIPPETS_REGISTER_PASS_ABSOLUTE_COMMON(Place::PipelineEnd, ov::intel_cpu::pass::MulAddToFMA);
 
 #ifdef SNIPPETS_LIBXSMM_TPP
-    SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(Place::Before, ov::intel_cpu::pass::BrgemmToBrgemmCPU,
+    SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(Place::Before,
+                                           ov::intel_cpu::pass::BrgemmToBrgemmCPU,
                                            ov::intel_cpu::tpp::pass::BrgemmToBrgemmTPP);
     // Note: There could be several ConvertConstantsToScalars instances in the pipeline
     SNIPPETS_REGISTER_PASS_ABSOLUTE_X86_64(Place::PipelineEnd, ov::intel_cpu::tpp::pass::ScalarToScalarTPP);
-    SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(Place::After, ov::intel_cpu::tpp::pass::BrgemmToBrgemmTPP,
+    SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(Place::After,
+                                           ov::intel_cpu::tpp::pass::BrgemmToBrgemmTPP,
                                            ov::intel_cpu::tpp::pass::EltwiseToEltwiseTPP);
-    SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(Place::After, ov::intel_cpu::tpp::pass::EltwiseToEltwiseTPP,
+    SNIPPETS_REGISTER_PASS_RELATIVE_X86_64(Place::After,
+                                           ov::intel_cpu::tpp::pass::EltwiseToEltwiseTPP,
                                            ov::intel_cpu::tpp::pass::FuseTPPToEquations);
 #endif
 
@@ -679,27 +702,34 @@ Subgraph::ControlFlowPasses Subgraph::getControlFlowPasses() const {
 #if defined(OPENVINO_ARCH_X86_64)
     using PassPosition = ov::snippets::pass::PassPosition;
     using Place = PassPosition::Place;
-#   define SNIPPETS_REGISTER_PASS_RELATIVE(PASS_PLACE, TARGET_PASS, PASS, ...) \
-            backend_passes.emplace_back(PassPosition(PASS_PLACE, TARGET_PASS::get_type_info_static()), std::make_shared<PASS>(__VA_ARGS__))
+#    define SNIPPETS_REGISTER_PASS_RELATIVE(PASS_PLACE, TARGET_PASS, PASS, ...)                    \
+        backend_passes.emplace_back(PassPosition(PASS_PLACE, TARGET_PASS::get_type_info_static()), \
+                                    std::make_shared<PASS>(__VA_ARGS__))
 #else
 #    define SNIPPETS_REGISTER_PASS_RELATIVE(PASS_PLACE, TARGET_PASS, PASS, ...)
 #endif  // OPENVINO_ARCH_X86_64
 
-    SNIPPETS_REGISTER_PASS_RELATIVE(Place::After, ov::snippets::lowered::pass::MarkLoops,
+    SNIPPETS_REGISTER_PASS_RELATIVE(Place::After,
+                                    ov::snippets::lowered::pass::MarkLoops,
                                     ov::intel_cpu::pass::BrgemmCPUBlocking);
 
-    SNIPPETS_REGISTER_PASS_RELATIVE(Place::After, ov::snippets::lowered::pass::InitLoops,
+    SNIPPETS_REGISTER_PASS_RELATIVE(Place::After,
+                                    ov::snippets::lowered::pass::InitLoops,
                                     ov::intel_cpu::pass::AdjustBrgemmCopyBLoopPorts);
 
-    SNIPPETS_REGISTER_PASS_RELATIVE(Place::After, ov::snippets::lowered::pass::InsertLoops,
+    SNIPPETS_REGISTER_PASS_RELATIVE(Place::After,
+                                    ov::snippets::lowered::pass::InsertLoops,
                                     ov::intel_cpu::pass::FuseLoadStoreConvert);
-    SNIPPETS_REGISTER_PASS_RELATIVE(Place::Before, ov::snippets::lowered::pass::InsertBuffers,
+    SNIPPETS_REGISTER_PASS_RELATIVE(Place::Before,
+                                    ov::snippets::lowered::pass::InsertBuffers,
                                     ov::intel_cpu::pass::InsertBrgemmCopyBuffers);
 
 #ifdef SNIPPETS_LIBXSMM_TPP
-    SNIPPETS_REGISTER_PASS_RELATIVE(Place::Before, ov::intel_cpu::pass::BrgemmCPUBlocking,
+    SNIPPETS_REGISTER_PASS_RELATIVE(Place::Before,
+                                    ov::intel_cpu::pass::BrgemmCPUBlocking,
                                     ov::intel_cpu::tpp::pass::BrgemmTPPBlocking);
-    SNIPPETS_REGISTER_PASS_RELATIVE(Place::After, ov::intel_cpu::pass::FuseLoadStoreConvert,
+    SNIPPETS_REGISTER_PASS_RELATIVE(Place::After,
+                                    ov::intel_cpu::pass::FuseLoadStoreConvert,
                                     ov::intel_cpu::tpp::pass::SetTPPLeadingDim);
 #endif
 
@@ -728,7 +758,7 @@ void Subgraph::optimizeIR() {
     // DataFlow transformations includes AnalyzeBroadcastableInputs pass:
     // we should verify that the received map is aligned with our blocked input shapes
     OPENVINO_ASSERT((broadcastable_inputs.size() < in_shapes.size()) ||
-                    (!broadcastable_inputs.empty() && broadcastable_inputs.rbegin()->first < in_shapes.size()),
+                        (!broadcastable_inputs.empty() && broadcastable_inputs.rbegin()->first < in_shapes.size()),
                     "Incorrect indexes of broadcastable inputs of Subgraph");
     for (const auto broadcastable_input : broadcastable_inputs) {
         OPENVINO_ASSERT(broadcastable_input.second < in_shapes[broadcastable_input.first].size(),
@@ -753,10 +783,13 @@ void Subgraph::optimizeIR() {
 #endif
 
     // Note: minimal JIT work amount is a predefined value that describes the number of kernel iterations (work amount)
-    // needed to cover kernel call overhead. It is used for balancing between parallel and JIT work amounts in domain optimization.
-    subgraph->control_flow_transformations(static_cast<size_t>(parallel_get_max_threads()), 256,
+    // needed to cover kernel call overhead. It is used for balancing between parallel and JIT work amounts in domain
+    // optimization.
+    subgraph->control_flow_transformations(static_cast<size_t>(parallel_get_max_threads()),
+                                           256,
                                            std::make_shared<snippets::CPUShapeInferSnippetsFactory>(),
-                                           control_flow_config, control_flow_passes);
+                                           control_flow_config,
+                                           control_flow_passes);
 }
 
 void Subgraph::prepareParams() {
@@ -775,14 +808,17 @@ void Subgraph::prepareParams() {
             // 2. Update runtime config with dynamic values
             //    If JIT code has been taken from cache, need to set cached kernel executor table for the configuration
             // 3. Create SubgraphDynamicSpecializedExecutor
-            const auto code_gen_result = cache->getOrCreate(SubgraphCodeGeneratorKey(subgraph_attrs, getBroadcastingMask(in_shapes)),
-                                                            [](const SubgraphCodeGeneratorKey& key) -> std::shared_ptr<SubgraphCodeGenerator> {
-                                                                return std::make_shared<SubgraphCodeGenerator>(key.attrs, std::make_shared<CPURuntimeConfig>());
-                                                            });
+            const auto code_gen_result = cache->getOrCreate(
+                SubgraphCodeGeneratorKey(subgraph_attrs, getBroadcastingMask(in_shapes)),
+                [](const SubgraphCodeGeneratorKey& key) -> std::shared_ptr<SubgraphCodeGenerator> {
+                    return std::make_shared<SubgraphCodeGenerator>(key.attrs, std::make_shared<CPURuntimeConfig>());
+                });
             const auto& code_gen = code_gen_result.first;
-            // [148644] : Update Kernel table from SubgraphCodeGenerator when JIT code was already generated with specific Kernel table
+            // [148644] : Update Kernel table from SubgraphCodeGenerator when JIT code was already generated with
+            // specific Kernel table
             if (code_gen_result.second == CacheEntryBase::LookUpStatus::Hit) {
-                snippet->get_runtime_configurator()->set_kernel_executor_table(code_gen->get()->lowering_result.kernel_executor_table);
+                snippet->get_runtime_configurator()->set_kernel_executor_table(
+                    code_gen->get()->lowering_result.kernel_executor_table);
             }
             const auto& snippet_config = ov::as_type_ptr<CPURuntimeConfig>(snippet->update_runtime_config());
             return std::make_shared<SubgraphDynamicSpecializedExecutor>(key.attrs,
@@ -793,14 +829,16 @@ void Subgraph::prepareParams() {
                                                                         allocator);
         } else {
             // Static case:
-            // 1. Update runtime config to get static scheduling data (io data offsets, parallel domain) which will be compiled in JIT code
+            // 1. Update runtime config to get static scheduling data (io data offsets, parallel domain) which will be
+            // compiled in JIT code
             // 2. Generate JIT code with this static data if needed
             // 3. Create SubgraphStaticExecutor
             const auto& snippet_config = ov::as_type_ptr<CPURuntimeConfig>(snippet->update_runtime_config());
-            const auto code_gen_result = cache->getOrCreate(SubgraphCodeGeneratorKey(subgraph_attrs, getBroadcastingMask(in_shapes)),
-                                                            [&snippet_config](const SubgraphCodeGeneratorKey& key) -> std::shared_ptr<SubgraphCodeGenerator> {
-                                                                return std::make_shared<SubgraphCodeGenerator>(key.attrs, snippet_config);
-                                                            });
+            const auto code_gen_result = cache->getOrCreate(
+                SubgraphCodeGeneratorKey(subgraph_attrs, getBroadcastingMask(in_shapes)),
+                [&snippet_config](const SubgraphCodeGeneratorKey& key) -> std::shared_ptr<SubgraphCodeGenerator> {
+                    return std::make_shared<SubgraphCodeGenerator>(key.attrs, snippet_config);
+                });
             return std::make_shared<SubgraphStaticExecutor>(key.attrs,
                                                             code_gen_result.first,
                                                             start_offset_in,
@@ -874,7 +912,8 @@ inline void init_parallel_domain(const std::shared_ptr<CPURuntimeConfig>& snippe
     domain.resize(tensor_rank, 1);
 
     std::fill(domain.begin(), domain.end(), 1);
-    std::copy(master_shape.cbegin(), master_shape.cbegin() + (master_shape.size() - tile_rank),
+    std::copy(master_shape.cbegin(),
+              master_shape.cbegin() + (master_shape.size() - tile_rank),
               domain.begin() + (tensor_rank - master_shape.size()));
 }
 }  // namespace
@@ -887,7 +926,8 @@ Subgraph::SubgraphCodeGenerator::SubgraphCodeGenerator(const std::shared_ptr<Sub
     jit_snippets_compile_args jcp;
     jcp.data_offsets = config->io_data_offsets;
     init_parallel_domain(config, jcp.exec_domain);
-    schedule = std::make_shared<ov::snippets::Schedule>(snippet_attrs->snippet->generate(reinterpret_cast<const void*>(&jcp)));
+    schedule =
+        std::make_shared<ov::snippets::Schedule>(snippet_attrs->snippet->generate(reinterpret_cast<const void*>(&jcp)));
 }
 
 Subgraph::SubgraphExecutor::SubgraphExecutor(const std::shared_ptr<Subgraph::SubgraphAttrs>& snippet_attrs,
@@ -896,16 +936,22 @@ Subgraph::SubgraphExecutor::SubgraphExecutor(const std::shared_ptr<Subgraph::Sub
                                              const std::vector<ptrdiff_t>& start_offset_out,
                                              const std::shared_ptr<CPURuntimeConfig>& snippet_config,
                                              const BufferScratchpadAllocator& allocator)
-    : m_schedule(snippet->get()), m_start_offset_in(start_offset_in), m_start_offset_out(start_offset_out) {
+    : m_schedule(snippet->get()),
+      m_start_offset_in(start_offset_in),
+      m_start_offset_out(start_offset_out) {
     OPENVINO_ASSERT(m_schedule, "Schedule is empty!");
     OPENVINO_ASSERT(snippet_config, "Runtime Config is empty!");
     init_parallel_domain(snippet_config, m_parallel_exec_domain);
 
-    m_harness_work_amount = std::accumulate(m_parallel_exec_domain.cbegin(), m_parallel_exec_domain.cend(), size_t(1), std::multiplies<size_t>());
+    m_harness_work_amount = std::accumulate(m_parallel_exec_domain.cbegin(),
+                                            m_parallel_exec_domain.cend(),
+                                            size_t(1),
+                                            std::multiplies<size_t>());
     m_nthreads = std::min(parallel_get_max_threads(), static_cast<int>(m_harness_work_amount));
 
     m_buffer_scratchpad_size = snippet_config->buffer_scratchpad_size;
-    OPENVINO_ASSERT(!ov::snippets::utils::is_dynamic_value(m_buffer_scratchpad_size), "Undefined buffer scratchpad size!");
+    OPENVINO_ASSERT(!ov::snippets::utils::is_dynamic_value(m_buffer_scratchpad_size),
+                    "Undefined buffer scratchpad size!");
     m_internal_buffer_size = static_cast<size_t>(m_nthreads) * m_buffer_scratchpad_size;
     m_in_requested_descs = snippet_config->m_in_requested_descs;
     const auto external_repacking_buffer_size =
@@ -918,7 +964,8 @@ Subgraph::SubgraphExecutor::SubgraphExecutor(const std::shared_ptr<Subgraph::Sub
     m_buffer_scratchpad = allocator(m_internal_buffer_size + external_repacking_buffer_size);
 
 #if defined(__linux__) && defined(OPENVINO_ARCH_X86_64) && defined(SNIPPETS_DEBUG_CAPS)
-    const auto target = std::dynamic_pointer_cast<const CPUTargetMachine>(snippet_attrs->snippet->get_generator()->get_target_machine());
+    const auto target = std::dynamic_pointer_cast<const CPUTargetMachine>(
+        snippet_attrs->snippet->get_generator()->get_target_machine());
     enabled_segfault_detector = target && target->debug_config.enable_segfault_detector;
 #endif
 }
@@ -931,17 +978,19 @@ void Subgraph::SubgraphExecutor::segfault_detector() {
             if (auto segfault_detector_emitter = ov::intel_cpu::g_custom_segfault_handler->local())
                 std::cout << segfault_detector_emitter->info() << std::endl;
             auto tid = parallel_get_thread_num();
-            OPENVINO_THROW("Segfault was caught by the signal handler in subgraph node execution on thread " + std::to_string(tid));
+            OPENVINO_THROW("Segfault was caught by the signal handler in subgraph node execution on thread " +
+                           std::to_string(tid));
         };
-        struct sigaction new_handler{};
+        struct sigaction new_handler {};
         new_handler.sa_handler = signal_handler;
         sigaction(SIGSEGV, &new_handler, nullptr);
     }
 }
 #endif
 
-void Subgraph::SubgraphExecutor::parallel_for6d(const std::function<void(jit_snippets_call_args&, size_t)>& initializer,
-                                                const std::function<void(jit_snippets_call_args&, const std::vector<size_t>&)>& caller) {
+void Subgraph::SubgraphExecutor::parallel_for6d(
+    const std::function<void(jit_snippets_call_args&, size_t)>& initializer,
+    const std::function<void(jit_snippets_call_args&, const std::vector<size_t>&)>& caller) {
     const auto& dom = m_parallel_exec_domain;
 
 #if defined(__linux__) && defined(OPENVINO_ARCH_X86_64) && defined(SNIPPETS_DEBUG_CAPS)
@@ -956,16 +1005,36 @@ void Subgraph::SubgraphExecutor::parallel_for6d(const std::function<void(jit_sni
         splitter(m_harness_work_amount, nthr, ithr, start, end);
 
         std::vector<size_t> indexes{0, 0, 0, 0, 0};
-        parallel_it_init(start, indexes[0], dom[0], indexes[1], dom[1], indexes[2], dom[2], indexes[3], dom[3], indexes[4], dom[4]);
+        parallel_it_init(start,
+                         indexes[0],
+                         dom[0],
+                         indexes[1],
+                         dom[1],
+                         indexes[2],
+                         dom[2],
+                         indexes[3],
+                         dom[3],
+                         indexes[4],
+                         dom[4]);
         for (size_t iwork = start; iwork < end; ++iwork) {
             caller(call_args, indexes);
-            parallel_it_step(indexes[0], dom[0], indexes[1], dom[1], indexes[2], dom[2], indexes[3], dom[3], indexes[4], dom[4]);
+            parallel_it_step(indexes[0],
+                             dom[0],
+                             indexes[1],
+                             dom[1],
+                             indexes[2],
+                             dom[2],
+                             indexes[3],
+                             dom[3],
+                             indexes[4],
+                             dom[4]);
         }
     });
 }
 
-void Subgraph::SubgraphExecutor::parallel_forNd(const std::function<void(jit_snippets_call_args&, size_t)>& initializer,
-                                                const std::function<void(jit_snippets_call_args&, const std::vector<size_t>&)>& caller) {
+void Subgraph::SubgraphExecutor::parallel_forNd(
+    const std::function<void(jit_snippets_call_args&, size_t)>& initializer,
+    const std::function<void(jit_snippets_call_args&, const std::vector<size_t>&)>& caller) {
     const auto& dom = m_parallel_exec_domain;
 
 #if defined(__linux__) && defined(OPENVINO_ARCH_X86_64) && defined(SNIPPETS_DEBUG_CAPS)
@@ -992,7 +1061,9 @@ void Subgraph::SubgraphExecutor::parallel_forNd(const std::function<void(jit_sni
     });
 }
 
-void Subgraph::SubgraphExecutor::execute(const dnnl::stream& strm, const std::vector<MemoryPtr>& inMemPtrs, const std::vector<MemoryPtr>& outMemPtrs) {
+void Subgraph::SubgraphExecutor::execute(const dnnl::stream& strm,
+                                         const std::vector<MemoryPtr>& inMemPtrs,
+                                         const std::vector<MemoryPtr>& outMemPtrs) {
     if (!m_in_requested_descs.empty()) {
         auto reorderedInMemPtrs = reorder_inputs(strm, inMemPtrs);
         exec_impl(reorderedInMemPtrs, outMemPtrs);
@@ -1001,7 +1072,8 @@ void Subgraph::SubgraphExecutor::execute(const dnnl::stream& strm, const std::ve
     }
 }
 
-std::vector<MemoryPtr> Subgraph::SubgraphExecutor::reorder_inputs(const dnnl::stream& strm, const std::vector<MemoryPtr>& inMemPtrs) {
+std::vector<MemoryPtr> Subgraph::SubgraphExecutor::reorder_inputs(const dnnl::stream& strm,
+                                                                  const std::vector<MemoryPtr>& inMemPtrs) {
     auto reordered_in_ptrs = inMemPtrs;
     size_t offset = m_internal_buffer_size;
     for (const auto& requested_descs_elem : m_in_requested_descs) {
@@ -1017,6 +1089,6 @@ std::vector<MemoryPtr> Subgraph::SubgraphExecutor::reorder_inputs(const dnnl::st
     return reordered_in_ptrs;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/subgraph.h b/src/plugins/intel_cpu/src/nodes/subgraph.h
index 8040da0a98ef57..aac0fa1ea2f535 100644
--- a/src/plugins/intel_cpu/src/nodes/subgraph.h
+++ b/src/plugins/intel_cpu/src/nodes/subgraph.h
@@ -4,16 +4,15 @@
 
 #pragma once
 
-#include "node.h"
-
 #include "emitters/snippets/cpu_runtime_configurator.hpp"
 #include "emitters/snippets/jit_snippets_call_args.hpp"
+#include "node.h"
 #include "snippets/op/subgraph.hpp"
 
 #if defined(OPENVINO_ARCH_ARM64)
-#include "cpu/aarch64/cpu_isa_traits.hpp"
+#    include "cpu/aarch64/cpu_isa_traits.hpp"
 #else
-#include "cpu/x64/cpu_isa_traits.hpp"
+#    include "cpu/x64/cpu_isa_traits.hpp"
 #endif
 
 #include <array>
@@ -27,7 +26,7 @@ class Subgraph : public Node {
     Subgraph(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr& context);
     ~Subgraph() override = default;
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void selectOptimalPrimitiveDescriptor() override;
     ov::element::Type getRuntimePrecision() const override;
@@ -109,9 +108,12 @@ class Subgraph : public Node {
 
 class Subgraph::SubgraphCodeGenerator {
 public:
-    SubgraphCodeGenerator(const std::shared_ptr<Subgraph::SubgraphAttrs>& snippet_attrs, const std::shared_ptr<CPURuntimeConfig>& config);
+    SubgraphCodeGenerator(const std::shared_ptr<Subgraph::SubgraphAttrs>& snippet_attrs,
+                          const std::shared_ptr<CPURuntimeConfig>& config);
 
-    const std::shared_ptr<snippets::Schedule>& get() const { return schedule; }
+    const std::shared_ptr<snippets::Schedule>& get() const {
+        return schedule;
+    }
 
 private:
     std::shared_ptr<snippets::Schedule> schedule;
@@ -129,7 +131,9 @@ class Subgraph::SubgraphExecutor {
                      const BufferScratchpadAllocator& allocator);
     virtual ~SubgraphExecutor() = default;
 
-    void execute(const dnnl::stream& strm, const std::vector<MemoryPtr>& inMemPtrs, const std::vector<MemoryPtr>& outMemPtrs);
+    void execute(const dnnl::stream& strm,
+                 const std::vector<MemoryPtr>& inMemPtrs,
+                 const std::vector<MemoryPtr>& outMemPtrs);
 
 protected:
     virtual void exec_impl(const std::vector<MemoryPtr>& inMemPtrs, const std::vector<MemoryPtr>& outMemPtrs) = 0;
@@ -174,6 +178,6 @@ class Subgraph::SubgraphExecutor {
     std::unordered_map<size_t, CpuBlockedMemoryDescPtr> m_in_requested_descs = {};
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/tensoriterator.cpp b/src/plugins/intel_cpu/src/nodes/tensoriterator.cpp
index dcf2b0f8ffd5ee..e2bd8ed6f25b5d 100644
--- a/src/plugins/intel_cpu/src/nodes/tensoriterator.cpp
+++ b/src/plugins/intel_cpu/src/nodes/tensoriterator.cpp
@@ -3,19 +3,20 @@
 //
 
 #include "tensoriterator.h"
+
+#include <string>
+#include <vector>
+
 #include "common/blocked_desc_creator.h"
 #include "common/cpu_memcpy.h"
 #include "common/reorder_prim.h"
 #include "dnnl_extension_utils.h"
+#include "openvino/op/loop.hpp"
+#include "openvino/op/tensor_iterator.hpp"
 #include "shape_inference/shape_inference_internal_dyn.hpp"
 #include "transformations/utils/utils.hpp"
-#include "utils/general_utils.h"
 #include "utils/debug_capabilities.h"
-#include "openvino/op/tensor_iterator.hpp"
-#include "openvino/op/loop.hpp"
-
-#include <string>
-#include <vector>
+#include "utils/general_utils.h"
 
 using namespace dnnl;
 
@@ -29,22 +30,22 @@ static NodeConfig make_plain_config(const std::shared_ptr<ov::Node>& op) {
     NodeConfig config;
 
     for (size_t i = 0; i < op->get_input_size(); i++) {
-        const auto &origShape = op->get_input_partial_shape(i);
+        const auto& origShape = op->get_input_partial_shape(i);
         const auto& shape = Shape(origShape.rank().get_length() == 0 ? ov::PartialShape{1} : origShape);
         const auto prec = op->get_input_element_type(i);
 
-        PortConfig data_conf {};
+        PortConfig data_conf{};
         auto descCreator = BlockedDescCreator::getCommonCreators().at(LayoutType::ncsp);
         data_conf.setMemDesc(descCreator->createSharedDesc(prec, shape));
         config.inConfs.push_back(data_conf);
     }
 
     for (size_t i = 0; i < op->get_output_size(); i++) {
-        const auto &origShape = op->get_output_partial_shape(i);
+        const auto& origShape = op->get_output_partial_shape(i);
         const auto& shape = Shape(origShape.rank().get_length() == 0 ? ov::PartialShape{1} : origShape);
         const auto prec = op->get_output_element_type(i);
 
-        PortConfig data_conf {};
+        PortConfig data_conf{};
         auto descCreator = BlockedDescCreator::getCommonCreators().at(LayoutType::ncsp);
         data_conf.setMemDesc(descCreator->createSharedDesc(prec, shape));
         config.outConfs.push_back(data_conf);
@@ -76,11 +77,15 @@ static void nullifyUndefinedDims(VectorDims& dims) {
 
 class PortIteratorHelper : public PortMapHelper {
 public:
-    PortIteratorHelper(MultiCachePtr cache, const MemoryPtr &from, const MemoryPtr &to, bool sliced_src,
-                       const PortMap &slice_rule, const dnnl::engine& eng)
-                       : sliced_src(sliced_src) {
-        const auto &full_blob = sliced_src ? from : to;
-        const auto &part_blob = !sliced_src ? from : to;
+    PortIteratorHelper(MultiCachePtr cache,
+                       const MemoryPtr& from,
+                       const MemoryPtr& to,
+                       bool sliced_src,
+                       const PortMap& slice_rule,
+                       const dnnl::engine& eng)
+        : sliced_src(sliced_src) {
+        const auto& full_blob = sliced_src ? from : to;
+        const auto& part_blob = !sliced_src ? from : to;
 
         auto axis = slice_rule.axis;
         auto stride = slice_rule.stride;
@@ -118,15 +123,16 @@ class PortIteratorHelper : public PortMapHelper {
             mem_holder_src = from->getPrimitive();
             mem_holder_dst = chunk_mem;
         }
-        reorder = getReorderPrim(cache, mem_holder_dst.get_engine(), mem_holder_src.get_desc(), mem_holder_dst.get_desc());
+        reorder =
+            getReorderPrim(cache, mem_holder_dst.get_engine(), mem_holder_src.get_desc(), mem_holder_dst.get_desc());
     }
 
     void execute(dnnl::stream strm, int iter) override {
         OPENVINO_ASSERT(iter >= 0 && iter < iter_count);
 
-        auto &chunk_mem = sliced_src ? mem_holder_src : mem_holder_dst;
-        chunk_mem.set_data_handle(static_cast<uint8_t *>(full_mem.get_data_handle()) +
-                                          chunk_offset_in_byte + chunk_stride_in_byte * iter);
+        auto& chunk_mem = sliced_src ? mem_holder_src : mem_holder_dst;
+        chunk_mem.set_data_handle(static_cast<uint8_t*>(full_mem.get_data_handle()) + chunk_offset_in_byte +
+                                  chunk_stride_in_byte * iter);
 
         reorder.execute(strm, {{DNNL_ARG_FROM, mem_holder_src}, {DNNL_ARG_TO, mem_holder_dst}});
     }
@@ -143,10 +149,11 @@ class PortIteratorHelper : public PortMapHelper {
 
 class BackEdgePortHelper : public PortMapHelper {
 public:
-    BackEdgePortHelper(MultiCachePtr cache, const MemoryPtr &from, const MemoryPtr &to) {
+    BackEdgePortHelper(MultiCachePtr cache, const MemoryPtr& from, const MemoryPtr& to) {
         mem_holder_src = from->getPrimitive();
         mem_holder_dst = to->getPrimitive();
-        reorder = getReorderPrim(cache, mem_holder_dst.get_engine(), mem_holder_src.get_desc(), mem_holder_dst.get_desc());
+        reorder =
+            getReorderPrim(cache, mem_holder_dst.get_engine(), mem_holder_src.get_desc(), mem_holder_dst.get_desc());
     }
 
     void execute(dnnl::stream strm, int iter = -1) override {
@@ -158,7 +165,7 @@ class BackEdgePortHelper : public PortMapHelper {
 
 class IterCountPortHelper : public PortMapHelper {
 public:
-    IterCountPortHelper(const MemoryPtr &to, const dnnl::engine& eng) {
+    IterCountPortHelper(const MemoryPtr& to, const dnnl::engine& eng) {
         // Only scalar I32 tensor is supported
         OPENVINO_ASSERT(to->getDataType() == memory::data_type::s32);
         OPENVINO_ASSERT(to->getShape() == Shape(VectorDims{1}));
@@ -177,7 +184,7 @@ class IterCountPortHelper : public PortMapHelper {
 
 class asBoolCheck : public PortChecker {
 public:
-    asBoolCheck(const MemoryPtr &mem) {
+    asBoolCheck(const MemoryPtr& mem) {
         OPENVINO_ASSERT(mem->getDataType() == memory::data_type::u8);
         OPENVINO_ASSERT(mem->getShape() == Shape(VectorDims{1}));
         mem_holder = mem->getPrimitive();
@@ -194,7 +201,7 @@ class asBoolCheck : public PortChecker {
 
 class asIntCheck : public PortChecker {
 public:
-    asIntCheck(const MemoryPtr &mem) {
+    asIntCheck(const MemoryPtr& mem) {
         OPENVINO_ASSERT(mem->getDataType() == memory::data_type::s32);
         OPENVINO_ASSERT(mem->getShape() == Shape(VectorDims{1}));
         mem_holder = mem->getPrimitive();
@@ -211,17 +218,20 @@ class asIntCheck : public PortChecker {
 
 class staticValueCheck : public PortChecker {
 public:
-    staticValueCheck(const int &value) : value(value) {}
+    staticValueCheck(const int& value) : value(value) {}
 
     int getStatus() override {
         return value;
     }
+
 private:
     int value;
 };
 
-DynamicBuffer::DynamicBuffer(const MemoryPtr &from_, const std::vector<MemoryPtr> &to_,
-                             const PortMap &map_rule_) : from(from_), to(to_), map_rule(map_rule_) {
+DynamicBuffer::DynamicBuffer(const MemoryPtr& from_, const std::vector<MemoryPtr>& to_, const PortMap& map_rule_)
+    : from(from_),
+      to(to_),
+      map_rule(map_rule_) {
     elem_size = DnnlExtensionUtils::sizeOfDataType(from->getDataType());
 }
 
@@ -261,7 +271,7 @@ void DynamicBuffer::init(const dnnl::engine& eng) {
     len = std::accumulate(dims.begin() + map_rule.axis + 1, dims.end(), elem_size, std::multiplies<size_t>());
     chunk_unit_in_byte = abs_stride * len;
 
-    if (!mem_holder_buffer) { // else reuse buffer holder of last inference
+    if (!mem_holder_buffer) {  // else reuse buffer holder of last inference
         // preallocate a large chunk of memory to hold intermediate concated outputs of all iterations.
         mem_holder_buffer = create_buffer(eng);
     }
@@ -274,9 +284,11 @@ void DynamicBuffer::init(const dnnl::engine& eng) {
 
 bool DynamicBuffer::check_buffer() {
     if (map_rule.stride > 0) {
-        if (static_cast<ptrdiff_t>(chunk_offset_in_byte + chunk_unit_in_byte) > chunk_stride_in_byte) return true;
+        if (static_cast<ptrdiff_t>(chunk_offset_in_byte + chunk_unit_in_byte) > chunk_stride_in_byte)
+            return true;
     } else {
-        if (chunk_offset_in_byte < 0) return true;
+        if (chunk_offset_in_byte < 0)
+            return true;
     }
     return false;
 }
@@ -284,14 +296,15 @@ bool DynamicBuffer::check_buffer() {
 MemoryPtr DynamicBuffer::create_buffer(const dnnl::engine& eng) {
     const auto abs_stride = std::abs(map_rule.stride);
 
-    const auto estimate_iters = [&] () {
-        if (max_iter_count != -1) return max_iter_count;
+    const auto estimate_iters = [&]() {
+        if (max_iter_count != -1)
+            return max_iter_count;
 
         // in case of no idea of memory upper boundary
-        return (num_execs == 0) ? 1 : 2 * num_execs; // growth factor 2
+        return (num_execs == 0) ? 1 : 2 * num_execs;  // growth factor 2
     };
     const auto estimated_iters = estimate_iters();
-    const Shape _shape = Shape({count, static_cast<size_t>(abs_stride * estimated_iters), len/elem_size});
+    const Shape _shape = Shape({count, static_cast<size_t>(abs_stride * estimated_iters), len / elem_size});
     auto _descCreator = BlockedDescCreator::getCommonCreators().at(LayoutType::ncsp);
     auto new_buffer_desc = _descCreator->createSharedDesc(from->getDesc().getPrecision(), _shape);
 
@@ -311,8 +324,11 @@ void DynamicBuffer::move_buffer(const MemoryPtr& new_buffer) {
     chunk_offset_in_byte = stride > 0 ? 0 : (dst_stride - valid_size);  // reset chunk_offset_in_byte
 
     copy(mem_holder_buffer->getDataAs<uint8_t>() + src_offset_in_byte,
-        new_buffer->getDataAs<uint8_t>() + chunk_offset_in_byte,
-        src_stride, dst_stride, count, valid_size);
+         new_buffer->getDataAs<uint8_t>() + chunk_offset_in_byte,
+         src_stride,
+         dst_stride,
+         count,
+         valid_size);
 
     // assign mem_holder_buffer
     mem_holder_buffer = new_buffer;
@@ -330,8 +346,12 @@ void DynamicBuffer::move_data() {
     const auto src_stride = abs(map_rule.stride) * len;
     const auto dst_stride = chunk_stride_in_byte;
 
-    copy(from->getDataAs<const uint8_t>(), mem_holder_buffer->getDataAs<uint8_t>() + chunk_offset_in_byte,
-         src_stride, dst_stride, count, chunk_unit_in_byte);
+    copy(from->getDataAs<const uint8_t>(),
+         mem_holder_buffer->getDataAs<uint8_t>() + chunk_offset_in_byte,
+         src_stride,
+         dst_stride,
+         count,
+         chunk_unit_in_byte);
 
     // adjust for next execution
     num_execs++;
@@ -352,8 +372,8 @@ void DynamicBuffer::transfer(const Node* node) {
         const auto& src_desc = src_mem.get_desc();
         auto dims = src_desc.get_dims();
         dims[axis] = abs_stride * num_execs;
-        const auto desc = node->getBaseMemDescAtOutputPort(map_rule.from)->cloneWithNewDims(
-                DnnlExtensionUtils::convertToVectorDims(dims));
+        const auto desc = node->getBaseMemDescAtOutputPort(map_rule.from)
+                              ->cloneWithNewDims(DnnlExtensionUtils::convertToVectorDims(dims));
 
         redefineToMemories(to, desc);
 
@@ -364,7 +384,10 @@ void DynamicBuffer::transfer(const Node* node) {
 
         copy(mem_holder_buffer->getDataAs<uint8_t>() + src_offset_in_byte,
              to.front()->getDataAs<uint8_t>(),
-             src_stride, dst_stride, count, dst_stride);
+             src_stride,
+             dst_stride,
+             count,
+             dst_stride);
     } else {
         VectorDims newDims = to.front()->getShape().getDims();
         nullifyUndefinedDims(newDims);
@@ -374,13 +397,19 @@ void DynamicBuffer::transfer(const Node* node) {
     }
 }
 
-void DynamicBuffer::copy(const uint8_t* src, uint8_t* dst, const size_t src_stride, const size_t dst_stride, const size_t count, const size_t len) {
+void DynamicBuffer::copy(const uint8_t* src,
+                         uint8_t* dst,
+                         const size_t src_stride,
+                         const size_t dst_stride,
+                         const size_t count,
+                         const size_t len) {
     parallel_for(count, [&](const size_t i) {
         cpu_memcpy(&dst[i * dst_stride], &src[i * src_stride], len);
     });
 }
 
-bool TensorIterator::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+bool TensorIterator::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
+                                          std::string& errorMessage) noexcept {
     try {
         if (!one_of(op->get_type_info(),
                     ov::op::v0::TensorIterator::get_type_info_static(),
@@ -394,8 +423,9 @@ bool TensorIterator::isSupportedOperation(const std::shared_ptr<const ov::Node>&
     return true;
 }
 
-TensorIterator::TensorIterator(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) :
-        Node(op, context, InternalDynShapeInferFactory()), ngraphOp(op) {
+TensorIterator::TensorIterator(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, InternalDynShapeInferFactory()),
+      ngraphOp(op) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
@@ -410,16 +440,16 @@ void TensorIterator::getSupportedDescriptors() {
     const std::shared_ptr<const ov::Model> body = tiOp->get_function();
     sub_graph.CreateGraph(body, context);
 
-    const auto &inMap = sub_graph.GetInputNodesMap();
-    for (const auto &param : tiOp->get_function()->get_parameters()) {
+    const auto& inMap = sub_graph.GetInputNodesMap();
+    for (const auto& param : tiOp->get_function()->get_parameters()) {
         auto inNode = inMap.find(tiOp->get_function()->get_parameter_index(param));
         if (inNode != inMap.end()) {
             input_mems.push_back(getToMemories(inNode->second.get(), 0));
         }
     }
 
-    const auto &outMap = sub_graph.GetOutputNodesMap();
-    for (const auto &out : tiOp->get_function()->get_results()) {
+    const auto& outMap = sub_graph.GetOutputNodesMap();
+    for (const auto& out : tiOp->get_function()->get_results()) {
         auto outNode = outMap.find(tiOp->get_function()->get_result_index(out));
         if (outNode != outMap.end()) {
             auto outMem = outNode->second->getSrcMemoryAtPort(0);
@@ -436,17 +466,24 @@ void TensorIterator::getSupportedDescriptors() {
             auto output_desc = ov::as_type_ptr<const ov::op::util::SubGraphOp::ConcatOutputDescription>(desc);
             OPENVINO_ASSERT(output_desc != nullptr);
 
-            outputPortMap.emplace_back(PortMap {
-                    static_cast<int>(output_desc->m_output_index), static_cast<int>(body_output_idx),
-                    static_cast<int>(output_desc->m_axis), static_cast<int>(output_desc->m_stride),
-                    static_cast<int>(output_desc->m_start), static_cast<int>(output_desc->m_end),
-                    static_cast<int>(output_desc->m_part_size)});
+            outputPortMap.emplace_back(PortMap{static_cast<int>(output_desc->m_output_index),
+                                               static_cast<int>(body_output_idx),
+                                               static_cast<int>(output_desc->m_axis),
+                                               static_cast<int>(output_desc->m_stride),
+                                               static_cast<int>(output_desc->m_start),
+                                               static_cast<int>(output_desc->m_end),
+                                               static_cast<int>(output_desc->m_part_size)});
         } else if (type_name == "BodyOutputDescription") {
             auto output_desc = ov::as_type_ptr<const ov::op::util::SubGraphOp::BodyOutputDescription>(desc);
             OPENVINO_ASSERT(output_desc != nullptr);
 
-            outputPortMap.emplace_back(PortMap {
-                    static_cast<int>(output_desc->m_output_index), static_cast<int>(body_output_idx), -1, 1, 0, -1, 1});
+            outputPortMap.emplace_back(PortMap{static_cast<int>(output_desc->m_output_index),
+                                               static_cast<int>(body_output_idx),
+                                               -1,
+                                               1,
+                                               0,
+                                               -1,
+                                               1});
         } else {
             OPENVINO_THROW("Incorrect type of the output description.");
         }
@@ -457,22 +494,34 @@ void TensorIterator::getSupportedDescriptors() {
         auto body_input_index = desc->m_body_parameter_index;
 
         if (auto slice_desc = ov::as_type_ptr<const ov::op::util::SubGraphOp::SliceInputDescription>(desc)) {
-            inputPortMap.emplace_back(PortMap {
-                    static_cast<int>(slice_desc->m_input_index), static_cast<int>(body_input_index),
-                    static_cast<int>(slice_desc->m_axis), static_cast<int>(slice_desc->m_stride),
-                    static_cast<int>(slice_desc->m_start), static_cast<int>(slice_desc->m_end),
-                    static_cast<int>(slice_desc->m_part_size)});
+            inputPortMap.emplace_back(PortMap{static_cast<int>(slice_desc->m_input_index),
+                                              static_cast<int>(body_input_index),
+                                              static_cast<int>(slice_desc->m_axis),
+                                              static_cast<int>(slice_desc->m_stride),
+                                              static_cast<int>(slice_desc->m_start),
+                                              static_cast<int>(slice_desc->m_end),
+                                              static_cast<int>(slice_desc->m_part_size)});
         } else if (auto merge_desc = ov::as_type_ptr<const ov::op::util::SubGraphOp::MergedInputDescription>(desc)) {
-            inputPortMap.emplace_back(PortMap {
-                    static_cast<int>(merge_desc->m_input_index), static_cast<int>(body_input_index), -1, 1, 0, -1, 1});
+            inputPortMap.emplace_back(PortMap{static_cast<int>(merge_desc->m_input_index),
+                                              static_cast<int>(body_input_index),
+                                              -1,
+                                              1,
+                                              0,
+                                              -1,
+                                              1});
 
             auto body_output_idx = merge_desc->m_body_value_index;
 
-            backEdges.emplace_back(PortMap {
-                    static_cast<int>(body_output_idx), static_cast<int>(body_input_index), -1, 1, 0, -1, 1});
+            backEdges.emplace_back(
+                PortMap{static_cast<int>(body_output_idx), static_cast<int>(body_input_index), -1, 1, 0, -1, 1});
         } else if (auto inv_desc = ov::as_type_ptr<const ov::op::util::SubGraphOp::InvariantInputDescription>(desc)) {
-            inputPortMap.emplace_back(PortMap {
-                    static_cast<int>(inv_desc->m_input_index), static_cast<int>(body_input_index), -1, 1, 0, -1, 1});
+            inputPortMap.emplace_back(PortMap{static_cast<int>(inv_desc->m_input_index),
+                                              static_cast<int>(body_input_index),
+                                              -1,
+                                              1,
+                                              0,
+                                              -1,
+                                              1});
         } else {
             THROW_ERROR("has incorrect type of the input description.");
         }
@@ -505,7 +554,7 @@ void TensorIterator::initSupportedPrimitiveDescriptors() {
 
 void TensorIterator::createPrimitive() {
     if (loopBodyConditionOutputIdx == -1)
-        continue_cond_check.reset(new staticValueCheck(true)); // always true
+        continue_cond_check.reset(new staticValueCheck(true));  // always true
     if (loopExecutionConditionIdx == -1) {
         initial_cond_check.reset(new staticValueCheck(true));
         lastUsedCond = initial_cond_check->getStatus();
@@ -537,9 +586,11 @@ bool TensorIterator::needPrepareParams() const {
     // In cases, when sliced input shapes of node and body input shapes are equal,
     // original input shapes of node may be not equal to previous input shapes and count of iterations will be another
     // For example, TensorIterator with single sliced input by axis 1:
-    //    Input shape of node: [10, 8, 10]  ->  Sliced input shape: [10, 1, 10]  ->  Body input shape:  [10, 1, 10]  -> 8 iterations
-    //    Input shape of node: [10, 4, 10]  ->  Sliced input shape: [10, 1, 10]  ->  Body input shape:  [10, 1, 10]  -> 4 iterations
-    // Thus, sliced input shapes and body input shapes are equal but iteration counts are different. So we should update trip count
+    //    Input shape of node: [10, 8, 10]  ->  Sliced input shape: [10, 1, 10]  ->  Body input shape:  [10, 1, 10]  ->
+    //    8 iterations Input shape of node: [10, 4, 10]  ->  Sliced input shape: [10, 1, 10]  ->  Body input shape: [10,
+    //    1, 10]  -> 4 iterations
+    // Thus, sliced input shapes and body input shapes are equal but iteration counts are different. So we should update
+    // trip count
     return Node::needPrepareParams();
 }
 void TensorIterator::prepareParams() {
@@ -575,7 +626,7 @@ void TensorIterator::prepareParamsImpl(const bool compileStage) {
 }
 
 void TensorIterator::execute(dnnl::stream strm) {
-    //Special case, the subgraph is dynamic while the node has all static shapes
+    // Special case, the subgraph is dynamic while the node has all static shapes
     if (runAsDynamic()) {
         restoreSubgraphInputByBackEdges();
         executeDynamicImpl(strm);
@@ -587,13 +638,13 @@ void TensorIterator::execute(dnnl::stream strm) {
     bool continue_cond = initial_cond_check->getStatus();
     int max_num_iter = trip_count_check->getStatus();
 
-    for (auto &mapper : first_mappers)
+    for (auto& mapper : first_mappers)
         mapper.second->execute(strm);
 
     // use  "i != max_num_iter" only to allow "-1" works like infinite loop
     for (int i = 0; i != max_num_iter && continue_cond; i++) {
         // copy data to subgraph iteration
-        for (auto &mapper : before_mappers)
+        for (auto& mapper : before_mappers)
             mapper->execute(strm, i);
 
         sub_graph.Infer();
@@ -602,30 +653,30 @@ void TensorIterator::execute(dnnl::stream strm) {
 
         // copy data from subgraph iteration to outputs
         // or to the next iteration inputs
-        for (auto &mapper : after_mappers)
+        for (auto& mapper : after_mappers)
             mapper->execute(strm, i);
     }
 
-    for (auto &mapper : last_mappers)
+    for (auto& mapper : last_mappers)
         mapper->execute(strm);
 }
 
 void TensorIterator::executeDynamicImpl(dnnl::stream strm) {
-    const auto &eng = getEngine();
+    const auto& eng = getEngine();
     sub_graph.ResetInferCount();
 
     bool continue_cond = initial_cond_check->getStatus();
     int max_num_iter = trip_count_check->getStatus();
 
-    for (auto &mapper : first_mappers)
+    for (auto& mapper : first_mappers)
         mapper.second->execute(strm);
 
     // use  "i != max_num_iter" only to allow "-1" works like infinite loop
     for (int i = 0; i != max_num_iter && continue_cond; i++) {
         // copy data to subgraph iteration
-        for (auto &mapper : before_mappers)
+        for (auto& mapper : before_mappers)
             mapper->execute(strm, i);
-        for (auto &mapper : back_mappers)
+        for (auto& mapper : back_mappers)
             mapper->execute(strm, i);
 
         sub_graph.Infer();
@@ -646,30 +697,37 @@ void TensorIterator::executeDynamicImpl(dnnl::stream strm) {
 /* *==============* Prepare reorders, edges between body and TI *==============* */
 
 void TensorIterator::prepareInputPorts() {
-    const auto &eng = getEngine();
+    const auto& eng = getEngine();
     for (auto map_rule : inputPortMap) {
         auto from_mem = getSrcMemoryAtPort(map_rule.from);
-        auto &to_mem = input_mems[map_rule.to].front();  // first memory is enough to access the shared underlying physical memory
+        auto& to_mem =
+            input_mems[map_rule.to].front();  // first memory is enough to access the shared underlying physical memory
 
         if (map_rule.axis == -1)
             first_mappers.emplace(std::make_pair(map_rule.from, map_rule.to),
-                                std::make_shared<BackEdgePortHelper>(context->getParamsCache(), from_mem, to_mem));
+                                  std::make_shared<BackEdgePortHelper>(context->getParamsCache(), from_mem, to_mem));
         else
             before_mappers.emplace_back(
-                    std::make_shared<PortIteratorHelper>(context->getParamsCache(), from_mem, to_mem, true, map_rule, eng));
+                std::make_shared<PortIteratorHelper>(context->getParamsCache(), from_mem, to_mem, true, map_rule, eng));
     }
 }
 
 void TensorIterator::prepareOutputPorts() {
-    const auto &eng = getEngine();
+    const auto& eng = getEngine();
     for (auto map_rule : outputPortMap) {
         auto to_mem = getDstMemoryAtPort(map_rule.from);
-        auto &from_mem = output_mem[map_rule.to];
+        auto& from_mem = output_mem[map_rule.to];
 
         if (map_rule.axis == -1)
-            last_mappers.emplace_back(std::make_shared<BackEdgePortHelper>(context->getParamsCache(), from_mem, to_mem));
+            last_mappers.emplace_back(
+                std::make_shared<BackEdgePortHelper>(context->getParamsCache(), from_mem, to_mem));
         else
-            after_mappers.emplace_back(std::make_shared<PortIteratorHelper>(context->getParamsCache(), from_mem, to_mem, false, map_rule, eng));
+            after_mappers.emplace_back(std::make_shared<PortIteratorHelper>(context->getParamsCache(),
+                                                                            from_mem,
+                                                                            to_mem,
+                                                                            false,
+                                                                            map_rule,
+                                                                            eng));
     }
 }
 
@@ -691,7 +749,8 @@ void TensorIterator::prepareDynamicBackEdges() {
         redefineToMemories(to_mems, from_mem->getDescPtr());
 
         // first memory is enough to get common memory ptr
-        back_mappers.emplace_back(std::make_shared<BackEdgePortHelper>(context->getParamsCache(), from_mem, to_mems.front()));
+        back_mappers.emplace_back(
+            std::make_shared<BackEdgePortHelper>(context->getParamsCache(), from_mem, to_mems.front()));
     }
 }
 
@@ -699,14 +758,14 @@ void TensorIterator::prepareDynamicBuffers() {
     for (auto map_rule : outputPortMap) {
         if (map_rule.axis != -1) {
             auto to_mems = getToMemories(this, map_rule.from);
-            auto &from_mem = output_mem[map_rule.to];
+            auto& from_mem = output_mem[map_rule.to];
             buffers.emplace_back(std::make_shared<DynamicBuffer>(from_mem, to_mems, map_rule));
         }
     }
 }
 
 void TensorIterator::prepareLoopBodyCurrentIteration() {
-    const auto &eng = getEngine();
+    const auto& eng = getEngine();
     for (auto idx : loopBodyCurrentIterationIdx) {
         auto to_mem = input_mems[idx].front();  // first memory is enough to get common memory ptr
         before_mappers.emplace_back(std::make_shared<IterCountPortHelper>(to_mem, eng));
@@ -758,10 +817,11 @@ inline VectorDims sliced_input_dims(const MemoryPtr& mem, const int axis, const
 void TensorIterator::reshapeSubgraphInput() {
     for (auto map_rule : inputPortMap) {
         auto new_dims = sliced_input_dims(getSrcMemoryAtPort(map_rule.from), map_rule.axis, map_rule.stride);
-        auto &to_mems = input_mems[map_rule.to];
+        auto& to_mems = input_mems[map_rule.to];
         const auto& body_inshape = to_mems.front()->getShape();
         if (body_inshape.isDynamic() || body_inshape.getDims() != new_dims) {
-            const auto desc = std::make_shared<CpuBlockedMemoryDesc>(to_mems.front()->getDesc().getPrecision(), Shape(new_dims));
+            const auto desc =
+                std::make_shared<CpuBlockedMemoryDesc>(to_mems.front()->getDesc().getPrecision(), Shape(new_dims));
             redefineToMemories(to_mems, desc);
         }
     }
@@ -771,7 +831,7 @@ void TensorIterator::reshapeAndFillOutput(dnnl::stream strm) {
     for (auto map_rule : outputPortMap) {
         if (map_rule.axis == -1) {
             auto to_mems = getToMemories(this, map_rule.from);
-            auto &from_mem = output_mem[map_rule.to];
+            auto& from_mem = output_mem[map_rule.to];
 
             // if Loop or TI isn't executed we should fill dynamic dims by zero
             auto newShape = from_mem->getShape();
@@ -797,7 +857,7 @@ void TensorIterator::reshapeAndFillOutput(dnnl::stream strm) {
 bool TensorIterator::checkForInputAndBodyShapesInequality() const {
     for (auto map_rule : inputPortMap) {
         auto original_dims = sliced_input_dims(getSrcMemoryAtPort(map_rule.from), map_rule.axis, map_rule.stride);
-        auto &to_mems = input_mems[map_rule.to];
+        auto& to_mems = input_mems[map_rule.to];
         const auto& body_inshape = to_mems.front()->getShape();
         if (body_inshape.isDynamic() || body_inshape.getDims() != original_dims) {
             return true;
@@ -814,12 +874,13 @@ void TensorIterator::restoreSubgraphInputByBackEdges() {
         const auto extern_input_index = std::get<0>(input_map.first);
         const auto body_input_index = std::get<1>(input_map.first);
         auto from_mem = getSrcMemoryAtPort(extern_input_index);
-        auto &to_mems = input_mems[body_input_index];
-        auto &to_mem = to_mems.front();
+        auto& to_mems = input_mems[body_input_index];
+        auto& to_mem = to_mems.front();
         const auto& input_dims = from_mem->getStaticDims();
         const auto& body_dims = to_mem->getStaticDims();
         if (body_dims != input_dims) {
-            const auto desc = std::make_shared<CpuBlockedMemoryDesc>(to_mem->getDesc().getPrecision(), Shape(input_dims));
+            const auto desc =
+                std::make_shared<CpuBlockedMemoryDesc>(to_mem->getDesc().getPrecision(), Shape(input_dims));
             redefineToMemories(to_mems, desc);
 
             // update first_mappers to replace its legacy input memory addr.
@@ -828,7 +889,8 @@ void TensorIterator::restoreSubgraphInputByBackEdges() {
     }
 }
 
-int TensorIterator::getNumIteration(const std::vector<PortMap>& inputPortMap, const std::vector<PortMap>& outputPortMap) const {
+int TensorIterator::getNumIteration(const std::vector<PortMap>& inputPortMap,
+                                    const std::vector<PortMap>& outputPortMap) const {
     const auto isIterable = [](const PortMap& rule) {
         return rule.axis != -1;
     };
@@ -844,7 +906,7 @@ int TensorIterator::getNumIteration(const std::vector<PortMap>& inputPortMap, co
         }
         const auto space = dimensions[axis];
         const int start = static_cast<int>((rule.start < 0 ? (space + 1) : 0) + rule.start);
-        const int end   = static_cast<int>((rule.end   < 0 ? (space + 1) : 0) + rule.end);
+        const int end = static_cast<int>((rule.end < 0 ? (space + 1) : 0) + rule.end);
 
         const auto stride = rule.stride;
         if (stride == 0) {
@@ -876,7 +938,6 @@ int TensorIterator::getNumIteration(const std::vector<PortMap>& inputPortMap, co
         return static_cast<int>(length / step);
     };
 
-
     int numIterations = 1;
     bool isDefault = true;
     for (const auto& rule : inputPortMap) {
@@ -945,6 +1006,6 @@ bool TensorIterator::created() const {
     return getType() == Type::TensorIterator;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/tensoriterator.h b/src/plugins/intel_cpu/src/nodes/tensoriterator.h
index f8a8110c3fae48..2da687817e6125 100644
--- a/src/plugins/intel_cpu/src/nodes/tensoriterator.h
+++ b/src/plugins/intel_cpu/src/nodes/tensoriterator.h
@@ -4,12 +4,13 @@
 
 #pragma once
 
-#include <node.h>
 #include <graph.h>
-#include <string>
+#include <node.h>
+
+#include <common/memory_desc_wrapper.hpp>
 #include <memory>
+#include <string>
 #include <vector>
-#include <common/memory_desc_wrapper.hpp>
 
 namespace ov {
 namespace intel_cpu {
@@ -37,13 +38,13 @@ class PortMapHelper {
 public:
     virtual ~PortMapHelper() = default;
     virtual void execute(dnnl::stream strm, int n_iter = -1) = 0;
+
 protected:
     dnnl::primitive reorder;
     dnnl::memory mem_holder_src;
     dnnl::memory mem_holder_dst;
 };
 
-
 /**
  * Functor interface to perform check of data tensor (captured in constructor)
  * Information extracted as int. Meaning of returned value is specific for
@@ -53,23 +54,23 @@ class PortChecker {
 public:
     virtual ~PortChecker() = default;
     virtual int getStatus() = 0;
+
 protected:
     dnnl::memory mem_holder;
 };
 
-
 /**
  * Class for storing intermediate output buffer state for dynamism when we don't know
  * final output shape but we should concatenate output after each iteration
  */
 class DynamicBuffer {
 public:
-    DynamicBuffer(const MemoryPtr &from_, const std::vector<MemoryPtr> &to_, const PortMap &map_rule_);
+    DynamicBuffer(const MemoryPtr& from_, const std::vector<MemoryPtr>& to_, const PortMap& map_rule_);
 
     void execute(const dnnl::engine& eng, const int iter);
     void transfer(const Node* node);
 
-    void reset(int max_iter_count_);   // reset local
+    void reset(int max_iter_count_);  // reset local
 
 private:
     void init(const dnnl::engine& eng);
@@ -80,7 +81,12 @@ class DynamicBuffer {
     void move_buffer(const MemoryPtr& new_buffer);
     void move_data();
 
-    static void copy(const uint8_t* src, uint8_t* dst, const size_t src_stride, const size_t dst_stride, const size_t count, const size_t len);
+    static void copy(const uint8_t* src,
+                     uint8_t* dst,
+                     const size_t src_stride,
+                     const size_t dst_stride,
+                     const size_t count,
+                     const size_t len);
 
     /* variable states */
     size_t len = 1lu;
@@ -88,9 +94,9 @@ class DynamicBuffer {
 
     ptrdiff_t chunk_stride_in_byte = 0;
     ptrdiff_t chunk_offset_in_byte = 0;
-    size_t chunk_unit_in_byte = 0lu;   // the amount of bytes copied per each count per each execution (iteration)
-    int num_execs = 0lu;      // number of executions happened
-    int max_iter_count = -1;   // estimated maximum iter count
+    size_t chunk_unit_in_byte = 0lu;  // the amount of bytes copied per each count per each execution (iteration)
+    int num_execs = 0lu;              // number of executions happened
+    int max_iter_count = -1;          // estimated maximum iter count
 
     /* invariable states */
     MemoryPtr from;
@@ -111,12 +117,16 @@ class TensorIterator : public Node {
     void createPrimitive() override;
     bool created() const override;
     void execute(dnnl::stream strm) override;
-    bool isExecutable() const override { return true; }
+    bool isExecutable() const override {
+        return true;
+    }
 
 protected:
     //  needShapeInfer() should return false
     //  because we cannot resolve the output dimensions before the inference is completed
-    bool needShapeInfer() const override { return false; };
+    bool needShapeInfer() const override {
+        return false;
+    };
 
     bool needPrepareParams() const override;
     void prepareParams() override;
@@ -156,24 +166,23 @@ class TensorIterator : public Node {
             return seed;
         }
     };
-    std::unordered_map<std::pair<int, int>, std::shared_ptr<PortMapHelper>, PortMapHasher> first_mappers;  /// < Applied once before loop
+    std::unordered_map<std::pair<int, int>, std::shared_ptr<PortMapHelper>, PortMapHasher>
+        first_mappers;  /// < Applied once before loop
 
-    std::vector<std::shared_ptr<PortMapHelper>>
-        last_mappers,    /// < Applied once after loop
-        before_mappers,  /// < Applied before each iteration
-        after_mappers,   /// < Applied after each iteration
-        back_mappers;    /// < Applied before each iteration for dynamic shapes
+    std::vector<std::shared_ptr<PortMapHelper>> last_mappers,  /// < Applied once after loop
+        before_mappers,                                        /// < Applied before each iteration
+        after_mappers,                                         /// < Applied after each iteration
+        back_mappers;                                          /// < Applied before each iteration for dynamic shapes
 
-    std::shared_ptr<PortChecker>
-        trip_count_check,      /// < Perform check of trip count value. value >= -1
-        initial_cond_check,    /// < Perform check of initial continue condition value. value [0, 1]
-        continue_cond_check;   /// < Perform check of continue condition value of body. value [0, 1]
+    std::shared_ptr<PortChecker> trip_count_check,  /// < Perform check of trip count value. value >= -1
+        initial_cond_check,   /// < Perform check of initial continue condition value. value [0, 1]
+        continue_cond_check;  /// < Perform check of continue condition value of body. value [0, 1]
 
     std::vector<std::shared_ptr<DynamicBuffer>> buffers;
 
-    std::vector<PortMap> inputPortMap;  //!< Input ports map
+    std::vector<PortMap> inputPortMap;   //!< Input ports map
     std::vector<PortMap> outputPortMap;  //!< Output ports map
-    std::vector<PortMap> backEdges;  //!< Back edges map
+    std::vector<PortMap> backEdges;      //!< Back edges map
 
     std::vector<int> loopBodyCurrentIterationIdx;
     int loopBodyConditionOutputIdx = -1;
@@ -186,6 +195,6 @@ class TensorIterator : public Node {
     const std::shared_ptr<ov::Node> ngraphOp;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/tile.cpp b/src/plugins/intel_cpu/src/nodes/tile.cpp
index 1d197a9c1d6ca0..1b48cf7ef25524 100644
--- a/src/plugins/intel_cpu/src/nodes/tile.cpp
+++ b/src/plugins/intel_cpu/src/nodes/tile.cpp
@@ -4,10 +4,9 @@
 
 #include "tile.h"
 
-#include "openvino/op/tile.hpp"
-#include "openvino/op/constant.hpp"
-
 #include "common/cpu_memcpy.h"
+#include "openvino/op/constant.hpp"
+#include "openvino/op/tile.hpp"
 #include "utils/ngraph_utils.hpp"
 
 namespace ov {
@@ -24,8 +23,7 @@ bool Tile::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::
             errorMessage = "Only static shape is supported for tile repeats input.";
             return false;
         }
-        if (!isDynamicNgraphNode(op) &&
-                !ov::is_type<ov::op::v0::Constant>(op->get_input_node_ptr(TILE_REPEATS))) {
+        if (!isDynamicNgraphNode(op) && !ov::is_type<ov::op::v0::Constant>(op->get_input_node_ptr(TILE_REPEATS))) {
             errorMessage = "Only constant 'Repeats' input is supported with static shapes.";
             return false;
         }
@@ -46,7 +44,8 @@ Tile::Tile(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context
 
     if (ov::is_type<ov::op::v0::Constant>(op->get_input_node_ptr(TILE_REPEATS))) {
         constMap[TILE_REPEATS] = true;
-        repeats = originRepeats = ov::as_type<const ov::op::v0::Constant>(op->get_input_node_ptr(TILE_REPEATS))->cast_vector<size_t>();
+        repeats = originRepeats =
+            ov::as_type<const ov::op::v0::Constant>(op->get_input_node_ptr(TILE_REPEATS))->cast_vector<size_t>();
         while (repeats.size() < getInputShapeAtPort(TILE_INPUT).getRank()) {
             repeats.insert(repeats.begin(), 1lu);
         }
@@ -180,9 +179,9 @@ void Tile::plainExecute(dnnl::stream strm) {
     int m_inner_dim = 1;
     int m_outer_dim = 1;
     auto inDims = srcMemory.getStaticDims();
-    for (int i = 0; i < axis; i++ )
+    for (int i = 0; i < axis; i++)
         m_outer_dim *= inDims[i];
-    for (size_t i = axis; i < inDims.size(); i++ )
+    for (size_t i = axis; i < inDims.size(); i++)
         m_inner_dim *= inDims[i];
 
     int MB = srcMemory.getStaticDims()[0];
@@ -222,6 +221,6 @@ bool Tile::created() const {
     return getType() == Type::Tile;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/tile.h b/src/plugins/intel_cpu/src/nodes/tile.h
index eae62761f44dcb..b79dd4cdbb4143 100644
--- a/src/plugins/intel_cpu/src/nodes/tile.h
+++ b/src/plugins/intel_cpu/src/nodes/tile.h
@@ -4,10 +4,10 @@
 
 #pragma once
 
-#include "common/tile_broadcast_utils.h"
-
 #include <string>
 
+#include "common/tile_broadcast_utils.h"
+
 namespace ov {
 namespace intel_cpu {
 namespace node {
@@ -43,6 +43,6 @@ class Tile : public Node, public TileBroadcastCommon {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/topk.cpp b/src/plugins/intel_cpu/src/nodes/topk.cpp
index 1210fbe5ae8bfd..cb67ba88a11e5c 100644
--- a/src/plugins/intel_cpu/src/nodes/topk.cpp
+++ b/src/plugins/intel_cpu/src/nodes/topk.cpp
@@ -4,6 +4,11 @@
 
 #include "topk.h"
 
+#include <algorithm>
+#include <set>
+#include <string>
+#include <vector>
+
 #include "common/cpu_memcpy.h"
 #include "cpu/x64/jit_generator.hpp"
 #include "cpu/x64/jit_uni_eltwise.hpp"
@@ -14,11 +19,6 @@
 #include "openvino/op/topk.hpp"
 #include "utils/ngraph_utils.hpp"
 
-#include <algorithm>
-#include <set>
-#include <string>
-#include <vector>
-
 using namespace dnnl;
 using namespace dnnl::impl;
 using namespace dnnl::impl::cpu::x64;
@@ -30,38 +30,38 @@ namespace intel_cpu {
 namespace node {
 
 #if defined(OPENVINO_ARCH_X86_64)
-#define GET_OFF(field) offsetof(jit_topk_call_args, field)
-
-#define vmm_mask    Vmm(0)
-#define vmm_tmp     Vmm(1)
-#define vmm_val(i)  Vmm(2 * (i) + 2)
-#define vmm_idx(i)  Vmm(2 * (i) + 3)
-#define vmm_val_l   Vmm(2)
-#define vmm_idx_l   Vmm(3)
-#define vmm_val_r   Vmm(4)
-#define vmm_idx_r   Vmm(5)
-
-#define xmm_mask    Xmm(0)
-#define xmm_tmp     Xmm(1)
-#define xmm_val(i)  Xmm(2 * (i) + 2)
-#define xmm_idx(i)  Xmm(2 * (i) + 3)
-#define xmm_val_l   Xmm(2)
-#define xmm_idx_l   Xmm(3)
-#define xmm_val_r   Xmm(4)
-#define xmm_idx_r   Xmm(5)
-
-#define xmm_val_p   Xmm(6)
-#define xmm_idx_p   Xmm(7)
-
-#define JMP_TO_LABEL(label)                  \
-    if (isa == cpu::x64::avx512_core) {    \
-        kmovw(reg_tmp_32, k_mask);           \
-    } else {                                 \
-        uni_vmovmskps(reg_tmp_32, xmm_mask); \
-    }                                        \
-    and_(reg_tmp_32, 0x1);                   \
-    cmp(reg_tmp_32, 0x0);                    \
-    je(label, T_NEAR);
+#    define GET_OFF(field) offsetof(jit_topk_call_args, field)
+
+#    define vmm_mask   Vmm(0)
+#    define vmm_tmp    Vmm(1)
+#    define vmm_val(i) Vmm(2 * (i) + 2)
+#    define vmm_idx(i) Vmm(2 * (i) + 3)
+#    define vmm_val_l  Vmm(2)
+#    define vmm_idx_l  Vmm(3)
+#    define vmm_val_r  Vmm(4)
+#    define vmm_idx_r  Vmm(5)
+
+#    define xmm_mask   Xmm(0)
+#    define xmm_tmp    Xmm(1)
+#    define xmm_val(i) Xmm(2 * (i) + 2)
+#    define xmm_idx(i) Xmm(2 * (i) + 3)
+#    define xmm_val_l  Xmm(2)
+#    define xmm_idx_l  Xmm(3)
+#    define xmm_val_r  Xmm(4)
+#    define xmm_idx_r  Xmm(5)
+
+#    define xmm_val_p Xmm(6)
+#    define xmm_idx_p Xmm(7)
+
+#    define JMP_TO_LABEL(label)                  \
+        if (isa == cpu::x64::avx512_core) {      \
+            kmovw(reg_tmp_32, k_mask);           \
+        } else {                                 \
+            uni_vmovmskps(reg_tmp_32, xmm_mask); \
+        }                                        \
+        and_(reg_tmp_32, 0x1);                   \
+        cmp(reg_tmp_32, 0x0);                    \
+        je(label, T_NEAR);
 
 static inline bool isFloatCompatible(memory::data_type type) {
     return memory::data_type::f32 == type || memory::data_type::bf16 == type;
@@ -72,7 +72,8 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
     DECLARE_CPU_JIT_AUX_FUNCTIONS(jit_uni_topk_kernel_f32)
 
     explicit jit_uni_topk_kernel_f32(jit_topk_config_params jcp)
-        : jit_uni_topk_kernel(jcp), jit_generator(jit_name()) {}
+        : jit_uni_topk_kernel(jcp),
+          jit_generator(jit_name()) {}
 
     void create_ker() override {
         jit_generator::create_kernel();
@@ -90,7 +91,7 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         mov(reg_work_amount, ptr[reg_params + GET_OFF(work_amount)]);
 
         bool shape_agnostic_alg = jcp_.algorithm == TopKAlgorithm::topk_heap_sort ||
-                                 (jcp_.algorithm == TopKAlgorithm::topk_bubble_sort && !jcp_.bubble_inplace);
+                                  (jcp_.algorithm == TopKAlgorithm::topk_bubble_sort && !jcp_.bubble_inplace);
 
         if (!shape_agnostic_alg)
             mov(reg_table, l_table);
@@ -101,8 +102,8 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
             blk_stride = jcp_.sort_stride * jcp_.blk_size;
 
         if (jcp_.mode_max) {
-            cmp_flg = _cmp_lt_os;       // if val[left] < val[right], set mask 1, swap
-            heap_cmp_flg = _cmp_nle_us; // min heap is used for max topk, if a > b, set mask 1, swap
+            cmp_flg = _cmp_lt_os;        // if val[left] < val[right], set mask 1, swap
+            heap_cmp_flg = _cmp_nle_us;  // min heap is used for max topk, if a > b, set mask 1, swap
         } else {
             cmp_flg = _cmp_nle_us;      // if val[left] > val[right], set mask 1, swap
             heap_cmp_flg = _cmp_lt_os;  // max heap is used for min topk, if a < b, set mask 1, swap
@@ -111,7 +112,8 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         if (isa == cpu::x64::avx512_core)
             uni_vpxor(vmm_zero, vmm_zero, vmm_zero);
 
-        load_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx()), static_cast<size_t>(reg_load_table.getIdx())};
+        load_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx()),
+                              static_cast<size_t>(reg_load_table.getIdx())};
         store_pool_gpr_idxs = {static_cast<size_t>(reg_load_store_mask.getIdx())};
         store_pool_vec_idxs = {static_cast<size_t>(vmm_zero.getIdx())};
 
@@ -126,16 +128,24 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
     }
 
 private:
-    using Vmm = typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2,
-            Xbyak::Ymm, Xbyak::Zmm>::type;
+    using Vmm =
+        typename conditional3<isa == cpu::x64::sse41, Xbyak::Xmm, isa == cpu::x64::avx2, Xbyak::Ymm, Xbyak::Zmm>::type;
     size_t vlen = cpu_isa_traits<isa>::vlen;
     dnnl::memory::data_type data_type;
     ov::element::Type precision_in_reg;
 
-    Xbyak::Address table_val(int index) { return ptr[reg_table + index * vlen]; }
-    Xbyak::Address table_bubble_block_idx(int index) { return ptr[reg_bubble_block_idx + index * vlen]; }
-    Xbyak::Address table_bubble_seq_idx(int index) { return ptr[reg_bubble_seq_idx + index * sizeof(int)]; }
-    Xbyak::Address table_heap_seq_idx(int index) { return ptr[reg_heap_seq_idx + index * sizeof(int)]; }
+    Xbyak::Address table_val(int index) {
+        return ptr[reg_table + index * vlen];
+    }
+    Xbyak::Address table_bubble_block_idx(int index) {
+        return ptr[reg_bubble_block_idx + index * vlen];
+    }
+    Xbyak::Address table_bubble_seq_idx(int index) {
+        return ptr[reg_bubble_seq_idx + index * sizeof(int)];
+    }
+    Xbyak::Address table_heap_seq_idx(int index) {
+        return ptr[reg_heap_seq_idx + index * sizeof(int)];
+    }
 
     Xbyak::Reg64 reg_src = r8;
     Xbyak::Reg64 reg_dst = r9;
@@ -156,57 +166,61 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
     Xbyak::Reg64 reg_load_table = rbp;
     Xbyak::Reg64 reg_load_store_mask = rsi;
 
-    // ================================================ for shape_agnostic_alg ================================================
+    // ================================================ for shape_agnostic_alg
+    // ================================================
     // *** for both heap sort and bubble sort ***
     Xbyak::Reg64 reg_tmp = reg_aux_idx;
 
     // *** for heap sort only ***
-    Xbyak::Reg64 reg_j = reg_i;                        // save reg_i by rsp before using reg_j
-    Xbyak::Reg64 reg_offset = reg_load_table;          // reuse reg_load_table after finish using load/store_emiter
-    Xbyak::Reg64 reg_offset_idx = reg_load_store_mask; // reuse reg_load_store_mask after finish using load/store_emiter
+    Xbyak::Reg64 reg_j = reg_i;                // save reg_i by rsp before using reg_j
+    Xbyak::Reg64 reg_offset = reg_load_table;  // reuse reg_load_table after finish using load/store_emiter
+    Xbyak::Reg64 reg_offset_idx =
+        reg_load_store_mask;  // reuse reg_load_store_mask after finish using load/store_emiter
     Xbyak::Reg64 reg_heap_seq_idx = reg_table;
     Xbyak::Reg64 reg_heap_axis_dim = reg_work_amount;
-    Xbyak::Reg64 reg_heap_top_k = reg_prc;             // save reg_top_k by rsp before using reg_prc
+    Xbyak::Reg64 reg_heap_top_k = reg_prc;  // save reg_top_k by rsp before using reg_prc
     Xbyak::Reg64 reg_heap_k_sub_step = reg_heap_top_k;
-    Xbyak::Reg64 reg_zero = reg_offset;                // save reg_zero by rsp before using reg_offset, also refer to reg_offset
-    Xbyak::Reg64 reg_end = reg_prc_idx;                // save reg_heap_outer_aux by rsp before using reg_prc_idx
+    Xbyak::Reg64 reg_zero = reg_offset;  // save reg_zero by rsp before using reg_offset, also refer to reg_offset
+    Xbyak::Reg64 reg_end = reg_prc_idx;  // save reg_heap_outer_aux by rsp before using reg_prc_idx
     Xbyak::Reg64 reg_heap_outer_aux = reg_prc_idx;
-    Xbyak::Reg64 reg_i_sub_1 = reg_i;                  // denotes i-1
-    Xbyak::Reg64 reg_heap_k_sub_1 = reg_heap_top_k;    // denotes k-1
-    Xbyak::Reg64 reg_heapify_end = reg_heap_axis_dim;  // save reg_heap_axis_dim by rsp before using reg_inner_end
-    Xbyak::Reg64 reg_heapify_i = reg_src;              // save reg_src by rsp before using reg_heapify_i
-    Xbyak::Reg64 reg_heapify_valid = reg_heap_seq_idx; // save reg_heap_seq_idx by rsp before using reg_heapify_valid
-    Xbyak::Reg64 reg_heapify_tmp = reg_params;         // save reg_params by rsp before using reg_heapify_tmp
+    Xbyak::Reg64 reg_i_sub_1 = reg_i;                   // denotes i-1
+    Xbyak::Reg64 reg_heap_k_sub_1 = reg_heap_top_k;     // denotes k-1
+    Xbyak::Reg64 reg_heapify_end = reg_heap_axis_dim;   // save reg_heap_axis_dim by rsp before using reg_inner_end
+    Xbyak::Reg64 reg_heapify_i = reg_src;               // save reg_src by rsp before using reg_heapify_i
+    Xbyak::Reg64 reg_heapify_valid = reg_heap_seq_idx;  // save reg_heap_seq_idx by rsp before using reg_heapify_valid
+    Xbyak::Reg64 reg_heapify_tmp = reg_params;          // save reg_params by rsp before using reg_heapify_tmp
 
     // *** for bubble sort only ***
     Xbyak::Reg64 reg_bubble_seq_idx = reg_table;
     Xbyak::Reg64 reg_bubble_block_idx = reg_prc;
     Xbyak::Reg64 reg_bubble_axis_dim = reg_prc_idx;
-    Xbyak::Reg64 reg_block_l = reg_bubble_block_idx;   // save reg_bubble_block_idx by rsp before using reg_l
-    Xbyak::Reg64 reg_block_r = reg_bubble_axis_dim;    // save reg_bubble_axis_dim by rsp before using reg_r
-    Xbyak::Reg64 reg_seq_l = reg_load_table;           // blocked layout on channel
-    Xbyak::Reg64 reg_seq_r = reg_prc;                  // blocked layout on channel
-    Xbyak::Reg64 reg_offset_l = reg_i;                 // save reg_i by rsp before using reg_offset_l
-    Xbyak::Reg64 reg_offset_r = reg_prc_idx;           // save reg_prc_idx by rsp before using reg_offset_r
+    Xbyak::Reg64 reg_block_l = reg_bubble_block_idx;  // save reg_bubble_block_idx by rsp before using reg_l
+    Xbyak::Reg64 reg_block_r = reg_bubble_axis_dim;   // save reg_bubble_axis_dim by rsp before using reg_r
+    Xbyak::Reg64 reg_seq_l = reg_load_table;          // blocked layout on channel
+    Xbyak::Reg64 reg_seq_r = reg_prc;                 // blocked layout on channel
+    Xbyak::Reg64 reg_offset_l = reg_i;                // save reg_i by rsp before using reg_offset_l
+    Xbyak::Reg64 reg_offset_r = reg_prc_idx;          // save reg_prc_idx by rsp before using reg_offset_r
     Xbyak::Reg64 reg_bubble_block_top_k = reg_bubble_seq_idx;
     Xbyak::Reg64 reg_bubble_block_k_sub_1 = reg_bubble_block_top_k;
     Xbyak::Reg64 reg_bubble_seq_top_k = reg_load_store_mask;
     Xbyak::Reg64 reg_bubble_seq_k_sub_1 = reg_bubble_seq_top_k;
-    Xbyak::Reg64 reg_block_sort_stride = reg_aux;      // by vector
-    Xbyak::Reg64 reg_block_sort_stride_byte = reg_block_sort_stride; // by vector
-    Xbyak::Reg64 reg_seq_tmp = reg_seq_l;              // blocked layout on channel
-    Xbyak::Reg64 reg_seq_sort_stride = reg_work_amount;// blocked layout on channel
-    Xbyak::Reg64 reg_blk_stride = reg_seq_sort_stride; // blocked layout on channel, denotes reg_seq_sort_stride * jcp_.blk_size
-    Xbyak::Reg64 reg_sub_idx = reg_bubble_block_idx;   // blocked layout on channel
+    Xbyak::Reg64 reg_block_sort_stride = reg_aux;                     // by vector
+    Xbyak::Reg64 reg_block_sort_stride_byte = reg_block_sort_stride;  // by vector
+    Xbyak::Reg64 reg_seq_tmp = reg_seq_l;                             // blocked layout on channel
+    Xbyak::Reg64 reg_seq_sort_stride = reg_work_amount;               // blocked layout on channel
+    Xbyak::Reg64 reg_blk_stride =
+        reg_seq_sort_stride;  // blocked layout on channel, denotes reg_seq_sort_stride * jcp_.blk_size
+    Xbyak::Reg64 reg_sub_idx = reg_bubble_block_idx;  // blocked layout on channel
     // ========================================================================================================================
 
-    Vmm vmm_zero = Vmm(0); // vmm_zero represents Vmm(0) when isa is avx512_core, otherwise vmm_mask represents Vmm(0)
+    Vmm vmm_zero = Vmm(0);  // vmm_zero represents Vmm(0) when isa is avx512_core, otherwise vmm_mask represents Vmm(0)
 
     const Xbyak::Opmask k_mask = Xbyak::Opmask(1);
     const int vector_step = vlen / sizeof(float);
     const int tail_step = jcp_.work_amount % vector_step;
 
-    int blk_stride = 0;    // stride of channel blocks at the same space coordinate, only used in blocked layout with topk on channel
+    int blk_stride =
+        0;  // stride of channel blocks at the same space coordinate, only used in blocked layout with topk on channel
     unsigned char cmp_flg;
     unsigned char heap_cmp_flg;
 
@@ -240,29 +254,44 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         emit_store(vmm_dst, reg_dst, ov::element::i32, ov::element::i32, elt_num, offset);
     }
 
-    inline void emit_load(Xbyak::Reg64 reg_src, Vmm vmm_src, ov::element::Type src_prc, ov::element::Type dst_prc, const int elt_num, const int offset = 0) {
+    inline void emit_load(Xbyak::Reg64 reg_src,
+                          Vmm vmm_src,
+                          ov::element::Type src_prc,
+                          ov::element::Type dst_prc,
+                          const int elt_num,
+                          const int offset = 0) {
         const auto seed = load_emitter_params(src_prc, dst_prc, elt_num).hash();
         if (!emitters[seed]) {
             emitters[seed].reset(new jit_load_emitter(this, isa, src_prc, dst_prc, elt_num));
         }
 
         emitters[seed]->emit_code({static_cast<size_t>(reg_src.getIdx()), static_cast<size_t>(offset)},
-                                  {static_cast<size_t>(vmm_src.getIdx())}, {}, {load_pool_gpr_idxs});
+                                  {static_cast<size_t>(vmm_src.getIdx())},
+                                  {},
+                                  {load_pool_gpr_idxs});
     }
 
-    inline void emit_store(Vmm vmm_dst, Xbyak::Reg64 reg_dst, ov::element::Type src_prc, ov::element::Type dst_prc, const int elt_num, const int offset = 0) {
+    inline void emit_store(Vmm vmm_dst,
+                           Xbyak::Reg64 reg_dst,
+                           ov::element::Type src_prc,
+                           ov::element::Type dst_prc,
+                           const int elt_num,
+                           const int offset = 0) {
         const auto seed = store_emitter_params(src_prc, dst_prc, elt_num).hash();
         if (!emitters[seed]) {
             emitters[seed].reset(new jit_store_emitter(this, isa, src_prc, dst_prc, elt_num));
         }
 
         // for cases when Store emitter need 2 aux vmm we can use vmm_dst as second aux vmm
-        std::vector<size_t> local_store_pool_vec_idxs = { static_cast<size_t>(vmm_dst.getIdx()) };
-        local_store_pool_vec_idxs.insert(local_store_pool_vec_idxs.begin(), store_pool_vec_idxs.begin(), store_pool_vec_idxs.end());
+        std::vector<size_t> local_store_pool_vec_idxs = {static_cast<size_t>(vmm_dst.getIdx())};
+        local_store_pool_vec_idxs.insert(local_store_pool_vec_idxs.begin(),
+                                         store_pool_vec_idxs.begin(),
+                                         store_pool_vec_idxs.end());
 
         emitters[seed]->emit_code({static_cast<size_t>(vmm_dst.getIdx())},
                                   {static_cast<size_t>(reg_dst.getIdx()), static_cast<size_t>(offset)},
-                                  {local_store_pool_vec_idxs}, {store_pool_gpr_idxs});
+                                  {local_store_pool_vec_idxs},
+                                  {store_pool_gpr_idxs});
     }
 
     inline void topk_loop() {
@@ -435,7 +464,9 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
                 store_scalar(ptr[reg_prc + (i * jcp_.sort_stride + j) * jcp_.data_size], xmm_tmp, data_type);
 
                 uni_vmovdqu(xmm_tmp, table_val(i));
-                store_scalar(ptr[reg_prc_idx + (i * jcp_.sort_stride + j) * sizeof(int)], xmm_tmp, memory::data_type::s32);
+                store_scalar(ptr[reg_prc_idx + (i * jcp_.sort_stride + j) * sizeof(int)],
+                             xmm_tmp,
+                             memory::data_type::s32);
             }
         }
     }
@@ -448,7 +479,9 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
                 load_scalar(xmm_tmp, ptr[reg_prc + (i * jcp_.sort_stride + j) * jcp_.data_size], data_type);
                 store_scalar(ptr[reg_dst + offset * jcp_.data_size], xmm_tmp, data_type);
 
-                load_scalar(xmm_tmp, ptr[reg_prc_idx + (i * jcp_.sort_stride + j) * sizeof(int)], memory::data_type::s32);
+                load_scalar(xmm_tmp,
+                            ptr[reg_prc_idx + (i * jcp_.sort_stride + j) * sizeof(int)],
+                            memory::data_type::s32);
                 store_scalar(ptr[reg_dst_idx + offset * sizeof(int)], xmm_tmp, memory::data_type::s32);
             }
         }
@@ -589,7 +622,7 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         }
     }
 
-    inline void topk_heap_load(Xbyak::Reg64 &reg_end, int s) {
+    inline void topk_heap_load(Xbyak::Reg64& reg_end, int s) {
         Xbyak::Label topk_init_loop_label;
         Xbyak::Label topk_init_loop_end_label;
         L(topk_init_loop_label);
@@ -640,7 +673,7 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         L(topk_extract_end_label);
     }
 
-    inline void heapify_sub_tree(const Xbyak::Reg64 &reg_idx, const Xbyak::Reg64 &reg_valid, bool cmp_val = true) {
+    inline void heapify_sub_tree(const Xbyak::Reg64& reg_idx, const Xbyak::Reg64& reg_valid, bool cmp_val = true) {
         Xbyak::Label topk_heapify_loop_label;
         Xbyak::Label topk_heapify_loop_end_label;
         Xbyak::Label topk_lchild_loop_label;
@@ -680,7 +713,7 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         mul_by_const(reg_offset, reg_heapify_tmp, jcp_.data_size);
         if (jcp_.data_size != sizeof(int)) {
             reg_mul_add(reg_offset_idx, reg_heapify_i, 2, 1);
-            mul_by_const(reg_offset_idx, reg_heapify_tmp,  sizeof(int));
+            mul_by_const(reg_offset_idx, reg_heapify_tmp, sizeof(int));
         }
 
         L(topk_heapify_loop_label);
@@ -784,8 +817,7 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         return mayiuse(cpu_isa);
     }
 
-    inline void uni_vpcmpgtd(const Xbyak::Xmm &x1, const Xbyak::Xmm &x2,
-            const Xbyak::Operand &op) {
+    inline void uni_vpcmpgtd(const Xbyak::Xmm& x1, const Xbyak::Xmm& x2, const Xbyak::Operand& op) {
         if (is_valid_isa(cpu::x64::avx)) {
             vpcmpgtd(x1, x2, op);
         } else {
@@ -795,13 +827,18 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         }
     }
 
-    inline void uni_vpcmpgtd(const Xbyak::Ymm &x1, const Xbyak::Ymm &x2,
-            const Xbyak::Operand &op) {
+    inline void uni_vpcmpgtd(const Xbyak::Ymm& x1, const Xbyak::Ymm& x2, const Xbyak::Operand& op) {
         vpcmpgtd(x1, x2, op);
     }
 
-    inline void compare_node_xmm(Xmm xmm_val_a, Xmm xmm_idx_a, Xmm xmm_val_b, Xmm xmm_idx_b, Xmm mask,
-                                 unsigned char val_cmp_flg, unsigned char idx_cmp_flg, bool cmp_val) {
+    inline void compare_node_xmm(Xmm xmm_val_a,
+                                 Xmm xmm_idx_a,
+                                 Xmm xmm_val_b,
+                                 Xmm xmm_idx_b,
+                                 Xmm mask,
+                                 unsigned char val_cmp_flg,
+                                 unsigned char idx_cmp_flg,
+                                 bool cmp_val) {
         if (isa == cpu::x64::avx512_core) {
             if (cmp_val) {
                 if (isFloatCompatible(data_type)) {
@@ -846,7 +883,7 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         store_scalar(ptr[reg_prc_idx], xmm_idx_n, memory::data_type::s32);
     }
 
-    inline void heap_swap_root(const Xbyak::Reg64 &reg_idx) {
+    inline void heap_swap_root(const Xbyak::Reg64& reg_idx) {
         get_addr_by_reg_idx(reg_aux, reg_dst, reg_idx, jcp_.data_size);
         get_addr_by_reg_idx(reg_aux_idx, reg_dst_idx, reg_idx, sizeof(int));
 
@@ -923,140 +960,164 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         }
     }
 
-    inline void reg_add(const Xbyak::Reg64 &reg_sum, const Xbyak::Reg64 &reg_a, const Xbyak::Reg64 &reg_b) {
+    inline void reg_add(const Xbyak::Reg64& reg_sum, const Xbyak::Reg64& reg_a, const Xbyak::Reg64& reg_b) {
         mov(reg_sum, reg_a);
         add(reg_sum, reg_b);
     }
 
-    inline void query_table_by_reg_idx(const Xbyak::Reg64 &reg_table, const Xbyak::Reg64 &reg_idx, int offset, size_t size) {
+    inline void query_table_by_reg_idx(const Xbyak::Reg64& reg_table,
+                                       const Xbyak::Reg64& reg_idx,
+                                       int offset,
+                                       size_t size) {
         mov(reg_tmp, reg_idx);
         add(reg_tmp, offset);
         mul_by_const(reg_tmp, reg_tmp_64, size);
         add(reg_tmp, reg_table);
     }
 
-    inline void table_to_vmm(Vmm vmm_src, const Xbyak::Reg64 &reg_table, const Xbyak::Reg64 &reg_idx, int offset, size_t size) {
+    inline void table_to_vmm(Vmm vmm_src,
+                             const Xbyak::Reg64& reg_table,
+                             const Xbyak::Reg64& reg_idx,
+                             int offset,
+                             size_t size) {
         query_table_by_reg_idx(reg_table, reg_idx, offset, size);
         uni_vmovdqu(vmm_src, ptr[reg_tmp]);
     }
 
-    inline void table_to_xmm(Xmm xmm_src, const Xbyak::Reg64 &reg_table, const Xbyak::Reg64 &reg_idx, int offset, size_t size) {
+    inline void table_to_xmm(Xmm xmm_src,
+                             const Xbyak::Reg64& reg_table,
+                             const Xbyak::Reg64& reg_idx,
+                             int offset,
+                             size_t size) {
         query_table_by_reg_idx(reg_table, reg_idx, offset, size);
         uni_vmovss(xmm_src, ptr[reg_tmp]);
     }
 
-    inline void get_addr_by_reg_idx(const Xbyak::Reg &reg_out, const Xbyak::Reg &reg_base, const Xbyak::Reg64 &reg_in, int value) {
+    inline void get_addr_by_reg_idx(const Xbyak::Reg& reg_out,
+                                    const Xbyak::Reg& reg_base,
+                                    const Xbyak::Reg64& reg_in,
+                                    int value) {
         mov(reg_out, reg_in);
         mul_by_const(reg_out, reg_tmp_64, value);
         add(reg_out, reg_base);
     }
 
-    inline void get_addr_by_reg_idx(const Xbyak::Reg &reg_out, const Xbyak::Reg &reg_base, const Xbyak::Reg64 &reg_in, int value,
-                             const Xbyak::Reg64 &reg_value) {
+    inline void get_addr_by_reg_idx(const Xbyak::Reg& reg_out,
+                                    const Xbyak::Reg& reg_base,
+                                    const Xbyak::Reg64& reg_in,
+                                    int value,
+                                    const Xbyak::Reg64& reg_value) {
         mov(reg_out, reg_in);
         imul(reg_out, reg_value);
         mul_by_const(reg_out, reg_tmp_64, value);
         add(reg_out, reg_base);
     }
 
-    inline void get_addr_by_reg_idx(const Xbyak::Reg &reg_out, const Xbyak::Reg &reg_base, const Xbyak::Reg64 &reg_in,
-                                    const Xbyak::Reg64 &reg_value) {
+    inline void get_addr_by_reg_idx(const Xbyak::Reg& reg_out,
+                                    const Xbyak::Reg& reg_base,
+                                    const Xbyak::Reg64& reg_in,
+                                    const Xbyak::Reg64& reg_value) {
         mov(reg_out, reg_in);
         imul(reg_out, reg_value);
         add(reg_out, reg_base);
     }
 
-    inline void reg_mul_add(const Xbyak::Reg &reg_out, const Xbyak::Reg64 &reg_in, int mul_val, int add_val) {
+    inline void reg_mul_add(const Xbyak::Reg& reg_out, const Xbyak::Reg64& reg_in, int mul_val, int add_val) {
         mov(reg_out, reg_in);
         mul_by_const(reg_out, reg_tmp_64, mul_val);
         add(reg_out, add_val);
     }
 
-    inline void reg_mul_add(const Xbyak::Reg &reg_out, const Xbyak::Reg &reg_tmp, const Xbyak::Reg64 &reg_in, int mul_val) {
+    inline void reg_mul_add(const Xbyak::Reg& reg_out,
+                            const Xbyak::Reg& reg_tmp,
+                            const Xbyak::Reg64& reg_in,
+                            int mul_val) {
         mov(reg_tmp, reg_in);
         mul_by_const(reg_tmp, reg_tmp_64, mul_val);
         add(reg_out, reg_tmp);
     }
 
-    inline void reg_mul_add(const Xbyak::Reg &reg_out, int mul_val, const Xbyak::Reg64 &reg_base) {
+    inline void reg_mul_add(const Xbyak::Reg& reg_out, int mul_val, const Xbyak::Reg64& reg_base) {
         mul_by_const(reg_out, reg_tmp_64, mul_val);
         add(reg_out, reg_base);
     }
 
-    inline void reg_sub_shr(const Xbyak::Reg &reg_out, const Xbyak::Reg64 &reg_in, int sub_val, int shr_val) {
+    inline void reg_sub_shr(const Xbyak::Reg& reg_out, const Xbyak::Reg64& reg_in, int sub_val, int shr_val) {
         mov(reg_out, reg_in);
         sub(reg_out, sub_val);
         shr(reg_out, shr_val);
     }
 
-    inline void reg_sub_mul(const Xbyak::Reg &reg_out, const Xbyak::Reg64 &reg_in, int sub_val, int mul_val) {
+    inline void reg_sub_mul(const Xbyak::Reg& reg_out, const Xbyak::Reg64& reg_in, int sub_val, int mul_val) {
         mov(reg_out, reg_in);
         sub(reg_out, sub_val);
         mul_by_const(reg_out, reg_tmp_64, mul_val);
     }
 
-    inline void reg_shl(const Xbyak::Reg &reg_out, int rate) {
+    inline void reg_shl(const Xbyak::Reg& reg_out, int rate) {
         switch (rate) {
-            case 1:
-                break;
-            case 2:
-                shl(reg_out, 1);
-                break;
-            case 4:
-                shl(reg_out, 2);
-                break;
-            default:
-                assert(!"incorrect data size rate");
+        case 1:
+            break;
+        case 2:
+            shl(reg_out, 1);
+            break;
+        case 4:
+            shl(reg_out, 2);
+            break;
+        default:
+            assert(!"incorrect data size rate");
         }
     }
 
-    inline void reg_shr(const Xbyak::Reg &reg_out, int rate) {
+    inline void reg_shr(const Xbyak::Reg& reg_out, int rate) {
         switch (rate) {
-            case 1:
-                break;
-            case 2:
-                shr(reg_out, 1);
-                break;
-            case 4:
-                shr(reg_out, 2);
-                break;
-            default:
-                assert(!"incorrect data size rate");
+        case 1:
+            break;
+        case 2:
+            shr(reg_out, 1);
+            break;
+        case 4:
+            shr(reg_out, 2);
+            break;
+        default:
+            assert(!"incorrect data size rate");
         }
     }
 
-    inline void reg_div_blk_size(const Xbyak::Reg &reg_out, const Xbyak::Reg64 &reg_in, int blk_size) {
+    inline void reg_div_blk_size(const Xbyak::Reg& reg_out, const Xbyak::Reg64& reg_in, int blk_size) {
         mov(reg_out, reg_in);
         switch (blk_size) {
-            case 8:
-                shr(reg_out, 3);
-                break;
-            case 16:
-                shr(reg_out, 4);
-                break;
-            default:
-                assert(!"incorrect blk_size");
+        case 8:
+            shr(reg_out, 3);
+            break;
+        case 16:
+            shr(reg_out, 4);
+            break;
+        default:
+            assert(!"incorrect blk_size");
         }
     }
 
-    inline void reg_mod_blk_size(const Xbyak::Reg &reg_out, const Xbyak::Reg64 &reg_in, int blk_size) {
+    inline void reg_mod_blk_size(const Xbyak::Reg& reg_out, const Xbyak::Reg64& reg_in, int blk_size) {
         mov(reg_out, reg_in);
         reg_div_blk_size(reg_tmp_64, reg_in, blk_size);
         switch (blk_size) {
-            case 8:
-                shl(reg_tmp_64, 3);
-                break;
-            case 16:
-                shl(reg_tmp_64, 4);
-                break;
-            default:
-                assert(!"incorrect blk_size");
+        case 8:
+            shl(reg_tmp_64, 3);
+            break;
+        case 16:
+            shl(reg_tmp_64, 4);
+            break;
+        default:
+            assert(!"incorrect blk_size");
         }
         sub(reg_out, reg_tmp_64);
     }
 
-    inline void reg_calc_offset_by_channel_idx(const Xbyak::Reg &reg_out, const Xbyak::Reg64 &reg_stride,
-                                               const Xbyak::Reg64 &reg_channel_idx, int blk_size) {
+    inline void reg_calc_offset_by_channel_idx(const Xbyak::Reg& reg_out,
+                                               const Xbyak::Reg64& reg_stride,
+                                               const Xbyak::Reg64& reg_channel_idx,
+                                               int blk_size) {
         reg_div_blk_size(reg_out, reg_channel_idx, blk_size);
         imul(reg_out, reg_stride);
         reg_mod_blk_size(reg_tmp, reg_channel_idx, blk_size);
@@ -1342,12 +1403,12 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
     // dst: xmm_val(0) and xmm_idx(0)
     // aux: xmm_val(3) and xmm_idx(3)
     inline void horize_top1() {
-        uni_vmovshdup(xmm_val(3), xmm_val(0));                           // dst:1,2,3,4; aux:2,2,4,4
+        uni_vmovshdup(xmm_val(3), xmm_val(0));  // dst:1,2,3,4; aux:2,2,4,4
         uni_vmovshdup(xmm_idx(3), xmm_idx(0));
-        bubble_swap_xmm(xmm_val(0), xmm_idx(0), xmm_val(3), xmm_idx(3)); // dst:f(1,2),f(2,2),f(3,4),f(4,4)
-        uni_vmovhlps(xmm_val(3), xmm_val(3), xmm_val(0));                // aux:f(3,4),f(4,4),4,4
+        bubble_swap_xmm(xmm_val(0), xmm_idx(0), xmm_val(3), xmm_idx(3));  // dst:f(1,2),f(2,2),f(3,4),f(4,4)
+        uni_vmovhlps(xmm_val(3), xmm_val(3), xmm_val(0));                 // aux:f(3,4),f(4,4),4,4
         uni_vmovhlps(xmm_idx(3), xmm_idx(3), xmm_idx(0));
-        bubble_swap_xmm(xmm_val(0), xmm_idx(0), xmm_val(3), xmm_idx(3)); // dst:f(1,2,3,4),...
+        bubble_swap_xmm(xmm_val(0), xmm_idx(0), xmm_val(3), xmm_idx(3));  // dst:f(1,2,3,4),...
     }
 
     inline void topk_bubble_BLK_on_channel_verti() {
@@ -1546,7 +1607,10 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         }
     }
 
-    inline void bubble_swap_vector(const Xbyak::Reg64 &reg_l, const Xbyak::Reg64 &reg_r, int elt_num, bool cmp_val = true) {
+    inline void bubble_swap_vector(const Xbyak::Reg64& reg_l,
+                                   const Xbyak::Reg64& reg_r,
+                                   int elt_num,
+                                   bool cmp_val = true) {
         mov(reg_tmp_64, reg_block_sort_stride_byte);
         imul(reg_tmp_64, reg_l);
 
@@ -1635,7 +1699,7 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         }
     }
 
-    inline void bubble_swap_by_index(const Xbyak::Reg64 &reg_l, const Xbyak::Reg64 &reg_r, bool cmp_val = true) {
+    inline void bubble_swap_by_index(const Xbyak::Reg64& reg_l, const Xbyak::Reg64& reg_r, bool cmp_val = true) {
         sub(rsp, sizeof(int));
         mov(ptr[rsp], reg_i.cvt32());
         sub(rsp, sizeof(int));
@@ -1711,26 +1775,26 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         }
     }
 
-    inline void load_scalar(Xmm xmm_src, const Xbyak::Address &op, memory::data_type src_dt, bool cvt_dt = false) {
+    inline void load_scalar(Xmm xmm_src, const Xbyak::Address& op, memory::data_type src_dt, bool cvt_dt = false) {
         switch (src_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovss(xmm_src, op);
-                break;
-            case memory::data_type::bf16:
-                uni_vpinsrw(xmm_src, xmm_src, op, 0x0);
-                uni_vpslld(xmm_src, xmm_src, 16);
-                break;
-            case memory::data_type::s8:
-                movsx(reg_tmp_32, op);
-                uni_vmovq(xmm_src, reg_tmp_64);
-                break;
-            case memory::data_type::u8:
-                movzx(reg_tmp_32, op);
-                uni_vmovq(xmm_src, reg_tmp_64);
-                break;
-            default:
-                assert(!"unknown src_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovss(xmm_src, op);
+            break;
+        case memory::data_type::bf16:
+            uni_vpinsrw(xmm_src, xmm_src, op, 0x0);
+            uni_vpslld(xmm_src, xmm_src, 16);
+            break;
+        case memory::data_type::s8:
+            movsx(reg_tmp_32, op);
+            uni_vmovq(xmm_src, reg_tmp_64);
+            break;
+        case memory::data_type::u8:
+            movzx(reg_tmp_32, op);
+            uni_vmovq(xmm_src, reg_tmp_64);
+            break;
+        default:
+            assert(!"unknown src_dt");
         }
 
         if (cvt_dt && !isFloatCompatible(src_dt)) {
@@ -1738,34 +1802,34 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
         }
     }
 
-    inline void store_scalar(const Xbyak::Address &op, Xmm xmm_dst, memory::data_type dst_dt, bool cvt_dt = false) {
+    inline void store_scalar(const Xbyak::Address& op, Xmm xmm_dst, memory::data_type dst_dt, bool cvt_dt = false) {
         if (cvt_dt && !isFloatCompatible(dst_dt)) {
             uni_vcvtps2dq(xmm_dst, xmm_dst);
         }
 
         switch (dst_dt) {
-            case memory::data_type::f32:
-            case memory::data_type::s32:
-                uni_vmovss(op, xmm_dst);
-                break;
-            case memory::data_type::bf16:
-                uni_vpsrld(xmm_dst, xmm_dst, 16);
-                uni_vpextrw(op, xmm_dst, 0x0);
-                break;
-            case memory::data_type::s8:
-                uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
-                uni_vmovq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_8);
-                break;
-            case memory::data_type::u8:
-                uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
-                uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
-                uni_vmovq(reg_tmp_64, xmm_dst);
-                mov(op, reg_tmp_8);
-                break;
-            default:
-                assert(!"unknown dst_dt");
+        case memory::data_type::f32:
+        case memory::data_type::s32:
+            uni_vmovss(op, xmm_dst);
+            break;
+        case memory::data_type::bf16:
+            uni_vpsrld(xmm_dst, xmm_dst, 16);
+            uni_vpextrw(op, xmm_dst, 0x0);
+            break;
+        case memory::data_type::s8:
+            uni_vpackssdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpacksswb(xmm_dst, xmm_dst, xmm_dst);
+            uni_vmovq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_8);
+            break;
+        case memory::data_type::u8:
+            uni_vpackusdw(xmm_dst, xmm_dst, xmm_dst);
+            uni_vpackuswb(xmm_dst, xmm_dst, xmm_dst);
+            uni_vmovq(reg_tmp_64, xmm_dst);
+            mov(op, reg_tmp_8);
+            break;
+        default:
+            assert(!"unknown dst_dt");
         }
     }
 
@@ -1789,30 +1853,32 @@ struct jit_uni_topk_kernel_f32 : public jit_uni_topk_kernel, public jit_generato
 
 bool TopK::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
-        if (!one_of(op->get_type_info(), ov::op::v1::TopK::get_type_info_static(),
-                                         ov::op::v3::TopK::get_type_info_static(),
-                                         ov::op::v11::TopK::get_type_info_static())) {
+        if (!one_of(op->get_type_info(),
+                    ov::op::v1::TopK::get_type_info_static(),
+                    ov::op::v3::TopK::get_type_info_static(),
+                    ov::op::v11::TopK::get_type_info_static())) {
             errorMessage = "Node is not an instance of the TopK from the operation sets v1, v3 or v11";
             return false;
         }
 
         auto topKOp = ov::as_type_ptr<const ov::op::util::TopKBase>(op);
         if (!isDynamicNgraphNode(op)) {
-            auto topKConst = std::dynamic_pointer_cast<const ov::op::v0::Constant>(topKOp->get_input_node_shared_ptr(TOPK_K));
+            auto topKConst =
+                std::dynamic_pointer_cast<const ov::op::v0::Constant>(topKOp->get_input_node_shared_ptr(TOPK_K));
             if (!topKConst) {
                 errorMessage = "Second tensor is not constant in static shape mode";
                 return false;
             }
         }
 
-        if (topKOp->get_mode() != ov::op::TopKMode::MAX &&
-            topKOp->get_mode() != ov::op::TopKMode::MIN) {
+        if (topKOp->get_mode() != ov::op::TopKMode::MAX && topKOp->get_mode() != ov::op::TopKMode::MIN) {
             errorMessage = "Unsupported mode.";
             return false;
         }
-        if (!one_of(topKOp->get_sort_type(), ov::op::TopKSortType::NONE,
-                                             ov::op::TopKSortType::SORT_VALUES,
-                                             ov::op::TopKSortType::SORT_INDICES)) {
+        if (!one_of(topKOp->get_sort_type(),
+                    ov::op::TopKSortType::NONE,
+                    ov::op::TopKSortType::SORT_VALUES,
+                    ov::op::TopKSortType::SORT_INDICES)) {
             errorMessage = "Unsupported sort type.";
             return false;
         }
@@ -1836,9 +1902,10 @@ TopK::TopK(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context
         auto in_dims_size = in_dims.size();
 
         if (!isDynamicNgraphNode(op)) {
-            auto topKConst = std::dynamic_pointer_cast<const ov::op::v0::Constant>(topKOp->get_input_node_shared_ptr(TOPK_K));
+            auto topKConst =
+                std::dynamic_pointer_cast<const ov::op::v0::Constant>(topKOp->get_input_node_shared_ptr(TOPK_K));
             if (!topKConst) {
-                OPENVINO_THROW(errorPrefix,  "gets non-constant second tensor in static shape mode!");
+                OPENVINO_THROW(errorPrefix, "gets non-constant second tensor in static shape mode!");
             }
         }
 
@@ -1903,19 +1970,17 @@ void TopK::initSupportedPrimitiveDescriptors() {
     jit_mode = false;
 #endif
 
-    static const ov::element::Type supportedPrecision[] = {
-        ov::element::f32,
-        ov::element::bf16,
-        ov::element::i32,
-        ov::element::i8,
-        ov::element::u8
-    };
+    static const ov::element::Type supportedPrecision[] = {ov::element::f32,
+                                                           ov::element::bf16,
+                                                           ov::element::i32,
+                                                           ov::element::i8,
+                                                           ov::element::u8};
 
     ov::element::Type dataPrecision = getOriginalOutputPrecisionAtPort(TOPK_DATA);
     if (dataPrecision == ov::element::bf16 && !mayiuse(avx512_core))
         OPENVINO_THROW(errorPrefix, " gets incorrect isa for BF16! AVX512 must be supported!");
-    bool precisionSupported = std::find(std::begin(supportedPrecision), std::end(supportedPrecision), dataPrecision)
-                                     != std::end(supportedPrecision);
+    bool precisionSupported = std::find(std::begin(supportedPrecision), std::end(supportedPrecision), dataPrecision) !=
+                              std::end(supportedPrecision);
     if (!precisionSupported) {
         if (dataPrecision.is_real()) {
             dataPrecision = ov::element::f32;
@@ -1924,16 +1989,16 @@ void TopK::initSupportedPrimitiveDescriptors() {
         }
     }
 
-    std::vector<std::pair<LayoutType, LayoutType>> dataFomats{
+    std::vector<std::pair<LayoutType, LayoutType>> dataFomats {
         {LayoutType::ncsp, LayoutType::ncsp},
 #if defined(OPENVINO_ARCH_X86_64)
-        {LayoutType::nspc, LayoutType::nspc},
-        {LayoutType::nCsp16c, LayoutType::nCsp16c},
-        {LayoutType::nCsp8c, LayoutType::nCsp8c}
+            {LayoutType::nspc, LayoutType::nspc}, {LayoutType::nCsp16c, LayoutType::nCsp16c}, {
+            LayoutType::nCsp8c, LayoutType::nCsp8c
+        }
 #endif
     };
 
-    for (const auto &df : dataFomats) {
+    for (const auto& df : dataFomats) {
         addSupportedPrimDesc({{df.first, dataPrecision}, {LayoutType::ncsp, ov::element::i32}},
                              {{df.second, dataPrecision}, {df.second, ov::element::i32}},
                              impl_type);
@@ -1952,11 +2017,13 @@ bool TopK::needPrepareParams() const {
 
 void TopK::preset_params() {
     auto selectedPD = getSelectedPrimitiveDescriptor();
-    auto data_type = DnnlExtensionUtils::ElementTypeToDataType(selectedPD->getConfig().inConfs[TOPK_DATA].getMemDesc()->getPrecision());
+    auto data_type = DnnlExtensionUtils::ElementTypeToDataType(
+        selectedPD->getConfig().inConfs[TOPK_DATA].getMemDesc()->getPrecision());
     data_size = DnnlExtensionUtils::sizeOfDataType(data_type);
 
-    topk_innermost = (layout == TopKLayoutType::topk_ncsp && axis == static_cast<int>(getOutputShapeAtPort(TOPK_DATA).getRank() - 1)) ||
-                    ((layout == TopKLayoutType::topk_nspc || layout == TopKLayoutType::topk_blocked) && axis == 1);
+    topk_innermost = (layout == TopKLayoutType::topk_ncsp &&
+                      axis == static_cast<int>(getOutputShapeAtPort(TOPK_DATA).getRank() - 1)) ||
+                     ((layout == TopKLayoutType::topk_nspc || layout == TopKLayoutType::topk_blocked) && axis == 1);
 
     if (mayiuse(cpu::x64::avx512_core)) {
         blk_size = 16;
@@ -2012,21 +2079,24 @@ void TopK::prepareParams() {
 
         axis_dim = src_dims[axis];
 
-        // [case 1]: if 2 * (top_k + 1) + 2 <= count_xmm, thus top_k is small enough that the vector registers are sufficient
-        //           to keep all necessary data for sorting, no need to load and store frequently, use inplace bubble sort;
-        //           (horizotal sorting cases not included)
-        // [case 2]: if stable sorting is required, bubble sort(topk_bubble_vector/topk_bubble_BLK_on_channel_verti) will be
-        //           applied currently, because among the implemented sorting algorithms, these bubble sort implementations
-        //           are the only stable ones;
-        // [case 3]: only when topk is imposed on innermost dimsension of planar(ncsp/nspc) layout, should heap sort be used;
-        // [case 4]: by default, use bitonic sort when alg_cost_bitonic < alg_cost_bubble, otherwise use bubble sort.
+        // [case 1]: if 2 * (top_k + 1) + 2 <= count_xmm, thus top_k is small enough that the vector registers are
+        // sufficient
+        //           to keep all necessary data for sorting, no need to load and store frequently, use inplace bubble
+        //           sort; (horizotal sorting cases not included)
+        // [case 2]: if stable sorting is required, bubble sort(topk_bubble_vector/topk_bubble_BLK_on_channel_verti)
+        // will be
+        //           applied currently, because among the implemented sorting algorithms, these bubble sort
+        //           implementations are the only stable ones;
+        // [case 3]: only when topk is imposed on innermost dimsension of planar(ncsp/nspc) layout, should heap sort be
+        // used; [case 4]: by default, use bitonic sort when alg_cost_bitonic < alg_cost_bubble, otherwise use bubble
+        // sort.
         //           alg_cost_bitonic = (N / 4) * logN * (logN + 1)
         //           alg_cost_bubble = K * (K - 1) / 2 + (N - K) * K
         //           where, N = axis_dim, K = topk_k
-        //           the above two alg_costs are not the exact implementation costs, yet it's proper to use them to decide
-        //           which algorithm should be used for specific N and K.
+        //           the above two alg_costs are not the exact implementation costs, yet it's proper to use them to
+        //           decide which algorithm should be used for specific N and K.
         if (!isDynamicNode()) {
-            const size_t count_xmm = 16; // only 16 vector registers are valid in sse instructions even for avx512_core
+            const size_t count_xmm = 16;  // only 16 vector registers are valid in sse instructions even for avx512_core
             if (static_cast<size_t>(top_k) <= count_xmm / 2 - 2) {
                 algorithm = TopKAlgorithm::topk_bubble_sort;
                 bubble_inplace = topk_innermost && top_k == 1 ? false : true;
@@ -2049,7 +2119,7 @@ void TopK::prepareParams() {
         }
 
         prepare_original_idx();
-    } else { //reference mode
+    } else {  // reference mode
         int j;
         for (j = src_dims.size() - 1; j >= 0; j--) {
             if (src_dims[j] != 1)
@@ -2138,27 +2208,27 @@ void TopK::execute(dnnl::stream strm) {
     auto dstMemPtr = getDstMemoryAtPort(TOPK_DATA);
     auto dstIndexesMemPtr = getDstMemoryAtPort(TOPK_INDEX);
 
-    const uint8_t *src_data = srcMemPtr->getDataAs<const uint8_t>();
-    uint8_t *dst_data = dstMemPtr->getDataAs<uint8_t>();
-    uint8_t *dst_idx = dstIndexesMemPtr->getDataAs<uint8_t>();
+    const uint8_t* src_data = srcMemPtr->getDataAs<const uint8_t>();
+    uint8_t* dst_data = dstMemPtr->getDataAs<uint8_t>();
+    uint8_t* dst_idx = dstIndexesMemPtr->getDataAs<uint8_t>();
 
     if (jit_mode) {
         topk_process(src_data, dst_data, dst_idx);
     } else {
         if (layout == TopKLayoutType::topk_ncsp) {
-            auto in_ptr = reinterpret_cast<const float *>(src_data);
-            auto out_ptr = reinterpret_cast<float *>(dst_data);
-            auto out_idx_ptr = reinterpret_cast<int32_t *>(dst_idx);
+            auto in_ptr = reinterpret_cast<const float*>(src_data);
+            auto out_ptr = reinterpret_cast<float*>(dst_data);
+            auto out_idx_ptr = reinterpret_cast<int32_t*>(dst_idx);
             topk_ref(in_ptr, out_ptr, out_idx_ptr);
         } else {
-            OPENVINO_THROW(errorPrefix,  "only support plain layout on machine w/o sse42.");
+            OPENVINO_THROW(errorPrefix, "only support plain layout on machine w/o sse42.");
         }
     }
 }
 
-void TopK::topk_process(const uint8_t *in_ptr, uint8_t *out_ptr, uint8_t *out_idx_ptr) {
-    uint8_t *process_ptr = vec_process_ptr.data();
-    uint8_t *process_idx_ptr = vec_process_idx_ptr.data();
+void TopK::topk_process(const uint8_t* in_ptr, uint8_t* out_ptr, uint8_t* out_idx_ptr) {
+    uint8_t* process_ptr = vec_process_ptr.data();
+    uint8_t* process_idx_ptr = vec_process_idx_ptr.data();
 
     // [blocked layout with topk on C]
     if (layout == TopKLayoutType::topk_blocked && topk_innermost) {
@@ -2166,30 +2236,30 @@ void TopK::topk_process(const uint8_t *in_ptr, uint8_t *out_ptr, uint8_t *out_id
         size_t OA = div_up(dst_dims[1], blk_size);
         if (algorithm == TopKAlgorithm::topk_bubble_sort) {
             parallel_for2d(O, I, [&](size_t o, size_t i) {
-                const uint8_t *in_ptr_a = in_ptr + (o * IA * I + i) * blk_size * data_size;
-                uint8_t *out_ptr_a = out_ptr + (o * OA * I + i) * blk_size * data_size;
-                uint8_t *out_idx_ptr_a = out_idx_ptr + (o * OA * I + i) * blk_size * sizeof(int32_t);
+                const uint8_t* in_ptr_a = in_ptr + (o * IA * I + i) * blk_size * data_size;
+                uint8_t* out_ptr_a = out_ptr + (o * OA * I + i) * blk_size * data_size;
+                uint8_t* out_idx_ptr_a = out_idx_ptr + (o * OA * I + i) * blk_size * sizeof(int32_t);
                 size_t work_amount = 1;
                 topk_kernel_process(in_ptr_a, out_ptr_a, out_idx_ptr_a, NULL, NULL, work_amount);
             });
         } else if (algorithm == TopKAlgorithm::topk_bitonic_sort) {
             parallel_for(O, [&](size_t o) {
-                const uint8_t *in_ptr_a = in_ptr + o * IA * I * blk_size * data_size;
-                uint8_t *process_ptr_a = process_ptr + o * IA * I * blk_size * data_size;
-                uint8_t *process_idx_ptr_a = process_idx_ptr + o * IA * I * blk_size * sizeof(int32_t);
-                uint8_t *out_ptr_a = out_ptr + o * OA * I * blk_size * data_size;
-                uint8_t *out_idx_ptr_a = out_idx_ptr + o * OA * I * blk_size * sizeof(int32_t);
+                const uint8_t* in_ptr_a = in_ptr + o * IA * I * blk_size * data_size;
+                uint8_t* process_ptr_a = process_ptr + o * IA * I * blk_size * data_size;
+                uint8_t* process_idx_ptr_a = process_idx_ptr + o * IA * I * blk_size * sizeof(int32_t);
+                uint8_t* out_ptr_a = out_ptr + o * OA * I * blk_size * data_size;
+                uint8_t* out_idx_ptr_a = out_idx_ptr + o * OA * I * blk_size * sizeof(int32_t);
                 size_t work_amount = I;
                 topk_kernel_process(in_ptr_a, out_ptr_a, out_idx_ptr_a, process_ptr_a, process_idx_ptr_a, work_amount);
             });
         }
-    } else { // [planar layout] [blocked layout with topk on non-C]
+    } else {  // [planar layout] [blocked layout with topk on non-C]
         parallel_for2d(O, I / blk_size, [&](size_t o, size_t k) {
-            const uint8_t *in_ptr_a = in_ptr + (o * A * I + k * blk_size) * data_size;
-            uint8_t *process_ptr_a = process_ptr + (o * A * I + k * blk_size) * data_size;
-            uint8_t *process_idx_ptr_a = process_idx_ptr + (o * A * I + k * blk_size) * sizeof(int32_t);
-            uint8_t *out_ptr_a = out_ptr + (o * top_k * I + k * blk_size) * data_size;
-            uint8_t *out_idx_ptr_a = out_idx_ptr + (o * top_k * I + k * blk_size) * sizeof(int32_t);
+            const uint8_t* in_ptr_a = in_ptr + (o * A * I + k * blk_size) * data_size;
+            uint8_t* process_ptr_a = process_ptr + (o * A * I + k * blk_size) * data_size;
+            uint8_t* process_idx_ptr_a = process_idx_ptr + (o * A * I + k * blk_size) * sizeof(int32_t);
+            uint8_t* out_ptr_a = out_ptr + (o * top_k * I + k * blk_size) * data_size;
+            uint8_t* out_idx_ptr_a = out_idx_ptr + (o * top_k * I + k * blk_size) * sizeof(int32_t);
             size_t work_amount = blk_size;
             topk_kernel_process(in_ptr_a, out_ptr_a, out_idx_ptr_a, process_ptr_a, process_idx_ptr_a, work_amount);
         });
@@ -2198,25 +2268,29 @@ void TopK::topk_process(const uint8_t *in_ptr, uint8_t *out_ptr, uint8_t *out_id
         size_t work_amount = I - tail_start;
         if (work_amount) {
             parallel_for(O, [&](size_t o) {
-                const uint8_t *in_ptr_a = in_ptr + (o * A * I + tail_start) * data_size;
-                uint8_t *process_ptr_a = process_ptr + (o * A * I + tail_start) * data_size;
-                uint8_t *process_idx_ptr_a = process_idx_ptr + (o * A * I + tail_start) * sizeof(int32_t);
-                uint8_t *out_ptr_a = out_ptr + (o * top_k * I + tail_start) * data_size;
-                uint8_t *out_idx_ptr_a = out_idx_ptr + (o * top_k * I + tail_start) * sizeof(int32_t);
+                const uint8_t* in_ptr_a = in_ptr + (o * A * I + tail_start) * data_size;
+                uint8_t* process_ptr_a = process_ptr + (o * A * I + tail_start) * data_size;
+                uint8_t* process_idx_ptr_a = process_idx_ptr + (o * A * I + tail_start) * sizeof(int32_t);
+                uint8_t* out_ptr_a = out_ptr + (o * top_k * I + tail_start) * data_size;
+                uint8_t* out_idx_ptr_a = out_idx_ptr + (o * top_k * I + tail_start) * sizeof(int32_t);
                 topk_kernel_process(in_ptr_a, out_ptr_a, out_idx_ptr_a, process_ptr_a, process_idx_ptr_a, work_amount);
             });
         }
     }
 }
 
-inline void TopK::topk_kernel_process(const uint8_t *in_p, uint8_t *out_p, uint8_t *out_idx_p,
-                                                uint8_t *process_p, uint8_t *process_idx_p, size_t work_amount) {
+inline void TopK::topk_kernel_process(const uint8_t* in_p,
+                                      uint8_t* out_p,
+                                      uint8_t* out_idx_p,
+                                      uint8_t* process_p,
+                                      uint8_t* process_idx_p,
+                                      size_t work_amount) {
     auto arg = jit_topk_call_args();
-    arg.src = static_cast<const void *>(in_p);
-    arg.process = static_cast<void *>(process_p);
-    arg.process_index = static_cast<void *>(process_idx_p);
-    arg.dst = static_cast<void *>(out_p);
-    arg.index = static_cast<void *>(out_idx_p);
+    arg.src = static_cast<const void*>(in_p);
+    arg.process = static_cast<void*>(process_p);
+    arg.process_index = static_cast<void*>(process_idx_p);
+    arg.dst = static_cast<void*>(out_p);
+    arg.index = static_cast<void*>(out_idx_p);
     arg.work_amount = work_amount;
     arg.bitonic_idx_buf = vec_bitonic_idx.data();
     arg.bitonic_k_idx_buf = vec_bitonic_k_idx.data();
@@ -2229,11 +2303,12 @@ inline void TopK::topk_kernel_process(const uint8_t *in_p, uint8_t *out_p, uint8
 }
 
 inline void TopK::prepare_original_idx() {
-    bool shape_agnostic_alg = algorithm == TopKAlgorithm::topk_heap_sort ||
-                             (algorithm == TopKAlgorithm::topk_bubble_sort && !bubble_inplace);
+    bool shape_agnostic_alg =
+        algorithm == TopKAlgorithm::topk_heap_sort || (algorithm == TopKAlgorithm::topk_bubble_sort && !bubble_inplace);
     if (shape_agnostic_alg) {
-        bool use_idx_seq = stable ? topk_innermost && (layout == TopKLayoutType::topk_blocked || (top_k == 1 && !stable))
-                                  : topk_innermost;
+        bool use_idx_seq = stable
+                               ? topk_innermost && (layout == TopKLayoutType::topk_blocked || (top_k == 1 && !stable))
+                               : topk_innermost;
         if (use_idx_seq) {
             if (vec_idx_seq.empty()) {
                 vec_idx_seq.resize(axis_dim);
@@ -2280,7 +2355,7 @@ inline void TopK::prepare_original_idx() {
 //            n: number of valid elements in bitonic sort
 //            p: pow of 2 number, so that p/2 < n <= p
 //   empty tail: p-n elements in the rear don't need sorting,
-inline void TopK::bitonic_push_idx(int p, int n, std::vector<int> &vec, int &cnt, bool cmp_val) {
+inline void TopK::bitonic_push_idx(int p, int n, std::vector<int>& vec, int& cnt, bool cmp_val) {
     // memory stride of adjacent elements in sorting
     int sort_stride = static_cast<int>(I);
     cnt = 0;
@@ -2313,8 +2388,7 @@ inline void TopK::bitonic_push_idx(int p, int n, std::vector<int> &vec, int &cnt
     }
     for (; sub_p > 0; sub_p >>= 1) {
         // support partial sort as well as full sort
-        for (int sub_start = 0; (!cmp_val || (cmp_val && sub_start < n)) && sub_start < p;
-             sub_start += sub_p) {
+        for (int sub_start = 0; (!cmp_val || (cmp_val && sub_start < n)) && sub_start < p; sub_start += sub_p) {
             int minor_p = sub_p >> 1;
             for (int j = 0; sub_start + j + minor_p < n && j < minor_p; j++) {
                 vec[cnt++] = (sub_start + j) * sort_stride;
@@ -2324,7 +2398,7 @@ inline void TopK::bitonic_push_idx(int p, int n, std::vector<int> &vec, int &cnt
     }
 }
 
-void TopK::calc_bitonic_idx(size_t n, int &cnt, bool cmp_val) {
+void TopK::calc_bitonic_idx(size_t n, int& cnt, bool cmp_val) {
     int m = n - 1;
     int log_p = 0;
     int p = 1;
@@ -2349,7 +2423,7 @@ void TopK::calc_bitonic_idx(size_t n, int &cnt, bool cmp_val) {
 // O: total size of the outer dimensions
 // A: size of the topk imposed dimension
 // I: total size of the inner dimensions
-void TopK::calc_dims_size(const VectorDims &layout_dims) {
+void TopK::calc_dims_size(const VectorDims& layout_dims) {
     O = 1, I = 1;
     A = src_dims[axis];
     int layout_axis = axis;
@@ -2366,15 +2440,22 @@ void TopK::calc_dims_size(const VectorDims &layout_dims) {
     }
 }
 
-void TopK::topk_ref(const float *in_ptr, float *out_ptr, int32_t *dst_idx) {
+void TopK::topk_ref(const float* in_ptr, float* out_ptr, int32_t* dst_idx) {
     if (mode_max)
-        topk_ref_process(in_ptr, out_ptr, dst_idx, src_dims, [](float x, float y)->float { return x > y; });
+        topk_ref_process(in_ptr, out_ptr, dst_idx, src_dims, [](float x, float y) -> float {
+            return x > y;
+        });
     else
-        topk_ref_process(in_ptr, out_ptr, dst_idx, src_dims, [](float x, float y)->float { return x < y; });
+        topk_ref_process(in_ptr, out_ptr, dst_idx, src_dims, [](float x, float y) -> float {
+            return x < y;
+        });
 }
 
-void TopK::topk_ref_process(const float* src_data, float* dst_data, int32_t* dst_idx, const VectorDims &in_dims,
-                               std::function<float(float, float)> compare) const {
+void TopK::topk_ref_process(const float* src_data,
+                            float* dst_data,
+                            int32_t* dst_idx,
+                            const VectorDims& in_dims,
+                            std::function<float(float, float)> compare) const {
     int after_num = count(in_dims, axis + 1, in_dims.size());
 
     parallel_for2d(before_num, after_num, [&](int i0, int i1) {
@@ -2452,6 +2533,6 @@ bool TopK::created() const {
     return getType() == Type::TopK;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/topk.h b/src/plugins/intel_cpu/src/nodes/topk.h
index cf8095b35f75bf..a61cb8662bc18c 100644
--- a/src/plugins/intel_cpu/src/nodes/topk.h
+++ b/src/plugins/intel_cpu/src/nodes/topk.h
@@ -6,65 +6,60 @@
 
 #include <node.h>
 
-#include <string>
 #include <memory>
+#include <string>
 #include <vector>
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-enum TopKLayoutType {
-    topk_ncsp,
-    topk_nspc,
-    topk_blocked
-};
+enum TopKLayoutType { topk_ncsp, topk_nspc, topk_blocked };
 
-enum TopKAlgorithm {
-    topk_bubble_sort,
-    topk_bitonic_sort,
-    topk_heap_sort
-};
+enum TopKAlgorithm { topk_bubble_sort, topk_bitonic_sort, topk_heap_sort };
 
 struct jit_topk_config_params {
-    bool mode_max;           // which of the two elements to select. ture: max; false: min
-    bool sort_index;         // sort by value or index. true: index; false: value
-    bool topk_innermost;     // if topk sorting is applied on innermost dimension or other dimension
-    bool bubble_inplace;     // all the elements in sorting is right in the register, no need to load and store for each comparison
-    bool stable;             // if require stable sorting
-    TopKLayoutType layout;   // memory layout
-    TopKAlgorithm algorithm; // topk sorting algorithm
-    ov::element::Type precision; // precision
-    int data_size;           // data size
-    int blk_size;            // block size
-    int top_k;               // number of the output elements in the sorting dimension
-    int work_amount;         // how many elements are processed when call jit kernel once
-    int axis_dim;            // size of topk axis
-    int sort_stride;         // memory stride of adjacent elements in sorting
-    int bitonic_idx_cnt;     // the repeatedly counted total number of elements in sorting, which equal the total number of comparison x 2
-    int bitonic_k_idx_cnt;   // the counterpart of bitonic_idx_cnt, when sort_index == true
+    bool mode_max;          // which of the two elements to select. ture: max; false: min
+    bool sort_index;        // sort by value or index. true: index; false: value
+    bool topk_innermost;    // if topk sorting is applied on innermost dimension or other dimension
+    bool bubble_inplace;    // all the elements in sorting is right in the register, no need to load and store for each
+                            // comparison
+    bool stable;            // if require stable sorting
+    TopKLayoutType layout;  // memory layout
+    TopKAlgorithm algorithm;      // topk sorting algorithm
+    ov::element::Type precision;  // precision
+    int data_size;                // data size
+    int blk_size;                 // block size
+    int top_k;                    // number of the output elements in the sorting dimension
+    int work_amount;              // how many elements are processed when call jit kernel once
+    int axis_dim;                 // size of topk axis
+    int sort_stride;              // memory stride of adjacent elements in sorting
+    int bitonic_idx_cnt;  // the repeatedly counted total number of elements in sorting, which equal the total number of
+                          // comparison x 2
+    int bitonic_k_idx_cnt;  // the counterpart of bitonic_idx_cnt, when sort_index == true
 };
 
 struct jit_topk_call_args {
-    const void *src;
-    void *process;
-    void *process_index;
-    void *dst;
-    void *index;
-    const int *bitonic_idx_buf;
-    const int *bitonic_k_idx_buf;
-    const int *idx_block_buf;// original idx sequence, repeated by block (eg. 00000000,11111111,...,77777777), only used in bubble sort
-    const int *idx_seq_buf;  // original idx sequence (eg. 01234567), only used in bubble sort and heap sort
-    size_t axis_dim;         // point to axis_dim, only used in heap sort with dynamic shapes to achieve axis_dim agnosic
+    const void* src;
+    void* process;
+    void* process_index;
+    void* dst;
+    void* index;
+    const int* bitonic_idx_buf;
+    const int* bitonic_k_idx_buf;
+    const int* idx_block_buf;  // original idx sequence, repeated by block (eg. 00000000,11111111,...,77777777), only
+                               // used in bubble sort
+    const int* idx_seq_buf;    // original idx sequence (eg. 01234567), only used in bubble sort and heap sort
+    size_t axis_dim;  // point to axis_dim, only used in heap sort with dynamic shapes to achieve axis_dim agnosic
     size_t top_k;
     size_t work_amount;
     size_t sort_stride;
 };
 
 struct jit_uni_topk_kernel {
-    void (*ker_)(const jit_topk_call_args *);
+    void (*ker_)(const jit_topk_call_args*);
 
-    void operator()(const jit_topk_call_args *args) {
+    void operator()(const jit_topk_call_args* args) {
         assert(ker_);
         ker_(args);
     }
@@ -95,20 +90,27 @@ class TopK : public Node {
         return false;
     }
 
-    static bool isSupportedOperation(const std::shared_ptr<const ov::Node> &op, std::string &errorMessage) noexcept;
+    static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
 private:
-    void topk_process(const uint8_t *in_ptr, uint8_t *out_ptr, uint8_t *dst_idx);
-    void topk_ref(const float *in_ptr, float *out_ptr, int32_t *dst_idx);
-    inline void topk_kernel_process(const uint8_t *in_p, uint8_t *out_p, uint8_t *src_idx,
-                                    uint8_t *process_p, uint8_t *process_idx_p, size_t work_amount);
+    void topk_process(const uint8_t* in_ptr, uint8_t* out_ptr, uint8_t* dst_idx);
+    void topk_ref(const float* in_ptr, float* out_ptr, int32_t* dst_idx);
+    inline void topk_kernel_process(const uint8_t* in_p,
+                                    uint8_t* out_p,
+                                    uint8_t* src_idx,
+                                    uint8_t* process_p,
+                                    uint8_t* process_idx_p,
+                                    size_t work_amount);
     inline static int count(const VectorDims& dims, size_t start_ind, size_t end_ind);
     inline static int count(const VectorDims& dims, size_t start_ind = 0);
-    inline void bitonic_push_idx(int p, int n, std::vector<int> &vec, int &cnt, bool cmp_val = true);
-    void calc_bitonic_idx(size_t n, int &cnt, bool cmp_val);
-    void calc_dims_size(const VectorDims &layout_dims);
-    void topk_ref_process(const float* src_data, float* dst_data, int32_t* dst_idx,
-                   const VectorDims &in_dims, std::function<float(float, float)> compare) const;
+    inline void bitonic_push_idx(int p, int n, std::vector<int>& vec, int& cnt, bool cmp_val = true);
+    void calc_bitonic_idx(size_t n, int& cnt, bool cmp_val);
+    void calc_dims_size(const VectorDims& layout_dims);
+    void topk_ref_process(const float* src_data,
+                          float* dst_data,
+                          int32_t* dst_idx,
+                          const VectorDims& in_dims,
+                          std::function<float(float, float)> compare) const;
     void preset_params();
     void prepare_original_idx();
 
@@ -148,6 +150,6 @@ class TopK : public Node {
     std::string errorPrefix;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/transpose.cpp b/src/plugins/intel_cpu/src/nodes/transpose.cpp
index 38712e04c50719..6c4750ac3f1766 100644
--- a/src/plugins/intel_cpu/src/nodes/transpose.cpp
+++ b/src/plugins/intel_cpu/src/nodes/transpose.cpp
@@ -4,14 +4,13 @@
 
 #include "transpose.h"
 
-#include "openvino/op/transpose.hpp"
-#include "openvino/op/constant.hpp"
-
-#include "nodes/common/reorder_prim.h"
-
 #include <string>
-#include "dnnl_extension_utils.h"
+
 #include "common/primitive_hashing_utils.hpp"
+#include "dnnl_extension_utils.h"
+#include "nodes/common/reorder_prim.h"
+#include "openvino/op/constant.hpp"
+#include "openvino/op/transpose.hpp"
 #include "shape_inference/custom/transpose.hpp"
 using namespace dnnl;
 
@@ -21,8 +20,7 @@ namespace node {
 
 bool Transpose::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
     try {
-        if (!one_of(op->get_type_info(),
-                ov::op::v1::Transpose::get_type_info_static())) {
+        if (!one_of(op->get_type_info(), ov::op::v1::Transpose::get_type_info_static())) {
             errorMessage = "Node is not an instance of the Transpose operation from opset1.";
             return false;
         }
@@ -39,7 +37,7 @@ bool Transpose::isSupportedOperation(const std::shared_ptr<const ov::Node>& op,
 }
 
 Transpose::Transpose(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
-        : Node(op, context, TransposeShapeInferFactory(op)) {
+    : Node(op, context, TransposeShapeInferFactory(op)) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
@@ -58,8 +56,7 @@ Transpose::Transpose(const std::shared_ptr<ov::Node>& op, const GraphContext::CP
     }
 }
 
-void Transpose::getSupportedDescriptors() {
-}
+void Transpose::getSupportedDescriptors() {}
 
 void Transpose::initSupportedPrimitiveDescriptors() {
     if (!supportedPrimitiveDescriptors.empty())
@@ -75,8 +72,8 @@ void Transpose::initSupportedPrimitiveDescriptors() {
     config.inConfs[INPUT_DATA_IDX].inPlace(-1);
     config.inConfs[INPUT_DATA_IDX].constant(false);
     config.inConfs[INPUT_ORDER_IDX].constant(isInputOrderConst);
-    config.inConfs[INPUT_ORDER_IDX].setMemDesc(creatorsMap.at(LayoutType::ncsp)->createSharedDesc(
-            ov::element::i32, getInputShapeAtPort(INPUT_ORDER_IDX)));
+    config.inConfs[INPUT_ORDER_IDX].setMemDesc(
+        creatorsMap.at(LayoutType::ncsp)->createSharedDesc(ov::element::i32, getInputShapeAtPort(INPUT_ORDER_IDX)));
     config.outConfs[0].inPlace(isOptimized ? 0 : -1);
     config.outConfs[0].constant(false);
     transpose_context = std::make_shared<ExecutorContext>(context, getImplPriority());
@@ -90,7 +87,10 @@ void Transpose::initSupportedPrimitiveDescriptors() {
         for (size_t i = 0; i < config.outConfs.size(); i++) {
             dstMemoryDescs.push_back(config.outConfs[i].getMemDesc());
         }
-        auto factory = std::make_shared<TransposeExecutorFactory>(transposeParams, srcMemoryDescs, dstMemoryDescs, transpose_context);
+        auto factory = std::make_shared<TransposeExecutorFactory>(transposeParams,
+                                                                  srcMemoryDescs,
+                                                                  dstMemoryDescs,
+                                                                  transpose_context);
         supportedPrimitiveDescriptors.push_back({config, impl_desc_type::unknown, factory});
     };
 
@@ -111,8 +111,9 @@ void Transpose::initSupportedPrimitiveDescriptors() {
             config.inConfs[0].setMemDesc(creatorsMap.at(LayoutType::nCsp16c)->createSharedDesc(prec, inputDataShape));
             supportedPrimitiveDescriptorsBuilder(config, transposeParams);
         }
-#endif // OPENVINO_ARCH_X86_64
-        if (prec == ov::element::f32 || prec == ov::element::f16 || prec == ov::element::i8 || prec == ov::element::u8 || prec == ov::element::bf16) {
+#endif  // OPENVINO_ARCH_X86_64
+        if (prec == ov::element::f32 || prec == ov::element::f16 || prec == ov::element::i8 ||
+            prec == ov::element::u8 || prec == ov::element::bf16) {
             config.inConfs[0].setMemDesc(creatorsMap.at(LayoutType::nspc)->createSharedDesc(prec, inputDataShape));
             config.outConfs[0].setMemDesc(creatorsMap.at(LayoutType::nspc)->createSharedDesc(prec, outputDataShape));
             supportedPrimitiveDescriptorsBuilder(config, transposeParams);
@@ -221,7 +222,8 @@ void Transpose::createPrimitive() {
 #endif
 
     if (!performAsReorder) {
-        transposeParams.permuteParams.data_size = getSelectedPrimitiveDescriptor()->getConfig().inConfs[0].getMemDesc()->getPrecision().size();
+        transposeParams.permuteParams.data_size =
+            getSelectedPrimitiveDescriptor()->getConfig().inConfs[0].getMemDesc()->getPrecision().size();
         if (isInputOrderConst)
             transposeParams.permuteParams.order = order;
         auto srcDesc = getParentEdgeAt(INPUT_DATA_IDX)->getMemory().getDescWithType<BlockedMemoryDesc>();
@@ -260,6 +262,6 @@ bool Transpose::created() const {
     return getType() == Type::Transpose;
 }
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/transpose.h b/src/plugins/intel_cpu/src/nodes/transpose.h
index 03b65c1333610c..1a1969f6bf9cba 100644
--- a/src/plugins/intel_cpu/src/nodes/transpose.h
+++ b/src/plugins/intel_cpu/src/nodes/transpose.h
@@ -4,14 +4,14 @@
 
 #pragma once
 
-#include "common/permute_kernel.h"
-#include "executors/transpose_list.hpp"
-
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "common/permute_kernel.h"
+#include "executors/transpose_list.hpp"
+
 namespace ov {
 namespace intel_cpu {
 namespace node {
@@ -63,6 +63,6 @@ class Transpose : public Node {
     bool isOptimized = false;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes/unique.cpp b/src/plugins/intel_cpu/src/nodes/unique.cpp
index a0a0cd95d000f3..e2570f901473ba 100644
--- a/src/plugins/intel_cpu/src/nodes/unique.cpp
+++ b/src/plugins/intel_cpu/src/nodes/unique.cpp
@@ -4,11 +4,11 @@
 
 #include "unique.hpp"
 
-#include <openvino/op/unique.hpp>
 #include <openvino/op/constant.hpp>
+#include <openvino/op/unique.hpp>
 
-#include "openvino/core/parallel.hpp"
 #include "common/cpu_memcpy.h"
+#include "openvino/core/parallel.hpp"
 #include "shape_inference/shape_inference_internal_dyn.hpp"
 
 using namespace ov::intel_cpu;
@@ -33,8 +33,8 @@ bool Unique::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std
     return true;
 }
 
-Unique::Unique(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context) :
-        Node(op, context, InternalDynShapeInferFactory()) {
+Unique::Unique(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, InternalDynShapeInferFactory()) {
     std::string errorMessage;
     if (!isSupportedOperation(op, errorMessage)) {
         OPENVINO_THROW_NOT_IMPLEMENTED(errorMessage);
@@ -73,7 +73,7 @@ void Unique::initSupportedPrimitiveDescriptors() {
 
     impl_desc_type implType = ref;
 
-    std::vector<PortConfigurator> inPortConfigs = { {LayoutType::ncsp, dataPrecision} };
+    std::vector<PortConfigurator> inPortConfigs = {{LayoutType::ncsp, dataPrecision}};
     if (!flattened) {
         inPortConfigs.push_back({LayoutType::ncsp, axisPrecision});
     }
@@ -118,33 +118,39 @@ void Unique::prepareParams() {
     occurTmp.resize(srcLen);
 }
 
-template<typename T>
+template <typename T>
 struct Unique::flattenExec {
-    void operator()(Unique *node) {
+    void operator()(Unique* node) {
         node->flattenTensorExec<T>();
     }
 };
 
-template<typename T>
+template <typename T>
 struct Unique::slicedExec {
-    void operator()(Unique *node) {
+    void operator()(Unique* node) {
         node->slicedTensorExec<T>();
     }
 };
 
 void Unique::execute(dnnl::stream strm) {
     if (flattened) {
-        OV_SWITCH(intel_cpu, flattenExec, this, dataPrecision,
-              OV_CASE(ov::element::f32, float),
-              OV_CASE(ov::element::i32, int32_t),
-              OV_CASE(ov::element::i8, int8_t),
-              OV_CASE(ov::element::u8, uint8_t))
+        OV_SWITCH(intel_cpu,
+                  flattenExec,
+                  this,
+                  dataPrecision,
+                  OV_CASE(ov::element::f32, float),
+                  OV_CASE(ov::element::i32, int32_t),
+                  OV_CASE(ov::element::i8, int8_t),
+                  OV_CASE(ov::element::u8, uint8_t))
     } else {
-        OV_SWITCH(intel_cpu, slicedExec, this, dataPrecision,
-              OV_CASE(ov::element::f32, float),
-              OV_CASE(ov::element::i32, int32_t),
-              OV_CASE(ov::element::i8, int8_t),
-              OV_CASE(ov::element::u8, uint8_t))
+        OV_SWITCH(intel_cpu,
+                  slicedExec,
+                  this,
+                  dataPrecision,
+                  OV_CASE(ov::element::f32, float),
+                  OV_CASE(ov::element::i32, int32_t),
+                  OV_CASE(ov::element::i8, int8_t),
+                  OV_CASE(ov::element::u8, uint8_t))
     }
 }
 
@@ -154,12 +160,12 @@ void Unique::executeDynamicImpl(dnnl::stream strm) {
     Dim uniqLen = 1;
     if (flattened) {
         uniqLen = std::accumulate(srcDataDims.begin(), srcDataDims.end(), 1, std::multiplies<Dim>());
-        dstDataDims = { uniqLen };
+        dstDataDims = {uniqLen};
     } else {
         uniqLen = srcDataDims[axis];
         dstDataDims = srcDataDims;
     }
-    redefineOutputMemory({ dstDataDims, {uniqLen}, {uniqLen}, {uniqLen}});
+    redefineOutputMemory({dstDataDims, {uniqLen}, {uniqLen}, {uniqLen}});
 
     execute(strm);
 }
@@ -253,12 +259,12 @@ void Unique::flattenTensorExec() {
         }
     }
 
-    redefineOutputMemory({ {uniqueLen}, {uniqueLen}, {inputLen}, {uniqueLen}});
+    redefineOutputMemory({{uniqueLen}, {uniqueLen}, {inputLen}, {uniqueLen}});
 
     T* uniDataPtr = getDstDataAtPortAs<T>(UNIQUE_DATA);
     cpu_parallel_memcpy(uniDataPtr, uniDataTmpPtr, uniqueLen * sizeof(T));
     if (definedOutputs[FIRST_UNIQUE_IDX]) {
-        int *firstPtr = getDstDataAtPortAs<int>(FIRST_UNIQUE_IDX);
+        int* firstPtr = getDstDataAtPortAs<int>(FIRST_UNIQUE_IDX);
         cpu_parallel_memcpy(firstPtr, firstUniTmp.data(), uniqueLen * sizeof(int));
     }
     if (definedOutputs[INPUT_TO_UNIQ_IDX]) {
@@ -329,7 +335,7 @@ void Unique::slicedTensorExec() {
                     break;
                 }
                 first1 += srcOuterStep;
-                last1  += srcOuterStep;
+                last1 += srcOuterStep;
                 first2 += srcOuterStep;
             }
             if (equal) {
@@ -355,7 +361,7 @@ void Unique::slicedTensorExec() {
     // Redefinition of output shapes.
     auto dstDataShape = srcDataShape;
     dstDataShape[axis] = uniqueLen;
-    redefineOutputMemory({ dstDataShape, {uniqueLen}, {axisDim}, {uniqueLen}});
+    redefineOutputMemory({dstDataShape, {uniqueLen}, {axisDim}, {uniqueLen}});
 
     int *firstPtr = nullptr, *inToOutPtr = nullptr, *occurNPtr = nullptr;
     if (definedOutputs[FIRST_UNIQUE_IDX]) {
@@ -401,17 +407,20 @@ void Unique::slicedTensorExec() {
         int *occurN1 = occurNPtr, *occurN2 = occurTmpPtr;
         int *inToOut1 = inToOutPtr, *inToOut2 = inToOutTmpPtr;
 
-        const bool defined3outputs = definedOutputs[FIRST_UNIQUE_IDX] || definedOutputs[OCCURRENCES_NUM] || definedOutputs[INPUT_TO_UNIQ_IDX];
+        const bool defined3outputs =
+            definedOutputs[FIRST_UNIQUE_IDX] || definedOutputs[OCCURRENCES_NUM] || definedOutputs[INPUT_TO_UNIQ_IDX];
 
-        for (int64_t o = outerLen - 1; o >= 0; o--) { // Backward loop through the outer block.
+        for (int64_t o = outerLen - 1; o >= 0; o--) {  // Backward loop through the outer block.
             const int64_t pos1Lim = o * dstOuterStep;
             int64_t pos1 = pos1Lim + innerLen - 1;
-            for (; pos1 >= pos1Lim ; pos1--) { // Backward loop through the inner block.
+            for (; pos1 >= pos1Lim; pos1--) {  // Backward loop through the inner block.
                 int64_t pos2 = pos1;
                 for (int64_t k = 0; k < static_cast<int64_t>(uniqueLen); k++, pos2 += innerLen) {
-                    colToSort[k] = { dst1[pos2], k };
+                    colToSort[k] = {dst1[pos2], k};
                 }
-                std::stable_sort(colToSort.begin(), colToSort.end(), [](const OrdEl &el1, const OrdEl &el2) { return el1.val < el2.val; });
+                std::stable_sort(colToSort.begin(), colToSort.end(), [](const OrdEl& el1, const OrdEl& el2) {
+                    return el1.val < el2.val;
+                });
 
                 // Permutation
                 parallel_for2d(outerLen, uniqueLen, [&](int64_t ot, size_t u) {
diff --git a/src/plugins/intel_cpu/src/nodes/unique.hpp b/src/plugins/intel_cpu/src/nodes/unique.hpp
index 626a529c3eba4c..3a1d4d4549abba 100644
--- a/src/plugins/intel_cpu/src/nodes/unique.hpp
+++ b/src/plugins/intel_cpu/src/nodes/unique.hpp
@@ -15,16 +15,20 @@ class Unique : public Node {
     Unique(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
     static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
 
-    void getSupportedDescriptors() override {};
+    void getSupportedDescriptors() override{};
     void initSupportedPrimitiveDescriptors() override;
     void createPrimitive() override;
     void execute(dnnl::stream strm) override;
-    bool created() const override { return getType() == Type::Unique; }
+    bool created() const override {
+        return getType() == Type::Unique;
+    }
 
 protected:
     void executeDynamicImpl(dnnl::stream strm) override;
     void prepareParams() override;
-    bool needShapeInfer() const override { return false; }
+    bool needShapeInfer() const override {
+        return false;
+    }
 
 private:
     template <typename T>
@@ -32,31 +36,31 @@ class Unique : public Node {
     template <typename T>
     void slicedTensorExec();
 
-    template<typename T>
+    template <typename T>
     struct flattenExec;
-    template<typename T>
+    template <typename T>
     struct slicedExec;
 
     std::vector<int32_t> firstUniTmp;
     std::vector<int32_t> inToOutTmp;
     std::vector<int32_t> occurTmp;
 
-    bool sorted    = false;
+    bool sorted = false;
     bool flattened = true;
-    int  axis = 0;
-    bool definedOutputs[4] = { false, false, false, false };
+    int axis = 0;
+    bool definedOutputs[4] = {false, false, false, false};
     ov::element::Type dataPrecision;
     int64_t dataTypeSize = 1l;
     size_t uniqueLen = 1lu;
 
     static constexpr size_t IN_DATA = 0;
-    static constexpr size_t AXIS    = 1;
-    static constexpr size_t UNIQUE_DATA       = 0;
-    static constexpr size_t FIRST_UNIQUE_IDX  = 1;
+    static constexpr size_t AXIS = 1;
+    static constexpr size_t UNIQUE_DATA = 0;
+    static constexpr size_t FIRST_UNIQUE_IDX = 1;
     static constexpr size_t INPUT_TO_UNIQ_IDX = 2;
-    static constexpr size_t OCCURRENCES_NUM   = 3;
+    static constexpr size_t OCCURRENCES_NUM = 3;
 };
 
-}   // namespace node
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/nodes_factory.cpp b/src/plugins/intel_cpu/src/nodes_factory.cpp
index 4a8e8205510fcf..ff27a0e4246baf 100644
--- a/src/plugins/intel_cpu/src/nodes_factory.cpp
+++ b/src/plugins/intel_cpu/src/nodes_factory.cpp
@@ -7,6 +7,7 @@
 #include "nodes/bin_conv.h"
 #include "nodes/broadcast.h"
 #include "nodes/bucketize.h"
+#include "nodes/causal_mask_preprocess.h"
 #include "nodes/col2im.h"
 #include "nodes/color_convert.h"
 #include "nodes/composite.h"
@@ -45,11 +46,11 @@
 #include "nodes/if.h"
 #include "nodes/input.h"
 #include "nodes/interaction.h"
-#include "nodes/llm_mlp.h"
-#include "nodes/qkv_proj.h"
 #include "nodes/interpolate.h"
 #include "nodes/inverse.hpp"
+#include "nodes/llm_mlp.h"
 #include "nodes/log_softmax.h"
+#include "nodes/lora.h"
 #include "nodes/lrn.h"
 #include "nodes/mathematics.h"
 #include "nodes/matmul.h"
@@ -71,6 +72,7 @@
 #include "nodes/priorbox_clustered.h"
 #include "nodes/proposal.h"
 #include "nodes/psroi_pooling.h"
+#include "nodes/qkv_proj.h"
 #include "nodes/random_uniform.hpp"
 #include "nodes/range.h"
 #include "nodes/rdft.h"
@@ -91,8 +93,6 @@
 #include "nodes/scaled_attn.h"
 #include "nodes/scatter_update.h"
 #include "nodes/search_sorted.h"
-#include "nodes/string_tensor_pack.h"
-#include "nodes/string_tensor_unpack.h"
 #include "nodes/shapeof.h"
 #include "nodes/shuffle_channels.h"
 #include "nodes/softmax.h"
@@ -101,14 +101,14 @@
 #include "nodes/split.h"
 #include "nodes/stft.h"
 #include "nodes/strided_slice.h"
+#include "nodes/string_tensor_pack.h"
+#include "nodes/string_tensor_unpack.h"
 #include "nodes/subgraph.h"
 #include "nodes/tensoriterator.h"
 #include "nodes/tile.h"
 #include "nodes/topk.h"
 #include "nodes/transpose.h"
 #include "nodes/unique.hpp"
-#include "nodes/causal_mask_preprocess.h"
-#include "nodes/lora.h"
 
 namespace ov {
 namespace intel_cpu {
diff --git a/src/plugins/intel_cpu/src/onednn/dnnl.cpp b/src/plugins/intel_cpu/src/onednn/dnnl.cpp
index ea4f6eadd02ad4..ed55b1648b9ff6 100644
--- a/src/plugins/intel_cpu/src/onednn/dnnl.cpp
+++ b/src/plugins/intel_cpu/src/onednn/dnnl.cpp
@@ -3,13 +3,15 @@
 //
 
 #include "dnnl.h"
+
 #include <dnnl_debug.h>
-#include <cpu/platform.hpp>
-#include "cpu/x64/cpu_isa_traits.hpp"
 
 #include <cassert>
+#include <cpu/platform.hpp>
 #include <cstring>
 
+#include "cpu/x64/cpu_isa_traits.hpp"
+
 namespace dnnl {
 namespace utils {
 
@@ -17,116 +19,114 @@ const char* fmt2str(memory::format_tag fmt) {
     return dnnl_fmt_tag2str(static_cast<dnnl_format_tag_t>(fmt));
 }
 
-dnnl::memory::format_tag str2fmt(const char *str) {
-#define CASE(_fmt) do { \
-    if (!strcmp(#_fmt, str) \
-            || !strcmp("dnnl_" #_fmt, str)) \
-        return static_cast<dnnl::memory::format_tag>(dnnl_ ## _fmt); \
-} while (0)
-        CASE(x);
-        CASE(nc);
-        CASE(ncw);
-        CASE(nwc);
-        CASE(nCw4c);
-        CASE(nCw8c);
-        CASE(nCw16c);
-        CASE(nchw);
-        CASE(nhwc);
-        CASE(chwn);
-        CASE(nChw4c);
-        CASE(nChw8c);
-        CASE(nChw16c);
-        CASE(oi);
-        CASE(io);
-        CASE(oiw);
-        CASE(wio);
-        CASE(OIw16i16o);
-        CASE(OIw16o16i);
-        CASE(Oiw16o);
-        CASE(Owi16o);
-        CASE(OIw8i16o2i);
-        CASE(OIw4i16o4i);
-        CASE(oihw);
-        CASE(ihwo);
-        CASE(hwio);
-        CASE(iohw);
-        CASE(dhwio);
-        CASE(OIhw8i8o);
-        CASE(OIhw16i16o);
-        CASE(OIhw8i16o2i);
-        CASE(OIdhw8i16o2i);
-        CASE(OIhw4i16o4i);
-        CASE(OIdhw4i16o4i);
-        CASE(OIhw8o16i2o);
-        CASE(IOhw8o16i2o);
-        CASE(OIhw8o8i);
-        CASE(OIhw8o32i);
-        CASE(OIhw16o32i);
-        CASE(OIhw16o16i);
-        CASE(IOhw16o16i);
-        CASE(Oihw16o);
-        CASE(Ohwi8o);
-        CASE(Ohwi16o);
-        CASE(goiw);
-        CASE(goihw);
-        CASE(hwigo);
-        CASE(giohw);
-        CASE(dhwigo);
-        CASE(goiw);
-        CASE(gOIw16i16o);
-        CASE(gOIw16o16i);
-        CASE(gOiw16o);
-        CASE(gOwi16o);
-        CASE(gOIw8i16o2i);
-        CASE(gOIw4i16o4i);
-        CASE(Goiw16g);
-        CASE(gOIhw8i8o);
-        CASE(gOIhw16i16o);
-        CASE(gOIhw8i16o2i);
-        CASE(gOIdhw8i16o2i);
-        CASE(gOIhw2i8o4i);
-        CASE(gOIhw4i16o4i);
-        CASE(gOIdhw4i16o4i);
-        CASE(gOIhw8o16i2o);
-        CASE(gIOhw8o16i2o);
-        CASE(gOIhw4o4i);
-        CASE(gOIhw8o8i);
-        CASE(gOIhw16o16i);
-        CASE(gIOhw16o16i);
-        CASE(gOihw16o);
-        CASE(gOhwi8o);
-        CASE(gOhwi16o);
-        CASE(Goihw8g);
-        CASE(Goihw16g);
-        CASE(Goidhw4g);
-        CASE(Goidhw8g);
-        CASE(Goidhw16g);
-        CASE(ncdhw);
-        CASE(ndhwc);
-        CASE(oidhw);
-        CASE(goidhw);
-        CASE(nCdhw4c);
-        CASE(nCdhw8c);
-        CASE(nCdhw16c);
-        CASE(OIdhw16i16o);
-        CASE(gOIdhw16i16o);
-        CASE(OIdhw16o16i);
-        CASE(gOIdhw16o16i);
-        CASE(Oidhw16o);
-        CASE(Odhwi16o);
-        CASE(gOidhw16o);
-        CASE(gOdhwi16o);
-        CASE(ntc);
-        CASE(tnc);
-        CASE(ldigo);
-        CASE(ldgoi);
-        CASE(ldgo);
+dnnl::memory::format_tag str2fmt(const char* str) {
+#define CASE(_fmt)                                                     \
+    do {                                                               \
+        if (!strcmp(#_fmt, str) || !strcmp("dnnl_" #_fmt, str))        \
+            return static_cast<dnnl::memory::format_tag>(dnnl_##_fmt); \
+    } while (0)
+    CASE(x);
+    CASE(nc);
+    CASE(ncw);
+    CASE(nwc);
+    CASE(nCw4c);
+    CASE(nCw8c);
+    CASE(nCw16c);
+    CASE(nchw);
+    CASE(nhwc);
+    CASE(chwn);
+    CASE(nChw4c);
+    CASE(nChw8c);
+    CASE(nChw16c);
+    CASE(oi);
+    CASE(io);
+    CASE(oiw);
+    CASE(wio);
+    CASE(OIw16i16o);
+    CASE(OIw16o16i);
+    CASE(Oiw16o);
+    CASE(Owi16o);
+    CASE(OIw8i16o2i);
+    CASE(OIw4i16o4i);
+    CASE(oihw);
+    CASE(ihwo);
+    CASE(hwio);
+    CASE(iohw);
+    CASE(dhwio);
+    CASE(OIhw8i8o);
+    CASE(OIhw16i16o);
+    CASE(OIhw8i16o2i);
+    CASE(OIdhw8i16o2i);
+    CASE(OIhw4i16o4i);
+    CASE(OIdhw4i16o4i);
+    CASE(OIhw8o16i2o);
+    CASE(IOhw8o16i2o);
+    CASE(OIhw8o8i);
+    CASE(OIhw8o32i);
+    CASE(OIhw16o32i);
+    CASE(OIhw16o16i);
+    CASE(IOhw16o16i);
+    CASE(Oihw16o);
+    CASE(Ohwi8o);
+    CASE(Ohwi16o);
+    CASE(goiw);
+    CASE(goihw);
+    CASE(hwigo);
+    CASE(giohw);
+    CASE(dhwigo);
+    CASE(goiw);
+    CASE(gOIw16i16o);
+    CASE(gOIw16o16i);
+    CASE(gOiw16o);
+    CASE(gOwi16o);
+    CASE(gOIw8i16o2i);
+    CASE(gOIw4i16o4i);
+    CASE(Goiw16g);
+    CASE(gOIhw8i8o);
+    CASE(gOIhw16i16o);
+    CASE(gOIhw8i16o2i);
+    CASE(gOIdhw8i16o2i);
+    CASE(gOIhw2i8o4i);
+    CASE(gOIhw4i16o4i);
+    CASE(gOIdhw4i16o4i);
+    CASE(gOIhw8o16i2o);
+    CASE(gIOhw8o16i2o);
+    CASE(gOIhw4o4i);
+    CASE(gOIhw8o8i);
+    CASE(gOIhw16o16i);
+    CASE(gIOhw16o16i);
+    CASE(gOihw16o);
+    CASE(gOhwi8o);
+    CASE(gOhwi16o);
+    CASE(Goihw8g);
+    CASE(Goihw16g);
+    CASE(Goidhw4g);
+    CASE(Goidhw8g);
+    CASE(Goidhw16g);
+    CASE(ncdhw);
+    CASE(ndhwc);
+    CASE(oidhw);
+    CASE(goidhw);
+    CASE(nCdhw4c);
+    CASE(nCdhw8c);
+    CASE(nCdhw16c);
+    CASE(OIdhw16i16o);
+    CASE(gOIdhw16i16o);
+    CASE(OIdhw16o16i);
+    CASE(gOIdhw16o16i);
+    CASE(Oidhw16o);
+    CASE(Odhwi16o);
+    CASE(gOidhw16o);
+    CASE(gOdhwi16o);
+    CASE(ntc);
+    CASE(tnc);
+    CASE(ldigo);
+    CASE(ldgoi);
+    CASE(ldgo);
 #undef CASE
-        assert(!"unknown memory format");
-        return dnnl::memory::format_tag::undef;
-    }
-
-
+    assert(!"unknown memory format");
+    return dnnl::memory::format_tag::undef;
+}
 
 unsigned get_cache_size(int level, bool per_core) {
     if (per_core) {
@@ -138,7 +138,7 @@ unsigned get_cache_size(int level, bool per_core) {
             return dnnl::impl::cpu::platform::get_per_core_cache_size(level);
         }
 
-        if (level > 0 && (unsigned) level <= cpu().getDataCacheLevels()) {
+        if (level > 0 && (unsigned)level <= cpu().getDataCacheLevels()) {
             unsigned l = level - 1;
             return cpu().getDataCacheSize(l);
         } else {
diff --git a/src/plugins/intel_cpu/src/onednn/dnnl.h b/src/plugins/intel_cpu/src/onednn/dnnl.h
index dc4f312d327598..85782af4a8e2de 100644
--- a/src/plugins/intel_cpu/src/onednn/dnnl.h
+++ b/src/plugins/intel_cpu/src/onednn/dnnl.h
@@ -15,7 +15,7 @@ namespace utils {
 unsigned get_cache_size(int level, bool per_core);
 
 const char* fmt2str(memory::format_tag fmt);
-dnnl::memory::format_tag str2fmt(const char *str);
+dnnl::memory::format_tag str2fmt(const char* str);
 
 }  // namespace utils
 }  // namespace dnnl
diff --git a/src/plugins/intel_cpu/src/onednn/iml_type_mapper.cpp b/src/plugins/intel_cpu/src/onednn/iml_type_mapper.cpp
index 5c57a94f69f67d..881cb784c8fc55 100644
--- a/src/plugins/intel_cpu/src/onednn/iml_type_mapper.cpp
+++ b/src/plugins/intel_cpu/src/onednn/iml_type_mapper.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "iml_type_mapper.h"
+
 #include <algorithm>
 #include <string>
 #include <vector>
@@ -13,8 +14,12 @@ namespace intel_cpu {
 impl_desc_type parse_impl_name(std::string impl_desc_name) {
     impl_desc_type res = impl_desc_type::unknown;
 
-#define REPLACE_WORD(_wrd, _sub) { auto pos = impl_desc_name.find(#_wrd); \
-    if (pos != std::string::npos) impl_desc_name.replace(pos, std::string(#_wrd).length(), #_sub); }
+#define REPLACE_WORD(_wrd, _sub)                                             \
+    {                                                                        \
+        auto pos = impl_desc_name.find(#_wrd);                               \
+        if (pos != std::string::npos)                                        \
+            impl_desc_name.replace(pos, std::string(#_wrd).length(), #_sub); \
+    }
     // Replace the ONEDNN pd name with OV definition.
     REPLACE_WORD(brg_conv, brgconv);
     REPLACE_WORD(brdgmm, brgconv);
@@ -25,10 +30,12 @@ impl_desc_type parse_impl_name(std::string impl_desc_name) {
 
 #undef REPLACE_WORD
 
-#define SEARCH_WORD(_wrd) if (impl_desc_name.find(#_wrd) != std::string::npos) \
-    res = static_cast<impl_desc_type>(res | impl_desc_type::_wrd);
-#define SEARCH_WORD_2(_wrd, _key) if (impl_desc_name.find(#_wrd) != std::string::npos) \
-    res = static_cast<impl_desc_type>(res | impl_desc_type::_key);
+#define SEARCH_WORD(_wrd)                                \
+    if (impl_desc_name.find(#_wrd) != std::string::npos) \
+        res = static_cast<impl_desc_type>(res | impl_desc_type::_wrd);
+#define SEARCH_WORD_2(_wrd, _key)                        \
+    if (impl_desc_name.find(#_wrd) != std::string::npos) \
+        res = static_cast<impl_desc_type>(res | impl_desc_type::_key);
 
     SEARCH_WORD(ref);
     SEARCH_WORD(jit);
@@ -55,8 +62,7 @@ impl_desc_type parse_impl_name(std::string impl_desc_name) {
     if ((res & impl_desc_type::avx2) != impl_desc_type::avx2 &&
         (res & impl_desc_type::avx512) != impl_desc_type::avx512)
         SEARCH_WORD(avx);
-    if ((res & impl_desc_type::sse42) != impl_desc_type::sse42 &&
-        (res & impl_desc_type::avx) != impl_desc_type::avx &&
+    if ((res & impl_desc_type::sse42) != impl_desc_type::sse42 && (res & impl_desc_type::avx) != impl_desc_type::avx &&
         (res & impl_desc_type::avx2) != impl_desc_type::avx2 &&
         (res & impl_desc_type::avx512) != impl_desc_type::avx512)
         SEARCH_WORD(uni);
@@ -69,14 +75,16 @@ impl_desc_type parse_impl_name(std::string impl_desc_name) {
 #undef SEARCH_WORD
     // Deconv case would set both jit and any in onednn, only set the jit bit.
     if ((res & jit) && (res & any))
-        res = static_cast<impl_desc_type> (res & ~any);
+        res = static_cast<impl_desc_type>(res & ~any);
     return res;
 }
 
 const char* impl_type_to_string(impl_desc_type type) {
-#define CASE(_type) do {                    \
-    if (type == _type) return #_type;       \
-} while (0)
+#define CASE(_type)        \
+    do {                   \
+        if (type == _type) \
+            return #_type; \
+    } while (0)
     CASE(unknown);
     CASE(undef);
     CASE(ref);
@@ -151,4 +159,4 @@ bool contains(const std::vector<impl_desc_type>& priorities, const impl_desc_typ
 }
 
 }  // namespace intel_cpu
-}   // namespace ov
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/onednn/iml_type_mapper.h b/src/plugins/intel_cpu/src/onednn/iml_type_mapper.h
index 45a71bdb88dd33..1ba599fcc5677d 100644
--- a/src/plugins/intel_cpu/src/onednn/iml_type_mapper.h
+++ b/src/plugins/intel_cpu/src/onednn/iml_type_mapper.h
@@ -14,119 +14,119 @@ enum impl_desc_type : int64_t {
     unknown = 0x00000000,
     undef,
     // Optimization approach
-    simple  = 1<<6,
-    ref     = 1<<7,
-    jit     = 1<<8,
-    gemm    = 1<<9,
-    brgconv = 1<<10,
-    brgemm  = 1<<11,
+    simple = 1 << 6,
+    ref = 1 << 7,
+    jit = 1 << 8,
+    gemm = 1 << 9,
+    brgconv = 1 << 10,
+    brgemm = 1 << 11,
     // CPU version
-    sse42  = 1<<12,
-    avx    = 1<<13,
-    avx2   = 1<<14,
-    avx512 = 1<<15,
-    amx    = 1<<16,
-    blas   = 1<<17,
-    any    = 1<<18,
-    uni    = 1<<19,
-    acl    = 1<<20,
+    sse42 = 1 << 12,
+    avx = 1 << 13,
+    avx2 = 1 << 14,
+    avx512 = 1 << 15,
+    amx = 1 << 16,
+    blas = 1 << 17,
+    any = 1 << 18,
+    uni = 1 << 19,
+    acl = 1 << 20,
     // Other specificator
-    _1x1    = 1<<21,
-    _dw     = 1<<22,
+    _1x1 = 1 << 21,
+    _dw = 1 << 22,
     // Other info
-    reorder = 1<<23,
+    reorder = 1 << 23,
     // winograd
-    winograd = 1<<24,
+    winograd = 1 << 24,
     // sparse
-    sparse = 1<<25,
-    //mlas backend
-    mlas = 1<<26,
+    sparse = 1 << 25,
+    // mlas backend
+    mlas = 1 << 26,
 
-    asimd  = 1<<27,
-    sve128 = 1<<28,
-    sve256 = 1<<29,
-    sve384 = 1<<30,
-    sve512 = 1<<31,
+    asimd = 1 << 27,
+    sve128 = 1 << 28,
+    sve256 = 1 << 29,
+    sve384 = 1 << 30,
+    sve512 = 1 << 31,
 
     // shl backend
-    shl = 1ll<<32,
+    shl = 1ll << 32,
 
     // real types
-    ref_any             = ref  | any,
-
-    gemm_any            = gemm | any,
-    gemm_blas           = gemm | blas,
-    gemm_avx512         = gemm | avx512,
-    gemm_avx2           = gemm | avx2,
-    gemm_avx            = gemm | avx,
-    gemm_sse42          = gemm | sse42,
-    jit_gemm            = jit | gemm,
-
-    jit_avx512_winograd = jit  | avx512 | winograd,
-    jit_avx512          = jit  | avx512,
-    jit_avx2            = jit  | avx2,
-    jit_avx             = jit  | avx,
-    jit_sse42           = jit  | sse42,
-    jit_uni             = jit  | uni,
-    jit_avx512_amx      = jit  | avx512 | amx,
-
-    jit_avx512_1x1      = jit  | avx512 | _1x1,
-    jit_avx2_1x1        = jit  | avx2   | _1x1,
-    jit_avx_1x1         = jit  | avx    | _1x1,
-    jit_sse42_1x1       = jit  | sse42  | _1x1,
-    jit_uni_1x1         = jit  | uni    | _1x1,
-    jit_avx512_amx_1x1  = jit  | avx512 | amx | _1x1,
-
-    jit_avx512_dw       = jit  | avx512 | _dw,
-    jit_avx2_dw         = jit  | avx2   | _dw,
-    jit_avx_dw          = jit  | avx    | _dw,
-    jit_sse42_dw        = jit  | sse42  | _dw,
-    jit_uni_dw          = jit  | uni    | _dw,
-    jit_avx512_amx_dw   = jit  | avx512 | amx | _dw,
-
-    brgconv_avx512      = brgconv  | avx512,
-    brgconv_avx2        = brgconv  | avx2,
-    brgconv_avx         = brgconv  | avx,
-    brgconv_sse42       = brgconv  | sse42,
-    brgconv_uni         = brgconv  | uni,
-    brgconv_avx512_amx  = brgconv  | avx512 | amx,
-
-    brgconv_avx512_1x1      = brgconv  | avx512 | _1x1,
-    brgconv_avx2_1x1        = brgconv  | avx2 | _1x1,
-    brgconv_avx_1x1         = brgconv  | avx | _1x1,
-    brgconv_sse42_1x1       = brgconv  | sse42 | _1x1,
-    brgconv_uni_1x1         = brgconv  | uni | _1x1,
-    brgconv_avx512_amx_1x1  = brgconv  | avx512 | amx | _1x1,
-
-    brgconv_avx2_dw    = brgconv_avx2 | _dw,
-    brgconv_avx512_dw    = brgconv_avx512 | _dw,
-
-    brgemm_avx512      = brgemm  | avx512,
-    brgemm_avx2        = brgemm  | avx2,
-    brgemm_avx         = brgemm  | avx,
-    brgemm_sse42       = brgemm  | sse42,
-    brgemm_uni         = brgemm  | uni,
-    brgemm_avx512_amx  = brgemm  | avx512 | amx,
+    ref_any = ref | any,
+
+    gemm_any = gemm | any,
+    gemm_blas = gemm | blas,
+    gemm_avx512 = gemm | avx512,
+    gemm_avx2 = gemm | avx2,
+    gemm_avx = gemm | avx,
+    gemm_sse42 = gemm | sse42,
+    jit_gemm = jit | gemm,
+
+    jit_avx512_winograd = jit | avx512 | winograd,
+    jit_avx512 = jit | avx512,
+    jit_avx2 = jit | avx2,
+    jit_avx = jit | avx,
+    jit_sse42 = jit | sse42,
+    jit_uni = jit | uni,
+    jit_avx512_amx = jit | avx512 | amx,
+
+    jit_avx512_1x1 = jit | avx512 | _1x1,
+    jit_avx2_1x1 = jit | avx2 | _1x1,
+    jit_avx_1x1 = jit | avx | _1x1,
+    jit_sse42_1x1 = jit | sse42 | _1x1,
+    jit_uni_1x1 = jit | uni | _1x1,
+    jit_avx512_amx_1x1 = jit | avx512 | amx | _1x1,
+
+    jit_avx512_dw = jit | avx512 | _dw,
+    jit_avx2_dw = jit | avx2 | _dw,
+    jit_avx_dw = jit | avx | _dw,
+    jit_sse42_dw = jit | sse42 | _dw,
+    jit_uni_dw = jit | uni | _dw,
+    jit_avx512_amx_dw = jit | avx512 | amx | _dw,
+
+    brgconv_avx512 = brgconv | avx512,
+    brgconv_avx2 = brgconv | avx2,
+    brgconv_avx = brgconv | avx,
+    brgconv_sse42 = brgconv | sse42,
+    brgconv_uni = brgconv | uni,
+    brgconv_avx512_amx = brgconv | avx512 | amx,
+
+    brgconv_avx512_1x1 = brgconv | avx512 | _1x1,
+    brgconv_avx2_1x1 = brgconv | avx2 | _1x1,
+    brgconv_avx_1x1 = brgconv | avx | _1x1,
+    brgconv_sse42_1x1 = brgconv | sse42 | _1x1,
+    brgconv_uni_1x1 = brgconv | uni | _1x1,
+    brgconv_avx512_amx_1x1 = brgconv | avx512 | amx | _1x1,
+
+    brgconv_avx2_dw = brgconv_avx2 | _dw,
+    brgconv_avx512_dw = brgconv_avx512 | _dw,
+
+    brgemm_avx512 = brgemm | avx512,
+    brgemm_avx2 = brgemm | avx2,
+    brgemm_avx = brgemm | avx,
+    brgemm_sse42 = brgemm | sse42,
+    brgemm_uni = brgemm | uni,
+    brgemm_avx512_amx = brgemm | avx512 | amx,
     brgemm_sparse_avx512_amx = brgemm | sparse | avx512 | amx,
 
-    dw_acl             = _dw | acl,
-    gemm_acl           = gemm | acl,
-    winograd_acl       = winograd | acl,
-    gemm_mlas          = gemm | mlas,
+    dw_acl = _dw | acl,
+    gemm_acl = gemm | acl,
+    winograd_acl = winograd | acl,
+    gemm_mlas = gemm | mlas,
 
-    jit_asimd          = jit | asimd,
-    jit_sve128        = jit | sve128,
-    jit_sve256        = jit | sve256,
-    jit_sve384        = jit | sve384,
-    jit_sve512        = jit | sve512,
+    jit_asimd = jit | asimd,
+    jit_sve128 = jit | sve128,
+    jit_sve256 = jit | sve256,
+    jit_sve384 = jit | sve384,
+    jit_sve512 = jit | sve512,
 
-    gemm_shl          = gemm | shl
+    gemm_shl = gemm | shl
 };
 
 std::vector<std::string> extractTypeAndImplName(const std::string& priority);
-const char * impl_type_to_string(impl_desc_type type);
+const char* impl_type_to_string(impl_desc_type type);
 impl_desc_type parse_impl_name(std::string impl_desc_name);
 bool contains(const std::vector<impl_desc_type>& priorities, const impl_desc_type impl_type_str);
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/partitioned_mem_blk.cpp b/src/plugins/intel_cpu/src/partitioned_mem_blk.cpp
index 0d20e58ba87074..f5a1947569a9fa 100644
--- a/src/plugins/intel_cpu/src/partitioned_mem_blk.cpp
+++ b/src/plugins/intel_cpu/src/partitioned_mem_blk.cpp
@@ -30,4 +30,3 @@ void PartitionedMemoryBlock::registerMemory(Memory* memPtr) {
 void PartitionedMemoryBlock::unregisterMemory(Memory* memPtr) {
     m_pBlock->unregisterMemory(memPtr);
 }
-
diff --git a/src/plugins/intel_cpu/src/partitioned_mem_blk.h b/src/plugins/intel_cpu/src/partitioned_mem_blk.h
index 58179ce5b04d55..b205e8ff45e99e 100644
--- a/src/plugins/intel_cpu/src/partitioned_mem_blk.h
+++ b/src/plugins/intel_cpu/src/partitioned_mem_blk.h
@@ -11,12 +11,18 @@ namespace intel_cpu {
 
 /**
  * This is a memory block that represents a view on a subblock inside another continuous dynamic memory block
- * 
+ *
  */
 class PartitionedMemoryBlock : public IMemoryBlockObserver {
 public:
-    PartitionedMemoryBlock(MemoryBlockPtr pBlock, size_t total_chunks = 1, ptrdiff_t offset_chunks = 0, size_t size_chunks = 1)
-        : m_pBlock(pBlock), m_total_chunks(total_chunks), m_offset_chunks(offset_chunks), m_size_chunks(size_chunks) {
+    PartitionedMemoryBlock(MemoryBlockPtr pBlock,
+                           size_t total_chunks = 1,
+                           ptrdiff_t offset_chunks = 0,
+                           size_t size_chunks = 1)
+        : m_pBlock(pBlock),
+          m_total_chunks(total_chunks),
+          m_offset_chunks(offset_chunks),
+          m_size_chunks(size_chunks) {
         OPENVINO_ASSERT(m_pBlock, "Memory block is uninitialized");
     }
 
@@ -29,11 +35,11 @@ class PartitionedMemoryBlock : public IMemoryBlockObserver {
 
 private:
     MemoryBlockPtr m_pBlock;
-    size_t m_total_chunks = 1; // size of the parent memory in abstract chunks
-    ptrdiff_t m_offset_chunks = 0; // offset from the beginning of the external memory in abstract chunks
-    size_t m_size_chunks = 1; // size of the viewed partition in abstract chunks
-    size_t m_size = 0; // size of the viewed partition in bytes
+    size_t m_total_chunks = 1;      // size of the parent memory in abstract chunks
+    ptrdiff_t m_offset_chunks = 0;  // offset from the beginning of the external memory in abstract chunks
+    size_t m_size_chunks = 1;       // size of the viewed partition in abstract chunks
+    size_t m_size = 0;              // size of the viewed partition in bytes
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/perf_count.h b/src/plugins/intel_cpu/src/perf_count.h
index a3da7981d78498..af7c17bcf7ea4b 100644
--- a/src/plugins/intel_cpu/src/perf_count.h
+++ b/src/plugins/intel_cpu/src/perf_count.h
@@ -18,14 +18,18 @@ class PerfCount {
     std::chrono::high_resolution_clock::time_point __finish = {};
 
 public:
-    PerfCount(): total_duration(0), num(0) {}
+    PerfCount() : total_duration(0), num(0) {}
 
     std::chrono::duration<double, std::milli> duration() const {
         return __finish - __start;
     }
 
-    uint64_t avg() const { return (num == 0) ? 0 : total_duration / num; }
-    uint32_t count() const { return num; }
+    uint64_t avg() const {
+        return (num == 0) ? 0 : total_duration / num;
+    }
+    uint32_t count() const {
+        return num;
+    }
 
 private:
     void start_itr() {
@@ -42,16 +46,20 @@ class PerfCount {
 };
 
 class PerfHelper {
-    PerfCount &counter;
+    PerfCount& counter;
 
 public:
-    explicit PerfHelper(PerfCount &count): counter(count) { counter.start_itr(); }
+    explicit PerfHelper(PerfCount& count) : counter(count) {
+        counter.start_itr();
+    }
 
-    ~PerfHelper() { counter.finish_itr(); }
+    ~PerfHelper() {
+        counter.finish_itr();
+    }
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
-#define GET_PERF(_node) std::unique_ptr<PerfHelper>(new PerfHelper(_node->PerfCounter()))
+#define GET_PERF(_node)    std::unique_ptr<PerfHelper>(new PerfHelper(_node->PerfCounter()))
 #define PERF(_node, _need) auto pc = _need ? GET_PERF(_node) : nullptr;
diff --git a/src/plugins/intel_cpu/src/plugin.cpp b/src/plugins/intel_cpu/src/plugin.cpp
index e34f5a5b36e36f..ad5143bc5262bd 100644
--- a/src/plugins/intel_cpu/src/plugin.cpp
+++ b/src/plugins/intel_cpu/src/plugin.cpp
@@ -7,6 +7,7 @@
 #include "cpu_streams_calculation.hpp"
 #include "internal_properties.hpp"
 #include "itt.h"
+#include "openvino/op/paged_attention.hpp"
 #include "openvino/runtime/intel_cpu/properties.hpp"
 #include "openvino/runtime/internal_properties.hpp"
 #include "openvino/runtime/properties.hpp"
@@ -19,7 +20,6 @@
 #include "utils/precision_support.h"
 #include "utils/serialize.hpp"
 #include "weights_cache.hpp"
-#include "openvino/op/paged_attention.hpp"
 
 #if defined(__linux__)
 #    include <signal.h>
@@ -200,7 +200,7 @@ static Config::ModelType getModelType(const std::shared_ptr<const Model>& model)
         return Config::ModelType::CNN;
 
     if ((op::util::has_op_with_type<op::v13::ScaledDotProductAttention>(model) && model->get_variables().size() > 0) ||
-         op::util::has_op_with_type<ov::op::PagedAttentionExtension>(model))
+        op::util::has_op_with_type<ov::op::PagedAttentionExtension>(model))
         return Config::ModelType::LLM;
 
     return Config::ModelType::Unknown;
@@ -458,15 +458,17 @@ ov::Any Plugin::get_ro_property(const std::string& name, const ov::AnyMap& optio
 
         return decltype(ov::supported_properties)::value_type(std::move(supportedProperties));
     } else if (ov::internal::supported_properties == name) {
-        return decltype(ov::internal::supported_properties)::value_type{
+        return decltype(ov::internal::supported_properties)::value_type {
             ov::PropertyName{ov::internal::caching_properties.name(), ov::PropertyMutability::RO},
 #if !defined(OPENVINO_ARCH_ARM) && !(defined(__APPLE__) || defined(__MACOSX))
-            ov::PropertyName{ov::internal::caching_with_mmap.name(), ov::PropertyMutability::RO},
+                ov::PropertyName{ov::internal::caching_with_mmap.name(), ov::PropertyMutability::RO},
 #endif
-            ov::PropertyName{ov::internal::exclusive_async_requests.name(), ov::PropertyMutability::RW},
-            ov::PropertyName{ov::internal::compiled_model_runtime_properties.name(), ov::PropertyMutability::RO},
-            ov::PropertyName{ov::internal::compiled_model_runtime_properties_supported.name(),
-                             ov::PropertyMutability::RO}};
+                ov::PropertyName{ov::internal::exclusive_async_requests.name(), ov::PropertyMutability::RW},
+                ov::PropertyName{ov::internal::compiled_model_runtime_properties.name(), ov::PropertyMutability::RO},
+                ov::PropertyName {
+                ov::internal::compiled_model_runtime_properties_supported.name(), ov::PropertyMutability::RO
+            }
+        };
     } else if (name == ov::device::full_name) {
         return decltype(ov::device::full_name)::value_type(deviceFullName);
     } else if (name == ov::available_devices) {
@@ -565,11 +567,10 @@ ov::SupportedOpsMap Plugin::query_model(const std::shared_ptr<const ov::Model>&
     return res;
 }
 
-std::shared_ptr<ov::ICompiledModel> Plugin::import_model(std::istream& model_stream,
-                                                         const ov::AnyMap& config) const {
+std::shared_ptr<ov::ICompiledModel> Plugin::import_model(std::istream& model_stream, const ov::AnyMap& config) const {
     OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::intel_cpu_LT, "import_model");
 
-    CacheDecrypt decrypt{ codec_xor };
+    CacheDecrypt decrypt{codec_xor};
     bool decript_from_string = false;
     if (config.count(ov::cache_encryption_callbacks.name())) {
         auto encryption_callbacks = config.at(ov::cache_encryption_callbacks.name()).as<EncryptionCallbacks>();
@@ -590,7 +591,8 @@ std::shared_ptr<ov::ICompiledModel> Plugin::import_model(std::istream& model_str
         [this](const std::shared_ptr<ov::AlignedBuffer>& model, const std::shared_ptr<ov::AlignedBuffer>& weights) {
             return get_core()->read_model(model, weights);
         },
-        decrypt, decript_from_string);
+        decrypt,
+        decript_from_string);
 
     std::shared_ptr<ov::Model> model;
     deserializer >> model;
diff --git a/src/plugins/intel_cpu/src/plugin.h b/src/plugins/intel_cpu/src/plugin.h
index 8973478d30403f..a67602ec4ece12 100644
--- a/src/plugins/intel_cpu/src/plugin.h
+++ b/src/plugins/intel_cpu/src/plugin.h
@@ -20,8 +20,7 @@ class Plugin : public ov::IPlugin {
     std::shared_ptr<ov::ICompiledModel> compile_model(const std::shared_ptr<const ov::Model>& model,
                                                       const ov::AnyMap& properties,
                                                       const ov::SoPtr<ov::IRemoteContext>& context) const override {
-        OPENVINO_THROW_NOT_IMPLEMENTED(
-            "compile_model with RemoteContext is not supported by CPU plugin!");
+        OPENVINO_THROW_NOT_IMPLEMENTED("compile_model with RemoteContext is not supported by CPU plugin!");
     };
 
     void set_property(const ov::AnyMap& properties) override;
@@ -30,8 +29,7 @@ class Plugin : public ov::IPlugin {
     std::shared_ptr<ov::ICompiledModel> import_model(std::istream& model,
                                                      const ov::SoPtr<ov::IRemoteContext>& context,
                                                      const ov::AnyMap& properties) const override {
-        OPENVINO_THROW_NOT_IMPLEMENTED(
-            "import_model with RemoteContext is not supported by CPU plugin!");
+        OPENVINO_THROW_NOT_IMPLEMENTED("import_model with RemoteContext is not supported by CPU plugin!");
     };
 
     ov::SupportedOpsMap query_model(const std::shared_ptr<const ov::Model>& model,
diff --git a/src/plugins/intel_cpu/src/post_ops.cpp b/src/plugins/intel_cpu/src/post_ops.cpp
index 73d8e6334cc48c..fcd250cc892e31 100644
--- a/src/plugins/intel_cpu/src/post_ops.cpp
+++ b/src/plugins/intel_cpu/src/post_ops.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "post_ops.hpp"
+
 #include "node.h"
 #include "nodes/eltwise.h"
 #include "nodes/fake_quantize.h"
@@ -40,7 +41,7 @@ EltwiseKind getEltwiseKind(const Algorithm alg) {
         return EltwiseKind::ScaleShift;
     default:
         OPENVINO_THROW("Unexpected eltwise algorithm: ", algToString(alg));
-     }
+    }
 }
 
 ScaleShiftPostOp::Type convertToScaleShiftOpt(const Algorithm alg) {
@@ -61,7 +62,7 @@ ScaleShiftPostOp::Type convertToScaleShiftOpt(const Algorithm alg) {
         return ScaleShiftPostOp::prelu;
     default:
         OPENVINO_THROW("Unexpected eltwise algorithm: ", algToString(alg));
-     }
+    }
 }
 
 ActivationPostOp::Type convertToActivationPostOpt(const Algorithm alg) {
@@ -102,7 +103,7 @@ ActivationPostOp::Type convertToActivationPostOpt(const Algorithm alg) {
         return ActivationPostOp::Type::round_half_away_from_zero;
     default:
         OPENVINO_THROW("Unexpected eltwise algorithm: ", algToString(alg));
-     }
+    }
 }
 
 Algorithm convertToEltwiseAlgorithm(const ActivationPostOp::Type type) {
@@ -117,7 +118,7 @@ Algorithm convertToEltwiseAlgorithm(const ActivationPostOp::Type type) {
         return Algorithm::EltwiseElu;
     case ActivationPostOp::Type::abs:
         return Algorithm::EltwiseAbs;
-    case  ActivationPostOp::Type::soft_relu:
+    case ActivationPostOp::Type::soft_relu:
         return Algorithm::EltwiseSoftRelu;
     case ActivationPostOp::Type::logistic:
         return Algorithm::EltwiseSigmoid;
@@ -137,9 +138,9 @@ Algorithm convertToEltwiseAlgorithm(const ActivationPostOp::Type type) {
         return Algorithm::EltwiseMish;
     case ActivationPostOp::Type::hsigmoid:
         return Algorithm::EltwiseHsigmoid;
-    case  ActivationPostOp::Type::round_half_to_even:
+    case ActivationPostOp::Type::round_half_to_even:
         return Algorithm::EltwiseRoundHalfToEven;
-    case  ActivationPostOp::Type::round_half_away_from_zero:
+    case ActivationPostOp::Type::round_half_away_from_zero:
         return Algorithm::EltwiseRoundHalfAwayFromZero;
     case ActivationPostOp::Type::square:
         OPENVINO_THROW("square is not supported");
@@ -193,5 +194,5 @@ PostOps getPostOps(std::vector<NodePtr> fused) {
     return ops;
 }
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/post_ops.hpp b/src/plugins/intel_cpu/src/post_ops.hpp
index 3ce63f59690342..27ffd4c6663361 100644
--- a/src/plugins/intel_cpu/src/post_ops.hpp
+++ b/src/plugins/intel_cpu/src/post_ops.hpp
@@ -9,8 +9,8 @@
 #include <vector>
 
 #include "cpu_types.h"
-#include "nodes/executors/executor.hpp"
 #include "node.h"
+#include "nodes/executors/executor.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -60,8 +60,7 @@ struct ActivationPostOp : PostOp {
         : m_type(type),
           m_alpha(alpha),
           m_beta(beta),
-          m_gamma(gamma)
-    {}
+          m_gamma(gamma) {}
 
     float alpha() const {
         return m_alpha;
@@ -97,9 +96,7 @@ struct ScaleShiftPostOp : PostOp {
         prelu,
     };
 
-    ScaleShiftPostOp(const Type m_type,
-                     std::vector<float> _scales,
-                     std::vector<float> _shifts)
+    ScaleShiftPostOp(const Type m_type, std::vector<float> _scales, std::vector<float> _shifts)
         : m_type(m_type),
           m_scales(std::move(_scales)),
           m_shifts(std::move(_shifts)) {}
@@ -129,14 +126,14 @@ struct FakeQuantizePostOp : PostOp {
                        std::vector<float> inputShift,
                        std::vector<float> outputScale,
                        std::vector<float> outputShift,
-                       const size_t levels) :
-        m_cropLow(std::move(cropLow)),
-        m_cropHigh(std::move(cropHigh)),
-        m_inputScale(std::move(inputScale)),
-        m_inputShift(std::move(inputShift)),
-        m_outputScale(std::move(outputScale)),
-        m_outputShift(std::move(outputShift)),
-        m_levels(levels) {}
+                       const size_t levels)
+        : m_cropLow(std::move(cropLow)),
+          m_cropHigh(std::move(cropHigh)),
+          m_inputScale(std::move(inputScale)),
+          m_inputShift(std::move(inputShift)),
+          m_outputScale(std::move(outputScale)),
+          m_outputShift(std::move(outputShift)),
+          m_levels(levels) {}
 
     const std::vector<float>& cropLow() const {
         return m_cropLow;
@@ -193,5 +190,5 @@ ActivationPostOp::Type convertToActivationPostOpt(const Algorithm alg);
 Algorithm convertToEltwiseAlgorithm(const ActivationPostOp::Type m_type);
 
 PostOps getPostOps(std::vector<NodePtr> fused);
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/proxy_mem_blk.cpp b/src/plugins/intel_cpu/src/proxy_mem_blk.cpp
index a10aaca9a9743b..af639a61013d14 100644
--- a/src/plugins/intel_cpu/src/proxy_mem_blk.cpp
+++ b/src/plugins/intel_cpu/src/proxy_mem_blk.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "proxy_mem_blk.h"
+
 #include "utils/debug_capabilities.h"
 
 using namespace ov::intel_cpu;
diff --git a/src/plugins/intel_cpu/src/proxy_mem_blk.h b/src/plugins/intel_cpu/src/proxy_mem_blk.h
index 9ce35887ef250e..a6fce67eacf880 100644
--- a/src/plugins/intel_cpu/src/proxy_mem_blk.h
+++ b/src/plugins/intel_cpu/src/proxy_mem_blk.h
@@ -49,5 +49,5 @@ class ProxyMemoryBlock : public IMemoryBlockObserver {
 using ProxyMemoryBlockPtr = std::shared_ptr<ProxyMemoryBlock>;
 using ProxyMemoryBlockCPtr = std::shared_ptr<const ProxyMemoryBlock>;
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/selective_build.h b/src/plugins/intel_cpu/src/selective_build.h
index 295303e518ef59..38dd7c6eda7492 100644
--- a/src/plugins/intel_cpu/src/selective_build.h
+++ b/src/plugins/intel_cpu/src/selective_build.h
@@ -7,6 +7,6 @@
 
 namespace ov {
 namespace intel_cpu {
-    OV_CC_DOMAINS(intel_cpu)
-}
+OV_CC_DOMAINS(intel_cpu)
 }
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/adaptive_pooling.cpp b/src/plugins/intel_cpu/src/shape_inference/custom/adaptive_pooling.cpp
index 566443ee125971..ee0a6dc9fc3ac5 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/adaptive_pooling.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/adaptive_pooling.cpp
@@ -3,21 +3,20 @@
 //
 
 #include "adaptive_pooling.hpp"
+
 #include "utils.hpp"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-
 /**
- * Implements Adaptive Pooling shape inference algorithm. The output tensor shape consists of the input [N, C] dimensions and
- * the [D_out, H_out, W_out] dimensions, which are placed in the second input parameter.
+ * Implements Adaptive Pooling shape inference algorithm. The output tensor shape consists of the input [N, C]
+ * dimensions and the [D_out, H_out, W_out] dimensions, which are placed in the second input parameter.
  *
  */
-Result AdaptivePoolingShapeInfer::infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
+Result AdaptivePoolingShapeInfer::infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                                        const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
     const auto& inputDims = input_shapes[0].get();
     const auto& spatialDims = input_shapes[1].get();
     const auto inputRank = inputDims.size();
@@ -40,6 +39,6 @@ ShapeInferPtr AdaptivePoolingShapeInferFactory::makeShapeInfer() const {
     return std::make_shared<AdaptivePoolingShapeInfer>(outputs_count);
 }
 
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/adaptive_pooling.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/adaptive_pooling.hpp
index 1ce771f906fde4..94d6181a01e965 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/adaptive_pooling.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/adaptive_pooling.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -12,16 +13,15 @@ namespace node {
 using Result = IShapeInfer::Result;
 
 /**
- * Implements Adaptive Pooling shape inference algorithm. The output tensor shape consists of the input [N, C] dimensions and
- * the [D_out, H_out, W_out] dimensions, which are placed in the second input parameter.
+ * Implements Adaptive Pooling shape inference algorithm. The output tensor shape consists of the input [N, C]
+ * dimensions and the [D_out, H_out, W_out] dimensions, which are placed in the second input parameter.
  *
  */
 class AdaptivePoolingShapeInfer : public ShapeInferEmptyPads {
 public:
     explicit AdaptivePoolingShapeInfer(size_t outputs_count) : m_outputs_count(outputs_count) {}
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
 
     port_mask_t get_port_mask() const override {
         return PortMask(1);
@@ -40,7 +40,6 @@ class AdaptivePoolingShapeInferFactory : public ShapeInferFactory {
     std::shared_ptr<ov::Node> m_op;
 };
 
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/color_convert.cpp b/src/plugins/intel_cpu/src/shape_inference/custom/color_convert.cpp
index 850c437e14cc83..50bb9737e6109e 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/color_convert.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/color_convert.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "nodes/color_convert.h"
+
 #include "color_convert.hpp"
 #include "utils.hpp"
 
@@ -21,17 +22,21 @@ Result ColorConvertShapeInfer::infer(const std::vector<std::reference_wrapper<co
     if (dims.size() != 4) {
         OPENVINO_THROW("NV12Converter node has incorrect input dimensions");
     }
-    return { m_singlePlain
-    ? std::vector<VectorDims>{ { dims[ColorConvert::Converter::N_DIM], dims[ColorConvert::Converter::H_DIM] * 2 / 3, dims[ColorConvert::Converter::W_DIM], 3 } }
-    :
-    std::vector<VectorDims>{ { dims[ColorConvert::Converter::N_DIM], dims[ColorConvert::Converter::H_DIM], dims[ColorConvert::Converter::W_DIM], 3 } },
-    ShapeInferStatus::success };
+    return {m_singlePlain ? std::vector<VectorDims>{{dims[ColorConvert::Converter::N_DIM],
+                                                     dims[ColorConvert::Converter::H_DIM] * 2 / 3,
+                                                     dims[ColorConvert::Converter::W_DIM],
+                                                     3}}
+                          : std::vector<VectorDims>{{dims[ColorConvert::Converter::N_DIM],
+                                                     dims[ColorConvert::Converter::H_DIM],
+                                                     dims[ColorConvert::Converter::W_DIM],
+                                                     3}},
+            ShapeInferStatus::success};
 }
 
 ShapeInferPtr ColorConvertShapeInferFactory::makeShapeInfer() const {
     bool isSinglePlain = m_op->get_input_size() == 1;
     return std::make_shared<ColorConvertShapeInfer>(isSinglePlain);
 }
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/color_convert.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/color_convert.hpp
index 824bc08d5d4a8c..98aafbf5f35102 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/color_convert.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/color_convert.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -20,7 +21,7 @@ class ColorConvertShapeInfer : public ShapeInferEmptyPads {
 public:
     ColorConvertShapeInfer(bool singlePlain) : m_singlePlain(singlePlain) {}
     Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-                           const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
     port_mask_t get_port_mask() const override {
         return EMPTY_PORT_MASK;
     }
@@ -38,7 +39,6 @@ class ColorConvertShapeInferFactory : public ShapeInferFactory {
     std::shared_ptr<ov::Node> m_op;
 };
 
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/eltwise.cpp b/src/plugins/intel_cpu/src/shape_inference/custom/eltwise.cpp
index aea90626c8124e..02cb60b730b2b1 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/eltwise.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/eltwise.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "eltwise.hpp"
+
 #include "utils.hpp"
 
 namespace ov {
@@ -14,9 +15,8 @@ namespace node {
  * according to the NUMPY broadcast rule. This implementation is more lightweight than the ngraph one.
  *
  */
-Result EltwiseShapeInfer::infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
+Result EltwiseShapeInfer::infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                                const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
     size_t max_rank = 0;
     size_t max_rank_idx = 0;
     for (size_t i = 0; i < input_shapes.size(); ++i) {
@@ -42,14 +42,15 @@ Result EltwiseShapeInfer::infer(
                 if (output_shape[offset + j] == 1) {
                     output_shape[offset + j] = input_shape[j];
                 } else {
-                    if (input_shape[j] != 1) OPENVINO_THROW("Eltwise shape infer input shapes dim index: ", j, " mismatch");
+                    if (input_shape[j] != 1)
+                        OPENVINO_THROW("Eltwise shape infer input shapes dim index: ", j, " mismatch");
                 }
             }
         }
     }
-    return { { std::move(output_shape) }, ShapeInferStatus::success };
+    return {{std::move(output_shape)}, ShapeInferStatus::success};
 }
 
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/eltwise.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/eltwise.hpp
index 6b48d2591fcbc2..b99c74583abbd9 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/eltwise.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/eltwise.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -18,9 +19,8 @@ using Result = IShapeInfer::Result;
  */
 class EltwiseShapeInfer : public ShapeInferEmptyPads {
 public:
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
     port_mask_t get_port_mask() const override {
         return EMPTY_PORT_MASK;
     }
@@ -32,7 +32,6 @@ class EltwiseShapeInferFactory : public ShapeInferFactory {
         return std::make_shared<EltwiseShapeInfer>();
     }
 };
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/fullyconnected.cpp b/src/plugins/intel_cpu/src/shape_inference/custom/fullyconnected.cpp
index 048b413b61a60b..fb107027eeceab 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/fullyconnected.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/fullyconnected.cpp
@@ -3,15 +3,15 @@
 //
 
 #include "fullyconnected.hpp"
+
 #include "utils.hpp"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-Result FCShapeInfer::infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
+Result FCShapeInfer::infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                           const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
     const VectorDims& activationShape = input_shapes[0].get();
     const VectorDims& weightShape = input_shapes[1].get();
     size_t activationRank = activationShape.size();
@@ -33,6 +33,6 @@ Result FCShapeInfer::infer(
 
     return {{std::move(outputShape)}, ShapeInferStatus::success};
 }
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/fullyconnected.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/fullyconnected.hpp
index 1ec05ab7774cc3..11bac8f2211dd7 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/fullyconnected.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/fullyconnected.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -14,9 +15,8 @@ using Result = IShapeInfer::Result;
 class FCShapeInfer : public ShapeInferEmptyPads {
 public:
     FCShapeInfer(size_t outPut_rank) : out_rank(outPut_rank) {}
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
 
     port_mask_t get_port_mask() const override {
         return EMPTY_PORT_MASK;
@@ -36,7 +36,6 @@ class FCShapeInferFactory : public ShapeInferFactory {
 private:
     std::shared_ptr<const ov::Node> m_op;
 };
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/gather.cpp b/src/plugins/intel_cpu/src/shape_inference/custom/gather.cpp
index f3a45f9025e709..3dfd51d7f9d624 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/gather.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/gather.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "gather.hpp"
+
 #include "utils.hpp"
 
 namespace ov {
@@ -14,8 +15,7 @@ Result GatherShapeInfer::infer(const std::vector<std::reference_wrapper<const Ve
     static constexpr size_t GATHER_DATA = 0, GATHER_INDICES = 1, GATHER_AXIS = 2;
     const auto& input_shape = input_shapes[GATHER_DATA].get();
     // Use VectorDims{} instead of {1} for Scalar
-    const auto& indices_shape = m_isIndicesScalar ? VectorDims{} :
-                                input_shapes[GATHER_INDICES].get();
+    const auto& indices_shape = m_isIndicesScalar ? VectorDims{} : input_shapes[GATHER_INDICES].get();
     if (!m_isAxisInputConst) {
         if (data_dependency.at(GATHER_AXIS)->getDesc().getPrecision() != ov::element::i32) {
             OPENVINO_THROW("Unsupported precision ",
@@ -46,15 +46,17 @@ ShapeInferPtr GatherShapeInferFactory::makeShapeInfer() const {
         OPENVINO_THROW("indicesShape do not support dynamic rank.");
     }
     bool isIndicesScalar = indicesShape.rank().get_length() == 0;
-    int axis = isAxisInputConst ? ov::as_type<ov::op::v0::Constant>(m_op->get_input_node_ptr(
-                   GATHER_AXIS))->cast_vector<int>()[0] : 0;
-    int batchDims = ov::is_type<ov::op::v8::Gather>(m_op) ? static_cast<int>(ov::as_type_ptr<ov::op::v8::Gather>
-                    (m_op)->get_batch_dims()) : (
-                        ov::is_type<ov::op::v7::Gather>(m_op) ? static_cast<int>(ov::as_type_ptr<ov::op::v7::Gather>
-                                (m_op)->get_batch_dims()) : 0);
+    int axis = isAxisInputConst
+                   ? ov::as_type<ov::op::v0::Constant>(m_op->get_input_node_ptr(GATHER_AXIS))->cast_vector<int>()[0]
+                   : 0;
+    int batchDims = ov::is_type<ov::op::v8::Gather>(m_op)
+                        ? static_cast<int>(ov::as_type_ptr<ov::op::v8::Gather>(m_op)->get_batch_dims())
+                        : (ov::is_type<ov::op::v7::Gather>(m_op)
+                               ? static_cast<int>(ov::as_type_ptr<ov::op::v7::Gather>(m_op)->get_batch_dims())
+                               : 0);
     return std::make_shared<GatherShapeInfer>(isAxisInputConst, isIndicesScalar, axis, batchDims);
 }
 
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/gather.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/gather.hpp
index f02711978dbc6b..456bd7cfbd7e97 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/gather.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/gather.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -13,11 +14,14 @@ using Result = IShapeInfer::Result;
 
 class GatherShapeInfer : public ShapeInferEmptyPads {
 public:
-    GatherShapeInfer(bool isAxisInputConst, bool isIndicesScalar, int axis, int batchDims) : m_isAxisInputConst(isAxisInputConst),
-                     m_isIndicesScalar(isIndicesScalar), m_axis(axis), m_batchDims(batchDims) {}
+    GatherShapeInfer(bool isAxisInputConst, bool isIndicesScalar, int axis, int batchDims)
+        : m_isAxisInputConst(isAxisInputConst),
+          m_isIndicesScalar(isIndicesScalar),
+          m_axis(axis),
+          m_batchDims(batchDims) {}
 
     Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-                               const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
     port_mask_t get_port_mask() const override {
         return PortMask(2);
     }
@@ -37,7 +41,6 @@ class GatherShapeInferFactory : public ShapeInferFactory {
 private:
     std::shared_ptr<ov::Node> m_op;
 };
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/matmul.cpp b/src/plugins/intel_cpu/src/shape_inference/custom/matmul.cpp
index 9a6fdb8b260b97..c2bbba15f5cb18 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/matmul.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/matmul.cpp
@@ -3,17 +3,17 @@
 //
 
 #include "matmul.hpp"
-#include "utils.hpp"
+
 #include "openvino/opsets/opset1.hpp"
 #include "shape_inference/shape_inference.hpp"
+#include "utils.hpp"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-Result MMShapeInfer::infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
+Result MMShapeInfer::infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                           const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
     const VectorDims& shapeA = input_shapes[0].get();
     const VectorDims& shapeB = input_shapes[1].get();
     const size_t rankA = shapeA.size();
@@ -30,20 +30,20 @@ Result MMShapeInfer::infer(
         return {{m_shapeY}, ShapeInferStatus::success};
     }
     OPENVINO_ASSERT(m_out_rank >= 2, "The output rank should be greater or euqal to 2.");
-    const size_t k_lhs = m_transpose_a ? shapeA[rankA-2] : shapeA[rankA-1];
-    const size_t k_rhs = m_transpose_b ? shapeB[rankB-1] : shapeB[rankB-2];
+    const size_t k_lhs = m_transpose_a ? shapeA[rankA - 2] : shapeA[rankA - 1];
+    const size_t k_rhs = m_transpose_b ? shapeB[rankB - 1] : shapeB[rankB - 2];
     OPENVINO_ASSERT(k_lhs == k_rhs,
-        "Matmul input shapes are incompatible shape A: ",
-        vec2str(shapeA),
-        m_transpose_a ? "T " : " ",
-        "shape B: ",
-        vec2str(shapeB),
-        m_transpose_b ? "T" : "");
+                    "Matmul input shapes are incompatible shape A: ",
+                    vec2str(shapeA),
+                    m_transpose_a ? "T " : " ",
+                    "shape B: ",
+                    vec2str(shapeB),
+                    m_transpose_b ? "T" : "");
 
-    m_shapeY[m_out_rank-2] = m_transpose_a ? shapeA[rankA-1] : shapeA[rankA-2];
-    m_shapeY[m_out_rank-1] = m_transpose_b ? shapeB[rankB-2] : shapeB[rankB-1];
+    m_shapeY[m_out_rank - 2] = m_transpose_a ? shapeA[rankA - 1] : shapeA[rankA - 2];
+    m_shapeY[m_out_rank - 1] = m_transpose_b ? shapeB[rankB - 2] : shapeB[rankB - 1];
 
-    for (size_t i=0; i < m_out_rank-2; ++i) {
+    for (size_t i = 0; i < m_out_rank - 2; ++i) {
         if (shapeA[i] != shapeB[i]) {
             if (shapeB[i] == 1) {
                 m_shapeY[i] = shapeA[i];
@@ -80,6 +80,6 @@ ShapeInferPtr MMShapeInferFactory::makeShapeInfer() const {
         OPENVINO_THROW("Unexpected operation type in the MatMul shape inference factory");
     }
 }
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/matmul.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/matmul.hpp
index 4ba83f6e72a639..6b9e83bae5a09f 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/matmul.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/matmul.hpp
@@ -13,13 +13,14 @@ namespace node {
 using Result = IShapeInfer::Result;
 class MMShapeInfer : public ShapeInferEmptyPads {
 public:
-    MMShapeInfer(const size_t& out_rank, const bool& transpose_a, const bool& transpose_b) :
-        m_out_rank(out_rank), m_transpose_a(transpose_a), m_transpose_b(transpose_b) {
-        m_shapeY = VectorDims(m_out_rank, 1); // for output and cache
+    MMShapeInfer(const size_t& out_rank, const bool& transpose_a, const bool& transpose_b)
+        : m_out_rank(out_rank),
+          m_transpose_a(transpose_a),
+          m_transpose_b(transpose_b) {
+        m_shapeY = VectorDims(m_out_rank, 1);  // for output and cache
     }
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
 
     port_mask_t get_port_mask() const override {
         return EMPTY_PORT_MASK;
@@ -36,9 +37,10 @@ class MMShapeInferFactory : public ShapeInferFactory {
 public:
     MMShapeInferFactory(const std::shared_ptr<ov::Node>& op) : m_op(op) {}
     ShapeInferPtr makeShapeInfer() const override;
+
 private:
     std::shared_ptr<ov::Node> m_op;
 };
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/ngram.cpp b/src/plugins/intel_cpu/src/shape_inference/custom/ngram.cpp
index 74ede9fb4395fb..baef903f4b6bf7 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/ngram.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/ngram.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "transformations/cpu_opset/common/op/ngram.hpp"
+
 #include "ngram.hpp"
 #include "utils.hpp"
 
@@ -10,9 +11,8 @@ namespace ov {
 namespace intel_cpu {
 namespace node {
 
-Result NgramShapeInfer::infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
+Result NgramShapeInfer::infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                              const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
     auto output_shape = input_shapes[0].get();
     output_shape[1] *= m_k;
     return {{std::move(output_shape)}, ShapeInferStatus::success};
@@ -25,6 +25,6 @@ ShapeInferPtr NgramShapeInferFactory::makeShapeInfer() const {
     }
     return std::make_shared<NgramShapeInfer>(ngram->get_k());
 }
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/ngram.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/ngram.hpp
index dbfa1efd4fcf1c..8ad8ea8978b0d0 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/ngram.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/ngram.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -13,9 +14,8 @@ using Result = IShapeInfer::Result;
 class NgramShapeInfer : public ShapeInferEmptyPads {
 public:
     NgramShapeInfer(const size_t k) : m_k(k) {}
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
 
     port_mask_t get_port_mask() const override {
         return EMPTY_PORT_MASK;
@@ -33,7 +33,6 @@ class NgramShapeInferFactory : public ShapeInferFactory {
 private:
     std::shared_ptr<ov::Node> m_op;
 };
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/one_hot.cpp b/src/plugins/intel_cpu/src/shape_inference/custom/one_hot.cpp
index 8a29b533672f5c..cf36557d7e3fe0 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/one_hot.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/one_hot.cpp
@@ -3,8 +3,9 @@
 //
 
 #include "one_hot.hpp"
-#include "utils.hpp"
+
 #include "openvino/opsets/opset1.hpp"
+#include "utils.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -15,9 +16,8 @@ namespace node {
  * of size `depth` is inserted at the dimension defined by the `axis` parameter.
  *
  */
-Result OneHotShapeInfer::infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
+Result OneHotShapeInfer::infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                               const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
     auto depth = data_dependency.at(1)->getDataAs<int32_t>()[0];
     if (depth < 0) {
         OPENVINO_THROW("OneHot depth value can't be negative.");
@@ -36,12 +36,13 @@ ShapeInferPtr OneHotShapeInferFactory::makeShapeInfer() const {
     auto axis = oneHot->get_axis();
     auto dstShape = oneHot->get_output_partial_shape(0);
     int output_dims_size = dstShape.size();
-    if (0 == output_dims_size) output_dims_size = 1;
+    if (0 == output_dims_size)
+        output_dims_size = 1;
     if (axis < 0) {
         axis += output_dims_size;
     }
     return std::make_shared<OneHotShapeInfer>(axis);
 }
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/one_hot.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/one_hot.hpp
index 1b86e6b0285c50..f4e52be344aad9 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/one_hot.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/one_hot.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -18,9 +19,8 @@ using Result = IShapeInfer::Result;
 class OneHotShapeInfer : public ShapeInferEmptyPads {
 public:
     explicit OneHotShapeInfer(int64_t axis) : m_axis(axis) {}
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
 
     port_mask_t get_port_mask() const override {
         return PortMask(1);
@@ -39,7 +39,6 @@ class OneHotShapeInferFactory : public ShapeInferFactory {
     std::shared_ptr<ov::Node> m_op;
 };
 
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/priorbox.cpp b/src/plugins/intel_cpu/src/shape_inference/custom/priorbox.cpp
index 06ba85cc86b448..98d2ba06b57872 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/priorbox.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/priorbox.cpp
@@ -3,21 +3,22 @@
 //
 
 #include "priorbox.hpp"
-#include "utils.hpp"
+
 #include "openvino/opsets/opset1.hpp"
+#include "utils.hpp"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
 /**
- * Implements Prior Box Clustered shape inference algorithm. The output shape is [2,  4 * height * width * number_of_priors].
- * `number_of_priors` is an attribute of the operation. heigh and width are in the the first input parameter.
+ * Implements Prior Box Clustered shape inference algorithm. The output shape is [2,  4 * height * width *
+ * number_of_priors]. `number_of_priors` is an attribute of the operation. heigh and width are in the the first input
+ * parameter.
  *
  */
-Result PriorBoxShapeInfer::infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
+Result PriorBoxShapeInfer::infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
     const int* in_data = data_dependency.at(0)->getDataAs<const int>();
     const int H = in_data[0];
     const int W = in_data[1];
@@ -25,7 +26,7 @@ Result PriorBoxShapeInfer::infer(
     return {{{2, output}}, ShapeInferStatus::success};
 }
 
-ShapeInferPtr  PriorBoxShapeInferFactory::makeShapeInfer() const {
+ShapeInferPtr PriorBoxShapeInferFactory::makeShapeInfer() const {
     auto priorBox = ov::as_type_ptr<const ov::opset1::PriorBox>(m_op);
     if (!priorBox) {
         OPENVINO_THROW("Unexpected op type in PriorBox shape inference factory: ", m_op->get_type_name());
@@ -34,6 +35,6 @@ ShapeInferPtr  PriorBoxShapeInferFactory::makeShapeInfer() const {
     auto number_of_priors = ov::opset1::PriorBox::number_of_priors(attrs);
     return std::make_shared<PriorBoxShapeInfer>(number_of_priors);
 }
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/priorbox.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/priorbox.hpp
index baa5a4b0edb823..3991282ea29d15 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/priorbox.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/priorbox.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -12,16 +13,16 @@ namespace node {
 using Result = IShapeInfer::Result;
 
 class PriorBoxShapeInfer : public ShapeInferEmptyPads {
-/**
- * Implements Prior Box Clustered shape inference algorithm. The output shape is [2,  4 * height * width * number_of_priors].
- * `number_of_priors` is an attribute of the operation. heigh and width are in the the first input parameter.
- *
- */
+    /**
+     * Implements Prior Box Clustered shape inference algorithm. The output shape is [2,  4 * height * width *
+     * number_of_priors]. `number_of_priors` is an attribute of the operation. heigh and width are in the the first
+     * input parameter.
+     *
+     */
 public:
     explicit PriorBoxShapeInfer(int64_t number_of_priors) : m_number_of_priors(number_of_priors) {}
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
 
     port_mask_t get_port_mask() const override {
         return PortMask(0);
@@ -39,7 +40,6 @@ class PriorBoxShapeInferFactory : public ShapeInferFactory {
 private:
     std::shared_ptr<ov::Node> m_op;
 };
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/priorbox_clustered.cpp b/src/plugins/intel_cpu/src/shape_inference/custom/priorbox_clustered.cpp
index 2cfc6d3578a242..da80e755503f95 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/priorbox_clustered.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/priorbox_clustered.cpp
@@ -3,22 +3,22 @@
 //
 
 #include "priorbox_clustered.hpp"
-#include "utils.hpp"
+
 #include "openvino/opsets/opset1.hpp"
+#include "utils.hpp"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
-
 /**
- * Implements Prior Box Clustered shape inference algorithm. The output shape is [2,  4 * height * width * number_of_priors].
- * `number_of_priors` is an attribute of the operation. heigh and width are in the the first input parameter.
+ * Implements Prior Box Clustered shape inference algorithm. The output shape is [2,  4 * height * width *
+ * number_of_priors]. `number_of_priors` is an attribute of the operation. heigh and width are in the the first input
+ * parameter.
  *
  */
-Result PriorBoxClusteredShapeInfer::infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
+Result PriorBoxClusteredShapeInfer::infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                                          const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
     const int* in_data = data_dependency.at(0)->getDataAs<const int>();
     const int H = in_data[0];
     const int W = in_data[1];
@@ -36,6 +36,6 @@ ShapeInferPtr PriorBoxClusteredShapeInferFactory::makeShapeInfer() const {
     return std::make_shared<PriorBoxClusteredShapeInfer>(number_of_priors);
 }
 
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/priorbox_clustered.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/priorbox_clustered.hpp
index 7a138c7b2491e9..ce6553759d4dfa 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/priorbox_clustered.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/priorbox_clustered.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -12,16 +13,16 @@ namespace node {
 using Result = IShapeInfer::Result;
 
 /**
- * Implements Prior Box Clustered shape inference algorithm. The output shape is [2,  4 * height * width * number_of_priors].
- * `number_of_priors` is an attribute of the operation. heigh and width are in the the first input parameter.
+ * Implements Prior Box Clustered shape inference algorithm. The output shape is [2,  4 * height * width *
+ * number_of_priors]. `number_of_priors` is an attribute of the operation. heigh and width are in the the first input
+ * parameter.
  *
  */
 class PriorBoxClusteredShapeInfer : public ShapeInferEmptyPads {
 public:
     explicit PriorBoxClusteredShapeInfer(size_t number_of_priors) : m_number_of_priors(number_of_priors) {}
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
 
     port_mask_t get_port_mask() const override {
         return PortMask(0);
@@ -40,7 +41,6 @@ class PriorBoxClusteredShapeInferFactory : public ShapeInferFactory {
     std::shared_ptr<ov::Node> m_op;
 };
 
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/reshape.cpp b/src/plugins/intel_cpu/src/shape_inference/custom/reshape.cpp
index 3bb4985591ac48..fd9a1841dc3384 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/reshape.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/reshape.cpp
@@ -3,7 +3,9 @@
 //
 
 #include "reshape.hpp"
+
 #include <vector>
+
 #include "utils.hpp"
 #include "utils/general_utils.h"
 
@@ -20,11 +22,10 @@ Result ReshapeShapeInfer::infer(const std::vector<std::reference_wrapper<const V
     const auto data = memPtr->getData();
     const auto& dims = memPtr->getStaticDims();
     const auto outputPatternSize = std::accumulate(dims.begin(), dims.end(), 1, std::multiplies<Dim>());
-    std::vector<int64_t> outPattern = ov::get_raw_data_as<int64_t>(
-                                          memPtr->getDesc().getPrecision(),
-                                          data,
-                                          outputPatternSize,
-                                          ov::util::Cast<int64_t>());
+    std::vector<int64_t> outPattern = ov::get_raw_data_as<int64_t>(memPtr->getDesc().getPrecision(),
+                                                                   data,
+                                                                   outputPatternSize,
+                                                                   ov::util::Cast<int64_t>());
     VectorDims outputShape(outputPatternSize);
     size_t outputProduct = 1;
     int32_t minusOneIdx = -1;
@@ -57,9 +58,11 @@ Result ReshapeShapeInfer::infer(const std::vector<std::reference_wrapper<const V
     }
     inputProduct = std::accumulate(inputShape.begin(), inputShape.end(), 1, std::multiplies<Dim>());
     outputProduct = std::accumulate(outputShape.begin(), outputShape.end(), 1, std::multiplies<Dim>());
-    if (minusOneCount > 1  || inputProduct != outputProduct) {
-        OPENVINO_THROW("[cpu]reshape: the shape of input data ", ov::intel_cpu::vec2str(inputShape),
-                    " conflicts with the reshape pattern ", ov::intel_cpu::vec2str(outPattern));
+    if (minusOneCount > 1 || inputProduct != outputProduct) {
+        OPENVINO_THROW("[cpu]reshape: the shape of input data ",
+                       ov::intel_cpu::vec2str(inputShape),
+                       " conflicts with the reshape pattern ",
+                       ov::intel_cpu::vec2str(outPattern));
     }
     return {{std::move(outputShape)}, ShapeInferStatus::success};
 }
@@ -78,18 +81,18 @@ Result SqueezeShapeInfer::infer(const std::vector<std::reference_wrapper<const V
         const auto& dims = memPtr->getStaticDims();
         if (dims.size() != 0) {
             const size_t outputPatternSize = std::accumulate(dims.begin(), dims.end(), 1, std::multiplies<Dim>());
-            std::vector<int64_t> outPattern = ov::get_raw_data_as<int64_t>(
-                                                  memPtr->getDesc().getPrecision(),
-                                                  data,
-                                                  outputPatternSize,
-                                                  ov::util::Cast<int64_t>());
+            std::vector<int64_t> outPattern = ov::get_raw_data_as<int64_t>(memPtr->getDesc().getPrecision(),
+                                                                           data,
+                                                                           outputPatternSize,
+                                                                           ov::util::Cast<int64_t>());
             std::vector<int64_t> originOutPattern = outPattern;
             std::vector<bool> removeMask(inputShapeSize, false);
             for (size_t i = 0; i < outputPatternSize; i++) {
                 if (outPattern[i] < 0) {
                     outPattern[i] = inputShapeSize + outPattern[i];
                 }
-                if (outPattern[i] >= 0 && outPattern[i] < static_cast<int64_t>(inputShapeSize) && inputShape[outPattern[i]] == 1) {
+                if (outPattern[i] >= 0 && outPattern[i] < static_cast<int64_t>(inputShapeSize) &&
+                    inputShape[outPattern[i]] == 1) {
                     removeMask[outPattern[i]] = true;
                 }
             }
@@ -100,9 +103,9 @@ Result SqueezeShapeInfer::infer(const std::vector<std::reference_wrapper<const V
             }
         } else {
             for (size_t i = 0; i < inputShapeSize; i++) {
-                 if (inputShape[i] != 1) {
-                     outputShape.push_back(inputShape[i]);
-                 }
+                if (inputShape[i] != 1) {
+                    outputShape.push_back(inputShape[i]);
+                }
             }
         }
     } else {
@@ -124,11 +127,10 @@ Result UnsqueezeShapeInfer::infer(const std::vector<std::reference_wrapper<const
     const auto data = memPtr->getData();
     const auto& dims = memPtr->getStaticDims();
     size_t outputPatternSize = std::accumulate(dims.begin(), dims.end(), 1, std::multiplies<Dim>());
-    std::vector<int64_t> originOutPattern = ov::get_raw_data_as<int64_t>(
-                                          memPtr->getDesc().getPrecision(),
-                                          data,
-                                          outputPatternSize,
-                                          ov::util::Cast<int64_t>());
+    std::vector<int64_t> originOutPattern = ov::get_raw_data_as<int64_t>(memPtr->getDesc().getPrecision(),
+                                                                         data,
+                                                                         outputPatternSize,
+                                                                         ov::util::Cast<int64_t>());
     // remove repeated pattern
     std::unordered_set<int64_t> tmp(originOutPattern.begin(), originOutPattern.end());
     std::vector<int64_t> outPattern = std::vector<int64_t>(tmp.begin(), tmp.end());
@@ -159,8 +161,10 @@ Result UnsqueezeShapeInfer::infer(const std::vector<std::reference_wrapper<const
         }
     }
     if (existError) {
-        OPENVINO_THROW("[cpu]unsqueeze: the shape of input data ", ov::intel_cpu::vec2str(inputShape),
-                " conflicts with the unsqueeze pattern ", ov::intel_cpu::vec2str(originOutPattern));
+        OPENVINO_THROW("[cpu]unsqueeze: the shape of input data ",
+                       ov::intel_cpu::vec2str(inputShape),
+                       " conflicts with the unsqueeze pattern ",
+                       ov::intel_cpu::vec2str(originOutPattern));
     }
     return {{std::move(outputShape)}, ShapeInferStatus::success};
 }
@@ -177,6 +181,6 @@ ShapeInferPtr ReshapeShapeInferFactory::makeShapeInfer() const {
     }
 }
 
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/reshape.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/reshape.hpp
index a4b8154750c444..321c36f71baafe 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/reshape.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/reshape.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -14,7 +15,7 @@ class ReshapeShapeInfer : public ShapeInferEmptyPads {
 public:
     ReshapeShapeInfer(bool specialZero) : m_specialZero(specialZero) {}
     Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-                                  const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
     port_mask_t get_port_mask() const override {
         return PortMask(1);
     }
@@ -27,7 +28,7 @@ class SqueezeShapeInfer : public ShapeInferEmptyPads {
 public:
     SqueezeShapeInfer() {}
     Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-                                  const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
     port_mask_t get_port_mask() const override {
         return PortMask(1);
     }
@@ -37,7 +38,7 @@ class UnsqueezeShapeInfer : public ShapeInferEmptyPads {
 public:
     UnsqueezeShapeInfer() {}
     Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-                                  const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
     port_mask_t get_port_mask() const override {
         return PortMask(1);
     }
@@ -51,7 +52,6 @@ class ReshapeShapeInferFactory : public ShapeInferFactory {
 private:
     std::shared_ptr<ov::Node> m_op;
 };
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/shapeof.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/shapeof.hpp
index 782195c9833d03..ff9d5a83241240 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/shapeof.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/shapeof.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -12,16 +13,15 @@ namespace node {
 using Result = IShapeInfer::Result;
 
 /**
- * Implements Shape Of shape inference algorithm. The output shape is simply a 1D tensor with the size of the input tensor
- * rank.
+ * Implements Shape Of shape inference algorithm. The output shape is simply a 1D tensor with the size of the input
+ * tensor rank.
  *
  */
 class ShapeOfShapeInfer : public ShapeInferEmptyPads {
 public:
     ShapeOfShapeInfer() = default;
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override {
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override {
         OPENVINO_ASSERT(!input_shapes.empty());
         return {{VectorDims{input_shapes.front().get().size()}}, ShapeInferStatus::success};
     }
@@ -38,7 +38,6 @@ class ShapeOfShapeInferFactory : public ShapeInferFactory {
     }
 };
 
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/strided_slice.cpp b/src/plugins/intel_cpu/src/shape_inference/custom/strided_slice.cpp
index 4850edae80a9c8..48cb6492e46283 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/strided_slice.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/strided_slice.cpp
@@ -3,35 +3,35 @@
 //
 
 #include "strided_slice.hpp"
-#include "utils.hpp"
-#include "slice_shape_inference.hpp"
+
 #include "shape_inference/shape_inference.hpp"
+#include "slice_shape_inference.hpp"
+#include "utils.hpp"
 
 namespace ov {
 namespace intel_cpu {
 namespace node {
 
 StridedSliceShapeInfer::StridedSliceShapeInfer(size_t output_size,
-        std::unordered_set<int64_t> begin_mask,
-        std::unordered_set<int64_t> end_mask,
-        std::unordered_set<int64_t> new_axis_mask,
-        std::unordered_set<int64_t> shrink_axis_mask)
+                                               std::unordered_set<int64_t> begin_mask,
+                                               std::unordered_set<int64_t> end_mask,
+                                               std::unordered_set<int64_t> new_axis_mask,
+                                               std::unordered_set<int64_t> shrink_axis_mask)
     : m_outputShape(output_size, 1),
-    m_begin_mask_set(std::move(begin_mask)),
-    m_end_mask_set(std::move(end_mask)),
-    m_new_axis_mask_set(std::move(new_axis_mask)),
-    m_shrink_axis_mask_set(std::move(shrink_axis_mask)) {}
+      m_begin_mask_set(std::move(begin_mask)),
+      m_end_mask_set(std::move(end_mask)),
+      m_new_axis_mask_set(std::move(new_axis_mask)),
+      m_shrink_axis_mask_set(std::move(shrink_axis_mask)) {}
 
-Result StridedSliceShapeInfer::infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
+Result StridedSliceShapeInfer::infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                                     const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
     // align with intel_cpu::node::StridedSlice
     static constexpr size_t DATA_ID = 0, BEGIN_ID = 1, END_ID = 2, STRIDE_ID = 3;
     const VectorDims& shapeIn = input_shapes[DATA_ID].get();
     const VectorDims& shapeBegin = input_shapes[BEGIN_ID].get();
     if (data_dependency.at(BEGIN_ID)->getDesc().getPrecision() != ov::element::i32 ||
-            data_dependency.at(END_ID)->getDesc().getPrecision() != ov::element::i32 ||
-            data_dependency.at(STRIDE_ID)->getDesc().getPrecision() != ov::element::i32) {
+        data_dependency.at(END_ID)->getDesc().getPrecision() != ov::element::i32 ||
+        data_dependency.at(STRIDE_ID)->getDesc().getPrecision() != ov::element::i32) {
         OPENVINO_THROW("The data type of begin/end/stride is NOT I32, which is unexpected!");
     }
     auto beginPtr = data_dependency.at(BEGIN_ID)->getDataAs<int32_t>();
@@ -47,10 +47,10 @@ Result StridedSliceShapeInfer::infer(
             int32_t begin = 0, end = 0;
             if (stridePtr[cur_idx] < 0) {
                 begin = m_begin_mask_set.count(cur_idx) ? shapeIn[in_idx] : beginPtr[cur_idx];
-                end  = m_end_mask_set.count(cur_idx) ? (-1 - shapeIn[in_idx]) : endPtr[cur_idx];
+                end = m_end_mask_set.count(cur_idx) ? (-1 - shapeIn[in_idx]) : endPtr[cur_idx];
             } else {
                 begin = m_begin_mask_set.count(cur_idx) ? 0 : beginPtr[cur_idx];
-                end  = m_end_mask_set.count(cur_idx) ? shapeIn[in_idx] : endPtr[cur_idx];
+                end = m_end_mask_set.count(cur_idx) ? shapeIn[in_idx] : endPtr[cur_idx];
             }
             return ov::op::slice::get_sliced_value(shapeIn[in_idx], begin, end, stridePtr[cur_idx]);
         }
@@ -80,10 +80,12 @@ ShapeInferPtr StridedSliceShapeInferFactory::makeShapeInfer() const {
         return make_shape_inference(m_op);
     } else if (const auto StridedSlice_op = ov::as_type_ptr<const ov::op::v1::StridedSlice>(m_op)) {
         const auto& ellipsis_mask = StridedSlice_op->get_ellipsis_mask();
-        if (std::any_of(ellipsis_mask.begin(), ellipsis_mask.end(), [](int64_t x){ return x == 1; })) {
+        if (std::any_of(ellipsis_mask.begin(), ellipsis_mask.end(), [](int64_t x) {
+                return x == 1;
+            })) {
             return make_shape_inference(m_op);
         } else {
-            auto vec_to_set = [](const std::vector<int64_t>& vec){
+            auto vec_to_set = [](const std::vector<int64_t>& vec) {
                 std::unordered_set<int64_t> to_set;
                 for (size_t i = 0; i < vec.size(); ++i) {
                     if (vec[i] == 1) {
@@ -92,18 +94,17 @@ ShapeInferPtr StridedSliceShapeInferFactory::makeShapeInfer() const {
                 }
                 return to_set;
             };
-            return std::make_shared<StridedSliceShapeInfer>(
-                    m_op->get_output_partial_shape(0).rank().get_length(),
-                    vec_to_set(StridedSlice_op->get_begin_mask()),
-                    vec_to_set(StridedSlice_op->get_end_mask()),
-                    vec_to_set(StridedSlice_op->get_new_axis_mask()),
-                    vec_to_set(StridedSlice_op->get_shrink_axis_mask()));
+            return std::make_shared<StridedSliceShapeInfer>(m_op->get_output_partial_shape(0).rank().get_length(),
+                                                            vec_to_set(StridedSlice_op->get_begin_mask()),
+                                                            vec_to_set(StridedSlice_op->get_end_mask()),
+                                                            vec_to_set(StridedSlice_op->get_new_axis_mask()),
+                                                            vec_to_set(StridedSlice_op->get_shrink_axis_mask()));
         }
     } else {
         OPENVINO_THROW("not Slice or StridedSlice");
     }
 }
 
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/strided_slice.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/strided_slice.hpp
index 4a6e57fb621516..7d8a7c9aa872a9 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/strided_slice.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/strided_slice.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -11,7 +12,7 @@ namespace intel_cpu {
 namespace node {
 using Result = IShapeInfer::Result;
 
-constexpr IShapeInfer::port_mask_t port_mask = PortMask(/*BEGIN_ID*/1, /*END_ID*/2, /*STRIDE_ID*/3, /*AXES_ID*/4);
+constexpr IShapeInfer::port_mask_t port_mask = PortMask(/*BEGIN_ID*/ 1, /*END_ID*/ 2, /*STRIDE_ID*/ 3, /*AXES_ID*/ 4);
 
 class StridedSliceShapeInfer : public ShapeInferEmptyPads {
 public:
@@ -21,9 +22,8 @@ class StridedSliceShapeInfer : public ShapeInferEmptyPads {
                            std::unordered_set<int64_t> new_axis_mask,
                            std::unordered_set<int64_t> shrink_axis_mask);
 
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
 
     port_mask_t get_port_mask() const override {
         return port_mask;
@@ -39,15 +39,13 @@ class StridedSliceShapeInfer : public ShapeInferEmptyPads {
 
 class StridedSliceShapeInferFactory : public ShapeInferFactory {
 public:
-    StridedSliceShapeInferFactory(const std::shared_ptr<ov::Node>& op)
-    : m_op(op) {}
+    StridedSliceShapeInferFactory(const std::shared_ptr<ov::Node>& op) : m_op(op) {}
     ShapeInferPtr makeShapeInfer() const override;
 
 private:
     const std::shared_ptr<ov::Node> m_op;
 };
 
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/subgraph.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/subgraph.hpp
index d915af083267ff..aa75c83b03681f 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/subgraph.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/subgraph.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -17,11 +18,11 @@ class SnippetShapeInfer : public ShapeInferEmptyPads {
         m_status_map[snippets::ShapeInferStatus::success] = ov::intel_cpu::ShapeInferStatus::success;
         m_status_map[snippets::ShapeInferStatus::skip] = ov::intel_cpu::ShapeInferStatus::skip;
     }
-    Result infer(
-            const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-            const std::unordered_map<size_t, MemoryPtr>& data_dependency) override {
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override {
         const auto& snippets_result = m_subgraph->shape_infer(input_shapes);
-        OPENVINO_ASSERT(m_status_map.count(snippets_result.status) != 0, "Failed to map snippets shapeInfer status to the plugin one");
+        OPENVINO_ASSERT(m_status_map.count(snippets_result.status) != 0,
+                        "Failed to map snippets shapeInfer status to the plugin one");
         return {snippets_result.dims, m_status_map.at(snippets_result.status)};
     }
 
@@ -47,7 +48,6 @@ class SnippetShapeInferFactory : public ShapeInferFactory {
 private:
     std::shared_ptr<snippets::op::Subgraph> m_subgraph = nullptr;
 };
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/transpose.cpp b/src/plugins/intel_cpu/src/shape_inference/custom/transpose.cpp
index f75fc7805e435b..17dc80f8735f87 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/transpose.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/transpose.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "transpose.hpp"
+
 #include "utils.hpp"
 
 namespace ov {
@@ -10,11 +11,13 @@ namespace intel_cpu {
 namespace node {
 
 TransposeShapeInfer::TransposeShapeInfer(const size_t& out_rank, const std::vector<size_t>& axes_vec)
-    : m_out_rank(out_rank), m_axes_vec(axes_vec), m_outputShape(out_rank, 1), m_needReverse(axes_vec.empty()) {}
+    : m_out_rank(out_rank),
+      m_axes_vec(axes_vec),
+      m_outputShape(out_rank, 1),
+      m_needReverse(axes_vec.empty()) {}
 
-Result TransposeShapeInfer::infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
+Result TransposeShapeInfer::infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                                  const std::unordered_map<size_t, MemoryPtr>& data_dependency) {
     const VectorDims& shapeIn = input_shapes[0].get();
     if (m_needReverse) {
         for (size_t i = 0; i < m_out_rank; ++i) {
@@ -28,13 +31,14 @@ Result TransposeShapeInfer::infer(
     return {{m_outputShape}, ShapeInferStatus::success};
 }
 ShapeInferPtr TransposeShapeInferFactory::makeShapeInfer() const {
-    if (const auto order = ov::as_type_ptr<const ov::op::v0::Constant>(m_op->get_input_node_shared_ptr(ov::op::v1::Transpose::ORDER))) {
+    if (const auto order = ov::as_type_ptr<const ov::op::v0::Constant>(
+            m_op->get_input_node_shared_ptr(ov::op::v1::Transpose::ORDER))) {
         const auto axes_vec = order->cast_vector<size_t>();
         return std::make_shared<TransposeShapeInfer>(m_op->get_output_partial_shape(0).rank().get_length(), axes_vec);
     } else {
         return std::make_shared<TransposeDynShapeInfer>();
     }
 }
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/custom/transpose.hpp b/src/plugins/intel_cpu/src/shape_inference/custom/transpose.hpp
index 63cd5b4a66b593..933e3bd79a8603 100644
--- a/src/plugins/intel_cpu/src/shape_inference/custom/transpose.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/custom/transpose.hpp
@@ -3,6 +3,7 @@
 //
 
 #include <node.h>
+
 #include "shape_inference/shape_inference_cpu.hpp"
 
 #pragma once
@@ -14,14 +15,14 @@ using Result = IShapeInfer::Result;
 class TransposeDynShapeInfer : public ShapeInferEmptyPads {
 public:
     TransposeDynShapeInfer() = default;
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override {
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override {
         OPENVINO_THROW("TODO: Support parameterized Order input for dynamic shapes.");
     }
     port_mask_t get_port_mask() const override {
         return EMPTY_PORT_MASK;
     }
+
 private:
 };
 
@@ -29,9 +30,8 @@ class TransposeShapeInfer : public ShapeInferEmptyPads {
 public:
     TransposeShapeInfer(const size_t& out_rank, const std::vector<size_t>& axes_vec);
 
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override;
 
     port_mask_t get_port_mask() const override {
         return EMPTY_PORT_MASK;
@@ -53,7 +53,6 @@ class TransposeShapeInferFactory : public ShapeInferFactory {
     const std::shared_ptr<ov::Node> m_op;
 };
 
-} // namespace node
-} // namespace intel_cpu
-} // namespace ov
-
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/memory_accessor.hpp b/src/plugins/intel_cpu/src/shape_inference/memory_accessor.hpp
index 3c199dd926282f..d596f4a5b0279e 100644
--- a/src/plugins/intel_cpu/src/shape_inference/memory_accessor.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/memory_accessor.hpp
@@ -4,6 +4,7 @@
 
 #pragma once
 #include <vector>
+
 #include "cpu_memory.h"
 #include "openvino/core/shape.hpp"
 #include "tensor_data_accessor.hpp"
@@ -17,8 +18,7 @@ class MemoryAccessor : public ov::ITensorAccessor {
     using container_type = std::unordered_map<size_t, MemoryPtr>;
 
 public:
-    MemoryAccessor(const container_type& ptrs, const std::vector<int64_t>& ranks)
-        : m_ptrs{ptrs}, m_ranks(ranks) {}
+    MemoryAccessor(const container_type& ptrs, const std::vector<int64_t>& ranks) : m_ptrs{ptrs}, m_ranks(ranks) {}
 
     ~MemoryAccessor() = default;
 
@@ -28,19 +28,15 @@ class MemoryAccessor : public ov::ITensorAccessor {
             auto memPtr = t_iter->second;
             // use scalar shape {} instead of {1} if required by shapeInference
             const auto shape = (m_ranks[port] != 0) ? ov::Shape(memPtr->getStaticDims()) : ov::Shape();
-            return {memPtr->getDesc().getPrecision(),
-                    shape,
-                    memPtr->getData()
-                   };
+            return {memPtr->getDesc().getPrecision(), shape, memPtr->getData()};
         } else {
             return {};
         }
     }
 
 private:
-    const container_type& m_ptrs;              //!< Pointer to cpu memory pointers with op data.
+    const container_type& m_ptrs;  //!< Pointer to cpu memory pointers with op data.
     const std::vector<int64_t>& m_ranks;
 };
 }  // namespace intel_cpu
 }  // namespace ov
-
diff --git a/src/plugins/intel_cpu/src/shape_inference/shape_inference.cpp b/src/plugins/intel_cpu/src/shape_inference/shape_inference.cpp
index 4ac8839b749d47..8f4ae8927ff1c8 100644
--- a/src/plugins/intel_cpu/src/shape_inference/shape_inference.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/shape_inference.cpp
@@ -23,10 +23,10 @@
 #include "augru_sequence_shape_inference.hpp"
 #include "avg_pool_shape_inference.hpp"
 #include "batch_to_space_shape_inference.hpp"
-#include "col2im_shape_inference.hpp"
 #include "binary_convolution_shape_inference.hpp"
 #include "broadcast_shape_inference.hpp"
 #include "bucketize_shape_inference.hpp"
+#include "col2im_shape_inference.hpp"
 #include "concat_shape_inference.hpp"
 #include "convolution_backprop_shape_inference.hpp"
 #include "convolution_shape_inference.hpp"
diff --git a/src/plugins/intel_cpu/src/shape_inference/shape_inference_cpu.cpp b/src/plugins/intel_cpu/src/shape_inference/shape_inference_cpu.cpp
index c94572cfb1868e..8980d26d66ba8c 100644
--- a/src/plugins/intel_cpu/src/shape_inference/shape_inference_cpu.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/shape_inference_cpu.cpp
@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "shape_inference/shape_inference.hpp"
 #include "shape_inference/shape_inference_cpu.hpp"
 
+#include "shape_inference/shape_inference.hpp"
+
 namespace ov {
 namespace intel_cpu {
 NgraphShapeInferFactory::NgraphShapeInferFactory(std::shared_ptr<ov::Node> op) : m_op(std::move(op)) {}
diff --git a/src/plugins/intel_cpu/src/shape_inference/shape_inference_cpu.hpp b/src/plugins/intel_cpu/src/shape_inference/shape_inference_cpu.hpp
index 661db2a739b57c..3481d50c0f4ef7 100644
--- a/src/plugins/intel_cpu/src/shape_inference/shape_inference_cpu.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/shape_inference_cpu.hpp
@@ -37,9 +37,8 @@ class IShapeInfer {
      * @return ShapeInferResult which contains resulting array of calculated shapes (per each output port) plus status
      * of the shape infer call
      */
-    virtual Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) = 0;
+    virtual Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                         const std::unordered_map<size_t, MemoryPtr>& data_dependency) = 0;
 
     /**
      * @brief Shape inference implementation may generate padding as by-product, these APIs is designed to retrieve them
@@ -67,12 +66,13 @@ class IShapeInfer {
  */
 class ShapeInferEmptyPads : public IShapeInfer {
 public:
-    const ov::CoordinateDiff& get_pads_begin() override final { // NOLINT
+    const ov::CoordinateDiff& get_pads_begin() override final {  // NOLINT
         return m_emptyVec;
     }
-    const ov::CoordinateDiff& get_pads_end() override final { // NOLINT
+    const ov::CoordinateDiff& get_pads_end() override final {  // NOLINT
         return m_emptyVec;
     }
+
 private:
     static const ov::CoordinateDiff m_emptyVec;
 };
@@ -107,5 +107,5 @@ class NgraphShapeInferFactory final : public ShapeInferFactory {
 private:
     std::shared_ptr<ov::Node> m_op;
 };
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/shape_inference_internal_dyn.hpp b/src/plugins/intel_cpu/src/shape_inference/shape_inference_internal_dyn.hpp
index e41c6d52816306..2d5252044e78a2 100644
--- a/src/plugins/intel_cpu/src/shape_inference/shape_inference_internal_dyn.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/shape_inference_internal_dyn.hpp
@@ -12,14 +12,13 @@ namespace intel_cpu {
 /**
  * Shape inference class for operations with internal dynamism. To reflect the fact that the output shapes may only be
  * calculated after the operation has been performed, the data dependency mask is fully set.
- * 
+ *
  */
 class InternalDynShapeInfer final : public ShapeInferEmptyPads {
 public:
     InternalDynShapeInfer() = default;
-    Result
-    infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-          const std::unordered_map<size_t, MemoryPtr>& data_dependency) override {
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override {
         return {{}, ShapeInferStatus::skip};
     }
 
@@ -35,5 +34,5 @@ class InternalDynShapeInferFactory final : public ShapeInferFactory {
     }
 };
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/shape_inference_pass_through.hpp b/src/plugins/intel_cpu/src/shape_inference/shape_inference_pass_through.hpp
index 0aa7cea949e055..48875b6b4da4cc 100644
--- a/src/plugins/intel_cpu/src/shape_inference/shape_inference_pass_through.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/shape_inference_pass_through.hpp
@@ -12,14 +12,13 @@ namespace intel_cpu {
 /**
  * Specific shape inference implementation designed to cover cases where there are no actual output shape calculation
  * and all the output shapes are equal to the input tensor shapes.
- * 
+ *
  */
 class ShapeInferPassThrough final : public ShapeInferEmptyPads {
 public:
     ShapeInferPassThrough() = default;
-    Result infer(
-        const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
-        const std::unordered_map<size_t, MemoryPtr>& data_dependency) override {
+    Result infer(const std::vector<std::reference_wrapper<const VectorDims>>& input_shapes,
+                 const std::unordered_map<size_t, MemoryPtr>& data_dependency) override {
         OPENVINO_ASSERT(!input_shapes.empty());
         return {{input_shapes.front()}, ShapeInferStatus::success};
     }
@@ -35,5 +34,5 @@ class PassThroughShapeInferFactory final : public ShapeInferFactory {
     }
 };
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/shape_inference_status.hpp b/src/plugins/intel_cpu/src/shape_inference/shape_inference_status.hpp
index 4a67714405d631..e472334ad2982c 100644
--- a/src/plugins/intel_cpu/src/shape_inference/shape_inference_status.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/shape_inference_status.hpp
@@ -8,8 +8,8 @@ namespace ov {
 namespace intel_cpu {
 
 enum class ShapeInferStatus {
-    success, ///< shapes were successfully calculated
-    skip ///< shape inference was skipped.
+    success,  ///< shapes were successfully calculated
+    skip      ///< shape inference was skipped.
     ///< This status is used when the implementation was expectedly not able to compute defined output shape
     ///< e.g. in the case of internal dynamism.
 };
diff --git a/src/plugins/intel_cpu/src/shape_inference/static_dimension.cpp b/src/plugins/intel_cpu/src/shape_inference/static_dimension.cpp
index e1c5ed5369a66e..24d78055d780a6 100644
--- a/src/plugins/intel_cpu/src/shape_inference/static_dimension.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/static_dimension.cpp
@@ -11,13 +11,15 @@ std::ostream& operator<<(std::ostream& str, const StaticDimension& dimension) {
     return str << dimension.get_length();
 }
 
-StaticDimension::StaticDimension(value_type dimension)
-        : m_dimension(dimension) {}
+StaticDimension::StaticDimension(value_type dimension) : m_dimension(dimension) {}
 
-StaticDimension::StaticDimension(value_type ldimension, value_type udimension)
-        : m_dimension(ldimension) {
+StaticDimension::StaticDimension(value_type ldimension, value_type udimension) : m_dimension(ldimension) {
     OPENVINO_ASSERT(ldimension == udimension,
-                    "Can not create StaticDimension out of [", ldimension, ", ", udimension, "]");
+                    "Can not create StaticDimension out of [",
+                    ldimension,
+                    ", ",
+                    udimension,
+                    "]");
 }
 
 bool StaticDimension::operator==(const StaticDimension& dim) const {
@@ -110,5 +112,5 @@ StaticDimension::value_type StaticDimension::get_min_length() const {
     return m_dimension;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/static_dimension.hpp b/src/plugins/intel_cpu/src/shape_inference/static_dimension.hpp
index 788e8d402fcfa8..1491d2af67925d 100644
--- a/src/plugins/intel_cpu/src/shape_inference/static_dimension.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/static_dimension.hpp
@@ -6,8 +6,8 @@
 
 #include <cstddef>
 #include <limits>
-#include <stdexcept>
 #include <ostream>
+#include <stdexcept>
 
 #include "openvino/core/dimension.hpp"
 #include "openvino/core/except.hpp"
@@ -35,7 +35,7 @@ class StaticDimension {
     /// \brief Construct a zero dimension
     StaticDimension() = default;
 
-    StaticDimension(const Dimension &) {
+    StaticDimension(const Dimension&) {
         OPENVINO_THROW("[shape infer] Shoudn't convert from Dimension to StaticDimension.");
     }
 
@@ -76,7 +76,7 @@ class StaticDimension {
     StaticDimension& operator*=(const StaticDimension& dim);
     StaticDimension& operator&=(const StaticDimension& dim);
     StaticDimension operator/(const value_type divisor) const;
-    StaticDimension &operator/=(const value_type divisor);
+    StaticDimension& operator/=(const value_type divisor);
 
     /// \brief Swap of dimensions
     friend void swap(StaticDimension& a, StaticDimension& b) {
@@ -90,5 +90,5 @@ class StaticDimension {
 
 std::ostream& operator<<(std::ostream& str, const StaticDimension& dimension);
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/static_shape.cpp b/src/plugins/intel_cpu/src/shape_inference/static_shape.cpp
index 89228d0cb20ef0..1d3a621d97d73d 100644
--- a/src/plugins/intel_cpu/src/shape_inference/static_shape.cpp
+++ b/src/plugins/intel_cpu/src/shape_inference/static_shape.cpp
@@ -2,9 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "shape_validation.hpp"
 #include "static_shape.hpp"
 
+#include "shape_validation.hpp"
+
 namespace ov {
 namespace intel_cpu {
 
@@ -155,7 +156,7 @@ ov::Shape StaticShapeRef::get_shape() const {
     return to_shape();
 }
 
-}   // namespace intel_cpu
+}  // namespace intel_cpu
 
 template <>
 void NodeValidationFailure::create(const char* file,
@@ -182,4 +183,4 @@ void NodeValidationFailure::create(const char* file,
                                               node_validation_failure_loc_string(ctx.first),
                                               ov::op::validate::shape_infer_explanation_str(*ctx.second, explanation)));
 }
-}   // namespace ov
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/shape_inference/static_shape.hpp b/src/plugins/intel_cpu/src/shape_inference/static_shape.hpp
index 42d09c0549947a..60c9f7ca0a677e 100644
--- a/src/plugins/intel_cpu/src/shape_inference/static_shape.hpp
+++ b/src/plugins/intel_cpu/src/shape_inference/static_shape.hpp
@@ -18,8 +18,8 @@
 
 namespace ov {
 namespace op {
-    struct AutoBroadcastSpec;
-}   // namespace op
+struct AutoBroadcastSpec;
+}  // namespace op
 
 namespace intel_cpu {
 /**
@@ -104,15 +104,13 @@ class StaticShapeAdapter<VectorDims> {
     }
 
     template <class T>
-    constexpr typename std::enable_if<is_static_shape_adapter<T>(), bool>::type compatible(
-        const T& other) const {
+    constexpr typename std::enable_if<is_static_shape_adapter<T>(), bool>::type compatible(const T& other) const {
         // for static shape compatible == both shape equals
         return *this == other;
     }
 
     template <class T>
-    constexpr typename std::enable_if<is_static_shape_adapter<T>(), bool>::type same_scheme(
-        const T& other) const {
+    constexpr typename std::enable_if<is_static_shape_adapter<T>(), bool>::type same_scheme(const T& other) const {
         // for static shape same_scheme == compatible;
         return compatible(other);
     }
@@ -254,15 +252,13 @@ class StaticShapeAdapter<const VectorDims> {
     }
 
     template <class T>
-    constexpr typename std::enable_if<is_static_shape_adapter<T>(), bool>::type compatible(
-        const T& other) const {
+    constexpr typename std::enable_if<is_static_shape_adapter<T>(), bool>::type compatible(const T& other) const {
         // for static shape compatible == both shape equals
         return *this == other;
     }
 
     template <class T>
-    constexpr typename std::enable_if<is_static_shape_adapter<T>(), bool>::type same_scheme(
-        const T& other) const {
+    constexpr typename std::enable_if<is_static_shape_adapter<T>(), bool>::type same_scheme(const T& other) const {
         // for static shape same_scheme == compatible;
         return compatible(other);
     }
@@ -305,7 +301,8 @@ class StaticShapeAdapter<const VectorDims> {
 };
 
 template <class T>
-typename std::enable_if<is_static_shape_adapter<T>(), std::ostream&>::type operator<<(std::ostream& out, const T& shape) {
+typename std::enable_if<is_static_shape_adapter<T>(), std::ostream&>::type operator<<(std::ostream& out,
+                                                                                      const T& shape) {
     out << '{';
     if (!shape.empty()) {
         std::copy(shape.cbegin(), shape.cend() - 1, std::ostream_iterator<StaticDimension>(out, ","));
diff --git a/src/plugins/intel_cpu/src/sub_memory_manager.hpp b/src/plugins/intel_cpu/src/sub_memory_manager.hpp
index 641584626e2873..c67cc5eaae34ee 100644
--- a/src/plugins/intel_cpu/src/sub_memory_manager.hpp
+++ b/src/plugins/intel_cpu/src/sub_memory_manager.hpp
@@ -4,11 +4,13 @@
 
 #pragma once
 
+#include <assert.h>
+
+#include <memory>
+#include <mutex>
 #include <string>
 #include <vector>
-#include <mutex>
-#include <memory>
-#include <assert.h>
+
 #include "cpu_memory.h"
 
 namespace ov {
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/causal_mask_preprocess.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/causal_mask_preprocess.cpp
index ddcbb0620c2e9a..c65eb2340dcd34 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/causal_mask_preprocess.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/causal_mask_preprocess.cpp
@@ -7,11 +7,14 @@
 
 #include "transformations/itt.hpp"
 
-ov::intel_cpu::CausalMaskPreprocessNode::CausalMaskPreprocessNode(const OutputVector& args, const Config& cfg) : Op(args), m_config(cfg) {
+ov::intel_cpu::CausalMaskPreprocessNode::CausalMaskPreprocessNode(const OutputVector& args, const Config& cfg)
+    : Op(args),
+      m_config(cfg) {
     constructor_validate_and_infer_types();
 }
 
-std::shared_ptr<ov::Node> ov::intel_cpu::CausalMaskPreprocessNode::clone_with_new_inputs(const ov::OutputVector& new_args) const {
+std::shared_ptr<ov::Node> ov::intel_cpu::CausalMaskPreprocessNode::clone_with_new_inputs(
+    const ov::OutputVector& new_args) const {
     INTERNAL_OP_SCOPE(CausalMaskPreprocessNode_with_new_inputs);
     check_new_args_count(this, new_args);
     return std::make_shared<ov::intel_cpu::CausalMaskPreprocessNode>(new_args, m_config);
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/leaky_relu.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/leaky_relu.cpp
index dfabf92bbee7be..92728bf915345c 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/leaky_relu.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/leaky_relu.cpp
@@ -3,12 +3,15 @@
 //
 
 #include "leaky_relu.hpp"
+
 #include "transformations/itt.hpp"
 
-ov::intel_cpu::LeakyReluNode::LeakyReluNode(const ov::Output<ov::Node> &data,
-                                           const float &negative_slope,
-                                           const ov::element::Type output_type)
-    : Op({data}), m_negative_slope(negative_slope), m_output_type(output_type) {
+ov::intel_cpu::LeakyReluNode::LeakyReluNode(const ov::Output<ov::Node>& data,
+                                            const float& negative_slope,
+                                            const ov::element::Type output_type)
+    : Op({data}),
+      m_negative_slope(negative_slope),
+      m_output_type(output_type) {
     validate_and_infer_types();
 }
 
@@ -20,13 +23,12 @@ std::shared_ptr<ov::Node> ov::intel_cpu::LeakyReluNode::clone_with_new_inputs(co
 
 void ov::intel_cpu::LeakyReluNode::validate_and_infer_types() {
     INTERNAL_OP_SCOPE(LeakyReluNode_validate_and_infer_types);
-    set_output_type(
-        0,
-        m_output_type == ov::element::undefined ? get_input_element_type(0) : m_output_type,
-        get_input_partial_shape(0));
+    set_output_type(0,
+                    m_output_type == ov::element::undefined ? get_input_element_type(0) : m_output_type,
+                    get_input_partial_shape(0));
 }
 
-bool ov::intel_cpu::LeakyReluNode::visit_attributes(ov::AttributeVisitor &visitor) {
+bool ov::intel_cpu::LeakyReluNode::visit_attributes(ov::AttributeVisitor& visitor) {
     INTERNAL_OP_SCOPE(LeakyReluNode_visit_attributes);
     visitor.on_attribute("negative_slope", m_negative_slope);
     visitor.on_attribute("out-type", m_output_type);
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/leaky_relu.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/leaky_relu.hpp
index 4557584f798c85..fda6e26ea56560 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/leaky_relu.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/leaky_relu.hpp
@@ -15,22 +15,26 @@ class LeakyReluNode : public ov::op::Op {
 
     LeakyReluNode() = default;
 
-    LeakyReluNode(const ov::Output<ov::Node> &data, const float &negative_slope, const ov::element::Type output_type);
+    LeakyReluNode(const ov::Output<ov::Node>& data, const float& negative_slope, const ov::element::Type output_type);
 
     void validate_and_infer_types() override;
 
-    bool visit_attributes(ov::AttributeVisitor &visitor) override;
+    bool visit_attributes(ov::AttributeVisitor& visitor) override;
 
-    std::shared_ptr<ov::Node> clone_with_new_inputs(const ov::OutputVector &new_args) const override;
+    std::shared_ptr<ov::Node> clone_with_new_inputs(const ov::OutputVector& new_args) const override;
 
-    float get_slope() { return m_negative_slope; }
+    float get_slope() {
+        return m_negative_slope;
+    }
 
-    ov::element::Type get_output_type() const { return m_output_type; }
+    ov::element::Type get_output_type() const {
+        return m_output_type;
+    }
 
 private:
     float m_negative_slope = 0.f;
     ov::element::Type m_output_type;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/ngram.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/ngram.cpp
index aec8cc220c54e4..e1e5f5dda7b087 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/ngram.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/ngram.cpp
@@ -3,10 +3,14 @@
 //
 
 #include "ngram.hpp"
+
 #include "transformations/itt.hpp"
 
-ov::intel_cpu::NgramNode::NgramNode(const ov::Output<Node>& embeddings, const ov::Output<Node>& batch_idces, const size_t k)
-    : Op({embeddings, batch_idces}), m_k(k) {
+ov::intel_cpu::NgramNode::NgramNode(const ov::Output<Node>& embeddings,
+                                    const ov::Output<Node>& batch_idces,
+                                    const size_t k)
+    : Op({embeddings, batch_idces}),
+      m_k(k) {
     validate_and_infer_types();
 }
 
@@ -16,7 +20,7 @@ std::shared_ptr<ov::Node> ov::intel_cpu::NgramNode::clone_with_new_inputs(const
     return std::make_shared<ov::intel_cpu::NgramNode>(new_args.at(0), new_args.at(1), m_k);
 }
 
-bool ov::intel_cpu::NgramNode::visit_attributes(ov::AttributeVisitor &visitor) {
+bool ov::intel_cpu::NgramNode::visit_attributes(ov::AttributeVisitor& visitor) {
     INTERNAL_OP_SCOPE(NgramNode_visit_attributes);
     visitor.on_attribute("k", m_k);
     return true;
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/ngram.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/ngram.hpp
index e2af0e8eb49271..2f7b70630e9ad1 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/ngram.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/ngram.hpp
@@ -10,11 +10,11 @@
 namespace ov {
 namespace intel_cpu {
 /**
- * The operation flattens embedding tensor of token vectors and traverse it by a sliding window of size times the original embedding sizes.
- * Inputs:
+ * The operation flattens embedding tensor of token vectors and traverse it by a sliding window of size times the
+ * original embedding sizes. Inputs:
  *     1. Embedding vectors of type T1 - shape [N, m], where N - number of tokens, m - embedding size. Required
- *     2. Indices of type T2 - shape [N, 2]. Contains pairs <batch_idx;idx> for the corresponding tokens. This op uses only batch indices. Required
- * Outputs:
+ *     2. Indices of type T2 - shape [N, 2]. Contains pairs <batch_idx;idx> for the corresponding tokens. This op uses
+ * only batch indices. Required Outputs:
  *     1. New embedding vector of type T1 and of shape [N, m * k], where k - operation attribute.
  * Types:
  *     T1 - only FP32 is supported
@@ -34,5 +34,5 @@ class NgramNode : public ov::op::Op {
 private:
     size_t m_k;
 };
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/power_static.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/power_static.cpp
index c0d551a2aa3fa2..e46c37a2fe975b 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/power_static.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/power_static.cpp
@@ -3,32 +3,44 @@
 //
 
 #include "power_static.hpp"
+
 #include "transformations/itt.hpp"
 
-ov::intel_cpu::PowerStaticNode::PowerStaticNode(const ov::Output<Node> &data,
-                                               const float &power,
-                                               const float &scale,
-                                               const float &shift,
-                                               const ov::element::Type output_type)
-    : Op({data}), scale(scale), power(power), shift(shift), m_output_type(output_type) {
+ov::intel_cpu::PowerStaticNode::PowerStaticNode(const ov::Output<Node>& data,
+                                                const float& power,
+                                                const float& scale,
+                                                const float& shift,
+                                                const ov::element::Type output_type)
+    : Op({data}),
+      scale(scale),
+      power(power),
+      shift(shift),
+      m_output_type(output_type) {
     validate_and_infer_types();
 }
 
-std::shared_ptr<ov::Node> ov::intel_cpu::PowerStaticNode::clone_with_new_inputs(const ov::OutputVector &new_args) const {
+std::shared_ptr<ov::Node> ov::intel_cpu::PowerStaticNode::clone_with_new_inputs(
+    const ov::OutputVector& new_args) const {
     INTERNAL_OP_SCOPE(PowerStaticNode_clone_with_new_inputs);
     if (new_args.size() != 1) {
         OPENVINO_THROW("Incorrect number of new arguments");
     }
 
-    return std::make_shared<ov::intel_cpu::PowerStaticNode>(new_args.at(0), this->power, this->scale, this->shift, this->m_output_type);
+    return std::make_shared<ov::intel_cpu::PowerStaticNode>(new_args.at(0),
+                                                            this->power,
+                                                            this->scale,
+                                                            this->shift,
+                                                            this->m_output_type);
 }
 
 void ov::intel_cpu::PowerStaticNode::validate_and_infer_types() {
     INTERNAL_OP_SCOPE(PowerStaticNode_validate_and_infer_types);
-    set_output_type(0, m_output_type == ov::element::undefined ? get_input_element_type(0) : m_output_type, get_input_partial_shape(0));
+    set_output_type(0,
+                    m_output_type == ov::element::undefined ? get_input_element_type(0) : m_output_type,
+                    get_input_partial_shape(0));
 }
 
-bool ov::intel_cpu::PowerStaticNode::visit_attributes(ov::AttributeVisitor &visitor) {
+bool ov::intel_cpu::PowerStaticNode::visit_attributes(ov::AttributeVisitor& visitor) {
     INTERNAL_OP_SCOPE(PowerStaticNode_visit_attributes);
     visitor.on_attribute("scale", scale);
     visitor.on_attribute("power", power);
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/power_static.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/power_static.hpp
index c44f363a67dd40..beec0ae6d60271 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/power_static.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/power_static.hpp
@@ -15,23 +15,32 @@ class PowerStaticNode : public ov::op::Op {
 
     PowerStaticNode() = default;
 
-    PowerStaticNode(const ov::Output<ov::Node> &data, const float &power, const float &scale, const float &shift,
+    PowerStaticNode(const ov::Output<ov::Node>& data,
+                    const float& power,
+                    const float& scale,
+                    const float& shift,
                     const ov::element::Type output_type = ov::element::undefined);
 
     void validate_and_infer_types() override;
 
-    bool visit_attributes(ov::AttributeVisitor &visitor) override;
+    bool visit_attributes(ov::AttributeVisitor& visitor) override;
 
-    std::shared_ptr<ov::Node> clone_with_new_inputs(const ov::OutputVector &new_args) const override;
+    std::shared_ptr<ov::Node> clone_with_new_inputs(const ov::OutputVector& new_args) const override;
 
-    float get_power() const { return power; }
-    float get_scale() const { return scale; }
-    float get_shift() const { return shift; }
+    float get_power() const {
+        return power;
+    }
+    float get_scale() const {
+        return scale;
+    }
+    float get_shift() const {
+        return shift;
+    }
 
 private:
     float scale, power, shift;
     ov::element::Type m_output_type;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/sdpa.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/sdpa.cpp
index bea56e2b8c833f..cc8e13f382b0e0 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/sdpa.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/sdpa.cpp
@@ -8,7 +8,8 @@
 
 #include "transformations/itt.hpp"
 
-ov::intel_cpu::ScaledDotProductAttentionWithKVCache::ScaledDotProductAttentionWithKVCache(const OutputVector& args, const Config& cfg)
+ov::intel_cpu::ScaledDotProductAttentionWithKVCache::ScaledDotProductAttentionWithKVCache(const OutputVector& args,
+                                                                                          const Config& cfg)
     : Op(args),
       m_config(cfg) {
     constructor_validate_and_infer_types();
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/submodel.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/submodel.cpp
index 0f72baed2b1206..b0ef9c9468b300 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/submodel.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/submodel.cpp
@@ -2,21 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include <memory>
-
 #include "submodel.hpp"
 
+#include <memory>
+
 namespace ov {
 namespace intel_cpu {
 
-SubModel::SubModel(const std::shared_ptr<ov::Model>& body)
-    : SubGraphOp() {
+SubModel::SubModel(const std::shared_ptr<ov::Model>& body) : SubGraphOp() {
     SubGraphOp::set_function(body);
 }
 
-SubModel::SubModel(const ov::OutputVector& args,
-                   const std::shared_ptr<ov::Model>& body)
-    : SubGraphOp(args) {
+SubModel::SubModel(const ov::OutputVector& args, const std::shared_ptr<ov::Model>& body) : SubGraphOp(args) {
     SubGraphOp::set_function(body);
     constructor_validate_and_infer_types();
     for (size_t i = 0; i < body->get_parameters().size(); ++i)
@@ -25,8 +22,7 @@ SubModel::SubModel(const ov::OutputVector& args,
         m_output_descriptions[0].push_back(std::make_shared<BodyOutputDescription>(i, i));
 }
 
-SubModel::SubModel(const ov::NodeVector& args,
-                   const std::shared_ptr<ov::Model>& body)
+SubModel::SubModel(const ov::NodeVector& args, const std::shared_ptr<ov::Model>& body)
     : SubModel(as_output_vector(args), body) {}
 
 std::shared_ptr<ov::Node> SubModel::clone_with_new_inputs(const ov::OutputVector& inputs) const {
@@ -61,5 +57,5 @@ bool SubModel::visit_attributes(ov::AttributeVisitor& visitor) {
     return true;
 }
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/swish_cpu.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/swish_cpu.cpp
index 33239944e8210e..cb4d27437b64a3 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/swish_cpu.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/swish_cpu.cpp
@@ -3,10 +3,12 @@
 //
 
 #include "swish_cpu.hpp"
+
 #include "transformations/itt.hpp"
 
-ov::intel_cpu::SwishNode::SwishNode(const ov::Output<ov::Node> & input, const float alpha)
-        : Op({input}), m_alpha(alpha) {
+ov::intel_cpu::SwishNode::SwishNode(const ov::Output<ov::Node>& input, const float alpha)
+    : Op({input}),
+      m_alpha(alpha) {
     validate_and_infer_types();
 }
 
@@ -30,4 +32,3 @@ void ov::intel_cpu::SwishNode::validate_and_infer_types() {
 float ov::intel_cpu::SwishNode::get_alpha() const {
     return m_alpha;
 }
-
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/swish_cpu.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/swish_cpu.hpp
index 8f59a05e126c1e..1d49e2f71758f4 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/swish_cpu.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/op/swish_cpu.hpp
@@ -15,11 +15,11 @@ class SwishNode : public ov::op::Op {
 
     SwishNode() = default;
 
-    explicit SwishNode(const ov::Output<Node> &input, float alpha = 1.0);
+    explicit SwishNode(const ov::Output<Node>& input, float alpha = 1.0);
 
     void validate_and_infer_types() override;
     bool visit_attributes(ov::AttributeVisitor& visitor) override;
-    std::shared_ptr<ov::Node> clone_with_new_inputs(const ov::OutputVector &new_args) const override;
+    std::shared_ptr<ov::Node> clone_with_new_inputs(const ov::OutputVector& new_args) const override;
 
     float get_alpha() const;
 
@@ -27,5 +27,5 @@ class SwishNode : public ov::op::Op {
     float m_alpha;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/align_matmul_input_ranks.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/align_matmul_input_ranks.cpp
index 947a569a5effde..044ef91a793f99 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/align_matmul_input_ranks.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/align_matmul_input_ranks.cpp
@@ -4,27 +4,25 @@
 
 #include "align_matmul_input_ranks.hpp"
 
-#include "openvino/op/matmul.hpp"
-#include "openvino/opsets/opset1.hpp"
-#include "openvino/core/rt_info.hpp"
-#include "openvino/pass/pattern/op/wrap_type.hpp"
+#include <algorithm>
 #include <transformations/utils/utils.hpp>
-#include "openvino/pass/pattern/op/or.hpp"
 
-#include <algorithm>
 #include "itt.hpp"
+#include "openvino/core/rt_info.hpp"
+#include "openvino/op/matmul.hpp"
+#include "openvino/opsets/opset1.hpp"
+#include "openvino/pass/pattern/op/or.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
 
 ov::intel_cpu::AlignMatMulInputRanks::AlignMatMulInputRanks() {
     MATCHER_SCOPE(AlignMatMulInputRanks);
-    ov::OutputVector twoInputs = {
-        ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()),
-        ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank())
-    };
+    ov::OutputVector twoInputs = {ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()),
+                                  ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank())};
 
     auto matmulPattern = ov::pass::pattern::wrap_type<ov::op::v0::MatMul>(twoInputs);
 
     ov::matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) {
-        auto matmul = std::dynamic_pointer_cast<ov::op::v0::MatMul> (m.get_match_root());
+        auto matmul = std::dynamic_pointer_cast<ov::op::v0::MatMul>(m.get_match_root());
 
         if (!matmul || transformation_callback(matmul))
             return false;
@@ -40,9 +38,8 @@ ov::intel_cpu::AlignMatMulInputRanks::AlignMatMulInputRanks() {
 
         const bool transposedUnsqueeze = input1shape.size() == 1;
 
-        if (input0shape.size() == input1shape.size() &&
-            input0shape.size() != 1)
-            return false; // nothing to do
+        if (input0shape.size() == input1shape.size() && input0shape.size() != 1)
+            return false;  // nothing to do
 
         auto getUnsqueeze = [&](const ov::Output<ov::Node>& nodeFrom, const ov::Output<ov::Node>& nodeTo) {
             auto rankFrom = nodeFrom.get_partial_shape().size();
@@ -52,7 +49,7 @@ ov::intel_cpu::AlignMatMulInputRanks::AlignMatMulInputRanks() {
             for (int64_t j = 0; j < static_cast<int64_t>(rankTo - rankFrom); ++j)
                 unsqueeze_axes.push_back(j);
 
-            if (transposedUnsqueeze) // special case for one-dimensional second input
+            if (transposedUnsqueeze)  // special case for one-dimensional second input
                 unsqueeze_axes[unsqueeze_axes.size() - 1]++;
 
             auto unsqueeze = std::make_shared<ov::opset1::Unsqueeze>(
@@ -141,7 +138,6 @@ ov::intel_cpu::AlignMatMulInputRanks::AlignMatMulInputRanks() {
             ov::replace_node(matmul, matmul_new);
         }
 
-
         return true;
     };
 
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/align_matmul_input_ranks.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/align_matmul_input_ranks.hpp
index 23a561de67f5e5..f9ab862b19f4dd 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/align_matmul_input_ranks.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/align_matmul_input_ranks.hpp
@@ -17,11 +17,11 @@
 namespace ov {
 namespace intel_cpu {
 
-class AlignMatMulInputRanks: public ov::pass::MatcherPass {
+class AlignMatMulInputRanks : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("AlignMatMulInputRanks", "0");
     AlignMatMulInputRanks();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/causal_mask_preprocess_fusion.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/causal_mask_preprocess_fusion.cpp
index 3e8a7fc6d5a3f0..5801dbb8ae74a9 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/causal_mask_preprocess_fusion.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/causal_mask_preprocess_fusion.cpp
@@ -17,8 +17,8 @@
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "ov_ops/type_relaxed.hpp"
 #include "transformations/cpu_opset/common/op/causal_mask_preprocess.hpp"
-#include "transformations/utils/utils.hpp"
 #include "transformations/utils/gen_pattern.hpp"
+#include "transformations/utils/utils.hpp"
 
 using namespace ov::gen_pattern;
 
@@ -120,20 +120,26 @@ CausalMaskPreprocess::CausalMaskPreprocess() {
         makePattern<ov::opset1::Reshape>({SliceAssign_201_Range, {-1, 1, max_seq_len, max_seq_len}},
                                          {{"special_zero", true}});  //  tensor_array<i32[?,1,8192,8192]>
 
-    auto ShapeOf_49034 = makePattern<ov::opset1::ShapeOf>({attention_mask});                 //  tensor_array<i32[2]>
+    auto ShapeOf_49034 = makePattern<ov::opset1::ShapeOf>({attention_mask});  //  tensor_array<i32[2]>
     auto Gather_41642 =
         makePattern<ov::opset8::Gather>({ShapeOf_49034, {1}, 0}, {{"batch_dims", 0}});  //  tensor_array<i32[1]>
     auto ScatterUpdate_93502 =
         makePattern<ov::opset3::ScatterUpdate>({{0, 0, 0, 0}, {3}, Gather_41642, {0}});  //  tensor_array<i32[4]>
     auto SliceAssign_201_Slice = makePattern<ov::opset8::Slice>({SliceAssign_201_Reshape, {0}, Gather_41642, {1}, {3}});
-    auto SliceAssign_201_StridedSlice = GenStridedSlice(SliceAssign_201_Reshape, {0, 0, 0, 0},
-                                                        ScatterUpdate_93502, {1, 1, 1, 1}, 3); //  tensor_array<i32[?,1,8192,..8192]>
+    auto SliceAssign_201_StridedSlice = GenStridedSlice(SliceAssign_201_Reshape,
+                                                        {0, 0, 0, 0},
+                                                        ScatterUpdate_93502,
+                                                        {1, 1, 1, 1},
+                                                        3);  //  tensor_array<i32[?,1,8192,..8192]>
     auto SliceAssign_201_Reshape_1 =
         makePattern<ov::opset1::Reshape>({SliceAssign_201_Slice | SliceAssign_201_StridedSlice, {-1, 1}},
                                          {{"special_zero", false}});  //  tensor_array<i32[?,1]>
     auto causal_mask_boolean_slice = makePattern<ov::opset8::Slice>({mul_Multiply_1, {0}, Gather_41642, {1}, {3}});
-    auto causal_mask_boolean_strided_slice = GenStridedSlice(mul_Multiply_1, {0, 0, 0, 0},
-                                                             ScatterUpdate_93502, {1, 1, 1, 1}, 3); //  tensor_array<f32[?,1,8192,..8192]>
+    auto causal_mask_boolean_strided_slice = GenStridedSlice(mul_Multiply_1,
+                                                             {0, 0, 0, 0},
+                                                             ScatterUpdate_93502,
+                                                             {1, 1, 1, 1},
+                                                             3);  //  tensor_array<f32[?,1,8192,..8192]>
     auto Constant_107278 = makeConst(ov::element::f32,
                                      ov::Shape({
                                          1,
@@ -162,12 +168,11 @@ CausalMaskPreprocess::CausalMaskPreprocess() {
     auto mul_LogicalAnd =
         makePattern<ov::opset1::LogicalAnd>({eq_Equal, eq_Equal_1},
                                             {{"auto_broadcast", "numpy"}});  //  tensor_array<u8[?,1,8192,?]>
-    auto masked_fill_Select =
-        makePattern<ov::opset1::Select>({mul_LogicalAnd, -FLT_MAX,
-                                         causal_mask_boolean_slice | causal_mask_boolean_strided_slice},
-                                        {{"auto_broadcast", "numpy"}});              //  tensor_array<f32[?,1,8192,?]>
-    auto copy__ShapeOf = makePattern<ov::opset1::ShapeOf>({causal_mask_boolean_slice |
-                                                           causal_mask_boolean_strided_slice});  //  tensor_array<i32[4]>
+    auto masked_fill_Select = makePattern<ov::opset1::Select>(
+        {mul_LogicalAnd, -FLT_MAX, causal_mask_boolean_slice | causal_mask_boolean_strided_slice},
+        {{"auto_broadcast", "numpy"}});  //  tensor_array<f32[?,1,8192,?]>
+    auto copy__ShapeOf = makePattern<ov::opset1::ShapeOf>(
+        {causal_mask_boolean_slice | causal_mask_boolean_strided_slice});  //  tensor_array<i32[4]>
     auto Constant_47319 = makeConst(ov::element::u8, ov::Shape({}), {0});
     auto copy__Broadcast =
         makePattern<ov::opset1::Broadcast>({masked_fill_Select, copy__ShapeOf, Constant_47319},
@@ -181,8 +186,11 @@ CausalMaskPreprocess::CausalMaskPreprocess() {
                                          {{"special_zero", true}});  //  tensor_array<f32[?,1,8192,8192]>
     auto ScatterUpdate_93554 =
         makePattern<ov::opset3::ScatterUpdate>({{0, 0, 0, 0}, {3}, kvLen, {0}});  //  tensor_array<i32[4]>
-    auto slice_StridedSlice_14 = GenStridedSlice(SliceAssign_201_Reshape_3, {0, 0, 0, 0},
-                                                 ScatterUpdate_93554, {1, 1, 1, 1}, 3); //  tensor_array<f32[?,1,8192,..8192]>
+    auto slice_StridedSlice_14 = GenStridedSlice(SliceAssign_201_Reshape_3,
+                                                 {0, 0, 0, 0},
+                                                 ScatterUpdate_93554,
+                                                 {1, 1, 1, 1},
+                                                 3);  //  tensor_array<f32[?,1,8192,..8192]>
     auto slice_Slice_14 = makePattern<ov::opset8::Slice>({SliceAssign_201_Reshape_3, {0}, kvLen, {1}, {3}});
     auto index_Gather = makePattern<ov::opset8::Gather>({slice_Slice_14 | slice_StridedSlice_14, cache_positions, 2},
                                                         {{"batch_dims", 0}},
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_broadcast_to_tiles.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_broadcast_to_tiles.cpp
index 5b175d15bf9f77..bd6a41f3314c99 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_broadcast_to_tiles.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_broadcast_to_tiles.cpp
@@ -4,12 +4,11 @@
 
 #include "convert_broadcast_to_tiles.hpp"
 
-#include "openvino/opsets/opset1.hpp"
+#include "itt.hpp"
 #include "openvino/core/rt_info.hpp"
+#include "openvino/opsets/opset1.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 
-#include "itt.hpp"
-
 ov::intel_cpu::ConvertBroadcastToTiles::ConvertBroadcastToTiles() {
     MATCHER_SCOPE(ConvertBroadcastToTiles);
     auto broadcast = ov::pass::pattern::wrap_type<ov::opset1::Broadcast>();
@@ -25,9 +24,12 @@ ov::intel_cpu::ConvertBroadcastToTiles::ConvertBroadcastToTiles() {
             return false;
         }
 
-        auto shape_node = std::dynamic_pointer_cast<ov::opset1::Constant>(broadcast->input_value(1).get_node_shared_ptr());
-        auto axes_node = std::dynamic_pointer_cast<ov::opset1::Constant>(broadcast->input_value(2).get_node_shared_ptr());
-        if (!shape_node || !axes_node) return false;
+        auto shape_node =
+            std::dynamic_pointer_cast<ov::opset1::Constant>(broadcast->input_value(1).get_node_shared_ptr());
+        auto axes_node =
+            std::dynamic_pointer_cast<ov::opset1::Constant>(broadcast->input_value(2).get_node_shared_ptr());
+        if (!shape_node || !axes_node)
+            return false;
 
         auto output_shape = shape_node->cast_vector<int64_t>();
         auto input_shape = data_node.get_shape();
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_broadcast_to_tiles.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_broadcast_to_tiles.hpp
index ef6cd5ddffb6ea..b0b1e5632f908a 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_broadcast_to_tiles.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_broadcast_to_tiles.hpp
@@ -9,11 +9,11 @@
 namespace ov {
 namespace intel_cpu {
 
-class ConvertBroadcastToTiles: public ov::pass::MatcherPass {
+class ConvertBroadcastToTiles : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("ConvertBroadcastToTiles", "0");
     ConvertBroadcastToTiles();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_fq_rnn_to_quantized_rnn.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_fq_rnn_to_quantized_rnn.cpp
index 3f70351dd729c7..38aea1324e7eb4 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_fq_rnn_to_quantized_rnn.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_fq_rnn_to_quantized_rnn.cpp
@@ -4,20 +4,19 @@
 
 #include "convert_fq_rnn_to_quantized_rnn.hpp"
 
+#include "itt.hpp"
+#include "openvino/core/rt_info.hpp"
 #include "openvino/op/constant.hpp"
 #include "openvino/op/convert.hpp"
 #include "openvino/op/gru_sequence.hpp"
 #include "openvino/op/lstm_sequence.hpp"
 #include "openvino/op/multiply.hpp"
 #include "openvino/op/subtract.hpp"
-#include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "openvino/pass/pattern/op/or.hpp"
-#include "openvino/core/rt_info.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "ov_ops/type_relaxed.hpp"
 #include "transformations/rt_info/disable_constant_folding.hpp"
 
-#include "itt.hpp"
-
 ov::intel_cpu::ConvertFqRnnToQuantizedRnn::ConvertFqRnnToQuantizedRnn() {
     MATCHER_SCOPE(ConvertFqRnnToQuantizedRnn);
 
@@ -27,11 +26,10 @@ ov::intel_cpu::ConvertFqRnnToQuantizedRnn::ConvertFqRnnToQuantizedRnn() {
     auto subtract_X = pass::pattern::wrap_type<op::v1::Subtract>({convert_X, input_shift_X});
     auto input_scale_X = pass::pattern::wrap_type<op::v0::Constant>();
 
-    auto deq_X = std::make_shared<pass::pattern::op::Or>(
-        OutputVector{
-            pass::pattern::wrap_type<op::v1::Multiply>({convert_X, input_scale_X}),
-            pass::pattern::wrap_type<op::v1::Multiply>({subtract_X, input_scale_X}),
-        });
+    auto deq_X = std::make_shared<pass::pattern::op::Or>(OutputVector{
+        pass::pattern::wrap_type<op::v1::Multiply>({convert_X, input_scale_X}),
+        pass::pattern::wrap_type<op::v1::Multiply>({subtract_X, input_scale_X}),
+    });
 
     auto H_m = ov::pass::pattern::any_input();
     auto convert_H = pass::pattern::wrap_type<op::v0::Convert>({H_m});
@@ -39,21 +37,16 @@ ov::intel_cpu::ConvertFqRnnToQuantizedRnn::ConvertFqRnnToQuantizedRnn() {
     auto subtract_H = pass::pattern::wrap_type<op::v1::Subtract>({convert_H, input_shift_H});
     auto input_scale_H = pass::pattern::wrap_type<op::v0::Constant>();
 
-    auto deq_H = std::make_shared<pass::pattern::op::Or>(
-        OutputVector{
-            pass::pattern::wrap_type<op::v1::Multiply>({convert_H, input_scale_H}),
-            pass::pattern::wrap_type<op::v1::Multiply>({subtract_H, input_scale_H}),
-        });
+    auto deq_H = std::make_shared<pass::pattern::op::Or>(OutputVector{
+        pass::pattern::wrap_type<op::v1::Multiply>({convert_H, input_scale_H}),
+        pass::pattern::wrap_type<op::v1::Multiply>({subtract_H, input_scale_H}),
+    });
 
     auto H_as_const = ov::pass::pattern::wrap_type<op::v0::Constant>();
-    auto H_in = std::make_shared<ov::pass::pattern::op::Or>(
-        OutputVector {
-            deq_H,
-            H_as_const
-        });
+    auto H_in = std::make_shared<ov::pass::pattern::op::Or>(OutputVector{deq_H, H_as_const});
 
-    auto cell_state_m = ov::pass::pattern::any_input(); // for LSTM
-    auto sequence_length_m = ov::pass::pattern::any_input(); // for Sequences
+    auto cell_state_m = ov::pass::pattern::any_input();       // for LSTM
+    auto sequence_length_m = ov::pass::pattern::any_input();  // for Sequences
 
     auto W_m = ov::pass::pattern::wrap_type<op::v0::Constant>();
     auto convert_W = ov::pass::pattern::wrap_type<op::v0::Convert>({W_m});
@@ -67,34 +60,32 @@ ov::intel_cpu::ConvertFqRnnToQuantizedRnn::ConvertFqRnnToQuantizedRnn() {
 
     const auto B_m = ov::pass::pattern::wrap_type<op::v0::Constant>();
 
-    auto lstm_seq_m = ov::pass::pattern::wrap_type<op::v5::LSTMSequence>({deq_X, H_in, cell_state_m, sequence_length_m, deq_W, deq_R, B_m});
-    auto gru_seq_m  = ov::pass::pattern::wrap_type<op::v5::GRUSequence> ({deq_X, H_in,               sequence_length_m, deq_W, deq_R, B_m});
+    auto lstm_seq_m = ov::pass::pattern::wrap_type<op::v5::LSTMSequence>(
+        {deq_X, H_in, cell_state_m, sequence_length_m, deq_W, deq_R, B_m});
+    auto gru_seq_m =
+        ov::pass::pattern::wrap_type<op::v5::GRUSequence>({deq_X, H_in, sequence_length_m, deq_W, deq_R, B_m});
 
-    auto rnn_pattern = std::make_shared<ov::pass::pattern::op::Or>(
-        OutputVector {
-            lstm_seq_m,
-            gru_seq_m
-        });
+    auto rnn_pattern = std::make_shared<ov::pass::pattern::op::Or>(OutputVector{lstm_seq_m, gru_seq_m});
 
     ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
         auto rnn = m.get_match_root();
         if (!rnn || transformation_callback(rnn))
             return false;
 
-        const auto& pattern_map  = m.get_pattern_value_map();
-        const auto& activation   = pattern_map.at(X_m);
-        const auto  hidden_state_it = pattern_map.find(H_m);
+        const auto& pattern_map = m.get_pattern_value_map();
+        const auto& activation = pattern_map.at(X_m);
+        const auto hidden_state_it = pattern_map.find(H_m);
 
         ov::Output<ov::Node> hidden_state;
-        if (hidden_state_it != pattern_map.end()) { // is it H(i8/u8) -> dequantized -> RNN pattern?
+        if (hidden_state_it != pattern_map.end()) {  // is it H(i8/u8) -> dequantized -> RNN pattern?
             hidden_state = hidden_state_it->second;
         } else {
-            hidden_state = pattern_map.at(H_as_const); // if not, then it is just H (f32 const) -> RNN
+            hidden_state = pattern_map.at(H_as_const);  // if not, then it is just H (f32 const) -> RNN
         }
 
-        const auto& weights      = pattern_map.at(W_m);
-        const auto& r_weights    = pattern_map.at(R_m);
-        const auto& bias         = pattern_map.at(B_m);
+        const auto& weights = pattern_map.at(W_m);
+        const auto& r_weights = pattern_map.at(R_m);
+        const auto& bias = pattern_map.at(B_m);
 
         // At the moment there is no optimal primitive for i8 LSTM in the plugin,
         // thus it's better to leave such cases in f32.
@@ -120,8 +111,14 @@ ov::intel_cpu::ConvertFqRnnToQuantizedRnn::ConvertFqRnnToQuantizedRnn() {
 
             // @todo prototype removal of unnecessary fq between two consecutive rnn nodes
             auto rnn_quantized_tr = std::make_shared<op::TypeRelaxed<op::v5::LSTMSequence>>(
-                element::TypeVector{ element::f32, element::f32, element::f32, element::f32, element::f32, element::f32, element::f32 },
-                element::TypeVector{ element::f32, element::f32, element::f32 },
+                element::TypeVector{element::f32,
+                                    element::f32,
+                                    element::f32,
+                                    element::f32,
+                                    element::f32,
+                                    element::f32,
+                                    element::f32},
+                element::TypeVector{element::f32, element::f32, element::f32},
                 op::TemporaryReplaceOutputType(activation, element::f32).get(),
                 op::TemporaryReplaceOutputType(hidden_state, element::f32).get(),
                 op::TemporaryReplaceOutputType(cell_state, element::f32).get(),
@@ -142,8 +139,13 @@ ov::intel_cpu::ConvertFqRnnToQuantizedRnn::ConvertFqRnnToQuantizedRnn() {
             const auto& sequence_length = pattern_map.at(sequence_length_m);
 
             auto rnn_quantized_tr = std::make_shared<op::TypeRelaxed<op::v5::GRUSequence>>(
-                std::vector<ov::element::Type>{ element::f32, element::f32, element::f32, element::f32, element::f32, element::f32},
-                std::vector<ov::element::Type>{ element::f32, element::f32 },
+                std::vector<ov::element::Type>{element::f32,
+                                               element::f32,
+                                               element::f32,
+                                               element::f32,
+                                               element::f32,
+                                               element::f32},
+                std::vector<ov::element::Type>{element::f32, element::f32},
                 op::TemporaryReplaceOutputType(activation, element::f32).get(),
                 op::TemporaryReplaceOutputType(hidden_state, element::f32).get(),
                 op::TemporaryReplaceOutputType(sequence_length, element::f32).get(),
@@ -165,11 +167,13 @@ ov::intel_cpu::ConvertFqRnnToQuantizedRnn::ConvertFqRnnToQuantizedRnn() {
         }
 
         // input scales (Multiply per tensor) and weights_scales (Multiply per multiple dimensions) must be present
-        const auto& input_scale_output   = pattern_map.at(input_scale_X);
+        const auto& input_scale_output = pattern_map.at(input_scale_X);
         const auto& weights_scale_output = pattern_map.at(weights_scale_W);
         // extract constant values
-        const auto input_scale_constant   = std::dynamic_pointer_cast<op::v0::Constant>(input_scale_output.get_node_shared_ptr());
-        const auto weights_scale_constant = std::dynamic_pointer_cast<op::v0::Constant>(weights_scale_output.get_node_shared_ptr());
+        const auto input_scale_constant =
+            std::dynamic_pointer_cast<op::v0::Constant>(input_scale_output.get_node_shared_ptr());
+        const auto weights_scale_constant =
+            std::dynamic_pointer_cast<op::v0::Constant>(weights_scale_output.get_node_shared_ptr());
 
         if (!input_scale_constant || !weights_scale_constant)
             return false;
@@ -178,24 +182,27 @@ ov::intel_cpu::ConvertFqRnnToQuantizedRnn::ConvertFqRnnToQuantizedRnn() {
         if (*input_scale_ptr == 0.f)
             OPENVINO_THROW("Cannot handle zero input scale");
 
-        const float input_scale  = 1 / *input_scale_ptr;
-        std::vector<float> weights_scales  = weights_scale_constant->get_vector<float>();
+        const float input_scale = 1 / *input_scale_ptr;
+        std::vector<float> weights_scales = weights_scale_constant->get_vector<float>();
 
         // transform dequantization scales into quantization ones
-        std::transform(weights_scales.begin(), weights_scales.end(), weights_scales.begin(), [](float& scale) { return 1 / scale; });
+        std::transform(weights_scales.begin(), weights_scales.end(), weights_scales.begin(), [](float& scale) {
+            return 1 / scale;
+        });
 
         auto& runtime_info = rnn_quantized->get_rt_info();
 
         // use runtime information to store input and weight scales
-        runtime_info["inputScale"]    = input_scale;
+        runtime_info["inputScale"] = input_scale;
         runtime_info["weightsScales"] = weights_scales;
 
         // input shift (Subtract) is optional
         const auto input_shift_it = pattern_map.find(input_shift_X);
 
         if (input_shift_it != pattern_map.end()) {
-            const auto  input_shift_constant = std::dynamic_pointer_cast<op::v0::Constant>(input_shift_it->second.get_node_shared_ptr());
-            const float* input_shift_ptr      = input_shift_constant->get_data_ptr<float>();
+            const auto input_shift_constant =
+                std::dynamic_pointer_cast<op::v0::Constant>(input_shift_it->second.get_node_shared_ptr());
+            const float* input_shift_ptr = input_shift_constant->get_data_ptr<float>();
             runtime_info["inputShift"] = *input_shift_ptr;
         }
 
@@ -210,15 +217,16 @@ ov::intel_cpu::ConvertFqRnnToQuantizedRnn::ConvertFqRnnToQuantizedRnn() {
          * oneDNN supports only equal data types on H in/out ports
          * either: u8u8, i8i8 or f32f32 */
         if (hidden_state_it != pattern_map.end()) {
-            const auto& convert  = pattern_map.at(convert_H).get_node_shared_ptr();
-            const auto  subtract_it = pattern_map.find(subtract_H);
+            const auto& convert = pattern_map.at(convert_H).get_node_shared_ptr();
+            const auto subtract_it = pattern_map.find(subtract_H);
             const auto& multiply = rnn->get_input_node_shared_ptr(1);
 
-            auto new_convert  = convert->clone_with_new_inputs({rnn_quantized->output(1)});
+            auto new_convert = convert->clone_with_new_inputs({rnn_quantized->output(1)});
             std::shared_ptr<Node> multiply_input = new_convert;
             // dequantize with subtract
             if (subtract_it != pattern_map.end()) {
-                const auto subtract = std::dynamic_pointer_cast<op::v1::Subtract>(subtract_it->second.get_node_shared_ptr());
+                const auto subtract =
+                    std::dynamic_pointer_cast<op::v1::Subtract>(subtract_it->second.get_node_shared_ptr());
                 multiply_input = subtract->clone_with_new_inputs({multiply_input, subtract->input_value(1)});
             }
 
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_fq_rnn_to_quantized_rnn.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_fq_rnn_to_quantized_rnn.hpp
index f3485609cd026d..ee3692f2ea4ca6 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_fq_rnn_to_quantized_rnn.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_fq_rnn_to_quantized_rnn.hpp
@@ -74,11 +74,11 @@
 namespace ov {
 namespace intel_cpu {
 
-class ConvertFqRnnToQuantizedRnn: public ov::pass::MatcherPass {
+class ConvertFqRnnToQuantizedRnn : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("ConvertFqRnnToQuantizedRnn", "0");
     ConvertFqRnnToQuantizedRnn();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_matmul_to_fc.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_matmul_to_fc.cpp
index da25e9aac30240..81e89ca80e5b6e 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_matmul_to_fc.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_matmul_to_fc.cpp
@@ -2,18 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "openvino/core/type/element_type.hpp"
-#include "ov_ops/fully_connected.hpp"
 #include "convert_matmul_to_fc.hpp"
-#include "openvino/op/matmul.hpp"
+
+#include "itt.hpp"
+#include "openvino/core/rt_info.hpp"
+#include "openvino/core/type/element_type.hpp"
 #include "openvino/op/convert.hpp"
+#include "openvino/op/matmul.hpp"
 #include "openvino/op/transpose.hpp"
-#include "openvino/core/rt_info.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "ov_ops/fully_connected.hpp"
 #include "transformations/utils/utils.hpp"
 
-#include "itt.hpp"
-
 ov::intel_cpu::ConvertMatMulToFC::ConvertMatMulToFC() {
     MATCHER_SCOPE(ConvertMatMulToFC);
     auto activations_m = ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank());
@@ -21,7 +21,8 @@ ov::intel_cpu::ConvertMatMulToFC::ConvertMatMulToFC() {
         return ov::op::util::is_on_constant_path(output);
     };
     auto weights_m = ov::pass::pattern::any_input(weights_path);
-    auto matmul_m = ov::pass::pattern::wrap_type<ov::op::v0::MatMul>({ activations_m, weights_m }, ov::pass::pattern::has_static_rank());
+    auto matmul_m = ov::pass::pattern::wrap_type<ov::op::v0::MatMul>({activations_m, weights_m},
+                                                                     ov::pass::pattern::has_static_rank());
 
     ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
         const auto& pattern_map = m.get_pattern_value_map();
@@ -59,7 +60,9 @@ ov::intel_cpu::ConvertMatMulToFC::ConvertMatMulToFC() {
 
         // Check that if second inputs is Constant path and it's shape without ones dimensions has length <= 2
         // we replace MatMul with FullyConnected operation.
-        if (std::count_if(shape_b.begin(), shape_b.end(), [](ov::Dimension x) { return x != 1; }) > 2) {
+        if (std::count_if(shape_b.begin(), shape_b.end(), [](ov::Dimension x) {
+                return x != 1;
+            }) > 2) {
             return false;
         }
         /*
@@ -69,7 +72,8 @@ ov::intel_cpu::ConvertMatMulToFC::ConvertMatMulToFC() {
          *  for example: [2, 32, 64] [3, 64, 64] it will raise an exception.
          */
 
-        auto get_aligned_shapes = [shape_a, shape_b, rank_a, rank_b, &matmul]() -> std::tuple<bool, ov::PartialShape, ov::PartialShape> {
+        auto get_aligned_shapes =
+            [shape_a, shape_b, rank_a, rank_b, &matmul]() -> std::tuple<bool, ov::PartialShape, ov::PartialShape> {
             ov::PartialShape shape_a_aligned(shape_a), shape_b_aligned(shape_b);
             size_t max_size = std::max(rank_a, rank_b);
             for (size_t i = 0, cnt = max_size - rank_a; i < cnt; ++i) {
@@ -106,12 +110,13 @@ ov::intel_cpu::ConvertMatMulToFC::ConvertMatMulToFC() {
          */
         ov::NodeVector new_ops;
 
-        auto create_transpose = [this, &new_ops ](const ov::Output<ov::Node>& node, const std::string& transpose_name) {
+        auto create_transpose = [this, &new_ops](const ov::Output<ov::Node>& node, const std::string& transpose_name) {
             std::vector<size_t> transpose_order(node.get_partial_shape().size());
             std::iota(transpose_order.begin(), transpose_order.end(), 0);
             std::swap(*(transpose_order.end() - 1), *(transpose_order.end() - 2));
 
-            auto transpose_const = ov::op::v0::Constant::create(ov::element::i32, ov::Shape{ transpose_order.size() }, transpose_order);
+            auto transpose_const =
+                ov::op::v0::Constant::create(ov::element::i32, ov::Shape{transpose_order.size()}, transpose_order);
             auto transpose = std::make_shared<ov::op::v1::Transpose>(node, transpose_const);
             if (!ov::is_type<ov::op::v0::Constant>(transpose)) {
                 new_ops.push_back(transpose_const);
@@ -131,7 +136,8 @@ ov::intel_cpu::ConvertMatMulToFC::ConvertMatMulToFC() {
         }
 
         auto aligned_a_rank = shape_a_aligned.rank(), aligned_b_rank = shape_b_aligned.rank();
-        if (aligned_a_rank.is_dynamic() || aligned_b_rank.is_dynamic() || aligned_a_rank.get_length() < 2 || aligned_b_rank.get_length() < 2) {
+        if (aligned_a_rank.is_dynamic() || aligned_b_rank.is_dynamic() || aligned_a_rank.get_length() < 2 ||
+            aligned_b_rank.get_length() < 2) {
             OPENVINO_THROW("MatMul " + matmul->get_friendly_name() + " shapes are inconsistent.");
         }
 
@@ -162,7 +168,7 @@ ov::intel_cpu::ConvertMatMulToFC::ConvertMatMulToFC() {
                                                                      matmul->get_output_element_type(0));
 
         fc->set_friendly_name(matmul->get_friendly_name());
-        ///todo: CVS-130863 Remove after fp16_compression is copyable
+        /// todo: CVS-130863 Remove after fp16_compression is copyable
         if (ov::fp16_compression_is_disabled(matmul))
             disable_fp16_compression(fc);
         new_ops.push_back(fc);
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_matmul_to_fc.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_matmul_to_fc.hpp
index 7d75fcc19170d0..03366161f8c904 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_matmul_to_fc.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_matmul_to_fc.hpp
@@ -9,11 +9,11 @@
 namespace ov {
 namespace intel_cpu {
 
-class ConvertMatMulToFC: public ov::pass::MatcherPass {
+class ConvertMatMulToFC : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("ConvertMatMulToFC", "0");
     ConvertMatMulToFC();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_tile_to_seq_tiles.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_tile_to_seq_tiles.cpp
index 327222883b6035..39247665591879 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_tile_to_seq_tiles.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_tile_to_seq_tiles.cpp
@@ -7,17 +7,16 @@
 #include <memory>
 #include <vector>
 
+#include "itt.hpp"
+#include "openvino/core/rt_info.hpp"
 #include "openvino/opsets/opset1.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 
-#include "openvino/core/rt_info.hpp"
-
-#include "itt.hpp"
-
 ov::intel_cpu::ConvertTileToSeqTiles::ConvertTileToSeqTiles() {
     MATCHER_SCOPE(ConvertTileToSeqTiles);
-    auto tile = ov::pass::pattern::wrap_type<ov::opset1::Tile>({ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()),
-                                                                  ov::pass::pattern::wrap_type<ov::opset1::Constant>()});
+    auto tile = ov::pass::pattern::wrap_type<ov::opset1::Tile>(
+        {ov::pass::pattern::any_input(ov::pass::pattern::has_static_rank()),
+         ov::pass::pattern::wrap_type<ov::opset1::Constant>()});
 
     ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) {
         auto tile = std::dynamic_pointer_cast<ov::opset1::Tile>(m.get_match_root());
@@ -26,13 +25,15 @@ ov::intel_cpu::ConvertTileToSeqTiles::ConvertTileToSeqTiles() {
         }
 
         auto tiles_node = std::dynamic_pointer_cast<ov::opset1::Constant>(tile->input_value(1).get_node_shared_ptr());
-        if (!tiles_node) return false;
+        if (!tiles_node)
+            return false;
 
         auto tiles = tiles_node->cast_vector<int64_t>();
         auto input_shape_rank = static_cast<size_t>(tile->get_input_partial_shape(0).rank().get_length());
         int64_t cur_dim_id = tiles.size() - 1;
 
-        if (tiles.size() != input_shape_rank) return false;
+        if (tiles.size() != input_shape_rank)
+            return false;
 
         auto last_node = tile->input_value(0);
         auto friendly_name = tile->get_friendly_name();
@@ -46,7 +47,7 @@ ov::intel_cpu::ConvertTileToSeqTiles::ConvertTileToSeqTiles() {
 
         if (num_of_tile_dims == 0) {
             auto outputs = tile->get_output_target_inputs(0);
-            for (const auto &out : outputs) {
+            for (const auto& out : outputs) {
                 if (std::dynamic_pointer_cast<ov::opset1::Result>(out.get_node()->shared_from_this())) {
                     return false;
                 }
@@ -73,7 +74,8 @@ ov::intel_cpu::ConvertTileToSeqTiles::ConvertTileToSeqTiles() {
             if (tile_dim != 1) {
                 std::vector<int64_t> dims(input_shape_rank, 1);
                 dims[cur_dim_id] = tile_dim;
-                auto const_node = std::make_shared<ov::opset1::Constant>(ov::element::i64, ov::Shape{input_shape_rank}, dims);
+                auto const_node =
+                    std::make_shared<ov::opset1::Constant>(ov::element::i64, ov::Shape{input_shape_rank}, dims);
                 auto new_tile = std::make_shared<ov::opset1::Tile>(last_node, const_node);
                 new_tile->set_friendly_name(friendly_name);
                 friendly_name += "_" + std::to_string(cur_dim_id);
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_tile_to_seq_tiles.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_tile_to_seq_tiles.hpp
index a22104c53267af..5a4928477abec9 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_tile_to_seq_tiles.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_tile_to_seq_tiles.hpp
@@ -9,11 +9,11 @@
 namespace ov {
 namespace intel_cpu {
 
-class ConvertTileToSeqTiles: public ov::pass::MatcherPass {
+class ConvertTileToSeqTiles : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("ConvertTileToSeqTiles", "0");
     ConvertTileToSeqTiles();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_leaky_relu.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_leaky_relu.cpp
index 1086b3a05c7a9f..f064eca3c2f345 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_leaky_relu.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_leaky_relu.cpp
@@ -4,18 +4,17 @@
 
 #include "convert_to_leaky_relu.hpp"
 
-#include "openvino/opsets/opset1.hpp"
+#include "itt.hpp"
 #include "openvino/core/rt_info.hpp"
+#include "openvino/opsets/opset1.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "transformations/cpu_opset/common/op/leaky_relu.hpp"
 
-#include "itt.hpp"
-
 ov::intel_cpu::ConvertToLeakyRelu::ConvertToLeakyRelu() {
     MATCHER_SCOPE(ConvertToLeakyRelu);
     auto input = ov::pass::pattern::any_input();
     auto slope_constant = ov::pass::pattern::wrap_type<ov::opset1::Constant>();
-    auto prelu = ov::pass::pattern::wrap_type<ov::opset1::PRelu>({ input, slope_constant });
+    auto prelu = ov::pass::pattern::wrap_type<ov::opset1::PRelu>({input, slope_constant});
 
     ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) {
         auto prelu = std::dynamic_pointer_cast<ov::opset1::PRelu>(m.get_match_root());
@@ -25,8 +24,9 @@ ov::intel_cpu::ConvertToLeakyRelu::ConvertToLeakyRelu() {
         auto slopeNode = std::dynamic_pointer_cast<ov::opset1::Constant>(prelu->get_input_node_shared_ptr(1));
         if (slopeNode != nullptr && ov::shape_size(slopeNode->get_shape()) == 1) {
             const float slope = slopeNode->cast_vector<float>()[0];
-            const auto leakyRelu = std::make_shared<ov::intel_cpu::LeakyReluNode>(prelu->input(0).get_source_output(), slope,
-                                                                                 prelu->output(0).get_element_type());
+            const auto leakyRelu = std::make_shared<ov::intel_cpu::LeakyReluNode>(prelu->input(0).get_source_output(),
+                                                                                  slope,
+                                                                                  prelu->output(0).get_element_type());
             leakyRelu->set_friendly_name(prelu->get_friendly_name());
             ov::copy_runtime_info(prelu, leakyRelu);
             ov::replace_node(prelu, leakyRelu);
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_leaky_relu.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_leaky_relu.hpp
index ba0ba4da6e4466..b09f14de5793c5 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_leaky_relu.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_leaky_relu.hpp
@@ -9,11 +9,11 @@
 namespace ov {
 namespace intel_cpu {
 
-class ConvertToLeakyRelu: public ov::pass::MatcherPass {
+class ConvertToLeakyRelu : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("ConvertToLeakyRelu", "0");
     ConvertToLeakyRelu();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_power_static.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_power_static.cpp
index 03d9a294bbcab9..8d9ab35dca5de3 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_power_static.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_power_static.cpp
@@ -4,22 +4,22 @@
 
 #include "convert_to_power_static.hpp"
 
-#include "openvino/opsets/opset1.hpp"
-#include "openvino/opsets/opset4.hpp"
 #include <openvino/opsets/opset6.hpp>
+
+#include "itt.hpp"
 #include "openvino/core/rt_info.hpp"
-#include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "openvino/opsets/opset1.hpp"
+#include "openvino/opsets/opset4.hpp"
 #include "openvino/pass/pattern/op/or.hpp"
-#include "transformations/rt_info/dequantization_node.hpp"
-#include "transformations/cpu_opset/common/op/power_static.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "ov_ops/fully_connected.hpp"
+#include "transformations/cpu_opset/common/op/power_static.hpp"
+#include "transformations/rt_info/dequantization_node.hpp"
 #include "utils/general_utils.h"
 
-#include "itt.hpp"
-
 namespace {
 
-int getConstPort(const std::shared_ptr<ov::Node> &node) {
+int getConstPort(const std::shared_ptr<ov::Node>& node) {
     const auto const1 = std::dynamic_pointer_cast<ov::opset1::Constant>(node->get_input_node_shared_ptr(0));
     const auto const2 = std::dynamic_pointer_cast<ov::opset1::Constant>(node->get_input_node_shared_ptr(1));
     int constPort = -1;
@@ -32,10 +32,10 @@ int getConstPort(const std::shared_ptr<ov::Node> &node) {
 }
 
 template <class BaseOp>
-bool isConvertableToPowerStatic(const std::shared_ptr<BaseOp> &node) {
+bool isConvertableToPowerStatic(const std::shared_ptr<BaseOp>& node) {
     const int constPort = getConstPort(node);
-    if ((!node->get_input_element_type(0).is_real() && !node->get_input_element_type(1).is_real()) || !node->get_output_element_type(0).is_real() ||
-            constPort == -1) {
+    if ((!node->get_input_element_type(0).is_real() && !node->get_input_element_type(1).is_real()) ||
+        !node->get_output_element_type(0).is_real() || constPort == -1) {
         return false;
     }
 
@@ -44,8 +44,7 @@ bool isConvertableToPowerStatic(const std::shared_ptr<BaseOp> &node) {
     if (input_rank.is_dynamic())
         return false;
     auto const_shape = node->get_input_shape(constPort);
-    return ov::shape_size(const_shape) == 1 &&
-           input_rank.get_length() >= static_cast<int64_t>(const_shape.size()) &&
+    return ov::shape_size(const_shape) == 1 && input_rank.get_length() >= static_cast<int64_t>(const_shape.size()) &&
            !ov::intel_cpu::one_of(node->get_input_node_shared_ptr(nonConstPort)->get_type_info(),
                                   ov::opset1::NormalizeL2::get_type_info_static(),
                                   ov::opset4::Interpolate::get_type_info_static(),
@@ -60,28 +59,35 @@ bool isConvertableToPowerStatic(const std::shared_ptr<BaseOp> &node) {
 }
 
 template <>
-bool isConvertableToPowerStatic(const std::shared_ptr<ov::opset1::Power> &node) {
+bool isConvertableToPowerStatic(const std::shared_ptr<ov::opset1::Power>& node) {
     auto input_rank = node->get_input_partial_shape(0).rank();
     if (input_rank.is_dynamic())
         return false;
-    auto const_node =  std::dynamic_pointer_cast<ov::opset1::Constant>(node->get_input_node_shared_ptr(1));
+    auto const_node = std::dynamic_pointer_cast<ov::opset1::Constant>(node->get_input_node_shared_ptr(1));
     return const_node &&
            input_rank.get_length() >= static_cast<ov::Dimension::value_type>(const_node->get_shape().size()) &&
            ov::shape_size(const_node->get_shape()) == 1;
 }
 
 template <class BaseOp>
-std::shared_ptr<ov::Node> convert(const std::shared_ptr<BaseOp> &node) {
+std::shared_ptr<ov::Node> convert(const std::shared_ptr<BaseOp>& node) {
     const int constPort = getConstPort(node);
     const int nonConstPort = 1 - constPort;
-    std::shared_ptr<ov::opset1::Constant> powerNode = std::dynamic_pointer_cast<ov::opset1::Constant>(node->get_input_node_shared_ptr(constPort));
+    std::shared_ptr<ov::opset1::Constant> powerNode =
+        std::dynamic_pointer_cast<ov::opset1::Constant>(node->get_input_node_shared_ptr(constPort));
     const float value = powerNode->cast_vector<float>()[0];
     if (std::is_same<BaseOp, ov::opset1::Power>::value) {
-        return std::make_shared<ov::intel_cpu::PowerStaticNode>(node->input(nonConstPort).get_source_output(), value, 1.0f, 0.0f,
-                                                               node->output(0).get_element_type());
+        return std::make_shared<ov::intel_cpu::PowerStaticNode>(node->input(nonConstPort).get_source_output(),
+                                                                value,
+                                                                1.0f,
+                                                                0.0f,
+                                                                node->output(0).get_element_type());
     } else if (std::is_same<BaseOp, ov::opset1::Add>::value) {
-        return std::make_shared<ov::intel_cpu::PowerStaticNode>(node->input(nonConstPort).get_source_output(), 1.0f, 1.0f, value,
-                                                               node->output(0).get_element_type());
+        return std::make_shared<ov::intel_cpu::PowerStaticNode>(node->input(nonConstPort).get_source_output(),
+                                                                1.0f,
+                                                                1.0f,
+                                                                value,
+                                                                node->output(0).get_element_type());
     } else if (std::is_same<BaseOp, ov::opset1::Subtract>::value) {
         float scale = 1.0f;
         float shift = value;
@@ -90,17 +96,23 @@ std::shared_ptr<ov::Node> convert(const std::shared_ptr<BaseOp> &node) {
         } else {
             shift *= -1.0f;
         }
-        return std::make_shared<ov::intel_cpu::PowerStaticNode>(node->input(nonConstPort).get_source_output(), 1.0f, scale, shift,
-                                                               node->output(0).get_element_type());
+        return std::make_shared<ov::intel_cpu::PowerStaticNode>(node->input(nonConstPort).get_source_output(),
+                                                                1.0f,
+                                                                scale,
+                                                                shift,
+                                                                node->output(0).get_element_type());
     } else if (std::is_same<BaseOp, ov::opset1::Multiply>::value) {
-        return std::make_shared<ov::intel_cpu::PowerStaticNode>(node->input(nonConstPort).get_source_output(), 1.f, value, 0.0f,
-                                                               node->output(0).get_element_type());
+        return std::make_shared<ov::intel_cpu::PowerStaticNode>(node->input(nonConstPort).get_source_output(),
+                                                                1.f,
+                                                                value,
+                                                                0.0f,
+                                                                node->output(0).get_element_type());
     } else {
         OPENVINO_THROW("ConvertToPowerStatic: op type is not supported");
     }
 }
 
-} // namespace
+}  // namespace
 
 ov::intel_cpu::ConvertToPowerStatic::ConvertToPowerStatic() {
     MATCHER_SCOPE(ConvertToPowerStatic);
@@ -118,7 +130,7 @@ ov::intel_cpu::ConvertToPowerStatic::ConvertToPowerStatic() {
     auto mult = ov::pass::pattern::wrap_type<ov::opset1::Multiply>(twoInputs, not_dequantization_or_decompression);
     const auto candidate = std::make_shared<ov::pass::pattern::op::Or>(ov::OutputVector{power, add, sub, mult});
 
-    ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher &m) {
+    ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) {
         auto node = m.get_match_root();
 
         std::shared_ptr<ov::Node> toReplace = node;
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_power_static.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_power_static.hpp
index c1d60ae9be19f0..d34a4c3667b5aa 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_power_static.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_power_static.hpp
@@ -9,11 +9,11 @@
 namespace ov {
 namespace intel_cpu {
 
-class ConvertToPowerStatic: public ov::pass::MatcherPass {
+class ConvertToPowerStatic : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("ConvertToPowerStatic", "0");
     ConvertToPowerStatic();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_swish_cpu.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_swish_cpu.cpp
index f0d3e66cb8ee21..af1bf8d9551a89 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_swish_cpu.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_swish_cpu.cpp
@@ -4,19 +4,18 @@
 
 #include "convert_to_swish_cpu.hpp"
 
-#include "openvino/opsets/opset4.hpp"
+#include "itt.hpp"
 #include "openvino/core/rt_info.hpp"
+#include "openvino/opsets/opset4.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "transformations/cpu_opset/common/op/swish_cpu.hpp"
 
-#include "itt.hpp"
-
 ov::intel_cpu::ConvertToSwishCPU::ConvertToSwishCPU() {
     MATCHER_SCOPE(ConvertToSwishCPU);
     auto swish = ov::pass::pattern::wrap_type<ov::opset4::Swish>();
 
     ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) {
-        auto swish = std::dynamic_pointer_cast<ov::opset4::Swish> (m.get_match_root());
+        auto swish = std::dynamic_pointer_cast<ov::opset4::Swish>(m.get_match_root());
         if (!swish) {
             return false;
         }
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_swish_cpu.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_swish_cpu.hpp
index 9ecba3d03cf733..3fe3569a13e745 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_swish_cpu.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_to_swish_cpu.hpp
@@ -9,11 +9,11 @@
 namespace ov {
 namespace intel_cpu {
 
-class ConvertToSwishCPU: public ov::pass::MatcherPass {
+class ConvertToSwishCPU : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("ConvertToSwishCPU", "0");
     ConvertToSwishCPU();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_integer_divide.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_integer_divide.cpp
index c96f756dbe336a..6e4eef050449df 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_integer_divide.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_integer_divide.cpp
@@ -2,31 +2,34 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "decompose_integer_divide.hpp"
-#include "openvino/opsets/opset1.hpp"
+
 #include "openvino/core/rt_info.hpp"
+#include "openvino/opsets/opset1.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
 DecomposeIntegerDivide::DecomposeIntegerDivide() {
-    register_matcher(std::make_shared<ov::pass::pattern::Matcher>(ov::pass::pattern::wrap_type<ov::opset1::Divide>(), "DecomposeIntegerDivide"),
-         [](ov::pass::pattern::Matcher& m) {
-             auto divide = std::dynamic_pointer_cast<ov::opset1::Divide>(m.get_match_root());
-             if (!divide) {
-                 return false;
-             }
-             if (!divide->get_element_type().is_integral_number()) {
-                 return false;
-             }
+    register_matcher(std::make_shared<ov::pass::pattern::Matcher>(ov::pass::pattern::wrap_type<ov::opset1::Divide>(),
+                                                                  "DecomposeIntegerDivide"),
+                     [](ov::pass::pattern::Matcher& m) {
+                         auto divide = std::dynamic_pointer_cast<ov::opset1::Divide>(m.get_match_root());
+                         if (!divide) {
+                             return false;
+                         }
+                         if (!divide->get_element_type().is_integral_number()) {
+                             return false;
+                         }
 
-             auto new_divide = std::make_shared<ov::opset1::Divide>(divide->input_value(0), divide->input_value(1));
-             auto new_floor = std::make_shared<ov::opset1::Floor>(new_divide);
-             new_floor->set_friendly_name(divide->get_friendly_name());
-             ov::copy_runtime_info(divide, new_floor);
-             ov::replace_node(divide, new_floor);
-             return true;
-         });
+                         auto new_divide =
+                             std::make_shared<ov::opset1::Divide>(divide->input_value(0), divide->input_value(1));
+                         auto new_floor = std::make_shared<ov::opset1::Floor>(new_divide);
+                         new_floor->set_friendly_name(divide->get_friendly_name());
+                         ov::copy_runtime_info(divide, new_floor);
+                         ov::replace_node(divide, new_floor);
+                         return true;
+                     });
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_integer_divide.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_integer_divide.hpp
index f1d65445571ff1..329febfcd21e92 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_integer_divide.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_integer_divide.hpp
@@ -3,17 +3,17 @@
 
 #pragma once
 
-#include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "openvino/pass/graph_rewrite.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
-class DecomposeIntegerDivide: public ov::pass::MatcherPass {
+class DecomposeIntegerDivide : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("DecomposeIntegerDivide", "0");
     DecomposeIntegerDivide();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_rms_norm.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_rms_norm.cpp
index 6f135139d9a148..c952b28285d89d 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_rms_norm.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_rms_norm.cpp
@@ -2,11 +2,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "decompose_rms_norm.hpp"
+
 #include "itt.hpp"
-#include "openvino/opsets/opset10.hpp"
 #include "openvino/core/rt_info.hpp"
-#include "ov_ops/rms.hpp"
+#include "openvino/opsets/opset10.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "ov_ops/rms.hpp"
 #include "transformations/utils/utils.hpp"
 
 namespace ov {
@@ -18,8 +19,8 @@ DecomposeRMSNorm::DecomposeRMSNorm() {
 
     matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
         auto& pattern_to_output = m.get_pattern_value_map();
-        auto node = std::dynamic_pointer_cast<ov::op::internal::RMS>(
-            pattern_to_output.at(pattern_node).get_node_shared_ptr());
+        auto node =
+            std::dynamic_pointer_cast<ov::op::internal::RMS>(pattern_to_output.at(pattern_node).get_node_shared_ptr());
 
         if (node == nullptr || transformation_callback(node)) {
             return false;
@@ -48,5 +49,5 @@ DecomposeRMSNorm::DecomposeRMSNorm() {
     register_matcher(m, callback);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_rms_norm.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_rms_norm.hpp
index 33ad0346dd6c27..f11a3afa23d20c 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_rms_norm.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/decompose_rms_norm.hpp
@@ -3,17 +3,17 @@
 
 #pragma once
 
-#include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "openvino/pass/graph_rewrite.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
-class DecomposeRMSNorm: public ov::pass::MatcherPass {
+class DecomposeRMSNorm : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("DecomposeRMSNorm", "0");
     DecomposeRMSNorm();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/fc_bias_fusion.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/fc_bias_fusion.hpp
index b21cf80ad327e6..d1e64969fbcf4e 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/fc_bias_fusion.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/fc_bias_fusion.hpp
@@ -15,5 +15,5 @@ class FullyConnectedBiasFusion : public ov::pass::MatcherPass {
     FullyConnectedBiasFusion();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/insert_convert_after_extension.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/insert_convert_after_extension.cpp
index 2b63c749d790f3..7d35af9d2d48f2 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/insert_convert_after_extension.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/insert_convert_after_extension.cpp
@@ -4,9 +4,9 @@
 
 #include "insert_convert_after_extension.hpp"
 
-#include "openvino/op/convert.hpp"
 #include "cpu_types.h"
 #include "itt.hpp"
+#include "openvino/op/convert.hpp"
 #include "transformations/utils/utils.hpp"
 
 ov::pass::InsertConvertAfterExtension::InsertConvertAfterExtension(bool convert_output_precision) {
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/insert_convert_after_extension.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/insert_convert_after_extension.hpp
index 06048de3f79443..49cfab68bc6911 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/insert_convert_after_extension.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/insert_convert_after_extension.hpp
@@ -12,7 +12,7 @@ namespace pass {
 // This pass inserts explicit Convert on Extension operation outputs for hard-coded list of precisions.
 // Supported cases: I64/U64 -> I32.
 
-class InsertConvertAfterExtension: public ov::pass::MatcherPass {
+class InsertConvertAfterExtension : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("InsertConvertAfterExtension", "0");
     InsertConvertAfterExtension(bool convert_output_precision = true);
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/move_fc_reshape_to_weights.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/move_fc_reshape_to_weights.cpp
index 18a54dc45e173f..54326fed49d76a 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/move_fc_reshape_to_weights.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/move_fc_reshape_to_weights.cpp
@@ -2,20 +2,20 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "ov_ops/fully_connected.hpp"
 #include "move_fc_reshape_to_weights.hpp"
-#include <transformations/utils/utils.hpp>
-#include <openvino/pass/pattern/op/wrap_type.hpp>
-#include <openvino/pass/pattern/op/or.hpp>
 
 #include <openvino/op/constant.hpp>
 #include <openvino/op/convert.hpp>
-#include <openvino/op/subtract.hpp>
 #include <openvino/op/multiply.hpp>
-#include <openvino/op/transpose.hpp>
 #include <openvino/op/reshape.hpp>
+#include <openvino/op/subtract.hpp>
+#include <openvino/op/transpose.hpp>
+#include <openvino/pass/pattern/op/or.hpp>
+#include <openvino/pass/pattern/op/wrap_type.hpp>
+#include <transformations/utils/utils.hpp>
 
 #include "itt.hpp"
+#include "ov_ops/fully_connected.hpp"
 
 ov::intel_cpu::MoveFCReshapeToWeights::MoveFCReshapeToWeights() {
     MATCHER_SCOPE(MoveFCReshapeToWeights);
@@ -33,7 +33,8 @@ ov::intel_cpu::MoveFCReshapeToWeights::MoveFCReshapeToWeights() {
     auto subtract_wo_convert_m = wrap_type<ov::op::v1::Subtract>({convert_m, sub_const_m}, consumers_count(1));
     auto sub_convert = wrap_type<ov::op::v0::Convert>({sub_const_m}, consumers_count(1));
     auto subtract_w_convert_m = wrap_type<ov::op::v1::Subtract>({convert_m, sub_convert}, consumers_count(1));
-    auto subtract_m = std::make_shared<ov::pass::pattern::op::Or>(OutputVector{subtract_wo_convert_m, subtract_w_convert_m});
+    auto subtract_m =
+        std::make_shared<ov::pass::pattern::op::Or>(OutputVector{subtract_wo_convert_m, subtract_w_convert_m});
 
     auto mul_const_m = wrap_type<ov::op::v0::Constant>(consumers_count(1));
     auto mul_with_sub_m = wrap_type<ov::op::v1::Multiply>({subtract_m, mul_const_m}, one_consumer_rank_equals(3));
@@ -56,7 +57,8 @@ ov::intel_cpu::MoveFCReshapeToWeights::MoveFCReshapeToWeights() {
         const auto weights_path = fully_connected->get_input_node_shared_ptr(1);
         const bool with_transpose = ov::is_type<ov::op::v1::Transpose>(weights_path);
         if (with_transpose) {
-            const auto transpose_const = ov::as_type_ptr<ov::op::v0::Constant>(weights_path->get_input_node_shared_ptr(1));
+            const auto transpose_const =
+                ov::as_type_ptr<ov::op::v0::Constant>(weights_path->get_input_node_shared_ptr(1));
             if (transpose_const->cast_vector<int>() != std::vector<int>{1, 0}) {
                 return false;
             }
@@ -75,7 +77,9 @@ ov::intel_cpu::MoveFCReshapeToWeights::MoveFCReshapeToWeights() {
 
             const auto comparison_start_pos = expected_shape.size() - node_shape.size();
             return std::equal(node_shape.begin(), node_shape.end(), expected_shape.begin() + comparison_start_pos) ||
-                   std::all_of(node_shape.cbegin(), node_shape.cend(), [](int dim) { return dim == 1; });
+                   std::all_of(node_shape.cbegin(), node_shape.cend(), [](int dim) {
+                       return dim == 1;
+                   });
         };
 
         const auto mul = reshape->get_input_node_shared_ptr(0);
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/move_fc_reshape_to_weights.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/move_fc_reshape_to_weights.hpp
index 08017b4b49cd8a..0af0469ce0135e 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/move_fc_reshape_to_weights.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/move_fc_reshape_to_weights.hpp
@@ -10,16 +10,11 @@ namespace ov {
 namespace intel_cpu {
 
 /**
- * This transformation is applied to the FC with compressed 3D u8 weights. It moves Reshape at the weights path to the constants
- * in order to constant fold the Reshape node.
- * Example:
- *                    Weights(3D)   Subtract_const(3D)                       Weights(2D)   Subtract_const(2D)
- *                       |             /                                        |             /
- *                    Convert    Subtract_convert(opt)                       Convert    Subtract_convert(opt)
- *                       |      /                                               |      /
- *                   Subtract(opt)                                          Subtract(opt)
- *                       |      Multiply_const(3D)        ====>                 |      Multiply_const(2D)
- *                       |     /                                                |     /
+ * This transformation is applied to the FC with compressed 3D u8 weights. It moves Reshape at the weights path to the
+ * constants in order to constant fold the Reshape node. Example: Weights(3D)   Subtract_const(3D) Weights(2D)
+ * Subtract_const(2D) |             /                                        |             / Convert
+ * Subtract_convert(opt)                       Convert    Subtract_convert(opt) |      / |      / Subtract(opt)
+ * Subtract(opt) |      Multiply_const(3D)        ====>                 |      Multiply_const(2D) |     / |     /
  *                    Multiply                                               Multiply
  *                       |                                                      |
  *                    Reshape(2D)                                               |
@@ -28,11 +23,11 @@ namespace intel_cpu {
  *             \     /                                                \     /
  *         FullyConnected                                         FullyConnected
  */
-class MoveFCReshapeToWeights: public ov::pass::MatcherPass {
+class MoveFCReshapeToWeights : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("MoveFCReshapeToWeights", "0");
     MoveFCReshapeToWeights();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/ngram_fusion.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/ngram_fusion.cpp
index ed1e82c8c29e49..988ed3f852d142 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/ngram_fusion.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/ngram_fusion.cpp
@@ -3,15 +3,16 @@
 //
 
 #include "ngram_fusion.hpp"
-#include "transformations/cpu_opset/common/op/ngram.hpp"
-#include "openvino/opsets/opset1.hpp"
-#include <openvino/opsets/opset10.hpp>
-#include <openvino/core/graph_util.hpp>
+
 #include <openvino/core/dimension.hpp>
-#include <openvino/pass/pattern/op/wrap_type.hpp>
+#include <openvino/core/graph_util.hpp>
+#include <openvino/opsets/opset10.hpp>
 #include <openvino/pass/pattern/op/or.hpp>
+#include <openvino/pass/pattern/op/wrap_type.hpp>
 #include <transformations/utils/utils.hpp>
 
+#include "openvino/opsets/opset1.hpp"
+#include "transformations/cpu_opset/common/op/ngram.hpp"
 #include "transformations/itt.hpp"
 
 using namespace ov::pass::pattern;
@@ -53,10 +54,12 @@ ov::intel_cpu::NgramFusion::NgramFusion() {
         };
 
         auto tokens_match = [](ov::Output<ov::Node> output) -> bool {
-            return ov::pass::pattern::rank_equals(2)(output) && ov::pass::pattern::type_matches(ov::element::f32)(output);
+            return ov::pass::pattern::rank_equals(2)(output) &&
+                   ov::pass::pattern::type_matches(ov::element::f32)(output);
         };
         auto idces_match = [](ov::Output<ov::Node> output) -> bool {
-            return ov::pass::pattern::rank_equals(2)(output) && ov::pass::pattern::type_matches(ov::element::i32)(output);
+            return ov::pass::pattern::rank_equals(2)(output) &&
+                   ov::pass::pattern::type_matches(ov::element::i32)(output);
         };
         auto as_is_cropped_shape_match = [](ov::Output<ov::Node> output) -> bool {
             const auto& symbols = output.get_tensor().get_value_symbol();
@@ -76,9 +79,9 @@ ov::intel_cpu::NgramFusion::NgramFusion() {
             auto padded_tokens_m = wrap_type<Concat>(padded_tokens_inputs);
             auto cropped_shape_m = any_input(as_is_cropped_shape_match);
             auto ss_bias = wrap_type<Constant>();
-            auto ss_biased_shape_m =
-                as_is_idx == 0 ? cropped_shape_m : wrap_type<Add>({cropped_shape_m, ss_bias});
-            auto cropped_tokens_m = wrap_type<StridedSlice>({padded_tokens_m, wrap_type<Constant>(), ss_biased_shape_m, wrap_type<Constant>()});
+            auto ss_biased_shape_m = as_is_idx == 0 ? cropped_shape_m : wrap_type<Add>({cropped_shape_m, ss_bias});
+            auto cropped_tokens_m = wrap_type<StridedSlice>(
+                {padded_tokens_m, wrap_type<Constant>(), ss_biased_shape_m, wrap_type<Constant>()});
             Matcher matcher(cropped_tokens_m);
 
             if (!matcher.match(inputs[as_is_idx])) {
@@ -92,9 +95,10 @@ ov::intel_cpu::NgramFusion::NgramFusion() {
 
             // To confirm that a subgraph can be replaced with NgramNode we only need to
             // 1. Check Add's constant to make sure that data values have a right bias in result tensor
-            // 2. Check subgraph input and output shapes to make sure that all rest constants in the subgraph are correct
-            if (!check_bias(pattern_map, ss_bias, as_is_idx) ||
-                concat_shape.rank() != tokens_shape.rank() || tokens_shape[1] * k != concat_shape[1]) {
+            // 2. Check subgraph input and output shapes to make sure that all rest constants in the subgraph are
+            // correct
+            if (!check_bias(pattern_map, ss_bias, as_is_idx) || concat_shape.rank() != tokens_shape.rank() ||
+                tokens_shape[1] * k != concat_shape[1]) {
                 return false;
             }
             // save symbol of cropped_shape and check it against first dimension of tokens shape
@@ -105,11 +109,13 @@ ov::intel_cpu::NgramFusion::NgramFusion() {
 
         auto cropped_shape_symbol_match = [cropped_shape_symbol](ov::Output<ov::Node> output) -> bool {
             const auto& symbols = output.get_tensor().get_value_symbol();
-            return ov::pass::pattern::rank_equals(1)(output) && !symbols.empty() && ov::symbol::are_equal(symbols[0], cropped_shape_symbol);
+            return ov::pass::pattern::rank_equals(1)(output) && !symbols.empty() &&
+                   ov::symbol::are_equal(symbols[0], cropped_shape_symbol);
         };
 
         auto tokens_symbol_match = [tokens_match, cropped_shape_symbol](ov::Output<ov::Node> output) -> bool {
-            return tokens_match(output) && symbol::are_equal(output.get_partial_shape()[0].get_symbol(), cropped_shape_symbol);
+            return tokens_match(output) &&
+                   symbol::are_equal(output.get_partial_shape()[0].get_symbol(), cropped_shape_symbol);
         };
 
         ov::Output<ov::Node> indices;
@@ -120,8 +126,8 @@ ov::intel_cpu::NgramFusion::NgramFusion() {
             auto cropped_shape_m = any_input(cropped_shape_symbol_match);
             auto idces_m = any_input(idces_match);
             auto idces_concat_inputs = as_is_idx == 0
-                                            ? ov::OutputVector{idces_m, wrap_type<Constant>()}
-                                            : ov::OutputVector{wrap_type<Constant>(), idces_m, wrap_type<Constant>()};
+                                           ? ov::OutputVector{idces_m, wrap_type<Constant>()}
+                                           : ov::OutputVector{wrap_type<Constant>(), idces_m, wrap_type<Constant>()};
             auto idces_concat_m = wrap_type<Concat>(idces_concat_inputs);
 
             // Concat can be replaced by symbolic optimizations as it can find alternative source for this op.
@@ -139,7 +145,8 @@ ov::intel_cpu::NgramFusion::NgramFusion() {
             auto idxes_crop_left_concat_m = std::make_shared<ov::pass::pattern::op::Or>(
                 ov::OutputVector{wrap_type<Concat>({crop_left_cropped_shape_m, wrap_type<Constant>()}),
                                  any_input(concat_shape_with_cropped_symbol_m)});
-            auto idxes_crop_left_m = wrap_type<StridedSlice>({idces_concat_m, wrap_type<Constant>(), idxes_crop_left_concat_m, wrap_type<Constant>()});
+            auto idxes_crop_left_m = wrap_type<StridedSlice>(
+                {idces_concat_m, wrap_type<Constant>(), idxes_crop_left_concat_m, wrap_type<Constant>()});
 
             // right equal branch
             auto crop_right_bias_m = wrap_type<Constant>();
@@ -163,11 +170,13 @@ ov::intel_cpu::NgramFusion::NgramFusion() {
             auto then_cropped_shape_bias_m = wrap_type<Constant>();
             auto then_cropped_shape_m = std::make_shared<ov::pass::pattern::op::Or>(
                 ov::OutputVector{wrap_type<Add>({cropped_shape_m, then_cropped_shape_bias_m}), cropped_shape_m});
-            auto then_m = wrap_type<StridedSlice>({padded_tokens_m, wrap_type<Constant>(), then_cropped_shape_m, wrap_type<Constant>()});
+            auto then_m = wrap_type<StridedSlice>(
+                {padded_tokens_m, wrap_type<Constant>(), then_cropped_shape_m, wrap_type<Constant>()});
 
             // else branch
             auto else_target_shape_concat_m = any_input(concat_shape_with_cropped_symbol_m);
-            auto else_m = wrap_type<Broadcast>({wrap_type<Constant>(), else_target_shape_concat_m, wrap_type<Constant>()});
+            auto else_m =
+                wrap_type<Broadcast>({wrap_type<Constant>(), else_target_shape_concat_m, wrap_type<Constant>()});
             auto select_m = wrap_type<Select>({condition_m, then_m, else_m});
             Matcher select_matcher(select_m);
 
@@ -189,10 +198,12 @@ ov::intel_cpu::NgramFusion::NgramFusion() {
                 // 1. Check that "tokens" input is equal to the input that was matched earlier
                 // 2. Check that "indices" input for all Select branches is the same
                 // 3. Check Add's constants to make sure that data values have a right bias in result tensor
-                const bool validate_eq_biases = (check_bias(pattern_map, crop_left_bias_m, i) && check_bias(pattern_map, crop_right_bias_m, as_is_idx)) ||
-                                                (check_bias(pattern_map, crop_right_bias_m, i) && check_bias(pattern_map, crop_left_bias_m, as_is_idx));
-                if (cur_tokens_input != tokens || cur_indices_input != indices ||
-                    !validate_eq_biases || !check_bias(pattern_map, then_cropped_shape_bias_m, i)) {
+                const bool validate_eq_biases = (check_bias(pattern_map, crop_left_bias_m, i) &&
+                                                 check_bias(pattern_map, crop_right_bias_m, as_is_idx)) ||
+                                                (check_bias(pattern_map, crop_right_bias_m, i) &&
+                                                 check_bias(pattern_map, crop_left_bias_m, as_is_idx));
+                if (cur_tokens_input != tokens || cur_indices_input != indices || !validate_eq_biases ||
+                    !check_bias(pattern_map, then_cropped_shape_bias_m, i)) {
                     return false;
                 }
             }
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/ngram_fusion.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/ngram_fusion.hpp
index 44e21984981bbc..a90487391b32ac 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/ngram_fusion.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/ngram_fusion.hpp
@@ -9,11 +9,11 @@
 namespace ov {
 namespace intel_cpu {
 
-class NgramFusion: public ov::pass::MatcherPass {
+class NgramFusion : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("NgramFusion", "0");
     NgramFusion();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/permute_slice_n_interpolation.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/permute_slice_n_interpolation.cpp
index 40af7e5822784d..5b77617872e5f2 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/permute_slice_n_interpolation.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/permute_slice_n_interpolation.cpp
@@ -4,38 +4,37 @@
 
 #include "permute_slice_n_interpolation.hpp"
 
+#include "itt.hpp"
 #include "openvino/core/rt_info.hpp"
 #include "openvino/op/interpolate.hpp"
 #include "openvino/op/slice.hpp"
 #include "openvino/op/transpose.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
-
-#include "itt.hpp"
 #include "utils/general_utils.h"
 
-
 namespace ov {
 
 intel_cpu::PermuteSliceAndInterpolation::PermuteSliceAndInterpolation() {
     MATCHER_SCOPE(PermuteSliceAndInterpolation);
 
-    element::TypeVector param_precisions{ element::i8, element::u8 };
+    element::TypeVector param_precisions{element::i8, element::u8};
     auto input_m = pass::pattern::wrap_type<op::v0::Parameter>(pass::pattern::type_matches_any(param_precisions));
     auto const_m = pass::pattern::wrap_type<op::v0::Constant>();
-    auto slice_m = pass::pattern::wrap_type<op::v8::Slice>({input_m, const_m, const_m, const_m, const_m}, ov::pass::pattern::consumers_count(1));
-    auto transpose_m = pass::pattern::wrap_type<op::v1::Transpose>({slice_m, const_m}, ov::pass::pattern::consumers_count(1));
-    auto interpolate_m = pass::pattern::wrap_type<op::v0::Interpolate,
-                                                  op::v4::Interpolate,
-                                                  op::v11::Interpolate>({transpose_m, const_m, const_m, const_m},
-                                                  pass::pattern::consumers_count(1));
+    auto slice_m = pass::pattern::wrap_type<op::v8::Slice>({input_m, const_m, const_m, const_m, const_m},
+                                                           ov::pass::pattern::consumers_count(1));
+    auto transpose_m =
+        pass::pattern::wrap_type<op::v1::Transpose>({slice_m, const_m}, ov::pass::pattern::consumers_count(1));
+    auto interpolate_m = pass::pattern::wrap_type<op::v0::Interpolate, op::v4::Interpolate, op::v11::Interpolate>(
+        {transpose_m, const_m, const_m, const_m},
+        pass::pattern::consumers_count(1));
 
     matcher_pass_callback callback = [=](pass::pattern::Matcher& m) {
         const auto& pattern_map = m.get_pattern_value_map();
 
         const auto& input = pattern_map.at(input_m);
-        auto interpolate  = pattern_map.at(interpolate_m).get_node_shared_ptr();
-        auto transpose    = pattern_map.at(transpose_m).get_node_shared_ptr();
-        auto slice        = pattern_map.at(slice_m).get_node_shared_ptr();
+        auto interpolate = pattern_map.at(interpolate_m).get_node_shared_ptr();
+        auto transpose = pattern_map.at(transpose_m).get_node_shared_ptr();
+        auto slice = pattern_map.at(slice_m).get_node_shared_ptr();
 
         // Check Slice axes
         auto in_rank = slice->get_input_partial_shape(0).rank();
@@ -46,14 +45,15 @@ intel_cpu::PermuteSliceAndInterpolation::PermuteSliceAndInterpolation() {
         if (axes[0] < 0L) {
             axes[0] += in_rank.get_length();
         }
-        if (!one_of(in_rank.get_length(), 3L, 4L, 5L)
-                || axes.size() != 1L
-                || axes[0] != (in_rank.get_length() - 1L)) {
+        if (!one_of(in_rank.get_length(), 3L, 4L, 5L) || axes.size() != 1L || axes[0] != (in_rank.get_length() - 1L)) {
             return false;
         }
         // Check Transpose order
         auto order = (as_type<op::v0::Constant>(transpose->get_input_node_ptr(1)))->cast_vector<int64_t>();
-        if (!one_of(order, std::vector<int64_t>{0, 2, 1}, std::vector<int64_t>{0, 3, 1, 2}, std::vector<int64_t>{0, 4, 1, 2, 3})) {
+        if (!one_of(order,
+                    std::vector<int64_t>{0, 2, 1},
+                    std::vector<int64_t>{0, 3, 1, 2},
+                    std::vector<int64_t>{0, 4, 1, 2, 3})) {
             return false;
         }
 
@@ -84,4 +84,4 @@ intel_cpu::PermuteSliceAndInterpolation::PermuteSliceAndInterpolation() {
     register_matcher(m, callback);
 }
 
-} // namespace ov
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/permute_slice_n_interpolation.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/permute_slice_n_interpolation.hpp
index 3c7994ac765f59..bbca2449a473af 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/permute_slice_n_interpolation.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/permute_slice_n_interpolation.hpp
@@ -18,5 +18,5 @@ class PermuteSliceAndInterpolation : public ov::pass::MatcherPass {
     PermuteSliceAndInterpolation();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/rnn_sequences_optimization.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/rnn_sequences_optimization.cpp
index 916e7b21ffa484..236f6c79fef406 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/rnn_sequences_optimization.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/rnn_sequences_optimization.cpp
@@ -4,89 +4,92 @@
 
 #include "rnn_sequences_optimization.hpp"
 
-#include "openvino/opsets/opset1.hpp"
 #include <openvino/opsets/opset5.hpp>
 #include <openvino/opsets/opset8.hpp>
-#include "openvino/pass/pattern/op/wrap_type.hpp"
-#include "openvino/core/rt_info.hpp"
 #include <transformations/utils/utils.hpp>
 
 #include "itt.hpp"
+#include "openvino/core/rt_info.hpp"
+#include "openvino/opsets/opset1.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
 
 namespace {
-    int64_t getSeqAxis(const std::shared_ptr<ov::Node>& sequenceOp) {
-        // Optimization.
-        // Plug-ins support seqAxis attribute (value 1 or 0) for Seq ops, but according to the spec we don't
-        // support this attribute and should insert Transpose layer before and after Seq op in TI to Sequences
-        // transformation. Additional Transpose layers affect the performance, so we try to detect pattern
-        // Transpose(axis_order={1,0,2}) -> Seq -> Transpose(axis_order={2,1,0,3}
-        // and replace unnecessary Transpose ops with SeqIE (seqAxis = 0) to transfer value
-        // of the attribute to plug-ins.
-        // todo: specify seqAxis attribute for Sequence ops.
-        int64_t seqAxis = 1; // default
-        const auto& target_inputs = sequenceOp->get_output_target_inputs(0);
-        if (target_inputs.size() == 1) {
-            const auto transpose_before = ov::as_type_ptr<ov::opset1::Transpose>(sequenceOp->get_input_node_shared_ptr(0));
-            const auto transpose_after = ov::as_type_ptr<ov::opset1::Transpose>(target_inputs.begin()->get_node()->shared_from_this());
-
-            if (transpose_after && transpose_before) {
-                auto order_before = ov::as_type_ptr<ov::opset1::Constant>(transpose_before->get_input_node_shared_ptr(1));
-                auto order_after = ov::as_type_ptr<ov::opset1::Constant>(transpose_after->get_input_node_shared_ptr(1));
-                if (order_before && order_after) {
-                    auto order_before_values = order_before->cast_vector<int64_t>();
-                    auto order_after_values = order_after->cast_vector<int64_t>();
-                    std::vector<int64_t> order_ref_before = {1, 0, 2};
-                    std::vector<int64_t> order_ref_after = {2, 1, 0, 3};
-                    if (order_before_values == order_ref_before && order_after_values == order_ref_after) {
-                        seqAxis = 0;
-                    }
+int64_t getSeqAxis(const std::shared_ptr<ov::Node>& sequenceOp) {
+    // Optimization.
+    // Plug-ins support seqAxis attribute (value 1 or 0) for Seq ops, but according to the spec we don't
+    // support this attribute and should insert Transpose layer before and after Seq op in TI to Sequences
+    // transformation. Additional Transpose layers affect the performance, so we try to detect pattern
+    // Transpose(axis_order={1,0,2}) -> Seq -> Transpose(axis_order={2,1,0,3}
+    // and replace unnecessary Transpose ops with SeqIE (seqAxis = 0) to transfer value
+    // of the attribute to plug-ins.
+    // todo: specify seqAxis attribute for Sequence ops.
+    int64_t seqAxis = 1;  // default
+    const auto& target_inputs = sequenceOp->get_output_target_inputs(0);
+    if (target_inputs.size() == 1) {
+        const auto transpose_before = ov::as_type_ptr<ov::opset1::Transpose>(sequenceOp->get_input_node_shared_ptr(0));
+        const auto transpose_after =
+            ov::as_type_ptr<ov::opset1::Transpose>(target_inputs.begin()->get_node()->shared_from_this());
+
+        if (transpose_after && transpose_before) {
+            auto order_before = ov::as_type_ptr<ov::opset1::Constant>(transpose_before->get_input_node_shared_ptr(1));
+            auto order_after = ov::as_type_ptr<ov::opset1::Constant>(transpose_after->get_input_node_shared_ptr(1));
+            if (order_before && order_after) {
+                auto order_before_values = order_before->cast_vector<int64_t>();
+                auto order_after_values = order_after->cast_vector<int64_t>();
+                std::vector<int64_t> order_ref_before = {1, 0, 2};
+                std::vector<int64_t> order_ref_after = {2, 1, 0, 3};
+                if (order_before_values == order_ref_before && order_after_values == order_ref_after) {
+                    seqAxis = 0;
                 }
             }
         }
-        return seqAxis;
     }
+    return seqAxis;
+}
 
-    bool transform(const std::shared_ptr<ov::Node>& sequenceOp) {
-        // Detect pattern: Transpose_before -> Seq -> Transpose_after
-        auto seqAxis = getSeqAxis(sequenceOp);
-        if (seqAxis == 0) {
-            ov::Output<ov::Node> in_0 = sequenceOp->get_input_node_shared_ptr(0)->input_value(0);
-
-            auto shapeBeforeTranspose = ov::op::util::make_try_fold<ov::opset1::ShapeOf>(in_0);
-            auto newInShape = ov::op::util::make_try_fold<ov::opset8::Gather>(shapeBeforeTranspose,
-                ov::opset1::Constant::create(ov::element::i32, { 3 }, { 1, 0, 2 }),
-                ov::opset1::Constant::create(ov::element::i32, {}, { 0 }));
-            auto reshape1 = std::make_shared<ov::opset1::Reshape>(in_0, newInShape, false);
-            ov::copy_runtime_info(sequenceOp->get_input_node_shared_ptr(0), reshape1);
-            ov::replace_node(sequenceOp->get_input_node_shared_ptr(0), reshape1);
-
-            const auto &seqTargetInputs = sequenceOp->get_output_target_inputs(0);
-            if (seqTargetInputs.empty())
-                return false;
-            auto transposeAfter = seqTargetInputs.begin()->get_node()->shared_from_this();
-
-            auto lstmOutShape = ov::op::util::make_try_fold<ov::opset1::ShapeOf>(sequenceOp->output(0));
-            auto newOutShape = ov::op::util::make_try_fold<ov::opset8::Gather>(lstmOutShape,
-                ov::opset1::Constant::create(ov::element::i32, { 4 }, { 2, 1, 0, 3 }),
-                ov::opset1::Constant::create(ov::element::i32, {}, { 0 }));
-
-            auto reshape2 = std::make_shared<ov::opset1::Reshape>(sequenceOp->output(0), newOutShape, false);
-            reshape2->set_friendly_name(transposeAfter->get_friendly_name());
-            ov::copy_runtime_info(transposeAfter, reshape2);
-            ov::replace_node(transposeAfter, reshape2);
-        }
+bool transform(const std::shared_ptr<ov::Node>& sequenceOp) {
+    // Detect pattern: Transpose_before -> Seq -> Transpose_after
+    auto seqAxis = getSeqAxis(sequenceOp);
+    if (seqAxis == 0) {
+        ov::Output<ov::Node> in_0 = sequenceOp->get_input_node_shared_ptr(0)->input_value(0);
+
+        auto shapeBeforeTranspose = ov::op::util::make_try_fold<ov::opset1::ShapeOf>(in_0);
+        auto newInShape = ov::op::util::make_try_fold<ov::opset8::Gather>(
+            shapeBeforeTranspose,
+            ov::opset1::Constant::create(ov::element::i32, {3}, {1, 0, 2}),
+            ov::opset1::Constant::create(ov::element::i32, {}, {0}));
+        auto reshape1 = std::make_shared<ov::opset1::Reshape>(in_0, newInShape, false);
+        ov::copy_runtime_info(sequenceOp->get_input_node_shared_ptr(0), reshape1);
+        ov::replace_node(sequenceOp->get_input_node_shared_ptr(0), reshape1);
+
+        const auto& seqTargetInputs = sequenceOp->get_output_target_inputs(0);
+        if (seqTargetInputs.empty())
+            return false;
+        auto transposeAfter = seqTargetInputs.begin()->get_node()->shared_from_this();
+
+        auto lstmOutShape = ov::op::util::make_try_fold<ov::opset1::ShapeOf>(sequenceOp->output(0));
+        auto newOutShape = ov::op::util::make_try_fold<ov::opset8::Gather>(
+            lstmOutShape,
+            ov::opset1::Constant::create(ov::element::i32, {4}, {2, 1, 0, 3}),
+            ov::opset1::Constant::create(ov::element::i32, {}, {0}));
+
+        auto reshape2 = std::make_shared<ov::opset1::Reshape>(sequenceOp->output(0), newOutShape, false);
+        reshape2->set_friendly_name(transposeAfter->get_friendly_name());
+        ov::copy_runtime_info(transposeAfter, reshape2);
+        ov::replace_node(transposeAfter, reshape2);
+    }
 
-        sequenceOp->get_rt_info()["seqAxis"] = seqAxis;
+    sequenceOp->get_rt_info()["seqAxis"] = seqAxis;
 
-        return true;
-    }
-} // namespace
+    return true;
+}
+}  // namespace
 
 ov::intel_cpu::OptimizeGRUSequenceTransposes::OptimizeGRUSequenceTransposes() {
     MATCHER_SCOPE(OptimizeGRUSequenceTransposes);
     auto gruSequenceNgraph = ov::pass::pattern::wrap_type<ov::opset5::GRUSequence>();
 
-    ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher &m) {
+    ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) {
         auto gruSequence = ov::as_type_ptr<ov::opset5::GRUSequence>(m.get_match_root());
         if (!gruSequence) {
             return false;
@@ -106,7 +109,7 @@ ov::intel_cpu::OptimizeRNNSequenceTransposes::OptimizeRNNSequenceTransposes() {
     MATCHER_SCOPE(OptimizeRNNSequenceTransposes);
     auto rnnSequenceNgraph = ov::pass::pattern::wrap_type<ov::opset5::RNNSequence>();
 
-    ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher &m) {
+    ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) {
         auto rnnSequence = ov::as_type_ptr<ov::opset5::RNNSequence>(m.get_match_root());
         if (!rnnSequence) {
             return false;
@@ -126,7 +129,7 @@ ov::intel_cpu::OptimizeLSTMSequenceTransposes::OptimizeLSTMSequenceTransposes()
     MATCHER_SCOPE(OptimizeLSTMSequenceTransposes);
     auto lstmSequenceNgraph = ov::pass::pattern::wrap_type<ov::opset5::LSTMSequence>();
 
-    ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher &m) {
+    ov::matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) {
         auto checkSequence = [](const std::shared_ptr<ov::Node>& node) {
             if (auto lstm5 = ov::as_type_ptr<ov::opset5::LSTMSequence>(node)) {
                 return lstm5->get_direction() != ov::op::RecurrentSequenceDirection::BIDIRECTIONAL;
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/rnn_sequences_optimization.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/rnn_sequences_optimization.hpp
index d7a2ced08e1745..d7bfd28f0db80d 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/rnn_sequences_optimization.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/rnn_sequences_optimization.hpp
@@ -33,5 +33,5 @@ class OptimizeSequenceTransposes : public ov::pass::GraphRewrite {
     OptimizeSequenceTransposes();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/stateful_sdpa_fusion.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/stateful_sdpa_fusion.cpp
index c2765b889c636c..0ec2049d1ccc1c 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/stateful_sdpa_fusion.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/stateful_sdpa_fusion.cpp
@@ -9,16 +9,16 @@
 #include <cstdint>
 #include <limits>
 #include <openvino/core/rt_info.hpp>
-#include "openvino/opsets/opset1.hpp"
 #include <openvino/opsets/opset13.hpp>
 #include <openvino/opsets/opset6.hpp>
 #include <openvino/opsets/opset8.hpp>
 #include <openvino/pass/pattern/op/or.hpp>
 #include <openvino/pass/pattern/op/wrap_type.hpp>
-#include <transformations/utils/utils.hpp>
 #include <transformations/utils/gen_pattern.hpp>
+#include <transformations/utils/utils.hpp>
 
 #include "itt.hpp"
+#include "openvino/opsets/opset1.hpp"
 #include "ov_ops/type_relaxed.hpp"
 #include "transformations/cpu_opset/common/op/sdpa.hpp"
 using namespace ov::gen_pattern;
@@ -60,7 +60,7 @@ StatefulSDPAFusion::StatefulSDPAFusion() {
         auto reshape_kv = wrap_type<opset6::Reshape>({kv, any_input()});
         auto unsqueeze_kv = makePattern<opset1::Unsqueeze>({kv, any_input()});
 
-        auto check_one = [] (Output<Node> output) -> bool {
+        auto check_one = [](Output<Node> output) -> bool {
             auto node = std::dynamic_pointer_cast<opset1::Constant>(output.get_node_shared_ptr());
             const auto& bcst_arg = node->cast_vector<float>();
             return std::all_of(bcst_arg.begin(), bcst_arg.end(), [](float i) {
@@ -69,8 +69,9 @@ StatefulSDPAFusion::StatefulSDPAFusion() {
         };
         auto constant_bcst = wrap_type<opset1::Constant>(check_one);
 
-        auto computed_bcst = makePattern<opset1::Broadcast>({wrap_type<opset1::Constant>(check_one),
-            any_input(), any_input()}, {{"mode", "numpy"}});
+        auto computed_bcst =
+            makePattern<opset1::Broadcast>({wrap_type<opset1::Constant>(check_one), any_input(), any_input()},
+                                           {{"mode", "numpy"}});
 
         auto multiply_kv = wrap_type<opset6::Multiply>({reshape_kv | unsqueeze_kv, constant_bcst | computed_bcst});
         auto result = wrap_type<opset6::Reshape>({multiply_kv, any_input()});
@@ -156,22 +157,22 @@ StatefulSDPAFusion::StatefulSDPAFusion() {
         for (auto&& item : {concat_k_node, concat_v_node}) {
             auto&& children = item->get_output_target_inputs(0);
             switch (children.size()) {
-                case 2:
-                    // pass, as the existence of Assign will be checked later
-                    break;
-                case 3:
-                    // the first one leads to SDPA, otherwise the matcher doesn't find the pattern
-                    // the second one leads to Assign, and this is checked later
-                    // the third child is allowed to be a ShapeOf op only, thus one of them must be ShapeOf
-                    if (!std::any_of(children.begin(), children.end(), [](const ov::Input<ov::Node>& child) {
-                            return ov::is_type<ov::op::v3::ShapeOf>(child.get_node()) ||
-                                ov::is_type<ov::op::v0::ShapeOf>(child.get_node());
-                        })) {
-                        return false;
-                    }
-                    break;
-                default:
+            case 2:
+                // pass, as the existence of Assign will be checked later
+                break;
+            case 3:
+                // the first one leads to SDPA, otherwise the matcher doesn't find the pattern
+                // the second one leads to Assign, and this is checked later
+                // the third child is allowed to be a ShapeOf op only, thus one of them must be ShapeOf
+                if (!std::any_of(children.begin(), children.end(), [](const ov::Input<ov::Node>& child) {
+                        return ov::is_type<ov::op::v3::ShapeOf>(child.get_node()) ||
+                               ov::is_type<ov::op::v0::ShapeOf>(child.get_node());
+                    })) {
                     return false;
+                }
+                break;
+            default:
+                return false;
             }
         }
 
@@ -187,7 +188,7 @@ StatefulSDPAFusion::StatefulSDPAFusion() {
         if (past_v_node->get_variable_id() != assign_v_node->get_variable_id())
             return false;
 
-        auto is_optional_one_child = [&pattern_map] (const std::vector<std::shared_ptr<Node>>& nodes) {
+        auto is_optional_one_child = [&pattern_map](const std::vector<std::shared_ptr<Node>>& nodes) {
             for (auto&& node : nodes) {
                 if (pattern_map.count(node)) {
                     auto p = pattern_map.at(node).get_node_shared_ptr();
@@ -197,10 +198,21 @@ StatefulSDPAFusion::StatefulSDPAFusion() {
             }
             return true;
         };
-        if (!is_optional_one_child({convert_past_k, convert_past_v, transpose_q, transpose_k, transpose_v,
-                                    reshape_k, unsqueeze_k, computed_bcst_k, multiply_k,
-                                    reshape_v, unsqueeze_v, computed_bcst_v, multiply_v,
-                                    mq_reshape_k, mq_reshape_v})) {
+        if (!is_optional_one_child({convert_past_k,
+                                    convert_past_v,
+                                    transpose_q,
+                                    transpose_k,
+                                    transpose_v,
+                                    reshape_k,
+                                    unsqueeze_k,
+                                    computed_bcst_k,
+                                    multiply_k,
+                                    reshape_v,
+                                    unsqueeze_v,
+                                    computed_bcst_v,
+                                    multiply_v,
+                                    mq_reshape_k,
+                                    mq_reshape_v})) {
             return false;
         }
 
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/stateful_sdpa_fusion.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/stateful_sdpa_fusion.hpp
index 2833f19a6bc138..bc000eb0485cd2 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/stateful_sdpa_fusion.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/stateful_sdpa_fusion.hpp
@@ -14,5 +14,5 @@ class StatefulSDPAFusion : public ov::pass::MatcherPass {
     StatefulSDPAFusion();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/swap_convert_transpose.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/swap_convert_transpose.cpp
old mode 100755
new mode 100644
index 8c5fb7017b7ae9..4ac73654caf4e1
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/swap_convert_transpose.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/swap_convert_transpose.cpp
@@ -4,17 +4,18 @@
 
 #include "swap_convert_transpose.hpp"
 
-#include "openvino/opsets/opset1.hpp"
+#include "itt.hpp"
 #include "openvino/core/rt_info.hpp"
+#include "openvino/opsets/opset1.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 
-#include "itt.hpp"
-
 ov::intel_cpu::SwapConvertTranspose::SwapConvertTranspose() {
     MATCHER_SCOPE(SwapConvertTranspose);
-    ov::element::TypeVector param_precisions{ ov::element::i8, ov::element::u8 };
-    auto input_m = ov::pass::pattern::wrap_type<ov::op::v0::Parameter>(ov::pass::pattern::type_matches_any(param_precisions));
-    auto convert_m = ov::pass::pattern::wrap_type<ov::op::v0::Convert>({input_m}, ov::pass::pattern::type_matches(ov::element::f32));
+    ov::element::TypeVector param_precisions{ov::element::i8, ov::element::u8};
+    auto input_m =
+        ov::pass::pattern::wrap_type<ov::op::v0::Parameter>(ov::pass::pattern::type_matches_any(param_precisions));
+    auto convert_m =
+        ov::pass::pattern::wrap_type<ov::op::v0::Convert>({input_m}, ov::pass::pattern::type_matches(ov::element::f32));
     auto transpose_m = ov::pass::pattern::wrap_type<ov::op::v1::Transpose>({convert_m, ov::pass::pattern::any_input()});
 
     ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
@@ -40,7 +41,7 @@ ov::intel_cpu::SwapConvertTranspose::SwapConvertTranspose() {
         ov::replace_node(transpose, newConvert);
         newConvert->set_friendly_name(transpose->get_friendly_name());
 
-        ov::copy_runtime_info(transpose, { newTranspose, newConvert });
+        ov::copy_runtime_info(transpose, {newTranspose, newConvert});
         return true;
     };
 
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/swap_convert_transpose.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/swap_convert_transpose.hpp
old mode 100755
new mode 100644
index acc9cf5c11f3f4..747ca3482eaf0c
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/swap_convert_transpose.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/swap_convert_transpose.hpp
@@ -14,5 +14,5 @@ class SwapConvertTranspose : public ov::pass::MatcherPass {
     SwapConvertTranspose();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/convert_to_cpu_specific_opset.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/convert_to_cpu_specific_opset.hpp
index 87fa1291bb7141..9793c63de821ec 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/convert_to_cpu_specific_opset.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/convert_to_cpu_specific_opset.hpp
@@ -2,33 +2,32 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "openvino/core/type/element_type.hpp"
-#include "openvino/pass/constant_folding.hpp"
-#include "openvino/pass/manager.hpp"
 #include "common/pass/align_matmul_input_ranks.hpp"
-#include "transformations/common_optimizations/nop_elimination.hpp"
-#include "common/pass/convert_tile_to_seq_tiles.hpp"
 #include "common/pass/convert_matmul_to_fc.hpp"
-#include "common/pass/convert_to_power_static.hpp"
+#include "common/pass/convert_tile_to_seq_tiles.hpp"
 #include "common/pass/convert_to_leaky_relu.hpp"
+#include "common/pass/convert_to_power_static.hpp"
 #include "common/pass/convert_to_swish_cpu.hpp"
-#include "common/pass/move_fc_reshape_to_weights.hpp"
 #include "common/pass/fc_bias_fusion.hpp"
-#include "transformations/convert_precision.hpp"
-#include "transformations/op_conversions/convert_fc_to_compressed.hpp"
-#include "transformations/op_conversions/convert_fc_to_quantized_legacy.hpp"
+#include "common/pass/move_fc_reshape_to_weights.hpp"
 #include "common/pass/rnn_sequences_optimization.hpp"
-#include "transformations/common_optimizations/reshape_sequence_fusion.hpp"
-#include "transformations/defs.hpp"
 #include "config.h"
-#include "nodes/fullyconnected.h"
-
 #include "itt.hpp"
+#include "nodes/fullyconnected.h"
+#include "openvino/core/type/element_type.hpp"
+#include "openvino/pass/constant_folding.hpp"
+#include "openvino/pass/manager.hpp"
+#include "transformations/common_optimizations/nop_elimination.hpp"
+#include "transformations/common_optimizations/reshape_sequence_fusion.hpp"
+#include "transformations/convert_precision.hpp"
+#include "transformations/defs.hpp"
+#include "transformations/op_conversions/convert_fc_to_compressed.hpp"
+#include "transformations/op_conversions/convert_fc_to_quantized_legacy.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
-inline void ConvertToCPUSpecificOpset(std::shared_ptr<ov::Model> &model, const Config& config) {
+inline void ConvertToCPUSpecificOpset(std::shared_ptr<ov::Model>& model, const Config& config) {
     RUN_ON_FUNCTION_SCOPE(ConvertToCPUSpecificOpset);
 
     ov::pass::Manager manager("CPU:ConvertToCPUSpecificOpset");
@@ -37,13 +36,13 @@ inline void ConvertToCPUSpecificOpset(std::shared_ptr<ov::Model> &model, const C
     CPU_REGISTER_PASS_COMMON(manager, ConvertMatMulToFC);
     CPU_REGISTER_PASS_COMMON(manager, FullyConnectedBiasFusion);
 
-    std::vector<ov::element::Type> supported_activation_types {
+    std::vector<ov::element::Type> supported_activation_types{
         // @todo enable for bf16 as well
         // after EnforceInferencePrecision is replaced with ConvertPrecision
         ov::element::f32,
     };
 
-    std::vector<ov::element::Type> supported_compressed_weights_types {
+    std::vector<ov::element::Type> supported_compressed_weights_types{
         ov::element::u8,
         ov::element::i8,
         ov::element::u4,
@@ -58,8 +57,11 @@ inline void ConvertToCPUSpecificOpset(std::shared_ptr<ov::Model> &model, const C
         supported_activation_types,
         supported_compressed_weights_types,
         [&config](const std::shared_ptr<ov::op::internal::FullyConnected>& fc, size_t IC, size_t OC, size_t G) {
-            return ov::intel_cpu::node::FullyConnected::isSupportedCompressedOperation(
-                fc, IC, OC, G, config.inferencePrecision);
+            return ov::intel_cpu::node::FullyConnected::isSupportedCompressedOperation(fc,
+                                                                                       IC,
+                                                                                       OC,
+                                                                                       G,
+                                                                                       config.inferencePrecision);
         });
 
     CPU_REGISTER_PASS_X64(manager, pass::ConvertFCToFCQuantizedLegacy);
@@ -71,7 +73,8 @@ inline void ConvertToCPUSpecificOpset(std::shared_ptr<ov::Model> &model, const C
     CPU_REGISTER_PASS_COMMON(manager, ConvertToLeakyRelu);
     CPU_REGISTER_PASS_COMMON(manager, ConvertToSwishCPU);
     CPU_REGISTER_PASS_COMMON(manager, OptimizeSequenceTransposes);
-    // after transformation "MoveEltwiseUpThroughDataMov" there can be reshaped sequences that should be eliminated or fused
+    // after transformation "MoveEltwiseUpThroughDataMov" there can be reshaped sequences that should be eliminated or
+    // fused
     CPU_REGISTER_PASS_COMMON(manager, ov::pass::ReshapeSequenceFusion);
     CPU_REGISTER_PASS_COMMON(manager, ov::pass::ConstantFolding);
     CPU_REGISTER_PASS_COMMON(manager,
@@ -81,10 +84,10 @@ inline void ConvertToCPUSpecificOpset(std::shared_ptr<ov::Model> &model, const C
                              false,
                              false);
     CPU_REGISTER_PASS_COMMON(manager, ov::pass::Validate);
-    CPU_REGISTER_PASS_COMMON(manager, ov::pass::EliminateConvert); // Need to clean up after the ConvertPrecision.
+    CPU_REGISTER_PASS_COMMON(manager, ov::pass::EliminateConvert);  // Need to clean up after the ConvertPrecision.
 
     manager.run_passes(model);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/interaction.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/interaction.cpp
index 776df0694f92d1..6c309eaa7d3a54 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/interaction.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/interaction.cpp
@@ -3,19 +3,19 @@
 //
 
 #include "interaction.hpp"
+
 #include "transformations/itt.hpp"
 
-ov::intel_cpu::InteractionNode::InteractionNode(const OutputVector& args) :
-    Op(args) {
+ov::intel_cpu::InteractionNode::InteractionNode(const OutputVector& args) : Op(args) {
     validate_and_infer_types();
 }
 
-ov::intel_cpu::InteractionNode::InteractionNode(const NodeVector& args) :
-    InteractionNode(as_output_vector(args)) {
+ov::intel_cpu::InteractionNode::InteractionNode(const NodeVector& args) : InteractionNode(as_output_vector(args)) {
     validate_and_infer_types();
 }
 
-std::shared_ptr<ov::Node> ov::intel_cpu::InteractionNode::clone_with_new_inputs(const ov::OutputVector& new_args) const {
+std::shared_ptr<ov::Node> ov::intel_cpu::InteractionNode::clone_with_new_inputs(
+    const ov::OutputVector& new_args) const {
     INTERNAL_OP_SCOPE(InteractionNode_with_new_inputs);
     check_new_args_count(this, new_args);
     return std::make_shared<ov::intel_cpu::InteractionNode>(new_args);
@@ -26,21 +26,18 @@ void ov::intel_cpu::InteractionNode::validate_and_infer_types() {
     const auto input_size = get_input_size();
     const auto& dense_pshape = get_input_partial_shape(0);
     NODE_VALIDATION_CHECK(this,
-        dense_pshape.rank().is_static() &&
-        dense_pshape.rank() == 2,
-        "feature shape rank must be 2");
+                          dense_pshape.rank().is_static() && dense_pshape.rank() == 2,
+                          "feature shape rank must be 2");
     const auto batch = dense_pshape[0];
     const auto feature = dense_pshape[1];
     for (size_t i = 1; i < input_size; i++) {
         const auto& sparse_pshape = get_input_partial_shape(i);
         NODE_VALIDATION_CHECK(this,
-            sparse_pshape.rank().is_static() &&
-            sparse_pshape.rank() == 2,
-            "sparse shape must be static");
+                              sparse_pshape.rank().is_static() && sparse_pshape.rank() == 2,
+                              "sparse shape must be static");
         NODE_VALIDATION_CHECK(this,
-            batch.compatible(sparse_pshape[0]) &&
-            feature.compatible(sparse_pshape[1]),
-            "dense & sparse shape must be compatible");
+                              batch.compatible(sparse_pshape[0]) && feature.compatible(sparse_pshape[1]),
+                              "dense & sparse shape must be compatible");
     }
 
     Dimension output_feature_size;
@@ -57,7 +54,7 @@ void ov::intel_cpu::InteractionNode::validate_and_infer_types() {
     return;
 }
 
-bool ov::intel_cpu::InteractionNode::visit_attributes(ov::AttributeVisitor &visitor) {
+bool ov::intel_cpu::InteractionNode::visit_attributes(ov::AttributeVisitor& visitor) {
     INTERNAL_OP_SCOPE(InteractionNode_visit_attributes);
     visitor.on_attribute("out-type", m_output_type);
     return true;
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/interaction.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/interaction.hpp
index 5b7b79113b20b1..3876dd7b153f62 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/interaction.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/interaction.hpp
@@ -20,13 +20,15 @@ class InteractionNode : public ov::op::Op {
 
     InteractionNode(const NodeVector& args);
 
-    bool visit_attributes(ov::AttributeVisitor &visitor) override;
+    bool visit_attributes(ov::AttributeVisitor& visitor) override;
 
     void validate_and_infer_types() override;
 
     std::shared_ptr<Node> clone_with_new_inputs(const ov::OutputVector& new_args) const override;
 
-    ov::element::Type get_output_type() const { return m_output_type; }
+    ov::element::Type get_output_type() const {
+        return m_output_type;
+    }
 
     void set_fq_scales(const std::vector<float>& scales) {
         m_fq_scales = scales;
@@ -41,5 +43,5 @@ class InteractionNode : public ov::op::Op {
     std::vector<float> m_fq_scales;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/llm_mlp.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/llm_mlp.cpp
index 0706f13c3a5450..a5b326e9a10a60 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/llm_mlp.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/llm_mlp.cpp
@@ -38,8 +38,10 @@ void LLMMLPNode::validate_and_infer_types() {
     INTERNAL_OP_SCOPE(LLMMLPNode_validate_and_infer_types);
     const auto input_size = get_input_size();
     size_t expect_input_size = 4;
-    if (m_config.gate_up_quantized) expect_input_size += 2;
-    if (m_config.down_quantized) expect_input_size += 1;
+    if (m_config.gate_up_quantized)
+        expect_input_size += 2;
+    if (m_config.down_quantized)
+        expect_input_size += 1;
     NODE_VALIDATION_CHECK(this, input_size == expect_input_size);
 
     const auto& ishape = get_input_partial_shape(0);
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/llm_mlp.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/llm_mlp.hpp
index fa1569dbb8e5d9..32446c82b06968 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/llm_mlp.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/llm_mlp.hpp
@@ -16,7 +16,7 @@ class LLMMLPNode : public ov::op::Op {
 
     LLMMLPNode() = default;
 
-    enum class ACT_FN { SILU = 0, GELU = 1};
+    enum class ACT_FN { SILU = 0, GELU = 1 };
 
     struct Config {
         ACT_FN act;
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/mha.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/mha.cpp
index 7cea1e270cc014..75b93858fc806e 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/mha.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/mha.cpp
@@ -3,18 +3,21 @@
 //
 
 #include "mha.hpp"
-#include "transformations/itt.hpp"
-#include "openvino/opsets/opset3.hpp"
+
 #include <matmul_shape_inference.hpp>
 
-ov::intel_cpu::MHANode::MHANode(const ov::Output<ov::Node> &in0,
-                                const ov::Output<ov::Node> &in1,
-                                const ov::Output<ov::Node> &in2,
-                                const ov::Output<ov::Node> &in3,
-                                const std::vector<float> &mul_scales,
+#include "openvino/opsets/opset3.hpp"
+#include "transformations/itt.hpp"
+
+ov::intel_cpu::MHANode::MHANode(const ov::Output<ov::Node>& in0,
+                                const ov::Output<ov::Node>& in1,
+                                const ov::Output<ov::Node>& in2,
+                                const ov::Output<ov::Node>& in3,
+                                const std::vector<float>& mul_scales,
                                 bool is_mul_first,
                                 const ov::element::Type output_type)
-    : Op({in0, in1, in2, in3}), m_output_type(output_type) {
+    : Op({in0, in1, in2, in3}),
+      m_output_type(output_type) {
     this->mul_scales = mul_scales;
     this->is_mul_first = is_mul_first;
     this->fq0_output_type = ov::element::undefined;
@@ -23,21 +26,22 @@ ov::intel_cpu::MHANode::MHANode(const ov::Output<ov::Node> &in0,
     validate_and_infer_types();
 }
 
-ov::intel_cpu::MHANode::MHANode(const ov::Output<ov::Node> &in0,
-                                const ov::Output<ov::Node> &in1,
-                                const ov::Output<ov::Node> &in2,
-                                const ov::Output<ov::Node> &in3,
-                                const std::vector<float> &mul_scales,
+ov::intel_cpu::MHANode::MHANode(const ov::Output<ov::Node>& in0,
+                                const ov::Output<ov::Node>& in1,
+                                const ov::Output<ov::Node>& in2,
+                                const ov::Output<ov::Node>& in3,
+                                const std::vector<float>& mul_scales,
                                 bool is_mul_first,
-                                const std::vector<float> &fq_scales0,
-                                const std::vector<float> &fq_scales1,
-                                const std::vector<float> &fq_scales2,
-                                const std::vector<float> &fq_scales3,
+                                const std::vector<float>& fq_scales0,
+                                const std::vector<float>& fq_scales1,
+                                const std::vector<float>& fq_scales2,
+                                const std::vector<float>& fq_scales3,
                                 const ov::element::Type fq0_output_type,
                                 const ov::element::Type fq1_output_type,
                                 const ov::element::Type fq2_output_type,
                                 const ov::element::Type output_type)
-    : Op({in0, in1, in2, in3}), m_output_type(output_type) {
+    : Op({in0, in1, in2, in3}),
+      m_output_type(output_type) {
     this->mul_scales = mul_scales;
     this->is_mul_first = is_mul_first;
     this->fq_scales0 = fq_scales0;
@@ -53,9 +57,20 @@ ov::intel_cpu::MHANode::MHANode(const ov::Output<ov::Node> &in0,
 std::shared_ptr<ov::Node> ov::intel_cpu::MHANode::clone_with_new_inputs(const ov::OutputVector& new_args) const {
     INTERNAL_OP_SCOPE(MHANode_clone_with_new_inputs);
     check_new_args_count(this, new_args);
-    return std::make_shared<ov::intel_cpu::MHANode>(new_args.at(0), new_args.at(1), new_args.at(2), new_args.at(3),
-                                                    mul_scales, is_mul_first, fq_scales0, fq_scales1, fq_scales2, fq_scales3,
-                                                    fq0_output_type, fq1_output_type, fq2_output_type, m_output_type);
+    return std::make_shared<ov::intel_cpu::MHANode>(new_args.at(0),
+                                                    new_args.at(1),
+                                                    new_args.at(2),
+                                                    new_args.at(3),
+                                                    mul_scales,
+                                                    is_mul_first,
+                                                    fq_scales0,
+                                                    fq_scales1,
+                                                    fq_scales2,
+                                                    fq_scales3,
+                                                    fq0_output_type,
+                                                    fq1_output_type,
+                                                    fq2_output_type,
+                                                    m_output_type);
 }
 
 void ov::intel_cpu::MHANode::validate_and_infer_types() {
@@ -91,13 +106,14 @@ void ov::intel_cpu::MHANode::validate_and_infer_types() {
 
     const auto output_shape = transpose(matmul1_output_shapes[0].get_shape(), {0, 2, 1, 3});
 
-    set_output_type(
-        0,
-        m_output_type == ov::element::undefined || m_output_type == ov::element::dynamic ? get_input_element_type(0) : m_output_type,
-        output_shape);
+    set_output_type(0,
+                    m_output_type == ov::element::undefined || m_output_type == ov::element::dynamic
+                        ? get_input_element_type(0)
+                        : m_output_type,
+                    output_shape);
 }
 
-bool ov::intel_cpu::MHANode::visit_attributes(ov::AttributeVisitor &visitor) {
+bool ov::intel_cpu::MHANode::visit_attributes(ov::AttributeVisitor& visitor) {
     INTERNAL_OP_SCOPE(MHANode_visit_attributes);
     visitor.on_attribute("out-type", m_output_type);
     return true;
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/mha.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/mha.hpp
index 3efdf17e63bac2..67a915fc031c7f 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/mha.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/mha.hpp
@@ -15,24 +15,24 @@ class MHANode : public ov::op::Op {
 
     MHANode() = default;
 
-    MHANode(const ov::Output<ov::Node> &in0,
-            const ov::Output<ov::Node> &in1,
-            const ov::Output<ov::Node> &in2,
-            const ov::Output<ov::Node> &in3,
-            const std::vector<float> &mul_scales,
+    MHANode(const ov::Output<ov::Node>& in0,
+            const ov::Output<ov::Node>& in1,
+            const ov::Output<ov::Node>& in2,
+            const ov::Output<ov::Node>& in3,
+            const std::vector<float>& mul_scales,
             bool is_mul_first,
             const ov::element::Type output_type);
 
-    MHANode(const ov::Output<ov::Node> &in0,
-            const ov::Output<ov::Node> &in1,
-            const ov::Output<ov::Node> &in2,
-            const ov::Output<ov::Node> &in3,
-            const std::vector<float> &mul_scales,
+    MHANode(const ov::Output<ov::Node>& in0,
+            const ov::Output<ov::Node>& in1,
+            const ov::Output<ov::Node>& in2,
+            const ov::Output<ov::Node>& in3,
+            const std::vector<float>& mul_scales,
             bool is_mul_first,
-            const std::vector<float> &fq_scales0,
-            const std::vector<float> &fq_scales1,
-            const std::vector<float> &fq_scales2,
-            const std::vector<float> &fq_scales3,
+            const std::vector<float>& fq_scales0,
+            const std::vector<float>& fq_scales1,
+            const std::vector<float>& fq_scales2,
+            const std::vector<float>& fq_scales3,
             const ov::element::Type fq0_output_type,
             const ov::element::Type fq1_output_type,
             const ov::element::Type fq2_output_type,
@@ -40,11 +40,13 @@ class MHANode : public ov::op::Op {
 
     void validate_and_infer_types() override;
 
-    bool visit_attributes(ov::AttributeVisitor &visitor) override;
+    bool visit_attributes(ov::AttributeVisitor& visitor) override;
 
-    std::shared_ptr<ov::Node> clone_with_new_inputs(const ov::OutputVector &new_args) const override;
+    std::shared_ptr<ov::Node> clone_with_new_inputs(const ov::OutputVector& new_args) const override;
 
-    ov::element::Type get_output_type() const { return m_output_type; }
+    ov::element::Type get_output_type() const {
+        return m_output_type;
+    }
 
     const std::vector<float>& get_mul_scales() const {
         return mul_scales;
@@ -90,5 +92,5 @@ class MHANode : public ov::op::Op {
     ov::element::Type fq2_output_type;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/qkv_proj.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/qkv_proj.cpp
index e770a7f530da30..994680723ba27a 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/qkv_proj.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/op/qkv_proj.cpp
@@ -23,9 +23,9 @@ void QKVProjectionNode::validate_and_infer_types() {
     auto oshape0 = ishape;
     auto oshape1 = ishape;
     auto oshape2 = ishape;
-    oshape0[oshape0.size()-1] = m_config.proj_size0;
-    oshape1[oshape1.size()-1] = m_config.proj_size1;
-    oshape2[oshape2.size()-1] = m_config.proj_size2;
+    oshape0[oshape0.size() - 1] = m_config.proj_size0;
+    oshape1[oshape1.size() - 1] = m_config.proj_size1;
+    oshape2[oshape2.size() - 1] = m_config.proj_size2;
 
     set_output_type(0, itype, oshape0);
     set_output_type(1, itype, oshape1);
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/convert_to_interaction.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/convert_to_interaction.cpp
index 84692dd88607dd..a3922a2be4e5a6 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/convert_to_interaction.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/convert_to_interaction.cpp
@@ -5,16 +5,16 @@
 #include "convert_to_interaction.hpp"
 
 #include <openvino/core/rt_info.hpp>
-#include "openvino/opsets/opset1.hpp"
 #include <openvino/opsets/opset8.hpp>
 #include <openvino/pass/pattern/op/or.hpp>
 #include <openvino/pass/pattern/op/wrap_type.hpp>
 #include <transformations/utils/utils.hpp>
 
 #include "itt.hpp"
+#include "openvino/opsets/opset1.hpp"
 #include "ov_ops/type_relaxed.hpp"
-#include "transformations/cpu_opset/x64/op/interaction.hpp"
 #include "simplify_fakequantize.hpp"
+#include "transformations/cpu_opset/x64/op/interaction.hpp"
 
 ov::intel_cpu::ConvertToInteraction::ConvertToInteraction() {
     MATCHER_SCOPE(ConvertToInteraction);
@@ -115,8 +115,7 @@ ov::intel_cpu::FuseFQtoInteraction::FuseFQtoInteraction() {
         inter_node->set_output_type(0, fq_node->get_output_element_type(0), inter_node->get_output_partial_shape(0));
 
         auto replacement =
-            std::make_shared<ov::op::TypeRelaxed<InteractionNode>>(*inter_node,
-                                                                       fq_node->get_output_element_type(0));
+            std::make_shared<ov::op::TypeRelaxed<InteractionNode>>(*inter_node, fq_node->get_output_element_type(0));
         copy_runtime_info(inter_node, replacement);
         replace_node(inter_node, replacement);
         return success;
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/convert_to_interaction.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/convert_to_interaction.hpp
index 79c9c1e1aa6e6e..9fee162128f3ab 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/convert_to_interaction.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/convert_to_interaction.hpp
@@ -9,23 +9,23 @@
 namespace ov {
 namespace intel_cpu {
 
-class ConvertToInteraction: public ov::pass::MatcherPass {
+class ConvertToInteraction : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("ConvertToInteraction", "0");
     ConvertToInteraction();
 };
 
-class FuseFQtoInteraction: public ov::pass::MatcherPass {
+class FuseFQtoInteraction : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("FuseFQtoInteraction", "0");
     FuseFQtoInteraction();
 };
 
-class ConvertInteractionInt8: public ov::pass::MatcherPass {
+class ConvertInteractionInt8 : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("ConvertInteractionInt8", "0");
     ConvertInteractionInt8();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mha_fusion.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mha_fusion.cpp
index aad632acbb2687..0e5859a097a8b9 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mha_fusion.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mha_fusion.cpp
@@ -4,16 +4,15 @@
 
 #include "mha_fusion.hpp"
 
+#include "itt.hpp"
+#include "openvino/core/rt_info.hpp"
 #include "openvino/opsets/opset1.hpp"
 #include "openvino/opsets/opset3.hpp"
-#include "openvino/core/rt_info.hpp"
-#include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "openvino/pass/pattern/op/or.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "simplify_fakequantize.hpp"
 #include "transformations/cpu_opset/x64/op/mha.hpp"
 #include "transformations/utils/utils.hpp"
-#include "simplify_fakequantize.hpp"
-
-#include "itt.hpp"
 
 // TODO: draw pattern
 ov::intel_cpu::MHAFloatFusion::MHAFloatFusion() {
@@ -50,7 +49,8 @@ ov::intel_cpu::MHAFloatFusion::MHAFloatFusion() {
         auto add_in1 = pattern_to_output.at(in3);
         auto transpose2_in = pattern_to_output.at(in8);
 
-        if (transpose0_in.get_shape() != transpose1_in.get_shape() || transpose0_in.get_shape() != transpose2_in.get_shape()) {
+        if (transpose0_in.get_shape() != transpose1_in.get_shape() ||
+            transpose0_in.get_shape() != transpose2_in.get_shape()) {
             return false;
         }
 
@@ -63,14 +63,19 @@ ov::intel_cpu::MHAFloatFusion::MHAFloatFusion() {
             return false;
         }
 
-        if (!valid_transpose_order(pattern_to_output.at(in4).get_node_shared_ptr(), {0, 2, 1, 3})) return false;
-        if (!valid_transpose_order(pattern_to_output.at(in5).get_node_shared_ptr(), {0, 2, 3, 1})) return false;
-        if (!valid_transpose_order(pattern_to_output.at(in9).get_node_shared_ptr(), {0, 2, 1, 3})) return false;
-        if (!valid_transpose_order(pattern_to_output.at(in10).get_node_shared_ptr(), {0, 2, 1, 3})) return false;
+        if (!valid_transpose_order(pattern_to_output.at(in4).get_node_shared_ptr(), {0, 2, 1, 3}))
+            return false;
+        if (!valid_transpose_order(pattern_to_output.at(in5).get_node_shared_ptr(), {0, 2, 3, 1}))
+            return false;
+        if (!valid_transpose_order(pattern_to_output.at(in9).get_node_shared_ptr(), {0, 2, 1, 3}))
+            return false;
+        if (!valid_transpose_order(pattern_to_output.at(in10).get_node_shared_ptr(), {0, 2, 1, 3}))
+            return false;
 
         std::vector<float> mul_scales;
         if (auto mul_node = ov::as_type_ptr<ov::opset3::Multiply>(pattern_to_output.at(mul).get_node_shared_ptr())) {
-            mul_scales = ov::as_type_ptr<ov::opset4::Constant>(mul_node->get_input_node_shared_ptr(1))->cast_vector<float>();
+            mul_scales =
+                ov::as_type_ptr<ov::opset4::Constant>(mul_node->get_input_node_shared_ptr(1))->cast_vector<float>();
 
             auto expected_shape = ov::Shape({1, transpose0_in.get_shape()[2], 1, 1});
             if (mul_scales.size() != 1 && mul_node->get_input_shape(1) != expected_shape) {
@@ -90,15 +95,16 @@ ov::intel_cpu::MHAFloatFusion::MHAFloatFusion() {
         if (!reshape0_node)
             return false;
 
-        if (auto reshape_pattern = ov::as_type_ptr<ov::opset4::Constant>(pattern_to_output.at(in6).get_node_shared_ptr())) {
+        if (auto reshape_pattern =
+                ov::as_type_ptr<ov::opset4::Constant>(pattern_to_output.at(in6).get_node_shared_ptr())) {
             if (reshape0_node->get_input_shape(0).size() != 4) {
                 return false;
             }
 
-            std::vector<int64_t> reshapeConstData = {static_cast<int64_t>(reshape0_node->get_input_shape(0)[0] *
-                                                                          reshape0_node->get_input_shape(0)[1] *
-                                                                          reshape0_node->get_input_shape(0)[2]),
-                                                     -1};
+            std::vector<int64_t> reshapeConstData = {
+                static_cast<int64_t>(reshape0_node->get_input_shape(0)[0] * reshape0_node->get_input_shape(0)[1] *
+                                     reshape0_node->get_input_shape(0)[2]),
+                -1};
 
             if (reshape_pattern->cast_vector<int64_t>() != reshapeConstData) {
                 return false;
@@ -107,7 +113,8 @@ ov::intel_cpu::MHAFloatFusion::MHAFloatFusion() {
             return false;
         }
 
-        if (auto reshape1_node = ov::as_type_ptr<ov::opset1::Reshape>(pattern_to_output.at(reshape1).get_node_shared_ptr())) {
+        if (auto reshape1_node =
+                ov::as_type_ptr<ov::opset1::Reshape>(pattern_to_output.at(reshape1).get_node_shared_ptr())) {
             if (reshape0_node->get_input_shape(0) != reshape1_node->get_output_shape(0)) {
                 return false;
             }
@@ -129,22 +136,29 @@ ov::intel_cpu::MHAFloatFusion::MHAFloatFusion() {
 
         bool is_mul_first = true;
         auto transpose3_node = pattern_to_output.at(transpose3).get_node_shared_ptr();
-        auto mha = std::make_shared<ov::intel_cpu::MHANode>(transpose0_in, transpose1_in, add_in1, transpose2_in, mul_scales, is_mul_first,
+        auto mha = std::make_shared<ov::intel_cpu::MHANode>(transpose0_in,
+                                                            transpose1_in,
+                                                            add_in1,
+                                                            transpose2_in,
+                                                            mul_scales,
+                                                            is_mul_first,
                                                             transpose3_node->get_output_element_type(0));
         mha->set_friendly_name(m.get_match_root()->get_friendly_name());
-        ov::copy_runtime_info({pattern_to_output.at(transpose0).get_node_shared_ptr(),
-                                   pattern_to_output.at(transpose1).get_node_shared_ptr(),
-                                   pattern_to_output.at(mul).get_node_shared_ptr(),
-                                   pattern_to_output.at(matmul0).get_node_shared_ptr(),
-                                   pattern_to_output.at(add).get_node_shared_ptr(),
-                                   pattern_to_output.at(reshape0).get_node_shared_ptr(),
-                                   pattern_to_output.at(softmax).get_node_shared_ptr(),
-                                   pattern_to_output.at(reshape1).get_node_shared_ptr(),
-                                   pattern_to_output.at(transpose2).get_node_shared_ptr(),
-                                   pattern_to_output.at(matmul1).get_node_shared_ptr(),
-                                   pattern_to_output.at(transpose3).get_node_shared_ptr(),
-                                  },
-                                  mha);
+        ov::copy_runtime_info(
+            {
+                pattern_to_output.at(transpose0).get_node_shared_ptr(),
+                pattern_to_output.at(transpose1).get_node_shared_ptr(),
+                pattern_to_output.at(mul).get_node_shared_ptr(),
+                pattern_to_output.at(matmul0).get_node_shared_ptr(),
+                pattern_to_output.at(add).get_node_shared_ptr(),
+                pattern_to_output.at(reshape0).get_node_shared_ptr(),
+                pattern_to_output.at(softmax).get_node_shared_ptr(),
+                pattern_to_output.at(reshape1).get_node_shared_ptr(),
+                pattern_to_output.at(transpose2).get_node_shared_ptr(),
+                pattern_to_output.at(matmul1).get_node_shared_ptr(),
+                pattern_to_output.at(transpose3).get_node_shared_ptr(),
+            },
+            mha);
 
         if (transformation_callback(mha)) {
             return false;
@@ -188,7 +202,8 @@ ov::intel_cpu::MHAFloatFusion2::MHAFloatFusion2() {
         auto add_in1 = pattern_to_output.at(in3);
         auto transpose2_in = pattern_to_output.at(in8);
 
-        if (transpose0_in.get_shape() != transpose1_in.get_shape() || transpose0_in.get_shape() != transpose2_in.get_shape()) {
+        if (transpose0_in.get_shape() != transpose1_in.get_shape() ||
+            transpose0_in.get_shape() != transpose2_in.get_shape()) {
             return false;
         }
 
@@ -201,10 +216,14 @@ ov::intel_cpu::MHAFloatFusion2::MHAFloatFusion2() {
             return false;
         }
 
-        if (!valid_transpose_order(pattern_to_output.at(in4).get_node_shared_ptr(), {0, 2, 1, 3})) return false;
-        if (!valid_transpose_order(pattern_to_output.at(in5).get_node_shared_ptr(), {0, 2, 3, 1})) return false;
-        if (!valid_transpose_order(pattern_to_output.at(in9).get_node_shared_ptr(), {0, 2, 1, 3})) return false;
-        if (!valid_transpose_order(pattern_to_output.at(in10).get_node_shared_ptr(), {0, 2, 1, 3})) return false;
+        if (!valid_transpose_order(pattern_to_output.at(in4).get_node_shared_ptr(), {0, 2, 1, 3}))
+            return false;
+        if (!valid_transpose_order(pattern_to_output.at(in5).get_node_shared_ptr(), {0, 2, 3, 1}))
+            return false;
+        if (!valid_transpose_order(pattern_to_output.at(in9).get_node_shared_ptr(), {0, 2, 1, 3}))
+            return false;
+        if (!valid_transpose_order(pattern_to_output.at(in10).get_node_shared_ptr(), {0, 2, 1, 3}))
+            return false;
 
         auto matmul0_node = ov::as_type_ptr<ov::opset3::MatMul>(pattern_to_output.at(matmul0).get_node_shared_ptr());
         if (!matmul0_node)
@@ -225,19 +244,26 @@ ov::intel_cpu::MHAFloatFusion2::MHAFloatFusion2() {
             return false;
 
         auto transpose3_node = pattern_to_output.at(transpose3).get_node_shared_ptr();
-        auto mha = std::make_shared<ov::intel_cpu::MHANode>(transpose0_in, transpose1_in, add_in1, transpose2_in, std::vector<float>(), false,
+        auto mha = std::make_shared<ov::intel_cpu::MHANode>(transpose0_in,
+                                                            transpose1_in,
+                                                            add_in1,
+                                                            transpose2_in,
+                                                            std::vector<float>(),
+                                                            false,
                                                             transpose3_node->get_output_element_type(0));
         mha->set_friendly_name(m.get_match_root()->get_friendly_name());
-        ov::copy_runtime_info({pattern_to_output.at(transpose0).get_node_shared_ptr(),
-                                   pattern_to_output.at(transpose1).get_node_shared_ptr(),
-                                   pattern_to_output.at(matmul0).get_node_shared_ptr(),
-                                   pattern_to_output.at(add).get_node_shared_ptr(),
-                                   pattern_to_output.at(softmax).get_node_shared_ptr(),
-                                   pattern_to_output.at(transpose2).get_node_shared_ptr(),
-                                   pattern_to_output.at(matmul1).get_node_shared_ptr(),
-                                   pattern_to_output.at(transpose3).get_node_shared_ptr(),
-                                  },
-                                  mha);
+        ov::copy_runtime_info(
+            {
+                pattern_to_output.at(transpose0).get_node_shared_ptr(),
+                pattern_to_output.at(transpose1).get_node_shared_ptr(),
+                pattern_to_output.at(matmul0).get_node_shared_ptr(),
+                pattern_to_output.at(add).get_node_shared_ptr(),
+                pattern_to_output.at(softmax).get_node_shared_ptr(),
+                pattern_to_output.at(transpose2).get_node_shared_ptr(),
+                pattern_to_output.at(matmul1).get_node_shared_ptr(),
+                pattern_to_output.at(transpose3).get_node_shared_ptr(),
+            },
+            mha);
 
         if (transformation_callback(mha)) {
             return false;
@@ -270,28 +296,31 @@ ov::intel_cpu::MHAQuantFusion::MHAQuantFusion() {
     auto transpose0 = std::make_shared<ov::opset3::Transpose>(in0, in4);
     auto transpose1 = std::make_shared<ov::opset3::Transpose>(in1, in5);
     auto matmul0 = std::make_shared<ov::opset3::MatMul>(transpose0, transpose1);
-    auto fakeQuantize0 = ov::pass::pattern::wrap_type<ov::opset1::FakeQuantize>({matmul0,
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>()});
+    auto fakeQuantize0 =
+        ov::pass::pattern::wrap_type<ov::opset1::FakeQuantize>({matmul0,
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>()});
     auto add = std::make_shared<ov::opset4::Add>(fakeQuantize0, in3);
     auto mul = std::make_shared<ov::opset3::Multiply>(add, in2);
     auto reshape0 = std::make_shared<ov::opset1::Reshape>(mul, in6, true);
     auto softmax = std::make_shared<ov::opset1::Softmax>(reshape0);
     auto reshape1 = std::make_shared<ov::opset1::Reshape>(softmax, in7, true);
-    auto fakeQuantize1 = ov::pass::pattern::wrap_type<ov::opset1::FakeQuantize>({reshape1,
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>()});
+    auto fakeQuantize1 =
+        ov::pass::pattern::wrap_type<ov::opset1::FakeQuantize>({reshape1,
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>()});
     auto transpose2 = std::make_shared<ov::opset3::Transpose>(in8, in9);
     auto matmul1 = std::make_shared<ov::opset3::MatMul>(fakeQuantize1, transpose2);
-    auto fakeQuantize2 = ov::pass::pattern::wrap_type<ov::opset1::FakeQuantize>({matmul1,
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>()});
+    auto fakeQuantize2 =
+        ov::pass::pattern::wrap_type<ov::opset1::FakeQuantize>({matmul1,
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>()});
     auto transpose3 = std::make_shared<ov::opset3::Transpose>(fakeQuantize2, in10);
 
     ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
@@ -301,7 +330,8 @@ ov::intel_cpu::MHAQuantFusion::MHAQuantFusion() {
         auto add_in1 = pattern_to_output.at(in3);
         auto transpose2_in = pattern_to_output.at(in8);
 
-        if (transpose0_in.get_shape() != transpose1_in.get_shape() || transpose0_in.get_shape() != transpose2_in.get_shape()) {
+        if (transpose0_in.get_shape() != transpose1_in.get_shape() ||
+            transpose0_in.get_shape() != transpose2_in.get_shape()) {
             return false;
         }
 
@@ -316,7 +346,8 @@ ov::intel_cpu::MHAQuantFusion::MHAQuantFusion() {
 
         std::vector<float> mul_scales;
         if (auto mul_node = ov::as_type_ptr<ov::opset3::Multiply>(pattern_to_output.at(mul).get_node_shared_ptr())) {
-            mul_scales = ov::as_type_ptr<ov::opset4::Constant>(mul_node->get_input_node_shared_ptr(1))->cast_vector<float>();
+            mul_scales =
+                ov::as_type_ptr<ov::opset4::Constant>(mul_node->get_input_node_shared_ptr(1))->cast_vector<float>();
             auto expected_shape = ov::Shape({1, transpose0_in.get_shape()[2], 1, 1});
             if (mul_scales.size() != 1 && mul_node->get_input_shape(1) != expected_shape) {
                 return false;
@@ -325,10 +356,14 @@ ov::intel_cpu::MHAQuantFusion::MHAQuantFusion() {
             return false;
         }
 
-        if (!valid_transpose_order(pattern_to_output.at(in4).get_node_shared_ptr(), {0, 2, 1, 3})) return false;
-        if (!valid_transpose_order(pattern_to_output.at(in5).get_node_shared_ptr(), {0, 2, 3, 1})) return false;
-        if (!valid_transpose_order(pattern_to_output.at(in9).get_node_shared_ptr(), {0, 2, 1, 3})) return false;
-        if (!valid_transpose_order(pattern_to_output.at(in10).get_node_shared_ptr(), {0, 2, 1, 3})) return false;
+        if (!valid_transpose_order(pattern_to_output.at(in4).get_node_shared_ptr(), {0, 2, 1, 3}))
+            return false;
+        if (!valid_transpose_order(pattern_to_output.at(in5).get_node_shared_ptr(), {0, 2, 3, 1}))
+            return false;
+        if (!valid_transpose_order(pattern_to_output.at(in9).get_node_shared_ptr(), {0, 2, 1, 3}))
+            return false;
+        if (!valid_transpose_order(pattern_to_output.at(in10).get_node_shared_ptr(), {0, 2, 1, 3}))
+            return false;
 
         auto matmul0_node = ov::as_type_ptr<ov::opset3::MatMul>(pattern_to_output.at(matmul0).get_node_shared_ptr());
         if (!matmul0_node)
@@ -337,7 +372,8 @@ ov::intel_cpu::MHAQuantFusion::MHAQuantFusion() {
             return false;
 
         std::vector<float> fq0_scale;
-        auto fq0_node = ov::as_type_ptr<ov::opset1::FakeQuantize>(pattern_to_output.at(fakeQuantize0).get_node_shared_ptr());
+        auto fq0_node =
+            ov::as_type_ptr<ov::opset1::FakeQuantize>(pattern_to_output.at(fakeQuantize0).get_node_shared_ptr());
         if (fq0_node) {
             fq0_scale = simplifyToScale(fq0_node);
             if (!fq0_scale.size())
@@ -348,15 +384,16 @@ ov::intel_cpu::MHAQuantFusion::MHAQuantFusion() {
         if (!reshape0_node)
             return false;
 
-        if (auto reshape_pattern = ov::as_type_ptr<ov::opset4::Constant>(pattern_to_output.at(in6).get_node_shared_ptr())) {
+        if (auto reshape_pattern =
+                ov::as_type_ptr<ov::opset4::Constant>(pattern_to_output.at(in6).get_node_shared_ptr())) {
             if (reshape0_node->get_input_shape(0).size() != 4) {
                 return false;
             }
 
-            std::vector<int64_t> reshapeConstData = {static_cast<int64_t>(reshape0_node->get_input_shape(0)[0] *
-                                                                          reshape0_node->get_input_shape(0)[1] *
-                                                                          reshape0_node->get_input_shape(0)[2]),
-                                                     -1};
+            std::vector<int64_t> reshapeConstData = {
+                static_cast<int64_t>(reshape0_node->get_input_shape(0)[0] * reshape0_node->get_input_shape(0)[1] *
+                                     reshape0_node->get_input_shape(0)[2]),
+                -1};
 
             if (reshape_pattern->cast_vector<int64_t>() != reshapeConstData) {
                 return false;
@@ -365,7 +402,8 @@ ov::intel_cpu::MHAQuantFusion::MHAQuantFusion() {
             return false;
         }
 
-        if (auto reshape1_node = ov::as_type_ptr<ov::opset1::Reshape>(pattern_to_output.at(reshape1).get_node_shared_ptr())) {
+        if (auto reshape1_node =
+                ov::as_type_ptr<ov::opset1::Reshape>(pattern_to_output.at(reshape1).get_node_shared_ptr())) {
             if (reshape0_node->get_input_shape(0) != reshape1_node->get_output_shape(0)) {
                 return false;
             }
@@ -380,7 +418,8 @@ ov::intel_cpu::MHAQuantFusion::MHAQuantFusion() {
             return false;
 
         std::vector<float> fq1_scale;
-        auto fq1_node = ov::as_type_ptr<ov::opset1::FakeQuantize>(pattern_to_output.at(fakeQuantize1).get_node_shared_ptr());
+        auto fq1_node =
+            ov::as_type_ptr<ov::opset1::FakeQuantize>(pattern_to_output.at(fakeQuantize1).get_node_shared_ptr());
         if (fq1_node) {
             fq1_scale = simplifyToScale(fq1_node);
             if (!fq1_scale.size())
@@ -396,7 +435,8 @@ ov::intel_cpu::MHAQuantFusion::MHAQuantFusion() {
             return false;
 
         std::vector<float> fq2_scale;
-        if (auto fq_node = ov::as_type_ptr<ov::opset1::FakeQuantize>(pattern_to_output.at(fakeQuantize2).get_node_shared_ptr())) {
+        if (auto fq_node =
+                ov::as_type_ptr<ov::opset1::FakeQuantize>(pattern_to_output.at(fakeQuantize2).get_node_shared_ptr())) {
             fq2_scale = simplifyToScale(fq_node);
             if (!fq2_scale.size())
                 return false;
@@ -404,28 +444,40 @@ ov::intel_cpu::MHAQuantFusion::MHAQuantFusion() {
 
         bool is_mul_first = false;
         auto transpose3_node = pattern_to_output.at(transpose3).get_node_shared_ptr();
-        auto mha = std::make_shared<ov::intel_cpu::MHANode>(transpose0_in, transpose1_in, add_in1, transpose2_in, mul_scales, is_mul_first,
-                                                            std::vector<float>(), fq0_scale, fq1_scale, fq2_scale,
-                                                            ov::element::undefined,
-                                                            fq0_node ? fq0_node->get_output_element_type(0) : ov::element::undefined,
-                                                            fq1_node->get_output_element_type(0), transpose3_node->get_output_element_type(0));
+        auto mha = std::make_shared<ov::intel_cpu::MHANode>(
+            transpose0_in,
+            transpose1_in,
+            add_in1,
+            transpose2_in,
+            mul_scales,
+            is_mul_first,
+            std::vector<float>(),
+            fq0_scale,
+            fq1_scale,
+            fq2_scale,
+            ov::element::undefined,
+            fq0_node ? fq0_node->get_output_element_type(0) : ov::element::undefined,
+            fq1_node->get_output_element_type(0),
+            transpose3_node->get_output_element_type(0));
         mha->set_friendly_name(m.get_match_root()->get_friendly_name());
-        ov::copy_runtime_info({pattern_to_output.at(transpose0).get_node_shared_ptr(),
-                                   pattern_to_output.at(transpose1).get_node_shared_ptr(),
-                                   pattern_to_output.at(matmul0).get_node_shared_ptr(),
-                                   pattern_to_output.at(fakeQuantize0).get_node_shared_ptr(),
-                                   pattern_to_output.at(add).get_node_shared_ptr(),
-                                   pattern_to_output.at(mul).get_node_shared_ptr(),
-                                   pattern_to_output.at(reshape0).get_node_shared_ptr(),
-                                   pattern_to_output.at(softmax).get_node_shared_ptr(),
-                                   pattern_to_output.at(reshape1).get_node_shared_ptr(),
-                                   pattern_to_output.at(fakeQuantize1).get_node_shared_ptr(),
-                                   pattern_to_output.at(transpose2).get_node_shared_ptr(),
-                                   pattern_to_output.at(matmul1).get_node_shared_ptr(),
-                                   pattern_to_output.at(fakeQuantize2).get_node_shared_ptr(),
-                                   pattern_to_output.at(transpose3).get_node_shared_ptr(),
-                                  },
-                                  mha);
+        ov::copy_runtime_info(
+            {
+                pattern_to_output.at(transpose0).get_node_shared_ptr(),
+                pattern_to_output.at(transpose1).get_node_shared_ptr(),
+                pattern_to_output.at(matmul0).get_node_shared_ptr(),
+                pattern_to_output.at(fakeQuantize0).get_node_shared_ptr(),
+                pattern_to_output.at(add).get_node_shared_ptr(),
+                pattern_to_output.at(mul).get_node_shared_ptr(),
+                pattern_to_output.at(reshape0).get_node_shared_ptr(),
+                pattern_to_output.at(softmax).get_node_shared_ptr(),
+                pattern_to_output.at(reshape1).get_node_shared_ptr(),
+                pattern_to_output.at(fakeQuantize1).get_node_shared_ptr(),
+                pattern_to_output.at(transpose2).get_node_shared_ptr(),
+                pattern_to_output.at(matmul1).get_node_shared_ptr(),
+                pattern_to_output.at(fakeQuantize2).get_node_shared_ptr(),
+                pattern_to_output.at(transpose3).get_node_shared_ptr(),
+            },
+            mha);
 
         if (transformation_callback(mha)) {
             return false;
@@ -455,23 +507,25 @@ ov::intel_cpu::MHAQuantFusion2::MHAQuantFusion2() {
     auto in10 = ov::pass::pattern::wrap_type<ov::opset4::Constant>();
     auto transpose0 = std::make_shared<ov::opset3::Transpose>(in0, in4);
     auto transpose1 = std::make_shared<ov::opset3::Transpose>(in1, in5);
-    auto fakeQuantize0 = ov::pass::pattern::wrap_type<ov::opset1::FakeQuantize>({transpose1,
-                                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>()});
+    auto fakeQuantize0 =
+        ov::pass::pattern::wrap_type<ov::opset1::FakeQuantize>({transpose1,
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>()});
     auto matmul0 = std::make_shared<ov::opset3::MatMul>(transpose0, fakeQuantize0);
     auto mul = std::make_shared<ov::opset3::Multiply>(matmul0, in2);
     auto add = std::make_shared<ov::opset4::Add>(mul, in3);
     auto softmax = std::make_shared<ov::opset1::Softmax>(add);
     auto transpose2 = std::make_shared<ov::opset3::Transpose>(in8, in9);
     auto matmul1 = std::make_shared<ov::opset3::MatMul>(softmax, transpose2);
-    auto fakeQuantize1 = ov::pass::pattern::wrap_type<ov::opset1::FakeQuantize>({matmul1,
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
-                                                                                   ov::pass::pattern::wrap_type<ov::opset4::Constant>()});
-    auto in11 = std::make_shared<ov::pass::pattern::op::Or>(OutputVector{ matmul1, fakeQuantize1 });
+    auto fakeQuantize1 =
+        ov::pass::pattern::wrap_type<ov::opset1::FakeQuantize>({matmul1,
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>(),
+                                                                ov::pass::pattern::wrap_type<ov::opset4::Constant>()});
+    auto in11 = std::make_shared<ov::pass::pattern::op::Or>(OutputVector{matmul1, fakeQuantize1});
     auto transpose3 = std::make_shared<ov::opset3::Transpose>(in11, in10);
 
     ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
@@ -481,7 +535,8 @@ ov::intel_cpu::MHAQuantFusion2::MHAQuantFusion2() {
         auto add_in1 = pattern_to_output.at(in3);
         auto transpose2_in = pattern_to_output.at(in8);
 
-        if (transpose0_in.get_shape() != transpose1_in.get_shape() || transpose0_in.get_shape() != transpose2_in.get_shape()) {
+        if (transpose0_in.get_shape() != transpose1_in.get_shape() ||
+            transpose0_in.get_shape() != transpose2_in.get_shape()) {
             return false;
         }
 
@@ -496,7 +551,8 @@ ov::intel_cpu::MHAQuantFusion2::MHAQuantFusion2() {
 
         std::vector<float> mul_scales;
         if (auto mul_node = ov::as_type_ptr<ov::opset3::Multiply>(pattern_to_output.at(mul).get_node_shared_ptr())) {
-            mul_scales = ov::as_type_ptr<ov::opset4::Constant>(mul_node->get_input_node_shared_ptr(1))->cast_vector<float>();
+            mul_scales =
+                ov::as_type_ptr<ov::opset4::Constant>(mul_node->get_input_node_shared_ptr(1))->cast_vector<float>();
 
             auto expected_shape = ov::Shape({1, transpose0_in.get_shape()[2], 1, 1});
             if (mul_scales.size() != 1 && mul_node->get_input_shape(1) != expected_shape) {
@@ -506,10 +562,14 @@ ov::intel_cpu::MHAQuantFusion2::MHAQuantFusion2() {
             return false;
         }
 
-        if (!valid_transpose_order(pattern_to_output.at(in4).get_node_shared_ptr(), {0, 2, 1, 3})) return false;
-        if (!valid_transpose_order(pattern_to_output.at(in5).get_node_shared_ptr(), {0, 2, 3, 1})) return false;
-        if (!valid_transpose_order(pattern_to_output.at(in9).get_node_shared_ptr(), {0, 2, 1, 3})) return false;
-        if (!valid_transpose_order(pattern_to_output.at(in10).get_node_shared_ptr(), {0, 2, 1, 3})) return false;
+        if (!valid_transpose_order(pattern_to_output.at(in4).get_node_shared_ptr(), {0, 2, 1, 3}))
+            return false;
+        if (!valid_transpose_order(pattern_to_output.at(in5).get_node_shared_ptr(), {0, 2, 3, 1}))
+            return false;
+        if (!valid_transpose_order(pattern_to_output.at(in9).get_node_shared_ptr(), {0, 2, 1, 3}))
+            return false;
+        if (!valid_transpose_order(pattern_to_output.at(in10).get_node_shared_ptr(), {0, 2, 1, 3}))
+            return false;
 
         auto matmul0_node = ov::as_type_ptr<ov::opset3::MatMul>(pattern_to_output.at(matmul0).get_node_shared_ptr());
         if (!matmul0_node)
@@ -518,7 +578,8 @@ ov::intel_cpu::MHAQuantFusion2::MHAQuantFusion2() {
             return false;
 
         std::vector<float> fq0_scale;
-        auto fq0_node = ov::as_type_ptr<ov::opset1::FakeQuantize>(pattern_to_output.at(fakeQuantize0).get_node_shared_ptr());
+        auto fq0_node =
+            ov::as_type_ptr<ov::opset1::FakeQuantize>(pattern_to_output.at(fakeQuantize0).get_node_shared_ptr());
         if (fq0_node) {
             fq0_scale = simplifyToScale(fq0_node);
             if (!fq0_scale.size())
@@ -536,7 +597,8 @@ ov::intel_cpu::MHAQuantFusion2::MHAQuantFusion2() {
         std::vector<float> fq1_scale;
         const bool fakeQuantize1Exists = pattern_to_output.find(fakeQuantize1) != pattern_to_output.end();
         if (fakeQuantize1Exists) {
-            if (auto fq_node = ov::as_type_ptr<ov::opset1::FakeQuantize>(pattern_to_output.at(fakeQuantize1).get_node_shared_ptr())) {
+            if (auto fq_node = ov::as_type_ptr<ov::opset1::FakeQuantize>(
+                    pattern_to_output.at(fakeQuantize1).get_node_shared_ptr())) {
                 fq1_scale = simplifyToScale(fq_node);
                 if (!fq1_scale.size())
                     return false;
@@ -551,9 +613,19 @@ ov::intel_cpu::MHAQuantFusion2::MHAQuantFusion2() {
 
         bool is_mul_first = true;
         auto transpose3_node = pattern_to_output.at(transpose3).get_node_shared_ptr();
-        auto mha = std::make_shared<ov::intel_cpu::MHANode>(transpose0_in, transpose1_in, add_in1, transpose2_in, mul_scales, is_mul_first,
-                                                            fq0_scale, std::vector<float>(), std::vector<float>(), fq1_scale,
-                                                            fq0_node->get_output_element_type(0), ov::element::undefined, ov::element::undefined,
+        auto mha = std::make_shared<ov::intel_cpu::MHANode>(transpose0_in,
+                                                            transpose1_in,
+                                                            add_in1,
+                                                            transpose2_in,
+                                                            mul_scales,
+                                                            is_mul_first,
+                                                            fq0_scale,
+                                                            std::vector<float>(),
+                                                            std::vector<float>(),
+                                                            fq1_scale,
+                                                            fq0_node->get_output_element_type(0),
+                                                            ov::element::undefined,
+                                                            ov::element::undefined,
                                                             transpose3_node->get_output_element_type(0));
         mha->set_friendly_name(m.get_match_root()->get_friendly_name());
         std::vector<std::shared_ptr<Node>> merged = {
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mha_fusion.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mha_fusion.hpp
index e28506afe0aa58..9273220c4a0a0c 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mha_fusion.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mha_fusion.hpp
@@ -4,8 +4,8 @@
 
 #pragma once
 
-#include "openvino/pass/graph_rewrite.hpp"
 #include "openvino/opsets/opset4.hpp"
+#include "openvino/pass/graph_rewrite.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -25,25 +25,25 @@ class MHAFusionBase : public ov::pass::MatcherPass {
     }
 };
 
-class MHAFloatFusion: public MHAFusionBase {
+class MHAFloatFusion : public MHAFusionBase {
 public:
     OPENVINO_RTTI("MHAFloatFusion", "0");
     MHAFloatFusion();
 };
 
-class MHAFloatFusion2: public MHAFusionBase {
+class MHAFloatFusion2 : public MHAFusionBase {
 public:
     OPENVINO_RTTI("MHAFloatFusion2", "0");
     MHAFloatFusion2();
 };
 
-class MHAQuantFusion: public MHAFusionBase {
+class MHAQuantFusion : public MHAFusionBase {
 public:
     OPENVINO_RTTI("MHAQuantFusion", "0");
     MHAQuantFusion();
 };
 
-class MHAQuantFusion2: public MHAFusionBase {
+class MHAQuantFusion2 : public MHAFusionBase {
 public:
     OPENVINO_RTTI("MHAQuantFusion2", "0");
     MHAQuantFusion2();
@@ -60,5 +60,5 @@ class MHAFusion : public ov::pass::GraphRewrite {
     }
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mlp_fusion.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mlp_fusion.cpp
index 6b31f7d4987cb4..38cf0bb42fcf45 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mlp_fusion.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mlp_fusion.cpp
@@ -19,8 +19,8 @@
 #include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "ov_ops/type_relaxed.hpp"
 #include "transformations/cpu_opset/x64/op/llm_mlp.hpp"
-#include "transformations/utils/utils.hpp"
 #include "transformations/utils/gen_pattern.hpp"
+#include "transformations/utils/utils.hpp"
 
 using namespace ov::gen_pattern;
 
@@ -44,33 +44,36 @@ ov::intel_cpu::MLPFusion::MLPFusion() {
         makeConst(ov::element::i8, ov::PartialShape({ov::Dimension(), ov::Dimension()}), nullptr);
     auto gate_proj_weight_scales_per_OC = makeConst(ov::element::f32, ov::PartialShape({ov::Dimension(), 1}), nullptr);
     auto gate_proj_weight_f32 = makePattern<opset1::Convert>({gate_proj_weight_i8}, {{"destination_type", "f32"}});
-    auto gate_proj_weight_deq =
-        makePattern<opset1::Multiply>({gate_proj_weight_f32, gate_proj_weight_scales_per_OC}, {{"auto_broadcast", "numpy"}});
+    auto gate_proj_weight_deq = makePattern<opset1::Multiply>({gate_proj_weight_f32, gate_proj_weight_scales_per_OC},
+                                                              {{"auto_broadcast", "numpy"}});
 
-    auto up_proj_weight_i8 =
-        makeConst(ov::element::i8, ov::PartialShape({ov::Dimension(), ov::Dimension()}), nullptr);
+    auto up_proj_weight_i8 = makeConst(ov::element::i8, ov::PartialShape({ov::Dimension(), ov::Dimension()}), nullptr);
     auto up_proj_weight_scales_per_OC = makeConst(ov::element::f32, ov::PartialShape({ov::Dimension(), 1}), nullptr);
     auto up_proj_weight_f32 = makePattern<opset1::Convert>({up_proj_weight_i8}, {{"destination_type", "f32"}});
-    auto up_proj_weight_deq =
-        makePattern<opset1::Multiply>({up_proj_weight_f32, up_proj_weight_scales_per_OC}, {{"auto_broadcast", "numpy"}});
+    auto up_proj_weight_deq = makePattern<opset1::Multiply>({up_proj_weight_f32, up_proj_weight_scales_per_OC},
+                                                            {{"auto_broadcast", "numpy"}});
 
     auto down_proj_weight_i8 =
         makeConst(ov::element::i8, ov::PartialShape({ov::Dimension(), ov::Dimension()}), nullptr);
     auto down_proj_weight_scales_per_OC = makeConst(ov::element::f32, ov::PartialShape({ov::Dimension(), 1}), nullptr);
     auto down_proj_weight_f32 = makePattern<opset1::Convert>({down_proj_weight_i8}, {{"destination_type", "f32"}});
-    auto down_proj_weight_deq =
-        makePattern<opset1::Multiply>({down_proj_weight_f32, down_proj_weight_scales_per_OC}, {{"auto_broadcast", "numpy"}});
+    auto down_proj_weight_deq = makePattern<opset1::Multiply>({down_proj_weight_f32, down_proj_weight_scales_per_OC},
+                                                              {{"auto_broadcast", "numpy"}});
 
     // gate-up weights are combined
-    auto gate_up_proj_weight = makeConst(ov::element::f16, ov::PartialShape({ov::Dimension(), ov::Dimension()}), nullptr);
+    auto gate_up_proj_weight =
+        makeConst(ov::element::f16, ov::PartialShape({ov::Dimension(), ov::Dimension()}), nullptr);
     auto gate_up_proj_weight_f32 = makePattern<opset1::Convert>({gate_up_proj_weight}, {{"destination_type", "f32"}});
 
     auto gate_up_proj_weight_const_i8 =
         makeConst(ov::element::i8, ov::PartialShape({ov::Dimension(), ov::Dimension()}), nullptr);
-    auto gate_up_proj_weight_cvt_f32 = makePattern<opset1::Convert>({gate_up_proj_weight_const_i8}, {{"destination_type", "f32"}});
-    auto gate_up_proj_weight_scales_per_OC = makeConst(ov::element::f32, ov::PartialShape({ov::Dimension(), 1}), nullptr);
-    auto gate_up_proj_weight_deq = makePattern<opset1::Multiply>({gate_up_proj_weight_cvt_f32, gate_up_proj_weight_scales_per_OC},
-                                                             {{"auto_broadcast", "numpy"}});
+    auto gate_up_proj_weight_cvt_f32 =
+        makePattern<opset1::Convert>({gate_up_proj_weight_const_i8}, {{"destination_type", "f32"}});
+    auto gate_up_proj_weight_scales_per_OC =
+        makeConst(ov::element::f32, ov::PartialShape({ov::Dimension(), 1}), nullptr);
+    auto gate_up_proj_weight_deq =
+        makePattern<opset1::Multiply>({gate_up_proj_weight_cvt_f32, gate_up_proj_weight_scales_per_OC},
+                                      {{"auto_broadcast", "numpy"}});
 
     auto gate_up_proj = makePattern<opset1::MatMul>({input, gate_up_proj_weight_f32 | gate_up_proj_weight_deq},
                                                     {{"transpose_a", false}, {"transpose_b", true}});
@@ -82,18 +85,21 @@ ov::intel_cpu::MLPFusion::MLPFusion() {
     auto gate_up_proj_split = makePattern<opset1::VariadicSplit>({gate_up_proj, -1, gate_up_split_lengths});
     gate_up_proj_split->set_output_size(2);
 
-    auto mlp_gate_proj = makePattern<opset1::MatMul>({input, gate_proj_weight | gate_proj_weight_compressed | gate_proj_weight_deq},
-                                                     {{"transpose_a", false}, {"transpose_b", true}});  // [?,?,up_size]
+    auto mlp_gate_proj =
+        makePattern<opset1::MatMul>({input, gate_proj_weight | gate_proj_weight_compressed | gate_proj_weight_deq},
+                                    {{"transpose_a", false}, {"transpose_b", true}});  // [?,?,up_size]
     auto mlp_silu_gate = makePattern<opset4::Swish>({mlp_gate_proj | gate_up_proj_split->output(0)});
     auto mlp_gelu_gate = makePattern<opset7::Gelu>({mlp_gate_proj | gate_up_proj_split->output(0)});
-    auto mlp_up_proj = makePattern<opset1::MatMul>({input, up_proj_weight | up_proj_weight_compressed | up_proj_weight_deq},
-                                                   {{"transpose_a", false}, {"transpose_b", true}});
+    auto mlp_up_proj =
+        makePattern<opset1::MatMul>({input, up_proj_weight | up_proj_weight_compressed | up_proj_weight_deq},
+                                    {{"transpose_a", false}, {"transpose_b", true}});
 
     auto mlp_gated_up =
         makePattern<opset1::Multiply>({mlp_silu_gate | mlp_gelu_gate, mlp_up_proj | gate_up_proj_split->output(1)},
                                       {{"auto_broadcast", "numpy"}});
-    auto down_proj = makePattern<opset1::MatMul>({mlp_gated_up, down_proj_weight | down_proj_weight_compressed | down_proj_weight_deq},
-                                                 {{"transpose_a", false}, {"transpose_b", true}});  //  [?,?,down_size]
+    auto down_proj = makePattern<opset1::MatMul>(
+        {mlp_gated_up, down_proj_weight | down_proj_weight_compressed | down_proj_weight_deq},
+        {{"transpose_a", false}, {"transpose_b", true}});  //  [?,?,down_size]
 
     auto result = down_proj;
 
@@ -119,33 +125,36 @@ ov::intel_cpu::MLPFusion::MLPFusion() {
         bool is_down_proj_int8 = false;
         bool is_gate_up_combined = false;
         if (pattern_map.count(gate_up_proj_weight_const_i8) > 0 && pattern_map.count(down_proj_weight_compressed) > 0) {
-            //gate-up combined & quantized
+            // gate-up combined & quantized
             is_gate_up_quantized_int8 = true;
             is_gate_up_combined = true;
             gate_proj_w = pattern_map.at(gate_up_proj_weight_const_i8);
             up_proj_w = pattern_map.at(gate_up_proj_weight_const_i8);
             down_proj_w = pattern_map.at(down_proj_weight_compressed);
         } else if (pattern_map.count(gate_up_proj_weight) > 0 && pattern_map.count(down_proj_weight_compressed) > 0) {
-            //gate-up combined
+            // gate-up combined
             is_gate_up_combined = true;
             gate_proj_w = pattern_map.at(gate_up_proj_weight);
             up_proj_w = pattern_map.at(gate_up_proj_weight);
             down_proj_w = pattern_map.at(down_proj_weight_compressed);
-        } else if (pattern_map.count(gate_proj_weight_compressed) > 0 && pattern_map.count(up_proj_weight_compressed) > 0 &&
-            pattern_map.count(down_proj_weight_compressed) > 0) {
+        } else if (pattern_map.count(gate_proj_weight_compressed) > 0 &&
+                   pattern_map.count(up_proj_weight_compressed) > 0 &&
+                   pattern_map.count(down_proj_weight_compressed) > 0) {
             is_gate_up_quantized_int8 = false;
             is_down_proj_int8 = false;
             gate_proj_w = pattern_map.at(gate_proj_weight_compressed);
             up_proj_w = pattern_map.at(up_proj_weight_compressed);
             down_proj_w = pattern_map.at(down_proj_weight_compressed);
         } else if (pattern_map.count(gate_proj_weight_i8) > 0 && pattern_map.count(up_proj_weight_i8) > 0 &&
-                   pattern_map.count(gate_proj_weight_scales_per_OC) > 0 && pattern_map.count(up_proj_weight_scales_per_OC) > 0) {
+                   pattern_map.count(gate_proj_weight_scales_per_OC) > 0 &&
+                   pattern_map.count(up_proj_weight_scales_per_OC) > 0) {
             is_gate_up_quantized_int8 = true;
             gate_proj_w = pattern_map.at(gate_proj_weight_i8);
             up_proj_w = pattern_map.at(up_proj_weight_i8);
 
             if (pattern_map.count(down_proj_weight_i8) > 0) {
-                if (pattern_map.count(down_proj_weight_scales_per_OC) == 0) return false;
+                if (pattern_map.count(down_proj_weight_scales_per_OC) == 0)
+                    return false;
                 is_down_proj_int8 = true;
                 down_proj_w = pattern_map.at(down_proj_weight_i8);
             } else {
@@ -226,14 +235,15 @@ ov::intel_cpu::MLPFusion::MLPFusion() {
         auto old_node = root;
         auto new_node = std::make_shared<LLMMLPNode>(new_args, config);
         new_node->set_friendly_name(old_node->get_friendly_name());
-        ov::copy_runtime_info({pattern_map.at(gate_act).get_node_shared_ptr(),
-                               pattern_map.at(down_proj).get_node_shared_ptr()},
-                              new_node);
+        ov::copy_runtime_info(
+            {pattern_map.at(gate_act).get_node_shared_ptr(), pattern_map.at(down_proj).get_node_shared_ptr()},
+            new_node);
         if (is_gate_up_combined) {
             ov::copy_runtime_info({pattern_map.at(gate_up_proj).get_node_shared_ptr()}, new_node);
         } else {
             ov::copy_runtime_info({pattern_map.at(mlp_gate_proj).get_node_shared_ptr(),
-                                   pattern_map.at(mlp_up_proj).get_node_shared_ptr()}, new_node);
+                                   pattern_map.at(mlp_up_proj).get_node_shared_ptr()},
+                                  new_node);
         }
         // callback is for plugin implementation to check if it can be supported
         if (!transformation_callback(new_node)) {
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mlp_fusion.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mlp_fusion.hpp
index aecb9292807e96..5754d0fa9b622f 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mlp_fusion.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mlp_fusion.hpp
@@ -9,11 +9,11 @@
 namespace ov {
 namespace intel_cpu {
 
-class MLPFusion: public ov::pass::MatcherPass {
+class MLPFusion : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("MLPFusion", "0");
     MLPFusion();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/qkv_proj_fusion.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/qkv_proj_fusion.hpp
index 4c398cb478a340..bfaf42f1f0acd3 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/qkv_proj_fusion.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/qkv_proj_fusion.hpp
@@ -9,17 +9,17 @@
 namespace ov {
 namespace intel_cpu {
 
-class QKVProjFusion: public ov::pass::MatcherPass {
+class QKVProjFusion : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("QKVProjFusion", "0");
     QKVProjFusion();
 };
 
-class QKVProjFusion2: public ov::pass::MatcherPass {
+class QKVProjFusion2 : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("QKVProjFusion2", "0");
     QKVProjFusion2();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/sdpa_fuse_transpose_reshape.cpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/sdpa_fuse_transpose_reshape.cpp
index 3aa0fd0d08e69b..9b48708bc8ed5a 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/sdpa_fuse_transpose_reshape.cpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/sdpa_fuse_transpose_reshape.cpp
@@ -124,11 +124,15 @@ intel_cpu::SDPAFuseTransposeReshape::SDPAFuseTransposeReshape() {
         qkv_transpose[0] = as_type_ptr<op::v1::Transpose>(pattern_map.at(q_transpose_node).get_node_shared_ptr());
         qkv_transpose[1] = as_type_ptr<op::v1::Transpose>(pattern_map.at(k_transpose_node).get_node_shared_ptr());
         qkv_transpose[2] = as_type_ptr<op::v1::Transpose>(pattern_map.at(v_transpose_node).get_node_shared_ptr());
-        qkv_transpose_order[0] = as_type_ptr<op::v0::Constant>(pattern_map.at(q_transpose_order_node).get_node_shared_ptr());
-        qkv_transpose_order[1] = as_type_ptr<op::v0::Constant>(pattern_map.at(k_transpose_order_node).get_node_shared_ptr());
-        qkv_transpose_order[2] = as_type_ptr<op::v0::Constant>(pattern_map.at(v_transpose_order_node).get_node_shared_ptr());
+        qkv_transpose_order[0] =
+            as_type_ptr<op::v0::Constant>(pattern_map.at(q_transpose_order_node).get_node_shared_ptr());
+        qkv_transpose_order[1] =
+            as_type_ptr<op::v0::Constant>(pattern_map.at(k_transpose_order_node).get_node_shared_ptr());
+        qkv_transpose_order[2] =
+            as_type_ptr<op::v0::Constant>(pattern_map.at(v_transpose_order_node).get_node_shared_ptr());
         auto out_tranpose = as_type_ptr<op::v1::Transpose>(pattern_map.at(out_transpose_node).get_node_shared_ptr());
-        auto out_transpose_order = as_type_ptr<op::v0::Constant>(pattern_map.at(out_transpose_order_node).get_node_shared_ptr());
+        auto out_transpose_order =
+            as_type_ptr<op::v0::Constant>(pattern_map.at(out_transpose_order_node).get_node_shared_ptr());
 
         if (!(is_expected_transpose(qkv_transpose[0]) && is_expected_transpose(qkv_transpose[1]) &&
               is_expected_transpose(qkv_transpose[2]))) {
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/sdpa_fuse_transpose_reshape.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/sdpa_fuse_transpose_reshape.hpp
index 74ba6ec6221d1e..d2bb84893c0728 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/sdpa_fuse_transpose_reshape.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/sdpa_fuse_transpose_reshape.hpp
@@ -14,5 +14,5 @@ class SDPAFuseTransposeReshape : public ov::pass::MatcherPass {
     SDPAFuseTransposeReshape();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/simplify_fakequantize.hpp b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/simplify_fakequantize.hpp
index fd68814f6d12f2..fef3d37216cea0 100644
--- a/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/simplify_fakequantize.hpp
+++ b/src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/simplify_fakequantize.hpp
@@ -2,15 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 #pragma once
-#include "openvino/opsets/opset1.hpp"
 #include <openvino/opsets/opset8.hpp>
 #include <vector>
 
+#include "openvino/opsets/opset1.hpp"
+
 namespace ov {
 namespace intel_cpu {
 
 inline std::vector<float> simplifyToScale(const std::shared_ptr<ov::opset8::FakeQuantize>& fq_node,
-                                   float threshold = 0.0001f) {
+                                          float threshold = 0.0001f) {
     auto levels = fq_node->get_levels();
     auto input_low = ov::as_type_ptr<ov::opset8::Constant>(fq_node->get_input_node_shared_ptr(1))->cast_vector<float>();
     auto input_high =
diff --git a/src/plugins/intel_cpu/src/transformations/defs.hpp b/src/plugins/intel_cpu/src/transformations/defs.hpp
index 890c357d641ac3..ffabb90e626688 100644
--- a/src/plugins/intel_cpu/src/transformations/defs.hpp
+++ b/src/plugins/intel_cpu/src/transformations/defs.hpp
@@ -7,78 +7,73 @@
 namespace ov {
 namespace intel_cpu {
 
-#define CPU_REGISTER_PASS_COMMON(MANAGER, PASS, ...) \
-    MANAGER.register_pass<PASS>(__VA_ARGS__);
+#define CPU_REGISTER_PASS_COMMON(MANAGER, PASS, ...) MANAGER.register_pass<PASS>(__VA_ARGS__);
 
-#define CPU_DISABLE_PASS_COMMON(MANAGER, PASS) \
-    MANAGER.get_pass_config()->disable<PASS>();
+#define CPU_DISABLE_PASS_COMMON(MANAGER, PASS) MANAGER.get_pass_config()->disable<PASS>();
 
-#define CPU_ENABLE_PASS_COMMON(MANAGER, PASS) \
-    MANAGER.get_pass_config()->enable<PASS>();
+#define CPU_ENABLE_PASS_COMMON(MANAGER, PASS) MANAGER.get_pass_config()->enable<PASS>();
 
-#define CPU_SET_CALLBACK_COMMON(MANAGER, CALLBACK, ...) \
-    MANAGER.get_pass_config()->set_callback<__VA_ARGS__>(CALLBACK);
+#define CPU_SET_CALLBACK_COMMON(MANAGER, CALLBACK, ...) MANAGER.get_pass_config()->set_callback<__VA_ARGS__>(CALLBACK);
 
 #if defined(OPENVINO_ARCH_X86_64)
 
-#define CPU_REGISTER_PASS_X64(MANAGER, PASS, ...) CPU_REGISTER_PASS_COMMON(MANAGER, PASS, __VA_ARGS__)
-#define CPU_DISABLE_PASS_X64(MANAGER, PASS) CPU_DISABLE_PASS_COMMON(MANAGER, PASS)
-#define CPU_ENABLE_PASS_X64(MANAGER, PASS) CPU_ENABLE_PASS_COMMON(MANAGER, PASS)
-#define CPU_SET_CALLBACK_X64(MANAGER, CALLBACK, ...) CPU_SET_CALLBACK_COMMON(MANAGER, CALLBACK, __VA_ARGS__)
+#    define CPU_REGISTER_PASS_X64(MANAGER, PASS, ...)    CPU_REGISTER_PASS_COMMON(MANAGER, PASS, __VA_ARGS__)
+#    define CPU_DISABLE_PASS_X64(MANAGER, PASS)          CPU_DISABLE_PASS_COMMON(MANAGER, PASS)
+#    define CPU_ENABLE_PASS_X64(MANAGER, PASS)           CPU_ENABLE_PASS_COMMON(MANAGER, PASS)
+#    define CPU_SET_CALLBACK_X64(MANAGER, CALLBACK, ...) CPU_SET_CALLBACK_COMMON(MANAGER, CALLBACK, __VA_ARGS__)
 
 #else
 
-#define CPU_REGISTER_PASS_X64(MANAGER, PASS, ...)
-#define CPU_DISABLE_PASS_X64(MANAGER, PASS)
-#define CPU_ENABLE_PASS_X64(MANAGER, PASS)
-#define CPU_SET_CALLBACK_X64(MANAGER, CALLBACK, ...)
-
-#endif // OPENVINO_ARCH_X86_64
+#    define CPU_REGISTER_PASS_X64(MANAGER, PASS, ...)
+#    define CPU_DISABLE_PASS_X64(MANAGER, PASS)
+#    define CPU_ENABLE_PASS_X64(MANAGER, PASS)
+#    define CPU_SET_CALLBACK_X64(MANAGER, CALLBACK, ...)
 
+#endif  // OPENVINO_ARCH_X86_64
 
 #if defined(OPENVINO_ARCH_X86)
 
-#define CPU_REGISTER_PASS_X86(MANAGER, PASS, ...) CPU_REGISTER_PASS_COMMON(MANAGER, PASS, __VA_ARGS__)
-#define CPU_DISABLE_PASS_X86(MANAGER, PASS) CPU_DISABLE_PASS_COMMON(MANAGER, PASS)
-#define CPU_ENABLE_PASS_X86(MANAGER, PASS) CPU_ENABLE_PASS_COMMON(MANAGER, PASS)
-#define CPU_SET_CALLBACK_X86(MANAGER, CALLBACK, ...) CPU_SET_CALLBACK_COMMON(MANAGER, CALLBACK, __VA_ARGS__)
+#    define CPU_REGISTER_PASS_X86(MANAGER, PASS, ...)    CPU_REGISTER_PASS_COMMON(MANAGER, PASS, __VA_ARGS__)
+#    define CPU_DISABLE_PASS_X86(MANAGER, PASS)          CPU_DISABLE_PASS_COMMON(MANAGER, PASS)
+#    define CPU_ENABLE_PASS_X86(MANAGER, PASS)           CPU_ENABLE_PASS_COMMON(MANAGER, PASS)
+#    define CPU_SET_CALLBACK_X86(MANAGER, CALLBACK, ...) CPU_SET_CALLBACK_COMMON(MANAGER, CALLBACK, __VA_ARGS__)
 
 #else
 
-#define CPU_REGISTER_PASS_X86(MANAGER, PASS, ...)
-#define CPU_DISABLE_PASS_X86(MANAGER, PASS)
-#define CPU_ENABLE_PASS_X86(MANAGER, PASS)
-#define CPU_SET_CALLBACK_X86(MANAGER, CALLBACK, ...)
+#    define CPU_REGISTER_PASS_X86(MANAGER, PASS, ...)
+#    define CPU_DISABLE_PASS_X86(MANAGER, PASS)
+#    define CPU_ENABLE_PASS_X86(MANAGER, PASS)
+#    define CPU_SET_CALLBACK_X86(MANAGER, CALLBACK, ...)
 
-#endif // OPENVINO_ARCH_X86
+#endif  // OPENVINO_ARCH_X86
 
 #if defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)
 
-#if defined(OPENVINO_ARCH_ARM)
-#define CPU_REGISTER_PASS_ARM64(MANAGER, PASS, ...)
-#define CPU_REGISTER_PASS_ARM32(MANAGER, PASS, ...) CPU_REGISTER_PASS_COMMON(MANAGER, PASS, __VA_ARGS__)
-#endif
+#    if defined(OPENVINO_ARCH_ARM)
+#        define CPU_REGISTER_PASS_ARM64(MANAGER, PASS, ...)
+#        define CPU_REGISTER_PASS_ARM32(MANAGER, PASS, ...) CPU_REGISTER_PASS_COMMON(MANAGER, PASS, __VA_ARGS__)
+#    endif
 
-#if defined(OPENVINO_ARCH_ARM64)
-#define CPU_REGISTER_PASS_ARM64(MANAGER, PASS, ...) CPU_REGISTER_PASS_COMMON(MANAGER, PASS, __VA_ARGS__)
-#define CPU_REGISTER_PASS_ARM32(MANAGER, PASS, ...)
-#endif
+#    if defined(OPENVINO_ARCH_ARM64)
+#        define CPU_REGISTER_PASS_ARM64(MANAGER, PASS, ...) CPU_REGISTER_PASS_COMMON(MANAGER, PASS, __VA_ARGS__)
+#        define CPU_REGISTER_PASS_ARM32(MANAGER, PASS, ...)
+#    endif
 
-#define CPU_REGISTER_PASS_ARM(MANAGER, PASS, ...) CPU_REGISTER_PASS_COMMON(MANAGER, PASS, __VA_ARGS__)
-#define CPU_DISABLE_PASS_ARM(MANAGER, PASS) CPU_DISABLE_PASS_COMMON(MANAGER, PASS)
-#define CPU_ENABLE_PASS_ARM(MANAGER, PASS) CPU_ENABLE_PASS_COMMON(MANAGER, PASS)
-#define CPU_SET_CALLBACK_ARM(MANAGER, CALLBACK, ...) CPU_SET_CALLBACK_COMMON(MANAGER, CALLBACK, __VA_ARGS__)
+#    define CPU_REGISTER_PASS_ARM(MANAGER, PASS, ...)    CPU_REGISTER_PASS_COMMON(MANAGER, PASS, __VA_ARGS__)
+#    define CPU_DISABLE_PASS_ARM(MANAGER, PASS)          CPU_DISABLE_PASS_COMMON(MANAGER, PASS)
+#    define CPU_ENABLE_PASS_ARM(MANAGER, PASS)           CPU_ENABLE_PASS_COMMON(MANAGER, PASS)
+#    define CPU_SET_CALLBACK_ARM(MANAGER, CALLBACK, ...) CPU_SET_CALLBACK_COMMON(MANAGER, CALLBACK, __VA_ARGS__)
 
 #else
 
-#define CPU_REGISTER_PASS_ARM64(MANAGER, PASS, ...)
-#define CPU_REGISTER_PASS_ARM32(MANAGER, PASS, ...)
-#define CPU_REGISTER_PASS_ARM(MANAGER, PASS, ...)
-#define CPU_DISABLE_PASS_ARM(MANAGER, PASS)
-#define CPU_ENABLE_PASS_ARM(MANAGER, PASS)
-#define CPU_SET_CALLBACK_ARM(MANAGER, CALLBACK, ...)\
+#    define CPU_REGISTER_PASS_ARM64(MANAGER, PASS, ...)
+#    define CPU_REGISTER_PASS_ARM32(MANAGER, PASS, ...)
+#    define CPU_REGISTER_PASS_ARM(MANAGER, PASS, ...)
+#    define CPU_DISABLE_PASS_ARM(MANAGER, PASS)
+#    define CPU_ENABLE_PASS_ARM(MANAGER, PASS)
+#    define CPU_SET_CALLBACK_ARM(MANAGER, CALLBACK, ...)
 
-#endif // OPENVINO_ARCH_ARM || OPENVINO_ARCH_ARM64
+#endif  // OPENVINO_ARCH_ARM || OPENVINO_ARCH_ARM64
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/itt.hpp b/src/plugins/intel_cpu/src/transformations/itt.hpp
index 358988de9a0f76..e8235f49e0dc1f 100644
--- a/src/plugins/intel_cpu/src/transformations/itt.hpp
+++ b/src/plugins/intel_cpu/src/transformations/itt.hpp
@@ -15,11 +15,11 @@ namespace ov {
 namespace intel_cpu {
 namespace itt {
 namespace domains {
-    OV_ITT_DOMAIN(CPUSpecificTransform);
-}   // namespace domains
-}   // namespace itt
-}   // namespace intel_cpu
-}   // namespace ov
+OV_ITT_DOMAIN(CPUSpecificTransform);
+}  // namespace domains
+}  // namespace itt
+}  // namespace intel_cpu
+}  // namespace ov
 
 OV_CC_DOMAINS(internal_op);
 
@@ -30,14 +30,14 @@ OV_CC_DOMAINS(internal_op);
  */
 #if defined(SELECTIVE_BUILD_ANALYZER)
 
-#define INTERNAL_OP_SCOPE(region) OV_SCOPE(internal_op, region)
+#    define INTERNAL_OP_SCOPE(region) OV_SCOPE(internal_op, region)
 
 #elif defined(SELECTIVE_BUILD)
 
-#define INTERNAL_OP_SCOPE(region) MATCHER_SCOPE_(internal_op, region)
+#    define INTERNAL_OP_SCOPE(region) MATCHER_SCOPE_(internal_op, region)
 
 #else
 
-#define INTERNAL_OP_SCOPE(region)
+#    define INTERNAL_OP_SCOPE(region)
 
 #endif
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/common/op/fused_mul_add.cpp b/src/plugins/intel_cpu/src/transformations/snippets/common/op/fused_mul_add.cpp
index 6c3cd868b7aaba..730956c2698ed3 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/common/op/fused_mul_add.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/common/op/fused_mul_add.cpp
@@ -4,13 +4,13 @@
 
 #include "fused_mul_add.hpp"
 
-#include "snippets/itt.hpp"
 #include "openvino/op/util/elementwise_args.hpp"
+#include "snippets/itt.hpp"
 
 using namespace ov;
 using namespace ov::intel_cpu;
 
-FusedMulAdd::FusedMulAdd(const Output<Node>& a, const Output<Node>& b, const Output<Node>& c) : Op({ a, b, c }) {
+FusedMulAdd::FusedMulAdd(const Output<Node>& a, const Output<Node>& b, const Output<Node>& c) : Op({a, b, c}) {
     constructor_validate_and_infer_types();
 }
 
@@ -35,9 +35,10 @@ void FusedMulAdd::validate_and_infer_types() {
         NODE_VALIDATION_CHECK(this,
                               element_type == get_input_element_type(i),
                               "Argument element types are inconsistent.");
-        NODE_VALIDATION_CHECK(this,
-                              PartialShape::broadcast_merge_into(pshape, get_input_partial_shape(i), ov::op::AutoBroadcastType::NUMPY),
-                              "Argument shapes are inconsistent.");
+        NODE_VALIDATION_CHECK(
+            this,
+            PartialShape::broadcast_merge_into(pshape, get_input_partial_shape(i), ov::op::AutoBroadcastType::NUMPY),
+            "Argument shapes are inconsistent.");
     }
     set_output_type(0, element_type, pshape);
 }
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/common/op/fused_mul_add.hpp b/src/plugins/intel_cpu/src/transformations/snippets/common/op/fused_mul_add.hpp
index fca16f0404abb5..0d0e1cb7a2721a 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/common/op/fused_mul_add.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/common/op/fused_mul_add.hpp
@@ -27,5 +27,5 @@ class FusedMulAdd : public ov::op::Op {
     const ov::op::AutoBroadcastSpec& get_autob() const override;
 };
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/common/pass/mul_add_to_fma.cpp b/src/plugins/intel_cpu/src/transformations/snippets/common/pass/mul_add_to_fma.cpp
index 9bc3ef378a3003..c889ad8e14b358 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/common/pass/mul_add_to_fma.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/common/pass/mul_add_to_fma.cpp
@@ -2,18 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include "mul_add_to_fma.hpp"
+
 #include <snippets/itt.hpp>
 
-#include "mul_add_to_fma.hpp"
+#include "openvino/core/rt_info.hpp"
+#include "openvino/pass/pattern/matcher.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "snippets/op/memory_access.hpp"
 #include "snippets/snippets_isa.hpp"
 #include "transformations/snippets/common/op/fused_mul_add.hpp"
 #include "transformations/utils/utils.hpp"
 
-#include "openvino/pass/pattern/op/wrap_type.hpp"
-#include "openvino/pass/pattern/matcher.hpp"
-#include "openvino/core/rt_info.hpp"
-#include "snippets/op/memory_access.hpp"
-
 ov::intel_cpu::pass::MulAddToFMA::MulAddToFMA() {
     MATCHER_SCOPE(MulAddToFMA);
     auto is_not_memory_access = [](const Output<Node>& out) {
@@ -21,13 +21,12 @@ ov::intel_cpu::pass::MulAddToFMA::MulAddToFMA() {
     };
     auto mul_input_1 = ov::pass::pattern::any_input();
     auto mul_input_2 = ov::pass::pattern::any_input();
-    auto mul_m = ov::pass::pattern::wrap_type<opset1::Multiply>({ mul_input_1, mul_input_2 },
-                                                                [=](const Output<Node>& out) {
-                                                                    return out.get_target_inputs().size() == 1 &&
-                                                                           is_not_memory_access(out);
-                                                                });
+    auto mul_m =
+        ov::pass::pattern::wrap_type<opset1::Multiply>({mul_input_1, mul_input_2}, [=](const Output<Node>& out) {
+            return out.get_target_inputs().size() == 1 && is_not_memory_access(out);
+        });
     auto add_input_2 = ov::pass::pattern::any_input();
-    auto add_m = ov::pass::pattern::wrap_type<opset1::Add>({ mul_m, add_input_2 }, is_not_memory_access);
+    auto add_m = ov::pass::pattern::wrap_type<opset1::Add>({mul_m, add_input_2}, is_not_memory_access);
 
     matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
         OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "Snippets::op::MulAddToFMA_callback")
@@ -44,7 +43,7 @@ ov::intel_cpu::pass::MulAddToFMA::MulAddToFMA() {
         const auto& c = pattern_map.at(add_input_2);
 
         const auto fma = std::make_shared<ov::intel_cpu::FusedMulAdd>(a, b, c);
-        ov::copy_runtime_info({ a.get_node_shared_ptr(), b.get_node_shared_ptr(), c.get_node_shared_ptr() }, fma);
+        ov::copy_runtime_info({a.get_node_shared_ptr(), b.get_node_shared_ptr(), c.get_node_shared_ptr()}, fma);
         fma->set_friendly_name(add->get_friendly_name());
         ov::replace_node(add, fma);
 
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/common/pass/mul_add_to_fma.hpp b/src/plugins/intel_cpu/src/transformations/snippets/common/pass/mul_add_to_fma.hpp
index a4b65bcba14c65..57cf48283e4552 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/common/pass/mul_add_to_fma.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/common/pass/mul_add_to_fma.hpp
@@ -11,10 +11,10 @@ namespace intel_cpu {
 namespace pass {
 
 /**
-* @interface MulAddToFMA
-* @brief Replaces mul and add with FusedMulAdd node
-* @ingroup snippets
-*/
+ * @interface MulAddToFMA
+ * @brief Replaces mul and add with FusedMulAdd node
+ * @ingroup snippets
+ */
 class MulAddToFMA : public ov::pass::MatcherPass {
 public:
     MulAddToFMA();
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_copy_b.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_copy_b.cpp
index 3bda760d2cc180..a513299a516f5f 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_copy_b.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_copy_b.cpp
@@ -98,11 +98,14 @@ void BrgemmCopyB::validate_element_type(const ov::element::Type& element_type) {
 std::shared_ptr<ov::Node> intel_cpu::BrgemmCopyB::clone_with_new_inputs(const OutputVector& new_args) const {
     INTERNAL_OP_SCOPE(BrgemmRepack_clone_with_new_inputs);
     check_new_args_count(this, new_args);
-    return std::make_shared<BrgemmCopyB>(new_args.at(0), m_src_type, m_type,
-                                         get_input_port_descriptor(0),
-                                         get_output_port_descriptor(0),
-                                         with_compensations(m_type) ? get_output_port_descriptor(1) : PortDescriptor{},
-                                         snippets::lowered::PortDescriptorUtils::get_port_descriptor_ptr(input(0))->get_layout());
+    return std::make_shared<BrgemmCopyB>(
+        new_args.at(0),
+        m_src_type,
+        m_type,
+        get_input_port_descriptor(0),
+        get_output_port_descriptor(0),
+        with_compensations(m_type) ? get_output_port_descriptor(1) : PortDescriptor{},
+        snippets::lowered::PortDescriptorUtils::get_port_descriptor_ptr(input(0))->get_layout());
 }
 
 size_t BrgemmCopyB::get_offset_compensations() const {
@@ -118,11 +121,12 @@ BrgemmCopyB::ShapeInfer::ShapeInfer(const std::shared_ptr<ov::Node>& n) {
     m_num_outs = brg_copyb->get_output_size();
 }
 
-ov::snippets::IShapeInferSnippets::Result BrgemmCopyB::ShapeInfer::infer(const std::vector<ov::snippets::VectorDimsRef>& input_shapes) {
+ov::snippets::IShapeInferSnippets::Result BrgemmCopyB::ShapeInfer::infer(
+    const std::vector<ov::snippets::VectorDimsRef>& input_shapes) {
     OPENVINO_ASSERT(input_shapes.size() == 1, "Got unexpected number of input shapes");
     const auto planar_shape = ov::snippets::utils::get_planar_vdims(input_shapes[0].get(), m_layout);
     std::vector<ov::snippets::VectorDims> new_shapes(m_num_outs, planar_shape);
     return {new_shapes, ov::snippets::ShapeInferStatus::success};
 }
-} // namespace intel_cpu
-} // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_copy_b.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_copy_b.hpp
index 93a595a3c5f0e9..54e2c39fcf1c06 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_copy_b.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_copy_b.hpp
@@ -4,11 +4,11 @@
 
 #pragma once
 
+#include "brgemm_utils.hpp"
 #include "openvino/core/attribute_visitor.hpp"
 #include "snippets/op/memory_access.hpp"
 #include "snippets/shape_inference/shape_inference.hpp"
 #include "snippets/shape_types.hpp"
-#include "brgemm_utils.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -25,29 +25,48 @@ class BrgemmCopyB : public snippets::modifier::MemoryAccess, public ov::op::Op {
     using BRGEMM_TYPE = brgemm_utils::BRGEMM_TYPE;
     OPENVINO_OP("BrgemmCopyB", "SnippetsOpset");
 
-    BrgemmCopyB(const Output<Node>& x, const element::Type src_type, BRGEMM_TYPE type = BRGEMM_TYPE::REPACKING_ONLY,
-                const size_t offset_in = 0lu, const size_t offset_out0 = 0lu, const size_t offset_out1 = 0lu,
+    BrgemmCopyB(const Output<Node>& x,
+                const element::Type src_type,
+                BRGEMM_TYPE type = BRGEMM_TYPE::REPACKING_ONLY,
+                const size_t offset_in = 0lu,
+                const size_t offset_out0 = 0lu,
+                const size_t offset_out1 = 0lu,
                 std::vector<size_t> layout_input = {});
-    BrgemmCopyB(const Output<Node>& x, const element::Type src_type, BRGEMM_TYPE type,
-                const PortDescriptor& desc_in0, const PortDescriptor& desc_out0, const PortDescriptor& desc_out1,
+    BrgemmCopyB(const Output<Node>& x,
+                const element::Type src_type,
+                BRGEMM_TYPE type,
+                const PortDescriptor& desc_in0,
+                const PortDescriptor& desc_out0,
+                const PortDescriptor& desc_out1,
                 std::vector<size_t> layout_input = {});
     BrgemmCopyB() = default;
 
-    size_t get_offset_in() const { return get_input_offset(0); }
-    size_t get_offset_out() const { return get_output_offset(0); }
+    size_t get_offset_in() const {
+        return get_input_offset(0);
+    }
+    size_t get_offset_out() const {
+        return get_output_offset(0);
+    }
     size_t get_offset_compensations() const;
 
-    BRGEMM_TYPE get_type() const { return m_type; }
-    element::Type get_src_element_type() const { return m_src_type; }
+    BRGEMM_TYPE get_type() const {
+        return m_type;
+    }
+    element::Type get_src_element_type() const {
+        return m_src_type;
+    }
 
     bool visit_attributes(AttributeVisitor& visitor) override;
     void validate_and_infer_types() override;
-    bool has_evaluate() const override { return false; }
+    bool has_evaluate() const override {
+        return false;
+    }
     std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& new_args) const override;
 
     class ShapeInfer : public snippets::IShapeInferSnippets {
         std::vector<size_t> m_layout{};
         size_t m_num_outs = 1;
+
     public:
         explicit ShapeInfer(const std::shared_ptr<ov::Node>& n);
         Result infer(const std::vector<snippets::VectorDimsRef>& input_shapes) override;
@@ -60,5 +79,5 @@ class BrgemmCopyB : public snippets::modifier::MemoryAccess, public ov::op::Op {
     BRGEMM_TYPE m_type = BRGEMM_TYPE::REPACKING_ONLY;
     element::Type m_src_type = ov::element::undefined;  // src element type of the corresponding BRGEMM
 };
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_cpu.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_cpu.cpp
index 1c3e90bbccf34f..7beab14c7e6737 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_cpu.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_cpu.cpp
@@ -3,21 +3,28 @@
 //
 
 #include "brgemm_cpu.hpp"
+
 #include "snippets/itt.hpp"
-#include "snippets/utils/utils.hpp"
-#include "snippets/snippets_isa.hpp"
 #include "snippets/lowered/port_descriptor.hpp"
+#include "snippets/snippets_isa.hpp"
+#include "snippets/utils/utils.hpp"
 #include "utils/general_utils.h"
 
-
 namespace ov {
 namespace intel_cpu {
 using namespace brgemm_utils;
 
-BrgemmCPU::BrgemmCPU(const Output<Node>& A, const Output<Node>& B, BRGEMM_TYPE type,
-                     const size_t offset_a, const size_t offset_b, const size_t offset_c,
-                     std::vector<size_t> layout_a, std::vector<size_t> layout_b, std::vector<size_t> layout_c)
-    : Brgemm(), m_type(type) {
+BrgemmCPU::BrgemmCPU(const Output<Node>& A,
+                     const Output<Node>& B,
+                     BRGEMM_TYPE type,
+                     const size_t offset_a,
+                     const size_t offset_b,
+                     const size_t offset_c,
+                     std::vector<size_t> layout_a,
+                     std::vector<size_t> layout_b,
+                     std::vector<size_t> layout_c)
+    : Brgemm(),
+      m_type(type) {
     // We call default ctor of Brgemm class to avoid incorrect shape infer in constructor_validate_and_type_infer() call
     set_arguments({A, B});
     set_output_size(1);
@@ -28,10 +35,19 @@ BrgemmCPU::BrgemmCPU(const Output<Node>& A, const Output<Node>& B, BRGEMM_TYPE t
     custom_constructor_validate_and_infer_types(std::move(layout_a), std::move(layout_b), std::move(layout_c));
 }
 
-BrgemmCPU::BrgemmCPU(const Output<Node>& A, const Output<Node>& B, const Output<Node>& scratch, BRGEMM_TYPE type,
-                     const size_t offset_a, const size_t offset_b, const size_t offset_scratch, const size_t offset_c,
-                     std::vector<size_t> layout_a, std::vector<size_t> layout_b, std::vector<size_t> layout_c)
-    : Brgemm(), m_type(type) {
+BrgemmCPU::BrgemmCPU(const Output<Node>& A,
+                     const Output<Node>& B,
+                     const Output<Node>& scratch,
+                     BRGEMM_TYPE type,
+                     const size_t offset_a,
+                     const size_t offset_b,
+                     const size_t offset_scratch,
+                     const size_t offset_c,
+                     std::vector<size_t> layout_a,
+                     std::vector<size_t> layout_b,
+                     std::vector<size_t> layout_c)
+    : Brgemm(),
+      m_type(type) {
     set_arguments({A, B, scratch});
     set_output_size(1);
     ctor_initialize(std::set<size_t>{0, 1, 2}, std::set<size_t>{0});
@@ -42,10 +58,17 @@ BrgemmCPU::BrgemmCPU(const Output<Node>& A, const Output<Node>& B, const Output<
     custom_constructor_validate_and_infer_types(std::move(layout_a), std::move(layout_b), std::move(layout_c));
 }
 
-BrgemmCPU::BrgemmCPU(const Output<Node>& A, const Output<Node>& B, BRGEMM_TYPE type,
-                     const PortDescriptor& desc_a, const PortDescriptor& desc_b, const PortDescriptor& desc_c,
-                     std::vector<size_t> layout_a, std::vector<size_t> layout_b, std::vector<size_t> layout_c)
-    : Brgemm(), m_type(type) {
+BrgemmCPU::BrgemmCPU(const Output<Node>& A,
+                     const Output<Node>& B,
+                     BRGEMM_TYPE type,
+                     const PortDescriptor& desc_a,
+                     const PortDescriptor& desc_b,
+                     const PortDescriptor& desc_c,
+                     std::vector<size_t> layout_a,
+                     std::vector<size_t> layout_b,
+                     std::vector<size_t> layout_c)
+    : Brgemm(),
+      m_type(type) {
     set_arguments({A, B});
     set_output_size(1);
     m_input_ports = {{0, desc_a}, {1, desc_b}};
@@ -53,10 +76,19 @@ BrgemmCPU::BrgemmCPU(const Output<Node>& A, const Output<Node>& B, BRGEMM_TYPE t
     custom_constructor_validate_and_infer_types(std::move(layout_a), std::move(layout_b), std::move(layout_c));
 }
 
-BrgemmCPU::BrgemmCPU(const Output<Node>& A, const Output<Node>& B, const Output<Node>& scratch, BRGEMM_TYPE type,
-                     const PortDescriptor& desc_a, const PortDescriptor& desc_b, const PortDescriptor& desc_scratch, const PortDescriptor& desc_c,
-                     std::vector<size_t> layout_a, std::vector<size_t> layout_b, std::vector<size_t> layout_c)
-    : Brgemm(), m_type(type) {
+BrgemmCPU::BrgemmCPU(const Output<Node>& A,
+                     const Output<Node>& B,
+                     const Output<Node>& scratch,
+                     BRGEMM_TYPE type,
+                     const PortDescriptor& desc_a,
+                     const PortDescriptor& desc_b,
+                     const PortDescriptor& desc_scratch,
+                     const PortDescriptor& desc_c,
+                     std::vector<size_t> layout_a,
+                     std::vector<size_t> layout_b,
+                     std::vector<size_t> layout_c)
+    : Brgemm(),
+      m_type(type) {
     set_arguments({A, B, scratch});
     set_output_size(1);
     m_input_ports = {{0, desc_a}, {1, desc_b}, {2, desc_scratch}};
@@ -64,7 +96,9 @@ BrgemmCPU::BrgemmCPU(const Output<Node>& A, const Output<Node>& B, const Output<
     custom_constructor_validate_and_infer_types(std::move(layout_a), std::move(layout_b), std::move(layout_c));
 }
 
-void BrgemmCPU::custom_constructor_validate_and_infer_types(std::vector<size_t> layout_a, std::vector<size_t> layout_b, std::vector<size_t> layout_c) {
+void BrgemmCPU::custom_constructor_validate_and_infer_types(std::vector<size_t> layout_a,
+                                                            std::vector<size_t> layout_b,
+                                                            std::vector<size_t> layout_c) {
     INTERNAL_OP_SCOPE(BrgemmCPU_constructor_validate_and_infer_types);
     validate_inputs();
 
@@ -93,7 +127,8 @@ void BrgemmCPU::validate_and_infer_types() {
 void BrgemmCPU::validate_with_scratchpad() const {
     // Additional check for 3rd input
     if (with_compensations(m_type)) {
-        OPENVINO_ASSERT(get_input_element_type(2) == ov::element::f32, "BRGEMM Scratch with compensations must have FP32 element type");
+        OPENVINO_ASSERT(get_input_element_type(2) == ov::element::f32,
+                        "BRGEMM Scratch with compensations must have FP32 element type");
     } else if (with_amx(m_type)) {
         OPENVINO_ASSERT(get_input_partial_shape(2).is_static(), "BRGEMM Scratch must have static shape");
         OPENVINO_ASSERT(get_input_element_type(2) == ov::element::u8, "BRGEMM Scratch must have U8 element type");
@@ -101,10 +136,12 @@ void BrgemmCPU::validate_with_scratchpad() const {
 }
 
 void BrgemmCPU::validate_inputs() const {
-    OPENVINO_ASSERT(implication(one_of(m_type, BRGEMM_TYPE::STAND_ALONE, BRGEMM_TYPE::REPACKING_ONLY), get_input_size() == 2),
-                    "BrgemmCPU expects 2 inputs in cases, when input precisions are f32|f32, u8|i8 or bf16|bf16 (non-AMX system)");
-    OPENVINO_ASSERT(implication(one_of(m_type, BRGEMM_TYPE::WITH_COMPENSATIONS, BRGEMM_TYPE::WITH_AMX), get_input_size() == 3),
-                    "BrgemmCPU expects 3 inputs with input precisions i8|i8 and bf16|bf16 on AMX system");
+    OPENVINO_ASSERT(
+        implication(one_of(m_type, BRGEMM_TYPE::STAND_ALONE, BRGEMM_TYPE::REPACKING_ONLY), get_input_size() == 2),
+        "BrgemmCPU expects 2 inputs in cases, when input precisions are f32|f32, u8|i8 or bf16|bf16 (non-AMX system)");
+    OPENVINO_ASSERT(
+        implication(one_of(m_type, BRGEMM_TYPE::WITH_COMPENSATIONS, BRGEMM_TYPE::WITH_AMX), get_input_size() == 3),
+        "BrgemmCPU expects 3 inputs with input precisions i8|i8 and bf16|bf16 on AMX system");
 }
 
 std::shared_ptr<Node> BrgemmCPU::clone_with_new_inputs(const OutputVector& new_args) const {
@@ -112,14 +149,26 @@ std::shared_ptr<Node> BrgemmCPU::clone_with_new_inputs(const OutputVector& new_a
     check_new_args_count(this, new_args);
     std::shared_ptr<BrgemmCPU> brgemm;
     if (!with_scratchpad(m_type)) {
-        return std::make_shared<BrgemmCPU>(new_args.at(0), new_args.at(1), m_type,
-                                           get_input_port_descriptor(0), get_input_port_descriptor(1), get_output_port_descriptor(0),
-                                           snippets::lowered::PortDescriptorUtils::get_port_descriptor_ptr(input(0))->get_layout(),
-                                           snippets::lowered::PortDescriptorUtils::get_port_descriptor_ptr(input(1))->get_layout(),
-                                           snippets::lowered::PortDescriptorUtils::get_port_descriptor_ptr(output(0))->get_layout());
+        return std::make_shared<BrgemmCPU>(
+            new_args.at(0),
+            new_args.at(1),
+            m_type,
+            get_input_port_descriptor(0),
+            get_input_port_descriptor(1),
+            get_output_port_descriptor(0),
+            snippets::lowered::PortDescriptorUtils::get_port_descriptor_ptr(input(0))->get_layout(),
+            snippets::lowered::PortDescriptorUtils::get_port_descriptor_ptr(input(1))->get_layout(),
+            snippets::lowered::PortDescriptorUtils::get_port_descriptor_ptr(output(0))->get_layout());
     } else {
-        return std::make_shared<BrgemmCPU>(new_args.at(0), new_args.at(1), new_args.at(2), m_type,
-            get_input_port_descriptor(0), get_input_port_descriptor(1), get_input_port_descriptor(2), get_output_port_descriptor(0),
+        return std::make_shared<BrgemmCPU>(
+            new_args.at(0),
+            new_args.at(1),
+            new_args.at(2),
+            m_type,
+            get_input_port_descriptor(0),
+            get_input_port_descriptor(1),
+            get_input_port_descriptor(2),
+            get_output_port_descriptor(0),
             snippets::lowered::PortDescriptorUtils::get_port_descriptor_ptr(input(0))->get_layout(),
             snippets::lowered::PortDescriptorUtils::get_port_descriptor_ptr(input(1))->get_layout(),
             snippets::lowered::PortDescriptorUtils::get_port_descriptor_ptr(output(0))->get_layout());
@@ -127,7 +176,8 @@ std::shared_ptr<Node> BrgemmCPU::clone_with_new_inputs(const OutputVector& new_a
 }
 
 size_t BrgemmCPU::get_offset_scratch() const {
-    OPENVINO_ASSERT(with_scratchpad(m_type) && get_input_size() == 3, "Offset of scratchpad must be only in Brgemm with scratchpad on 3rd input");
+    OPENVINO_ASSERT(with_scratchpad(m_type) && get_input_size() == 3,
+                    "Offset of scratchpad must be only in Brgemm with scratchpad on 3rd input");
     return get_input_offset(2);
 }
 
@@ -136,6 +186,6 @@ bool BrgemmCPU::visit_attributes(AttributeVisitor& visitor) {
     visitor.on_attribute("type", m_type);
     return true;
 }
-} // namespace intel_cpu
+}  // namespace intel_cpu
 
-} // namespace ov
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_cpu.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_cpu.hpp
index a781bc7ddd4e15..c2329fdf8af62d 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_cpu.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_cpu.hpp
@@ -4,11 +4,10 @@
 
 #pragma once
 
-#include "snippets/op/brgemm.hpp"
 #include "brgemm_copy_b.hpp"
 #include "brgemm_utils.hpp"
-
 #include "snippets/lowered/port_descriptor.hpp"
+#include "snippets/op/brgemm.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -24,24 +23,54 @@ class BrgemmCPU : public snippets::op::Brgemm {
     using BRGEMM_TYPE = brgemm_utils::BRGEMM_TYPE;
     OPENVINO_OP("BrgemmCPU", "SnippetsOpset", snippets::op::Brgemm);
 
-    BrgemmCPU(const Output<Node>& A, const Output<Node>& B, BRGEMM_TYPE type,
-              const size_t offset_a = 0, const size_t offset_b = 0, const size_t offset_c = 0,
-              std::vector<size_t> layout_a = {}, std::vector<size_t> layout_b = {}, std::vector<size_t> layout_c = {});
-    BrgemmCPU(const Output<Node>& A, const Output<Node>& B, const Output<Node>& scratch, BRGEMM_TYPE type,
-              const size_t offset_a = 0, const size_t offset_b = 0, const size_t offset_scratch = 0, const size_t offset_c = 0,
-              std::vector<size_t> layout_a = {}, std::vector<size_t> layout_b = {}, std::vector<size_t> layout_c = {});
-    BrgemmCPU(const Output<Node>& A, const Output<Node>& B, BRGEMM_TYPE type,
-              const PortDescriptor& desc_a, const PortDescriptor& desc_b, const PortDescriptor& desc_c,
-              std::vector<size_t> layout_a = {}, std::vector<size_t> layout_b = {}, std::vector<size_t> layout_c = {});
-    BrgemmCPU(const Output<Node>& A, const Output<Node>& B, const Output<Node>& scratch, BRGEMM_TYPE type,
-              const PortDescriptor& desc_a, const PortDescriptor& desc_b, const PortDescriptor& desc_scratch, const PortDescriptor& desc_c,
-              std::vector<size_t> layout_a = {}, std::vector<size_t> layout_b = {}, std::vector<size_t> layout_c = {});
+    BrgemmCPU(const Output<Node>& A,
+              const Output<Node>& B,
+              BRGEMM_TYPE type,
+              const size_t offset_a = 0,
+              const size_t offset_b = 0,
+              const size_t offset_c = 0,
+              std::vector<size_t> layout_a = {},
+              std::vector<size_t> layout_b = {},
+              std::vector<size_t> layout_c = {});
+    BrgemmCPU(const Output<Node>& A,
+              const Output<Node>& B,
+              const Output<Node>& scratch,
+              BRGEMM_TYPE type,
+              const size_t offset_a = 0,
+              const size_t offset_b = 0,
+              const size_t offset_scratch = 0,
+              const size_t offset_c = 0,
+              std::vector<size_t> layout_a = {},
+              std::vector<size_t> layout_b = {},
+              std::vector<size_t> layout_c = {});
+    BrgemmCPU(const Output<Node>& A,
+              const Output<Node>& B,
+              BRGEMM_TYPE type,
+              const PortDescriptor& desc_a,
+              const PortDescriptor& desc_b,
+              const PortDescriptor& desc_c,
+              std::vector<size_t> layout_a = {},
+              std::vector<size_t> layout_b = {},
+              std::vector<size_t> layout_c = {});
+    BrgemmCPU(const Output<Node>& A,
+              const Output<Node>& B,
+              const Output<Node>& scratch,
+              BRGEMM_TYPE type,
+              const PortDescriptor& desc_a,
+              const PortDescriptor& desc_b,
+              const PortDescriptor& desc_scratch,
+              const PortDescriptor& desc_c,
+              std::vector<size_t> layout_a = {},
+              std::vector<size_t> layout_b = {},
+              std::vector<size_t> layout_c = {});
     BrgemmCPU() = default;
 
     void validate_and_infer_types() override;
     std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& new_args) const override;
 
-    BRGEMM_TYPE get_type() const { return m_type; }
+    BRGEMM_TYPE get_type() const {
+        return m_type;
+    }
 
     size_t get_offset_scratch() const;
 
@@ -50,11 +79,13 @@ class BrgemmCPU : public snippets::op::Brgemm {
     constexpr static size_t SCRATCH_BYTE_SIZE = 32 * 1024;
 
 private:
-    void custom_constructor_validate_and_infer_types(std::vector<size_t> layout_a, std::vector<size_t> layout_b, std::vector<size_t> layout_c);
+    void custom_constructor_validate_and_infer_types(std::vector<size_t> layout_a,
+                                                     std::vector<size_t> layout_b,
+                                                     std::vector<size_t> layout_c);
     void validate_with_scratchpad() const;
     void validate_inputs() const;
 
     BRGEMM_TYPE m_type = BRGEMM_TYPE::STAND_ALONE;
 };
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_utils.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_utils.cpp
index 9088ced9c18649..e1802d2914127a 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_utils.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_utils.cpp
@@ -23,9 +23,14 @@ namespace brgemm_utils {
 
 cpu_isa_t get_primitive_isa(const ov::element::Type& dt_in0, bool is_with_amx) {
     auto isa = isa_undef;
-#define SUPPORT(X, Y) if (mayiuse(X)) { isa = X; } else { Y }
-#define SUPPORT_ONE(X, MESSAGE) SUPPORT(X, OV_CPU_JIT_EMITTER_THROW(MESSAGE);)
-#define SUPPORT_TWO(X, Y, MESSAGE) SUPPORT(X, SUPPORT_ONE(Y, MESSAGE))
+#define SUPPORT(X, Y) \
+    if (mayiuse(X)) { \
+        isa = X;      \
+    } else {          \
+        Y             \
+    }
+#define SUPPORT_ONE(X, MESSAGE)         SUPPORT(X, OV_CPU_JIT_EMITTER_THROW(MESSAGE);)
+#define SUPPORT_TWO(X, Y, MESSAGE)      SUPPORT(X, SUPPORT_ONE(Y, MESSAGE))
 #define SUPPORT_THREE(X, Y, Z, MESSAGE) SUPPORT(X, SUPPORT_TWO(Y, Z, MESSAGE))
 
     // Note: AMX might be not used even if it's supported by the hardware, check the BrgemmToBrgemmCPU pass for details
@@ -34,9 +39,14 @@ cpu_isa_t get_primitive_isa(const ov::element::Type& dt_in0, bool is_with_amx) {
     } else if (dt_in0 == ov::element::bf16) {
         SUPPORT_ONE(avx512_core_bf16, "Unsupported hardware configuration: bf16 is supported only on avx512 platforms")
     } else if (one_of(dt_in0, ov::element::u8, ov::element::i8)) {
-        SUPPORT_THREE(avx512_core_vnni, avx2_vnni_2, avx2_vnni, "Unsupported hardware configuration: int8 is supported only on vnni platforms")
+        SUPPORT_THREE(avx512_core_vnni,
+                      avx2_vnni_2,
+                      avx2_vnni,
+                      "Unsupported hardware configuration: int8 is supported only on vnni platforms")
     } else {
-        SUPPORT_TWO(avx512_core, cpu::x64::avx2, "Unsupported hardware configuration: brgemm requires at least avx2 isa")
+        SUPPORT_TWO(avx512_core,
+                    cpu::x64::avx2,
+                    "Unsupported hardware configuration: brgemm requires at least avx2 isa")
     }
     return isa;
 #undef SUPPORT_TWO
@@ -58,7 +68,8 @@ BRGEMM_TYPE get_brgemm_type(const ov::element::Type& element_type_a, bool transp
     // Note: this condition reproduces logic from the OneDNN Brgemm implementation. This is needed to align with the
     // backend requirements. More details in onednn/src/cpu/x64/brgemm/brgemm_utils.cpp
     if (element_type_a == ov::element::i8)
-       return dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2_vnni_2) ? BRGEMM_TYPE::REPACKING_ONLY : BRGEMM_TYPE::WITH_COMPENSATIONS;
+        return dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2_vnni_2) ? BRGEMM_TYPE::REPACKING_ONLY
+                                                                                : BRGEMM_TYPE::WITH_COMPENSATIONS;
 
     if (one_of(element_type_a, element::u8, ov::element::bf16))
         return BRGEMM_TYPE::REPACKING_ONLY;
@@ -66,23 +77,29 @@ BRGEMM_TYPE get_brgemm_type(const ov::element::Type& element_type_a, bool transp
 }
 
 size_t compute_vnni_factor(const ov::element::Type& precision) {
-    return data_type_vnni_granularity(static_cast<dnnl_data_type_t>(ov::intel_cpu::DnnlExtensionUtils::ElementTypeToDataType(precision)));
+    return data_type_vnni_granularity(
+        static_cast<dnnl_data_type_t>(ov::intel_cpu::DnnlExtensionUtils::ElementTypeToDataType(precision)));
 }
 
 size_t get_elems_in_vec(const ov::element::Type& precision) {
     using namespace dnnl::impl::cpu;
     OV_CPU_JIT_EMITTER_ASSERT(x64::mayiuse(x64::avx2), "doesn't support non avx512 platforms");
-    const auto vlen = x64::mayiuse(avx512_core) ? x64::cpu_isa_traits<x64::avx512_core>::vlen : x64::cpu_isa_traits<x64::avx2>::vlen;
+    const auto vlen =
+        x64::mayiuse(avx512_core) ? x64::cpu_isa_traits<x64::avx512_core>::vlen : x64::cpu_isa_traits<x64::avx2>::vlen;
     return vlen / precision.size();
 }
 
 namespace repacking {
 size_t compute_inner_n_block(const ov::element::Type& precision) {
     switch (precision) {
-        case element::i8: return 64;
-        case element::bf16: return 32;
-        case element::f32: return 16;
-        default: OPENVINO_THROW("BrgemmCopyB doesn't support precision ", precision);
+    case element::i8:
+        return 64;
+    case element::bf16:
+        return 32;
+    case element::f32:
+        return 16;
+    default:
+        OPENVINO_THROW("BrgemmCopyB doesn't support precision ", precision);
     }
 }
 
@@ -91,12 +108,14 @@ size_t compute_inner_k_block(const ov::element::Type& precision) {
 }
 
 ov::snippets::lowered::ExpressionPtr get_copy_b_expr(const ov::snippets::lowered::ExpressionPtr& brgemm_expr) {
-    OPENVINO_ASSERT(ov::is_type<BrgemmCPU>(brgemm_expr->get_node()), "get_copy_b_expr must be called only for BrgemmCPU node");
+    OPENVINO_ASSERT(ov::is_type<BrgemmCPU>(brgemm_expr->get_node()),
+                    "get_copy_b_expr must be called only for BrgemmCPU node");
     const auto b_input_expr = brgemm_expr->get_input_port_connector(1)->get_source().get_expr();
     if (ov::is_type<BrgemmCopyB>(b_input_expr->get_node())) {
         return b_input_expr;
     } else if (ov::is_type<snippets::lowered::BufferExpression>(b_input_expr)) {
-        OPENVINO_ASSERT(b_input_expr->get_input_count() >= 1, "BufferExpression on brgemm's B input must have at least one input");
+        OPENVINO_ASSERT(b_input_expr->get_input_count() >= 1,
+                        "BufferExpression on brgemm's B input must have at least one input");
         const auto input_buffer_expr = b_input_expr->get_input_port_connector(0)->get_source().get_expr();
         if (ov::is_type<BrgemmCopyB>(input_buffer_expr->get_node())) {
             return input_buffer_expr;
@@ -104,17 +123,17 @@ ov::snippets::lowered::ExpressionPtr get_copy_b_expr(const ov::snippets::lowered
     }
     return nullptr;
 }
-}   // namespace repacking
-}   // namespace brgemm_utils
-}   // namespace intel_cpu
+}  // namespace repacking
+}  // namespace brgemm_utils
+}  // namespace intel_cpu
 template <>
 EnumNames<ov::intel_cpu::brgemm_utils::BRGEMM_TYPE>& EnumNames<ov::intel_cpu::brgemm_utils::BRGEMM_TYPE>::get() {
-    static auto enum_names =
-            EnumNames<ov::intel_cpu::brgemm_utils::BRGEMM_TYPE>("ov::intel_cpu::jit_bgremm_utils::BRGEMM_TYPE",
-                                                                {{"stand_alone", ov::intel_cpu::brgemm_utils::BRGEMM_TYPE::STAND_ALONE},
-                                                                 {"with_amx", ov::intel_cpu::brgemm_utils::BRGEMM_TYPE::WITH_AMX},
-                                                                 {"with_compensations", ov::intel_cpu::brgemm_utils::BRGEMM_TYPE::WITH_COMPENSATIONS},
-                                                                 {"repacking_only", ov::intel_cpu::brgemm_utils::BRGEMM_TYPE::REPACKING_ONLY}});
+    static auto enum_names = EnumNames<ov::intel_cpu::brgemm_utils::BRGEMM_TYPE>(
+        "ov::intel_cpu::jit_bgremm_utils::BRGEMM_TYPE",
+        {{"stand_alone", ov::intel_cpu::brgemm_utils::BRGEMM_TYPE::STAND_ALONE},
+         {"with_amx", ov::intel_cpu::brgemm_utils::BRGEMM_TYPE::WITH_AMX},
+         {"with_compensations", ov::intel_cpu::brgemm_utils::BRGEMM_TYPE::WITH_COMPENSATIONS},
+         {"repacking_only", ov::intel_cpu::brgemm_utils::BRGEMM_TYPE::REPACKING_ONLY}});
     return enum_names;
 }
-}   // namespace ov
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_utils.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_utils.hpp
index 672b67888eef9b..46428828e7139c 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_utils.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/brgemm_utils.hpp
@@ -5,8 +5,8 @@
 #pragma once
 
 #include "cpu/x64/cpu_isa_traits.hpp"
-#include "openvino/core/type/element_type.hpp"
 #include "openvino/core/dimension.hpp"
+#include "openvino/core/type/element_type.hpp"
 #include "snippets/lowered/expression.hpp"
 #include "snippets/utils/utils.hpp"
 
@@ -15,27 +15,40 @@ namespace intel_cpu {
 namespace brgemm_utils {
 
 enum class BRGEMM_TYPE {
-    STAND_ALONE,            // No extra requirements, used for f32|f32
-    WITH_AMX,               // i8|i8 or bf16|bf16 on AMX system - needs BrgemmCopyB and scratchpad
-    WITH_COMPENSATIONS,     // i8|i8 (non-AMX system) - needs BrgemmCopyB for data repacking and compensations
-    REPACKING_ONLY,         // u8|i8, or bf16|bf16 (non-AMX system), or brgemm with transpose_b=true - needs BrgemmCopyB on second input for data repacking
+    STAND_ALONE,         // No extra requirements, used for f32|f32
+    WITH_AMX,            // i8|i8 or bf16|bf16 on AMX system - needs BrgemmCopyB and scratchpad
+    WITH_COMPENSATIONS,  // i8|i8 (non-AMX system) - needs BrgemmCopyB for data repacking and compensations
+    REPACKING_ONLY,      // u8|i8, or bf16|bf16 (non-AMX system), or brgemm with transpose_b=true - needs BrgemmCopyB on
+                         // second input for data repacking
 };
 
 dnnl::impl::cpu::x64::cpu_isa_t get_primitive_isa(const ov::element::Type& dt_in0, bool is_with_amx);
 
 BRGEMM_TYPE get_brgemm_type(const element::Type& element_type_a, bool transpose_b);
 
-inline bool stand_alone(BRGEMM_TYPE type) { return type == BRGEMM_TYPE::STAND_ALONE; }
+inline bool stand_alone(BRGEMM_TYPE type) {
+    return type == BRGEMM_TYPE::STAND_ALONE;
+}
 
-inline bool with_amx(BRGEMM_TYPE type) { return type == BRGEMM_TYPE::WITH_AMX; }
+inline bool with_amx(BRGEMM_TYPE type) {
+    return type == BRGEMM_TYPE::WITH_AMX;
+}
 
-inline bool with_compensations(BRGEMM_TYPE type) { return type == BRGEMM_TYPE::WITH_COMPENSATIONS; }
+inline bool with_compensations(BRGEMM_TYPE type) {
+    return type == BRGEMM_TYPE::WITH_COMPENSATIONS;
+}
 
-inline bool repacking_only(BRGEMM_TYPE type) { return type == BRGEMM_TYPE::REPACKING_ONLY; }
+inline bool repacking_only(BRGEMM_TYPE type) {
+    return type == BRGEMM_TYPE::REPACKING_ONLY;
+}
 
-inline bool with_repacking(BRGEMM_TYPE type) { return type != BRGEMM_TYPE::STAND_ALONE; }
+inline bool with_repacking(BRGEMM_TYPE type) {
+    return type != BRGEMM_TYPE::STAND_ALONE;
+}
 
-inline bool with_scratchpad(BRGEMM_TYPE type) { return with_compensations(type) || with_amx(type); }
+inline bool with_scratchpad(BRGEMM_TYPE type) {
+    return with_compensations(type) || with_amx(type);
+}
 
 /// \brief Computes VNNI factor used by OneDNN implementation. Depends on tensor precision
 size_t compute_vnni_factor(const ov::element::Type& precision);
@@ -52,28 +65,30 @@ size_t compute_inner_k_block(const ov::element::Type& precision);
  * @param n_block N block size shared between BrgemmCPU and BrgemmCopyB node
  * @param precision tensor precision
  */
-template<typename T, typename = typename std::enable_if<(std::is_same<T, size_t>::value || std::is_same<T, int64_t>::value), bool>::type>
+template <
+    typename T,
+    typename = typename std::enable_if<(std::is_same<T, size_t>::value || std::is_same<T, int64_t>::value), bool>::type>
 T compute_LDB(T n_block, const ov::element::Type& precision) {
-    return snippets::utils::is_dynamic_value<T>(n_block) ?
-           n_block :
-           std::max(n_block, static_cast<T>(compute_inner_n_block(precision)));
+    return snippets::utils::is_dynamic_value<T>(n_block)
+               ? n_block
+               : std::max(n_block, static_cast<T>(compute_inner_n_block(precision)));
 }
 /**
- * @brief Retrieves the expression pointer for the brgemm_copy_b expression corresponding to the given BrgemmCPU expression.
+ * @brief Retrieves the expression pointer for the brgemm_copy_b expression corresponding to the given BrgemmCPU
+ * expression.
  * @param brgemm_expr The expression pointer for the BrgemmCPU operation.
  * @return The expression pointer for the BrgemmCopyB operation.
  */
 snippets::lowered::ExpressionPtr get_copy_b_expr(const snippets::lowered::ExpressionPtr& brgemm_expr);
-}   // namespace repacking
-}   // namespace brgemm_utils
-}   // namespace intel_cpu
+}  // namespace repacking
+}  // namespace brgemm_utils
+}  // namespace intel_cpu
 template <>
-class AttributeAdapter<intel_cpu::brgemm_utils::BRGEMM_TYPE> :
-        public EnumAttributeAdapterBase<intel_cpu::brgemm_utils::BRGEMM_TYPE> {
+class AttributeAdapter<intel_cpu::brgemm_utils::BRGEMM_TYPE>
+    : public EnumAttributeAdapterBase<intel_cpu::brgemm_utils::BRGEMM_TYPE> {
 public:
-    AttributeAdapter(intel_cpu::brgemm_utils::BRGEMM_TYPE& value) :
-        EnumAttributeAdapterBase<intel_cpu::brgemm_utils::BRGEMM_TYPE>(value) {
-    }
+    AttributeAdapter(intel_cpu::brgemm_utils::BRGEMM_TYPE& value)
+        : EnumAttributeAdapterBase<intel_cpu::brgemm_utils::BRGEMM_TYPE>(value) {}
     OPENVINO_RTTI("AttributeAdapter<ov::intel_cpu::jit_brgemm_utils::BRGEMM_TYPE>");
 };
-}   // namespace ov
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/load_convert.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/load_convert.cpp
index 6af3660c940045..88e5fe7930fec5 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/load_convert.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/load_convert.cpp
@@ -2,16 +2,19 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "snippets/itt.hpp"
-
 #include "load_convert.hpp"
 
+#include "snippets/itt.hpp"
+
 using namespace std;
 using namespace ov;
 
-intel_cpu::LoadConvertSaturation::LoadConvertSaturation(const Output<Node>& x, const ov::element::Type& destination_type,
-    const size_t count, const size_t offset) :
-    Load(x, count, offset), m_destination_type(destination_type) {
+intel_cpu::LoadConvertSaturation::LoadConvertSaturation(const Output<Node>& x,
+                                                        const ov::element::Type& destination_type,
+                                                        const size_t count,
+                                                        const size_t offset)
+    : Load(x, count, offset),
+      m_destination_type(destination_type) {
     constructor_validate_and_infer_types();
 }
 
@@ -30,13 +33,15 @@ void intel_cpu::LoadConvertSaturation::validate_and_infer_types() {
 std::shared_ptr<Node> intel_cpu::LoadConvertSaturation::clone_with_new_inputs(const OutputVector& new_args) const {
     INTERNAL_OP_SCOPE(LoadConvert_clone_with_new_inputs);
     check_new_args_count(this, new_args);
-    return std::make_shared<LoadConvertSaturation>(
-            new_args.at(0), m_destination_type, get_count(), get_offset());
+    return std::make_shared<LoadConvertSaturation>(new_args.at(0), m_destination_type, get_count(), get_offset());
 }
 
-intel_cpu::LoadConvertTruncation::LoadConvertTruncation(const Output<Node>& x, const ov::element::Type& destination_type,
-    const size_t count, const size_t offset) :
-        Load(x, count, offset), m_destination_type(destination_type) {
+intel_cpu::LoadConvertTruncation::LoadConvertTruncation(const Output<Node>& x,
+                                                        const ov::element::Type& destination_type,
+                                                        const size_t count,
+                                                        const size_t offset)
+    : Load(x, count, offset),
+      m_destination_type(destination_type) {
     constructor_validate_and_infer_types();
 }
 
@@ -55,6 +60,5 @@ void intel_cpu::LoadConvertTruncation::validate_and_infer_types() {
 std::shared_ptr<Node> intel_cpu::LoadConvertTruncation::clone_with_new_inputs(const OutputVector& new_args) const {
     INTERNAL_OP_SCOPE(LoadConvert_clone_with_new_inputs);
     check_new_args_count(this, new_args);
-    return std::make_shared<LoadConvertTruncation>(
-            new_args.at(0), m_destination_type, get_count(), get_offset());
+    return std::make_shared<LoadConvertTruncation>(new_args.at(0), m_destination_type, get_count(), get_offset());
 }
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/load_convert.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/load_convert.hpp
index 25a69b4b2cdbce..74bc7887e8158c 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/load_convert.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/load_convert.hpp
@@ -19,10 +19,15 @@ class LoadConvertSaturation : public snippets::op::Load {
 public:
     OPENVINO_OP("LoadConvertSaturation", "SnippetsOpset", snippets::op::Load);
 
-    LoadConvertSaturation(const Output<Node>& x, const ov::element::Type& destination_type, const size_t count = 1lu, const size_t offset = 0lu);
+    LoadConvertSaturation(const Output<Node>& x,
+                          const ov::element::Type& destination_type,
+                          const size_t count = 1lu,
+                          const size_t offset = 0lu);
     LoadConvertSaturation() = default;
 
-    ov::element::Type get_destination_type() const { return m_destination_type; }
+    ov::element::Type get_destination_type() const {
+        return m_destination_type;
+    }
 
     bool visit_attributes(AttributeVisitor& visitor) override;
 
@@ -30,7 +35,9 @@ class LoadConvertSaturation : public snippets::op::Load {
 
     std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& new_args) const override;
 
-    bool has_evaluate() const override { return false; }
+    bool has_evaluate() const override {
+        return false;
+    }
 
 protected:
     ov::element::Type m_destination_type;
@@ -46,10 +53,15 @@ class LoadConvertTruncation : public snippets::op::Load {
 public:
     OPENVINO_OP("LoadConvertTruncation", "SnippetsOpset", snippets::op::Load);
 
-    LoadConvertTruncation(const Output<Node>& x, const ov::element::Type& destination_type, const size_t count = 1lu, const size_t offset = 0lu);
+    LoadConvertTruncation(const Output<Node>& x,
+                          const ov::element::Type& destination_type,
+                          const size_t count = 1lu,
+                          const size_t offset = 0lu);
     LoadConvertTruncation() = default;
 
-    ov::element::Type get_destination_type() const { return m_destination_type; }
+    ov::element::Type get_destination_type() const {
+        return m_destination_type;
+    }
 
     bool visit_attributes(AttributeVisitor& visitor) override;
 
@@ -57,11 +69,13 @@ class LoadConvertTruncation : public snippets::op::Load {
 
     std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& new_args) const override;
 
-    bool has_evaluate() const override { return false; }
+    bool has_evaluate() const override {
+        return false;
+    }
 
 protected:
     ov::element::Type m_destination_type;
 };
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/perf_count_rdtsc.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/perf_count_rdtsc.cpp
index f350463923370e..24972b2dc8c425 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/perf_count_rdtsc.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/perf_count_rdtsc.cpp
@@ -3,7 +3,7 @@
 //
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#include "perf_count_rdtsc.hpp"
+#    include "perf_count_rdtsc.hpp"
 
 using namespace ov;
 using namespace ov::intel_cpu;
@@ -18,7 +18,10 @@ std::shared_ptr<Node> PerfCountRdtscBegin::clone_with_new_inputs(const OutputVec
 }
 
 /////////////////////////PerfCountRdtscEnd//////////////////////
-PerfCountRdtscEnd::PerfCountRdtscEnd(const Output<Node>& pc_begin) : ov::snippets::op::PerfCountEndBase({pc_begin}), accumulation(0ul), iteration(0u) {
+PerfCountRdtscEnd::PerfCountRdtscEnd(const Output<Node>& pc_begin)
+    : ov::snippets::op::PerfCountEndBase({pc_begin}),
+      accumulation(0ul),
+      iteration(0u) {
     constructor_validate_and_infer_types();
 }
 
@@ -27,8 +30,9 @@ std::shared_ptr<Node> PerfCountRdtscEnd::clone_with_new_inputs(const OutputVecto
 }
 
 std::shared_ptr<PerfCountRdtscBegin> PerfCountRdtscEnd::get_pc_begin() {
-    const auto& pc_begin = ov::as_type_ptr<PerfCountRdtscBegin>(get_input_source_output(get_input_size() - 1).get_node_shared_ptr());
+    const auto& pc_begin =
+        ov::as_type_ptr<PerfCountRdtscBegin>(get_input_source_output(get_input_size() - 1).get_node_shared_ptr());
     OPENVINO_ASSERT(pc_begin != nullptr, "PerfCountRdtscEnd last input is not connected to PerfCountRdtscBegin");
-    return  pc_begin;
+    return pc_begin;
 }
-#endif // SNIPPETS_DEBUG_CAPS
+#endif  // SNIPPETS_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/perf_count_rdtsc.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/perf_count_rdtsc.hpp
index 31e1b9b3633ef5..eeefdf8241aba7 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/perf_count_rdtsc.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/perf_count_rdtsc.hpp
@@ -3,11 +3,12 @@
 //
 #ifdef SNIPPETS_DEBUG_CAPS
 
-#pragma once
+#    pragma once
 
-#include "openvino/op/op.hpp"
-#include "snippets/op/perf_count.hpp"
-#include <iomanip>
+#    include <iomanip>
+
+#    include "openvino/op/op.hpp"
+#    include "snippets/op/perf_count.hpp"
 
 using namespace ov::snippets::op;
 
@@ -48,7 +49,7 @@ class PerfCountRdtscEnd : public PerfCountEndBase {
             avg = integral + static_cast<double>(accumulation - integral * iteration) / iteration;
         }
         std::cerr << "name : " << get_friendly_name() << " : acc : " << accumulation << " : num_hit : " << iteration
-         << std::fixed << std::setprecision(4) << " : avg : " << avg << std::endl;
+                  << std::fixed << std::setprecision(4) << " : avg : " << avg << std::endl;
     }
     std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& inputs) const override;
 
@@ -61,6 +62,6 @@ class PerfCountRdtscEnd : public PerfCountEndBase {
     uint64_t iteration = 0ul;
 };
 
-} // namespace intel_cpu
-} // namespace ov
-#endif // SNIPPETS_DEBUG_CAPS
+}  // namespace intel_cpu
+}  // namespace ov
+#endif  // SNIPPETS_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/store_convert.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/store_convert.cpp
index 61d14970cb08b6..304e09742ba958 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/store_convert.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/store_convert.cpp
@@ -2,16 +2,19 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "snippets/itt.hpp"
-
 #include "store_convert.hpp"
 
+#include "snippets/itt.hpp"
+
 using namespace std;
 using namespace ov;
 
-intel_cpu::StoreConvertSaturation::StoreConvertSaturation(const Output<Node>& x, const ov::element::Type& destination_type,
-    const size_t count, const size_t offset) :
-    Store(x, count, offset), m_destination_type(destination_type) {
+intel_cpu::StoreConvertSaturation::StoreConvertSaturation(const Output<Node>& x,
+                                                          const ov::element::Type& destination_type,
+                                                          const size_t count,
+                                                          const size_t offset)
+    : Store(x, count, offset),
+      m_destination_type(destination_type) {
     constructor_validate_and_infer_types();
 }
 
@@ -30,13 +33,15 @@ void intel_cpu::StoreConvertSaturation::validate_and_infer_types() {
 std::shared_ptr<Node> intel_cpu::StoreConvertSaturation::clone_with_new_inputs(const OutputVector& new_args) const {
     INTERNAL_OP_SCOPE(StoreConvert_clone_with_new_inputs);
     check_new_args_count(this, new_args);
-    return std::make_shared<StoreConvertSaturation>(
-            new_args.at(0), m_destination_type, get_count(), get_offset());
+    return std::make_shared<StoreConvertSaturation>(new_args.at(0), m_destination_type, get_count(), get_offset());
 }
 
-intel_cpu::StoreConvertTruncation::StoreConvertTruncation(const Output<Node>& x, const ov::element::Type& destination_type,
-    const size_t count, const size_t offset) :
-        Store(x, count, offset), m_destination_type(destination_type) {
+intel_cpu::StoreConvertTruncation::StoreConvertTruncation(const Output<Node>& x,
+                                                          const ov::element::Type& destination_type,
+                                                          const size_t count,
+                                                          const size_t offset)
+    : Store(x, count, offset),
+      m_destination_type(destination_type) {
     constructor_validate_and_infer_types();
 }
 
@@ -55,6 +60,5 @@ void intel_cpu::StoreConvertTruncation::validate_and_infer_types() {
 std::shared_ptr<Node> intel_cpu::StoreConvertTruncation::clone_with_new_inputs(const OutputVector& new_args) const {
     INTERNAL_OP_SCOPE(StoreConvert_clone_with_new_inputs);
     check_new_args_count(this, new_args);
-    return std::make_shared<StoreConvertTruncation>(
-            new_args.at(0), m_destination_type, get_count(), get_offset());
+    return std::make_shared<StoreConvertTruncation>(new_args.at(0), m_destination_type, get_count(), get_offset());
 }
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/store_convert.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/store_convert.hpp
index 0298239d222e69..2022f5e56c4c14 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/op/store_convert.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/op/store_convert.hpp
@@ -19,10 +19,15 @@ class StoreConvertSaturation : public snippets::op::Store {
 public:
     OPENVINO_OP("StoreConvertSaturation", "SnippetsOpset", snippets::op::Store);
 
-    StoreConvertSaturation(const Output<Node>& x, const ov::element::Type& destination_type, const size_t count = 1lu, const size_t offset = 0lu);
+    StoreConvertSaturation(const Output<Node>& x,
+                           const ov::element::Type& destination_type,
+                           const size_t count = 1lu,
+                           const size_t offset = 0lu);
     StoreConvertSaturation() = default;
 
-    ov::element::Type get_destination_type() const { return m_destination_type; }
+    ov::element::Type get_destination_type() const {
+        return m_destination_type;
+    }
 
     bool visit_attributes(AttributeVisitor& visitor) override;
 
@@ -30,7 +35,9 @@ class StoreConvertSaturation : public snippets::op::Store {
 
     void validate_and_infer_types() override;
 
-    bool has_evaluate() const override { return false; }
+    bool has_evaluate() const override {
+        return false;
+    }
 
 protected:
     ov::element::Type m_destination_type;
@@ -46,10 +53,15 @@ class StoreConvertTruncation : public snippets::op::Store {
 public:
     OPENVINO_OP("StoreConvertTruncation", "SnippetsOpset", snippets::op::Store);
 
-    StoreConvertTruncation(const Output<Node>& x, const ov::element::Type& destination_type, const size_t count = 1lu, const size_t offset = 0lu);
+    StoreConvertTruncation(const Output<Node>& x,
+                           const ov::element::Type& destination_type,
+                           const size_t count = 1lu,
+                           const size_t offset = 0lu);
     StoreConvertTruncation() = default;
 
-    ov::element::Type get_destination_type() const { return m_destination_type; }
+    ov::element::Type get_destination_type() const {
+        return m_destination_type;
+    }
 
     bool visit_attributes(AttributeVisitor& visitor) override;
 
@@ -57,11 +69,13 @@ class StoreConvertTruncation : public snippets::op::Store {
 
     void validate_and_infer_types() override;
 
-    bool has_evaluate() const override { return false; }
+    bool has_evaluate() const override {
+        return false;
+    }
 
 protected:
     ov::element::Type m_destination_type;
 };
 
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/brgemm_to_brgemm_cpu.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/brgemm_to_brgemm_cpu.cpp
index 50182765856777..48456b8220300a 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/brgemm_to_brgemm_cpu.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/brgemm_to_brgemm_cpu.cpp
@@ -2,46 +2,43 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "snippets/itt.hpp"
-
 #include "brgemm_to_brgemm_cpu.hpp"
 
-#include "snippets/utils/utils.hpp"
+#include "cpu/x64/cpu_isa_traits.hpp"
+#include "cpu_shape.h"
+#include "openvino/core/rt_info.hpp"
+#include "openvino/pass/pattern/matcher.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
+#include "snippets/itt.hpp"
 #include "snippets/op/brgemm.hpp"
 #include "snippets/op/buffer.hpp"
+#include "snippets/utils/utils.hpp"
 #include "transformations/snippets/x64/op/brgemm_copy_b.hpp"
 #include "transformations/snippets/x64/op/brgemm_cpu.hpp"
-#include "transformations/tpp/x64/op/modifiers.hpp"
-
-#include "openvino/core/rt_info.hpp"
-#include "openvino/pass/pattern/op/wrap_type.hpp"
-#include "openvino/pass/pattern/matcher.hpp"
-
-#include "cpu/x64/cpu_isa_traits.hpp"
 #include "transformations/snippets/x64/op/brgemm_utils.hpp"
-
-#include "cpu_shape.h"
+#include "transformations/tpp/x64/op/modifiers.hpp"
 #include "utils/general_utils.h"
 
-
 namespace ov {
 namespace intel_cpu {
 
 using namespace snippets::lowered;
 
 namespace {
-template<typename T>
+template <typename T>
 void set_full_port_desc(const T& port) {
     const auto& shape_rank = port.get_partial_shape().size();
-    static const std::vector<size_t> full_dim_subtensor(std::min(shape_rank, size_t(2)), ov::snippets::utils::get_full_dim_value());
+    static const std::vector<size_t> full_dim_subtensor(std::min(shape_rank, size_t(2)),
+                                                        ov::snippets::utils::get_full_dim_value());
     PortDescriptorUtils::set_port_descriptor(port, full_dim_subtensor);
 }
-} // namespace
+}  // namespace
 
 pass::BrgemmToBrgemmCPU::BrgemmToBrgemmCPU() {
     MATCHER_SCOPE(BrgemmToBrgemmCPU);
     auto is_not_tpp = [](const Output<Node>& out) {
-        return !std::dynamic_pointer_cast<const intel_cpu::tpp::modifier::TensorProcessingPrimitive>(out.get_node_shared_ptr());
+        return !std::dynamic_pointer_cast<const intel_cpu::tpp::modifier::TensorProcessingPrimitive>(
+            out.get_node_shared_ptr());
     };
     auto m_brgemm = ov::pass::pattern::wrap_type<snippets::op::Brgemm>(is_not_tpp);
 
@@ -74,30 +71,68 @@ pass::BrgemmToBrgemmCPU::BrgemmToBrgemmCPU() {
         std::shared_ptr<BrgemmCPU> brgemm_cpu = nullptr;
         std::shared_ptr<BrgemmCopyB> brgemm_repacking = nullptr;
         if (stand_alone(brgemm_type)) {
-            brgemm_cpu = std::make_shared<BrgemmCPU>(brgemm->input_value(0), brgemm->input_value(1), brgemm_type,
-                                                     offset_a, offset_b, offset_c, layout_a, layout_b, layout_c);
+            brgemm_cpu = std::make_shared<BrgemmCPU>(brgemm->input_value(0),
+                                                     brgemm->input_value(1),
+                                                     brgemm_type,
+                                                     offset_a,
+                                                     offset_b,
+                                                     offset_c,
+                                                     layout_a,
+                                                     layout_b,
+                                                     layout_c);
         } else {
-            const auto copy_b_type = with_compensations(brgemm_type) ? brgemm_type : brgemm_utils::BRGEMM_TYPE::REPACKING_ONLY;
-            brgemm_repacking = std::make_shared<BrgemmCopyB>(brgemm->input_value(1), element_type_a, copy_b_type, offset_b, 0, 0, layout_b);
-            PortDescriptorUtils::set_port_descriptor(brgemm_repacking->input(0), brgemm_in1_desc->get_subtensor(), layout_b);
+            const auto copy_b_type =
+                with_compensations(brgemm_type) ? brgemm_type : brgemm_utils::BRGEMM_TYPE::REPACKING_ONLY;
+            brgemm_repacking = std::make_shared<BrgemmCopyB>(brgemm->input_value(1),
+                                                             element_type_a,
+                                                             copy_b_type,
+                                                             offset_b,
+                                                             0,
+                                                             0,
+                                                             layout_b);
+            PortDescriptorUtils::set_port_descriptor(brgemm_repacking->input(0),
+                                                     brgemm_in1_desc->get_subtensor(),
+                                                     layout_b);
             for (const auto& output : brgemm_repacking->outputs())
                 set_full_port_desc(output);
 
             if (with_amx(brgemm_type)) {
                 const auto scratch = std::make_shared<snippets::op::Buffer>(ov::Shape{BrgemmCPU::SCRATCH_BYTE_SIZE});
-                brgemm_cpu = std::make_shared<BrgemmCPU>(brgemm->input_value(0), brgemm_repacking->output(0), scratch, brgemm_type,
-                                                         offset_a, offset_b, 0, offset_c,
-                                                         layout_a, std::vector<size_t>{}, layout_c);
+                brgemm_cpu = std::make_shared<BrgemmCPU>(brgemm->input_value(0),
+                                                         brgemm_repacking->output(0),
+                                                         scratch,
+                                                         brgemm_type,
+                                                         offset_a,
+                                                         offset_b,
+                                                         0,
+                                                         offset_c,
+                                                         layout_a,
+                                                         std::vector<size_t>{},
+                                                         layout_c);
                 set_full_port_desc(scratch->output(0));
                 set_full_port_desc(brgemm_cpu->input(2));
             } else if (with_compensations(brgemm_type)) {
-                brgemm_cpu = std::make_shared<BrgemmCPU>(brgemm->input_value(0), brgemm_repacking->output(0), brgemm_repacking->output(1),
-                                                         brgemm_type, offset_a, offset_b, 0, offset_c,
-                                                         layout_a, std::vector<size_t>{}, layout_c);
+                brgemm_cpu = std::make_shared<BrgemmCPU>(brgemm->input_value(0),
+                                                         brgemm_repacking->output(0),
+                                                         brgemm_repacking->output(1),
+                                                         brgemm_type,
+                                                         offset_a,
+                                                         offset_b,
+                                                         0,
+                                                         offset_c,
+                                                         layout_a,
+                                                         std::vector<size_t>{},
+                                                         layout_c);
             } else if (repacking_only(brgemm_type)) {
-                brgemm_cpu = std::make_shared<BrgemmCPU>(brgemm->input_value(0), brgemm_repacking->output(0), brgemm_type,
-                                                         offset_a, offset_b, offset_c,
-                                                         layout_a, std::vector<size_t>{}, layout_c);
+                brgemm_cpu = std::make_shared<BrgemmCPU>(brgemm->input_value(0),
+                                                         brgemm_repacking->output(0),
+                                                         brgemm_type,
+                                                         offset_a,
+                                                         offset_b,
+                                                         offset_c,
+                                                         layout_a,
+                                                         std::vector<size_t>{},
+                                                         layout_c);
             } else {
                 OPENVINO_THROW("Invalid configuration for BRGEMM CPU");
             }
@@ -127,5 +162,5 @@ pass::BrgemmToBrgemmCPU::BrgemmToBrgemmCPU() {
     auto m = std::make_shared<ov::pass::pattern::Matcher>(m_brgemm, matcher_name);
     register_matcher(m, callback);
 }
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/brgemm_to_brgemm_cpu.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/brgemm_to_brgemm_cpu.hpp
index aa61b7a8293ce2..2cbf2d7e087919 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/brgemm_to_brgemm_cpu.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/brgemm_to_brgemm_cpu.hpp
@@ -32,13 +32,12 @@ namespace pass {
  *                               BrgemmCPU
  * @ingroup snippets
  */
-class BrgemmToBrgemmCPU: public ov::pass::MatcherPass {
+class BrgemmToBrgemmCPU : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("BrgemmToBrgemmCPU", "0");
     BrgemmToBrgemmCPU();
 };
 
-
 }  // namespace pass
 }  // namespace intel_cpu
 }  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/eliminate_brgemm_copy_b.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/eliminate_brgemm_copy_b.cpp
index 4ad2bb8a11a667..939ae93ad92b18 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/eliminate_brgemm_copy_b.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/eliminate_brgemm_copy_b.cpp
@@ -6,8 +6,8 @@
 
 #include "cpu/x64/cpu_isa_traits.hpp"
 #include "openvino/pass/pattern/matcher.hpp"
-#include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "openvino/pass/pattern/op/optional.hpp"
+#include "openvino/pass/pattern/op/wrap_type.hpp"
 #include "snippets/itt.hpp"
 #include "snippets/op/rank_normalization.hpp"
 #include "transformations/snippets/x64/op/brgemm_copy_b.hpp"
@@ -42,5 +42,5 @@ pass::EliminateBrgemmCopyB::EliminateBrgemmCopyB() {
     auto m = std::make_shared<ov::pass::pattern::Matcher>(m_copy_b, matcher_name);
     register_matcher(m, callback);
 }
-} // namespace intel_cpu
-} // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/eliminate_brgemm_copy_b.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/eliminate_brgemm_copy_b.hpp
index 2cdeae53fab026..89815eb1d6ffbf 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/eliminate_brgemm_copy_b.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/eliminate_brgemm_copy_b.hpp
@@ -13,17 +13,17 @@ namespace pass {
 /**
  * @interface EliminateBrgemmCopyB
  * @brief EliminateBrgemmCopyB identifies BrgemmCopyB nodes which can be inferred outside the Subgraph.
- * If this is possible, CopyB node is removed, and the external repacking is configured on the further pipeline stages in RuntimeConfigurator.
- * 
+ * If this is possible, CopyB node is removed, and the external repacking is configured on the further pipeline stages
+ * in RuntimeConfigurator.
+ *
  * @ingroup snippets
  */
-class EliminateBrgemmCopyB: public ov::pass::MatcherPass {
+class EliminateBrgemmCopyB : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("EliminateBrgemmCopyB", "0");
     EliminateBrgemmCopyB();
 };
 
-
 }  // namespace pass
 }  // namespace intel_cpu
 }  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/enforce_precision.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/enforce_precision.cpp
index b90b35f9359aa4..92b5be2692f3b2 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/enforce_precision.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/enforce_precision.cpp
@@ -6,11 +6,11 @@
 
 #include <memory>
 
+#include "cpu/x64/cpu_isa_traits.hpp"
+#include "openvino/core/rt_info.hpp"
 #include "ov_ops/type_relaxed.hpp"
 #include "snippets/itt.hpp"
-#include "openvino/core/rt_info.hpp"
 #include "snippets/pass/propagate_precision.hpp"
-#include "cpu/x64/cpu_isa_traits.hpp"
 #include "transformations/utils/utils.hpp"
 
 using namespace ov::intel_cpu::pass;
@@ -18,10 +18,12 @@ using namespace ov::intel_cpu::pass;
 EnforcePrecision::EnforcePrecision(
     const ov::element::Type source,
     const ov::element::Type target,
-    std::function<std::set<std::vector<ov::element::Type>>(const std::shared_ptr<ov::Node>& op)> get_supported_precisions) :
-    source(source),
-    target(target),
-    get_supported_precisions(get_supported_precisions == nullptr ? get_supported_precisions_default : get_supported_precisions) {
+    std::function<std::set<std::vector<ov::element::Type>>(const std::shared_ptr<ov::Node>& op)>
+        get_supported_precisions)
+    : source(source),
+      target(target),
+      get_supported_precisions(get_supported_precisions == nullptr ? get_supported_precisions_default
+                                                                   : get_supported_precisions) {
     OPENVINO_ASSERT(source != target, "source and target precisions have to be different");
 }
 
@@ -58,7 +60,8 @@ bool EnforcePrecision::run_on_model(const std::shared_ptr<ov::Model>& f) {
                 if ((supported_precisions[index] == target) && (actual_precisions[index] == source)) {
                     // actual input precision has to be enforced: at least one port has to be handled
                     port_has_to_be_handled = true;
-                } else if ((supported_precisions[index] != element::undefined) && (supported_precisions[index] != actual_precisions[index])) {
+                } else if ((supported_precisions[index] != element::undefined) &&
+                           (supported_precisions[index] != actual_precisions[index])) {
                     // actual input precision is not enforced but not supported, operation has to be ignored
                     op_is_appropriate = false;
                     break;
@@ -78,28 +81,24 @@ bool EnforcePrecision::run_on_model(const std::shared_ptr<ov::Model>& f) {
             continue;
         }
 
-        const auto insert_convert = [](
-            const Output<Node>& parent_output,
-            const std::shared_ptr<Node>& op,
-            const size_t input_index,
-            const element::Type& target) {
-            auto convert = std::make_shared<snippets::op::ConvertSaturation>(
-                parent_output,
-                target);
+        const auto insert_convert = [](const Output<Node>& parent_output,
+                                       const std::shared_ptr<Node>& op,
+                                       const size_t input_index,
+                                       const element::Type& target) {
+            auto convert = std::make_shared<snippets::op::ConvertSaturation>(parent_output, target);
             ov::copy_runtime_info(parent_output.get_node_shared_ptr(), convert);
             op->set_argument(input_index, convert);
         };
 
         for (auto index = 0ull; index < supported_precisions_to_enforce.size(); ++index) {
             if ((supported_precisions_to_enforce[index] == target) || (actual_precisions[index] == source)) {
-                const auto op_parent = ov::as_type_ptr<snippets::op::ConvertSaturation>(op->get_input_node_shared_ptr(index));
-                if ((op_parent != nullptr) &&
-                    (op_parent->get_input_element_type(0) == target) &&
+                const auto op_parent =
+                    ov::as_type_ptr<snippets::op::ConvertSaturation>(op->get_input_node_shared_ptr(index));
+                if ((op_parent != nullptr) && (op_parent->get_input_element_type(0) == target) &&
                     // we can remove existing convertion only if precisions before and after are appropriate for removal
-                    snippets::pass::PropagatePrecision::can_be_removed(
-                        op_parent->get_input_element_type(0),
-                        actual_precisions[index],
-                        supported_precisions_to_enforce[index])) {
+                    snippets::pass::PropagatePrecision::can_be_removed(op_parent->get_input_element_type(0),
+                                                                       actual_precisions[index],
+                                                                       supported_precisions_to_enforce[index])) {
                     // remove convert
                     op_parent->output(0).replace(op_parent->get_input_source_output(0));
                     was_updated = true;
@@ -121,8 +120,9 @@ bool EnforcePrecision::run_on_model(const std::shared_ptr<ov::Model>& f) {
 }
 
 std::set<std::vector<ov::element::Type>> EnforcePrecision::get_supported_precisions_default(
-    const std::shared_ptr<ov::Node>&op) noexcept {
-    if (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_bf16) && ov::is_type<snippets::op::Brgemm>(op)) {
+    const std::shared_ptr<ov::Node>& op) noexcept {
+    if (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_bf16) &&
+        ov::is_type<snippets::op::Brgemm>(op)) {
         return {{element::bf16, element::bf16}};
     }
     return {};
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/enforce_precision.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/enforce_precision.hpp
index 3af14277f7936c..05f8d1206715f0 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/enforce_precision.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/enforce_precision.hpp
@@ -4,32 +4,34 @@
 
 #pragma once
 
-#include "snippets/generator.hpp"
-#include "openvino/pass/graph_rewrite.hpp"
-
 #include <memory>
 
+#include "openvino/pass/graph_rewrite.hpp"
+#include "snippets/generator.hpp"
+
 namespace ov {
 namespace intel_cpu {
 namespace pass {
 
-class EnforcePrecision: public ov::pass::ModelPass {
+class EnforcePrecision : public ov::pass::ModelPass {
 public:
     OPENVINO_RTTI("EnforcePrecision", "0");
 
-    EnforcePrecision(
-        const element::Type source,
-        const element::Type target,
-        std::function<std::set<std::vector<element::Type>>(const std::shared_ptr<ov::Node>& op)> get_supported_precisions = nullptr);
+    EnforcePrecision(const element::Type source,
+                     const element::Type target,
+                     std::function<std::set<std::vector<element::Type>>(const std::shared_ptr<ov::Node>& op)>
+                         get_supported_precisions = nullptr);
 
     bool run_on_model(const std::shared_ptr<ov::Model>& m) override;
 
 private:
-    static std::set<std::vector<element::Type>> get_supported_precisions_default(const std::shared_ptr<ov::Node>& op) noexcept;
+    static std::set<std::vector<element::Type>> get_supported_precisions_default(
+        const std::shared_ptr<ov::Node>& op) noexcept;
 
     const element::Type source;
     const element::Type target;
-    const std::function<std::set<std::vector<element::Type>>(const std::shared_ptr<ov::Node>& op)> get_supported_precisions;
+    const std::function<std::set<std::vector<element::Type>>(const std::shared_ptr<ov::Node>& op)>
+        get_supported_precisions;
 };
 
 }  // namespace pass
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/adjust_brgemm_copy_b_loop_ports.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/adjust_brgemm_copy_b_loop_ports.cpp
index 7dfe711a5a5c67..1cb8263d189d18 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/adjust_brgemm_copy_b_loop_ports.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/adjust_brgemm_copy_b_loop_ports.cpp
@@ -2,26 +2,26 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "snippets/itt.hpp"
-
 #include "adjust_brgemm_copy_b_loop_ports.hpp"
-#include "snippets/utils/utils.hpp"
-#include "snippets/lowered/loop_manager.hpp"
+
+#include "snippets/itt.hpp"
 #include "snippets/lowered/expressions/buffer_expression.hpp"
+#include "snippets/lowered/loop_manager.hpp"
+#include "snippets/utils/utils.hpp"
 #include "transformations/snippets/x64/op/brgemm_copy_b.hpp"
 #include "transformations/snippets/x64/op/brgemm_cpu.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
-bool pass::AdjustBrgemmCopyBLoopPorts::update_loop_info(const std::shared_ptr<snippets::lowered::UnifiedLoopInfo>& loop_info) {
+bool pass::AdjustBrgemmCopyBLoopPorts::update_loop_info(
+    const std::shared_ptr<snippets::lowered::UnifiedLoopInfo>& loop_info) {
     OPENVINO_ASSERT(loop_info, "Invalid loop info pointer");
     bool modified = false;
-    auto caller = [&](snippets::lowered::LoopPort &loop_port,
-                      snippets::lowered::UnifiedLoopInfo::LoopPortDesc &loop_desc) {
+    auto caller = [&](snippets::lowered::LoopPort& loop_port,
+                      snippets::lowered::UnifiedLoopInfo::LoopPortDesc& loop_desc) {
         const auto& p = *loop_port.expr_port;
-        if (p.get_type() == snippets::lowered::ExpressionPort::Input &&
-            p.get_index() == 1) {
+        if (p.get_type() == snippets::lowered::ExpressionPort::Input && p.get_index() == 1) {
             const auto& node = p.get_expr()->get_node();
             if (auto brg = as_type_ptr<BrgemmCPU>(node)) {
                 const auto precision = node->get_input_element_type(1);
@@ -30,8 +30,8 @@ bool pass::AdjustBrgemmCopyBLoopPorts::update_loop_info(const std::shared_ptr<sn
                  *  1) VNNI format is applied: KN4k for I8/U8, or KN2k for BF16
                  *  2) Zero padding is applied if N4k < 256 or N2k < 64
                  */
-                if (brgemm_utils::with_repacking(brg->get_type()) &&
-                    precision != element::f32 && loop_port.is_incremented) {
+                if (brgemm_utils::with_repacking(brg->get_type()) && precision != element::f32 &&
+                    loop_port.is_incremented) {
                     // K blocking loop: account for zero padding
                     if (loop_port.dim_idx == 1) {
                         const auto ptr_incr = loop_desc.ptr_increment;
@@ -40,14 +40,16 @@ bool pass::AdjustBrgemmCopyBLoopPorts::update_loop_info(const std::shared_ptr<sn
                             loop_desc.ptr_increment = blocked_shape_ptr_inc;
                             OPENVINO_ASSERT(loop_desc.finalization_offset % ptr_incr == 0,
                                             "Can't rescale finalization offsets");
-                            loop_desc.finalization_offset = loop_desc.ptr_increment *
-                                                             (loop_desc.finalization_offset / ptr_incr);
+                            loop_desc.finalization_offset =
+                                loop_desc.ptr_increment * (loop_desc.finalization_offset / ptr_incr);
                         }
-                    // N blocking loop: account for the VNNI format
+                        // N blocking loop: account for the VNNI format
                     } else if (loop_port.dim_idx == 0) {
                         auto k_blk_size = static_cast<int64_t>(brgemm_utils::compute_vnni_factor(precision));
-                        loop_desc.ptr_increment = snippets::utils::dynamic_safe_mul(loop_desc.ptr_increment, k_blk_size);
-                        loop_desc.finalization_offset = snippets::utils::dynamic_safe_mul(loop_desc.finalization_offset, k_blk_size);
+                        loop_desc.ptr_increment =
+                            snippets::utils::dynamic_safe_mul(loop_desc.ptr_increment, k_blk_size);
+                        loop_desc.finalization_offset =
+                            snippets::utils::dynamic_safe_mul(loop_desc.finalization_offset, k_blk_size);
                     } else {
                         OPENVINO_THROW("Unexpected loop port dimension index in AdjustBrgemmCopyBLoopPorts");
                     }
@@ -66,8 +68,10 @@ bool pass::AdjustBrgemmCopyBLoopPorts::run(const snippets::lowered::LinearIR& li
     bool modified = false;
 
     auto get_repacking_loop_idces = [](const snippets::lowered::ExpressionPtr& brgemm_expr) {
-        // Repacking may be extracted outside the snippets kernel. In this case, brgemm parent expression is a parameter.
-        if (is_type<ov::op::v0::Parameter>(brgemm_expr->get_input_port_connector(1)->get_source().get_expr()->get_node()))
+        // Repacking may be extracted outside the snippets kernel. In this case, brgemm parent expression is a
+        // parameter.
+        if (is_type<ov::op::v0::Parameter>(
+                brgemm_expr->get_input_port_connector(1)->get_source().get_expr()->get_node()))
             return std::vector<size_t>{};
         const auto repacking_expr = brgemm_utils::repacking::get_copy_b_expr(brgemm_expr);
         OPENVINO_ASSERT(repacking_expr, "BrgemmCopyB expression is not found");
@@ -85,9 +89,9 @@ bool pass::AdjustBrgemmCopyBLoopPorts::run(const snippets::lowered::LinearIR& li
             continue;
 
         OPENVINO_ASSERT(brgemm_loop_ids.size() > repacking_loop_ids.size(), "Invalid BrgemmCopyB loop configuration");
-        const auto &loop_manager = linear_ir.get_loop_manager();
+        const auto& loop_manager = linear_ir.get_loop_manager();
         for (auto i = repacking_loop_ids.size(); i < brgemm_loop_ids.size(); i++) {
-            const auto &loop = loop_manager->get_loop_info(brgemm_loop_ids[i]);
+            const auto& loop = loop_manager->get_loop_info(brgemm_loop_ids[i]);
             auto uni_loop = ov::as_type_ptr<snippets::lowered::UnifiedLoopInfo>(loop);
             if (!uni_loop)
                 uni_loop = ov::as_type_ptr<snippets::lowered::ExpandedLoopInfo>(loop)->get_unified_loop_info();
@@ -100,5 +104,5 @@ bool pass::AdjustBrgemmCopyBLoopPorts::run(const snippets::lowered::LinearIR& li
 
     return modified;
 }
-} // namespace intel_cpu
-} // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/adjust_brgemm_copy_b_loop_ports.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/adjust_brgemm_copy_b_loop_ports.hpp
index 794c55d868158a..9ed4162a433411 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/adjust_brgemm_copy_b_loop_ports.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/adjust_brgemm_copy_b_loop_ports.hpp
@@ -4,8 +4,8 @@
 
 #pragma once
 
-#include "snippets/lowered/pass/pass.hpp"
 #include "snippets/lowered/loop_info.hpp"
+#include "snippets/lowered/pass/pass.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -16,15 +16,18 @@ namespace pass {
  * @brief BrgemmCopyB is located outside of blocking loops and repacks input data into a blocked layout.
  *        This layout should be accounted for when we increment BrgemmCopyB data pointers. This pass
  *        Finds loop ports connected to BrgemmCopyB and sets appropriate pointer increments.
-  * @ingroup snippets
+ * @ingroup snippets
  */
-class AdjustBrgemmCopyBLoopPorts: public snippets::lowered::pass::ConstPass {
+class AdjustBrgemmCopyBLoopPorts : public snippets::lowered::pass::ConstPass {
 public:
     AdjustBrgemmCopyBLoopPorts() = default;
     OPENVINO_RTTI("AdjustBrgemmCopyBLoopPorts", "ConstPass");
     bool run(const snippets::lowered::LinearIR& linear_ir) override;
     static bool update_loop_info(const snippets::lowered::UnifiedLoopInfoPtr& uni_loop_info);
-    const std::unordered_set<snippets::lowered::UnifiedLoopInfoPtr>& get_affected_loops() { return m_affected_loops; }
+    const std::unordered_set<snippets::lowered::UnifiedLoopInfoPtr>& get_affected_loops() {
+        return m_affected_loops;
+    }
+
 private:
     std::unordered_set<snippets::lowered::UnifiedLoopInfoPtr> m_affected_loops;
 };
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_copy_b_loop_ports_adjuster.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_copy_b_loop_ports_adjuster.cpp
index d88e0660e9e6fb..bdf811bad90c9d 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_copy_b_loop_ports_adjuster.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_copy_b_loop_ports_adjuster.cpp
@@ -45,5 +45,5 @@ bool BrgemmCopyBLoopPortsAdjuster::run(const snippets::lowered::LinearIR& linear
     return true;
 }
 
-} // namespace intel_cpu
-} // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_copy_b_loop_ports_adjuster.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_copy_b_loop_ports_adjuster.hpp
index 7b9f30ac96e4b1..e6feb6526f41c3 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_copy_b_loop_ports_adjuster.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_copy_b_loop_ports_adjuster.hpp
@@ -19,15 +19,18 @@ namespace intel_cpu {
 class BrgemmCopyBLoopPortsAdjuster : public ov::snippets::lowered::pass::RuntimeOptimizer {
 public:
     BrgemmCopyBLoopPortsAdjuster() = default;
-    BrgemmCopyBLoopPortsAdjuster(const ov::snippets::lowered::LinearIRCPtr& linear_ir, const CPURuntimeConfigurator* configurator);
+    BrgemmCopyBLoopPortsAdjuster(const ov::snippets::lowered::LinearIRCPtr& linear_ir,
+                                 const CPURuntimeConfigurator* configurator);
 
     bool run(const snippets::lowered::LinearIR& linear_ir) override;
-    bool applicable() const override { return !m_affected_uni2exp_map.empty(); }
+    bool applicable() const override {
+        return !m_affected_uni2exp_map.empty();
+    }
 
 private:
-    std::unordered_map<snippets::lowered::UnifiedLoopInfoPtr,
-                       std::vector<snippets::lowered::ExpandedLoopInfoPtr>> m_affected_uni2exp_map;
+    std::unordered_map<snippets::lowered::UnifiedLoopInfoPtr, std::vector<snippets::lowered::ExpandedLoopInfoPtr>>
+        m_affected_uni2exp_map;
 };
 
-} // namespace intel_cpu
-} // namespace ov
\ No newline at end of file
+}  // namespace intel_cpu
+}  // namespace ov
\ No newline at end of file
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_cpu_blocking.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_cpu_blocking.cpp
index 66d6f4d223c90f..f0f87457364e0f 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_cpu_blocking.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_cpu_blocking.cpp
@@ -13,7 +13,6 @@
 #include "transformations/snippets/x64/op/brgemm_cpu.hpp"
 #include "transformations/snippets/x64/op/brgemm_utils.hpp"
 
-
 namespace ov {
 namespace intel_cpu {
 namespace pass {
@@ -27,11 +26,13 @@ using namespace ov::snippets::utils;
 bool BrgemmCPUBlocking::DummyPass::run(LinearIR& linear_ir, LinearIR::constExprIt begin, LinearIR::constExprIt end) {
     return true;
 }
-std::shared_ptr<snippets::lowered::pass::PassBase> BrgemmCPUBlocking::DummyPass::merge(const std::shared_ptr<snippets::lowered::pass::PassBase>& other) {
+std::shared_ptr<snippets::lowered::pass::PassBase> BrgemmCPUBlocking::DummyPass::merge(
+    const std::shared_ptr<snippets::lowered::pass::PassBase>& other) {
     return !other || ov::is_type<DummyPass>(other) ? std::make_shared<DummyPass>() : nullptr;
 }
 
-LinearIR::constExprIt BrgemmCPUBlocking::move_new_memory_buffer(LinearIR& linear_ir, const LinearIR::constExprIt& brgemm_it) {
+LinearIR::constExprIt BrgemmCPUBlocking::move_new_memory_buffer(LinearIR& linear_ir,
+                                                                const LinearIR::constExprIt& brgemm_it) {
     const auto& brgemm_expr = brgemm_it->get();
     const auto wsp_expr = brgemm_expr->get_input_port_connector(2)->get_source().get_expr();
     const auto wsp_buffer = ov::as_type_ptr<ov::snippets::lowered::BufferExpression>(wsp_expr);
@@ -48,7 +49,8 @@ size_t BrgemmCPUBlocking::get_default_n_blk(size_t n) const {
     return dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core) ? 64 : 24;
 }
 
-std::tuple<size_t, size_t, size_t> BrgemmCPUBlocking::get_blocking_params(const ov::snippets::lowered::ExpressionPtr& brgemm_expr) const {
+std::tuple<size_t, size_t, size_t> BrgemmCPUBlocking::get_blocking_params(
+    const ov::snippets::lowered::ExpressionPtr& brgemm_expr) const {
     const auto brgemm = ov::as_type_ptr<ov::intel_cpu::BrgemmCPU>(brgemm_expr->get_node());
     OPENVINO_ASSERT(brgemm, "BrgemmCPU is expected!");
 
@@ -64,7 +66,8 @@ std::tuple<size_t, size_t, size_t> BrgemmCPUBlocking::get_blocking_params(const
 }
 
 SpecificIterationHandlers BrgemmCPUBlocking::get_k_loop_handlers(size_t work_amount, size_t block_size) const {
-    SpecificIterationHandlers handlers = ov::snippets::lowered::pass::BrgemmBlockingBase::get_k_loop_handlers(work_amount, block_size);
+    SpecificIterationHandlers handlers =
+        ov::snippets::lowered::pass::BrgemmBlockingBase::get_k_loop_handlers(work_amount, block_size);
     handlers.register_pass<SpecificLoopIterType::FIRST_ITER, DummyPass>();
     return handlers;
 }
@@ -78,7 +81,11 @@ bool BrgemmCPUBlocking::mark_blocking_loops(LinearIR& linear_ir,
     const auto brgemm = ov::as_type_ptr<ov::intel_cpu::BrgemmCPU>(brgemm_expr->get_node());
     const auto type = brgemm->get_type();
 
-    auto res = ov::snippets::lowered::pass::BrgemmBlockingBase::mark_blocking_loops(linear_ir, brgemm_it, m_block, n_block, k_block);
+    auto res = ov::snippets::lowered::pass::BrgemmBlockingBase::mark_blocking_loops(linear_ir,
+                                                                                    brgemm_it,
+                                                                                    m_block,
+                                                                                    n_block,
+                                                                                    k_block);
 
     if (stand_alone(type))
         return res;
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_cpu_blocking.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_cpu_blocking.hpp
index 0fee4e80454f9a..e354dbe0c5a7fa 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_cpu_blocking.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_cpu_blocking.hpp
@@ -33,16 +33,20 @@ class BrgemmCPUBlocking : public ov::snippets::lowered::pass::BrgemmBlocking<Brg
         bool run(snippets::lowered::LinearIR& linear_ir,
                  snippets::lowered::LinearIR::constExprIt begin,
                  snippets::lowered::LinearIR::constExprIt end) override;
-        std::shared_ptr<snippets::lowered::pass::PassBase> merge(const std::shared_ptr<snippets::lowered::pass::PassBase>& other) override;
+        std::shared_ptr<snippets::lowered::pass::PassBase> merge(
+            const std::shared_ptr<snippets::lowered::pass::PassBase>& other) override;
     };
 
 private:
-    static snippets::lowered::LinearIR::constExprIt move_new_memory_buffer(snippets::lowered::LinearIR& linear_ir,
-                                                                           const snippets::lowered::LinearIR::constExprIt& brgemm_it);
+    static snippets::lowered::LinearIR::constExprIt move_new_memory_buffer(
+        snippets::lowered::LinearIR& linear_ir,
+        const snippets::lowered::LinearIR::constExprIt& brgemm_it);
 
-    snippets::lowered::SpecificIterationHandlers get_k_loop_handlers(size_t work_amount, size_t block_size) const override;
+    snippets::lowered::SpecificIterationHandlers get_k_loop_handlers(size_t work_amount,
+                                                                     size_t block_size) const override;
 
-    std::tuple<size_t, size_t, size_t> get_blocking_params(const ov::snippets::lowered::ExpressionPtr& brgemm_expr) const override;
+    std::tuple<size_t, size_t, size_t> get_blocking_params(
+        const ov::snippets::lowered::ExpressionPtr& brgemm_expr) const override;
     bool mark_blocking_loops(snippets::lowered::LinearIR& linear_ir,
                              const snippets::lowered::LinearIR::constExprIt& brgemm_it,
                              size_t m_block,
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/expressions/brgemm_copy_b_buffer_expressions.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/expressions/brgemm_copy_b_buffer_expressions.cpp
index 638cd8a1005e12..172f337683db2d 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/expressions/brgemm_copy_b_buffer_expressions.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/expressions/brgemm_copy_b_buffer_expressions.cpp
@@ -6,19 +6,19 @@
 
 #include "snippets/lowered/loop_manager.hpp"
 #include "snippets/utils/utils.hpp"
-
 #include "transformations/snippets/x64/op/brgemm_copy_b.hpp"
 #include "utils/general_utils.h"
 
-
 using namespace ov::intel_cpu::brgemm_utils::repacking;
 using namespace ov::snippets::lowered;
 
 namespace ov {
 namespace intel_cpu {
 
-RepackedWeightsBufferExpression::RepackedWeightsBufferExpression(const std::shared_ptr<ov::Node>& n,
-    const std::shared_ptr<snippets::IShapeInferSnippetsFactory>& factory) : BufferExpression(n, factory) {}
+RepackedWeightsBufferExpression::RepackedWeightsBufferExpression(
+    const std::shared_ptr<ov::Node>& n,
+    const std::shared_ptr<snippets::IShapeInferSnippetsFactory>& factory)
+    : BufferExpression(n, factory) {}
 
 snippets::lowered::ExpressionPtr RepackedWeightsBufferExpression::clone() const {
     return std::shared_ptr<RepackedWeightsBufferExpression>(new RepackedWeightsBufferExpression(*this));
@@ -28,13 +28,16 @@ void RepackedWeightsBufferExpression::validate() const {
     BufferExpression::validate();
     OPENVINO_ASSERT(get_input_count() == 1, "RepackedWeightsBufferExpression must have only one input");
     const auto& parent_out = get_input_port_connector(0)->get_source();
-    OPENVINO_ASSERT(ov::is_type<ov::intel_cpu::BrgemmCopyB>(parent_out.get_expr()->get_node()) && parent_out.get_index() == 0,
-                    "RepackedWeightsBufferExpression expects BrgemmCopyB as parent expression");
+    OPENVINO_ASSERT(
+        ov::is_type<ov::intel_cpu::BrgemmCopyB>(parent_out.get_expr()->get_node()) && parent_out.get_index() == 0,
+        "RepackedWeightsBufferExpression expects BrgemmCopyB as parent expression");
 }
 
-void RepackedWeightsBufferExpression::init_allocation_size(const std::shared_ptr<snippets::lowered::LoopManager>& loop_manager, size_t allocation_rank) {
+void RepackedWeightsBufferExpression::init_allocation_size(
+    const std::shared_ptr<snippets::lowered::LoopManager>& loop_manager,
+    size_t allocation_rank) {
     const auto& parent_expr = get_input_port_connector(0)->get_source().get_expr();
-    const auto& in_layout =  parent_expr->get_input_port_descriptor(0)->get_layout();
+    const auto& in_layout = parent_expr->get_input_port_descriptor(0)->get_layout();
     const auto& in_subtensor = ov::snippets::utils::get_projected_subtensor(parent_expr->get_input_port(0));
 
     const size_t n_blk = *in_subtensor.rbegin();
@@ -45,21 +48,25 @@ void RepackedWeightsBufferExpression::init_allocation_size(const std::shared_ptr
     const size_t N_dim = std::max(n_blk, compute_inner_n_block(precision));
     if (!in_layout.empty() && in_layout.back() != in_layout.size() - 1) {
         // In case of transpose, K dimension must be rounded-up to number of elems in vector register
-        // For the details, please see 'transpose16x8' and 'fixup16x16' implementations and usage in onednn/src/cpu/x64/matmul/brgemm_matmul_copy_utils.cpp
+        // For the details, please see 'transpose16x8' and 'fixup16x16' implementations and usage in
+        // onednn/src/cpu/x64/matmul/brgemm_matmul_copy_utils.cpp
         const auto elems_in_vec = brgemm_utils::get_elems_in_vec(precision);
         m_allocation_size = snippets::utils::dynamic_safe_mul(N_dim, snippets::utils::rnd_up(k_blk, elems_in_vec));
     } else {
         // Low precision repacking writes the result by m_brgemmVNNIFactor * m_inner_n_block blocks
-        // despite the actual size of the input data. Because of that we have to round-up the allocation shape to always have enough memory allocated.
-        // For the details, please see 'copy_4x64' and 'copy_2x32' implementations and usage in onednn/src/cpu/x64/matmul/brgemm_matmul_copy_utils.cpp
+        // despite the actual size of the input data. Because of that we have to round-up the allocation shape to always
+        // have enough memory allocated. For the details, please see 'copy_4x64' and 'copy_2x32' implementations and
+        // usage in onednn/src/cpu/x64/matmul/brgemm_matmul_copy_utils.cpp
         const auto brgemmVNNIFactor = brgemm_utils::compute_vnni_factor(precision);
         OPENVINO_ASSERT(brgemmVNNIFactor > 0, "brgemmVNNIFactor value must be positive.");
         m_allocation_size = snippets::utils::dynamic_safe_mul(N_dim, snippets::utils::rnd_up(k_blk, brgemmVNNIFactor));
     }
 }
 
-CompensationsBufferExpression::CompensationsBufferExpression(const std::shared_ptr<ov::Node>& n,
-    const std::shared_ptr<snippets::IShapeInferSnippetsFactory>& factory) : BufferExpression(n, factory) {}
+CompensationsBufferExpression::CompensationsBufferExpression(
+    const std::shared_ptr<ov::Node>& n,
+    const std::shared_ptr<snippets::IShapeInferSnippetsFactory>& factory)
+    : BufferExpression(n, factory) {}
 
 snippets::lowered::ExpressionPtr CompensationsBufferExpression::clone() const {
     return std::shared_ptr<CompensationsBufferExpression>(new CompensationsBufferExpression(*this));
@@ -69,11 +76,14 @@ void CompensationsBufferExpression::validate() const {
     BufferExpression::validate();
     OPENVINO_ASSERT(get_input_count() == 1, "CompensationsBufferExpression must have only one input");
     const auto& parent_out = get_input_port_connector(0)->get_source();
-    OPENVINO_ASSERT(ov::is_type<ov::intel_cpu::BrgemmCopyB>(parent_out.get_expr()->get_node()) && parent_out.get_index() == 1,
-                    "CompensationsBufferExpression expects BrgemmCopyB as parent expression");
+    OPENVINO_ASSERT(
+        ov::is_type<ov::intel_cpu::BrgemmCopyB>(parent_out.get_expr()->get_node()) && parent_out.get_index() == 1,
+        "CompensationsBufferExpression expects BrgemmCopyB as parent expression");
 }
 
-void CompensationsBufferExpression::init_allocation_size(const std::shared_ptr<snippets::lowered::LoopManager>& loop_manager, size_t allocation_rank) {
+void CompensationsBufferExpression::init_allocation_size(
+    const std::shared_ptr<snippets::lowered::LoopManager>& loop_manager,
+    size_t allocation_rank) {
     const auto& parent_expr = get_input_port_connector(0)->get_source().get_expr();
     // Compensations are computed during repacking, so we need to round-up allocation shape according to m_inner_n_block
     // because of OneDNN implementation nuances (as in get_repacking_buffer_size).
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/expressions/brgemm_copy_b_buffer_expressions.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/expressions/brgemm_copy_b_buffer_expressions.hpp
index b85e75c55da30b..2fb3f67d754433 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/expressions/brgemm_copy_b_buffer_expressions.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/expressions/brgemm_copy_b_buffer_expressions.hpp
@@ -11,30 +11,36 @@ namespace intel_cpu {
 
 class RepackedWeightsBufferExpression : public snippets::lowered::BufferExpression {
     friend class snippets::lowered::ExpressionFactory;
+
 public:
     OPENVINO_RTTI("RepackedWeightsBufferExpression", "0", BufferExpression)
     RepackedWeightsBufferExpression() = default;
 
     void validate() const override;
-    void init_allocation_size(const std::shared_ptr<snippets::lowered::LoopManager>& loop_manager, size_t allocation_rank) override;
+    void init_allocation_size(const std::shared_ptr<snippets::lowered::LoopManager>& loop_manager,
+                              size_t allocation_rank) override;
 
 private:
-    RepackedWeightsBufferExpression(const std::shared_ptr<ov::Node>& n, const std::shared_ptr<snippets::IShapeInferSnippetsFactory>& factory);
+    RepackedWeightsBufferExpression(const std::shared_ptr<ov::Node>& n,
+                                    const std::shared_ptr<snippets::IShapeInferSnippetsFactory>& factory);
 
     snippets::lowered::ExpressionPtr clone() const override;
 };
 
 class CompensationsBufferExpression : public snippets::lowered::BufferExpression {
     friend class snippets::lowered::ExpressionFactory;
+
 public:
     OPENVINO_RTTI("CompensationsBufferExpression", "0", BufferExpression)
     CompensationsBufferExpression() = default;
 
     void validate() const override;
-    void init_allocation_size(const std::shared_ptr<snippets::lowered::LoopManager>& loop_manager, size_t allocation_rank) override;
+    void init_allocation_size(const std::shared_ptr<snippets::lowered::LoopManager>& loop_manager,
+                              size_t allocation_rank) override;
 
 private:
-    CompensationsBufferExpression(const std::shared_ptr<ov::Node>& n, const std::shared_ptr<snippets::IShapeInferSnippetsFactory>& factory);
+    CompensationsBufferExpression(const std::shared_ptr<ov::Node>& n,
+                                  const std::shared_ptr<snippets::IShapeInferSnippetsFactory>& factory);
 
     snippets::lowered::ExpressionPtr clone() const override;
 };
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/external_repacking_adjuster.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/external_repacking_adjuster.cpp
index e98c8ebbecf49b..78f9b928298a9d 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/external_repacking_adjuster.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/external_repacking_adjuster.cpp
@@ -50,16 +50,18 @@ bool BrgemmExternalRepackingAdjuster::run(const snippets::lowered::LinearIR& lin
         // Firstly, batch dims are set
         VectorDims requested_blocked_shape(shape.begin(), shape.end() - brgemm_kernel_rank);
         // Then, the blocked dims are formed
-        requested_blocked_shape.insert(
-            requested_blocked_shape.end(),
-            {snippets::utils::div_up(K, vnni_factor), std::max(N, brgemm_utils::repacking::compute_inner_n_block(precision)), vnni_factor});
+        requested_blocked_shape.insert(requested_blocked_shape.end(),
+                                       {snippets::utils::div_up(K, vnni_factor),
+                                        std::max(N, brgemm_utils::repacking::compute_inner_n_block(precision)),
+                                        vnni_factor});
 
         VectorDims requested_order(shape.size() - brgemm_kernel_rank);
         std::iota(requested_order.begin(), requested_order.end(), 0);
         const auto last_idx = shape.size() - 1;
         requested_order.insert(requested_order.end(), {last_idx - 1, last_idx, last_idx - 1});
 
-        optimal_descs[i] = std::make_shared<CpuBlockedMemoryDesc>(precision, Shape(shape), requested_blocked_shape, requested_order);
+        optimal_descs[i] =
+            std::make_shared<CpuBlockedMemoryDesc>(precision, Shape(shape), requested_blocked_shape, requested_order);
 
         ov::snippets::VectorDims shape_for_offset(cpu_config->tensor_rank - shape.size(), 1);
         shape_for_offset.insert(shape_for_offset.end(), requested_blocked_shape.begin(), requested_blocked_shape.end());
@@ -68,5 +70,5 @@ bool BrgemmExternalRepackingAdjuster::run(const snippets::lowered::LinearIR& lin
     return true;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/external_repacking_adjuster.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/external_repacking_adjuster.hpp
index f102af8f23fe5b..4d0c9586f3be31 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/external_repacking_adjuster.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/external_repacking_adjuster.hpp
@@ -19,14 +19,17 @@ namespace intel_cpu {
 class BrgemmExternalRepackingAdjuster : public ov::snippets::lowered::pass::RuntimeOptimizer {
 public:
     BrgemmExternalRepackingAdjuster() = default;
-    BrgemmExternalRepackingAdjuster(const ov::snippets::lowered::LinearIRCPtr& linear_ir, const CPURuntimeConfigurator* configurator);
+    BrgemmExternalRepackingAdjuster(const ov::snippets::lowered::LinearIRCPtr& linear_ir,
+                                    const CPURuntimeConfigurator* configurator);
 
     bool run(const snippets::lowered::LinearIR& linear_ir) override;
-    bool applicable() const override { return !m_param_idces_with_external_repacking.empty(); }
+    bool applicable() const override {
+        return !m_param_idces_with_external_repacking.empty();
+    }
 
 private:
     std::set<size_t> m_param_idces_with_external_repacking;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/fuse_load_store_and_convert.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/fuse_load_store_and_convert.cpp
index de36f1e4a70148..0f5a6472b741f4 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/fuse_load_store_and_convert.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/fuse_load_store_and_convert.cpp
@@ -2,18 +2,17 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
-#include "snippets/itt.hpp"
-
 #include "fuse_load_store_and_convert.hpp"
-#include "snippets/snippets_isa.hpp"
-#include "snippets/lowered/loop_manager.hpp"
 
+#include "snippets/itt.hpp"
+#include "snippets/lowered/loop_manager.hpp"
+#include "snippets/snippets_isa.hpp"
 #include "transformations/snippets/x64/op/load_convert.hpp"
 #include "transformations/snippets/x64/op/store_convert.hpp"
 
-
-bool ov::intel_cpu::pass::FuseLoadStoreConvert::fuse_load_convert(snippets::lowered::LinearIR& linear_ir,
-                                                                  snippets::lowered::LinearIR::constExprIt& convert_it) {
+bool ov::intel_cpu::pass::FuseLoadStoreConvert::fuse_load_convert(
+    snippets::lowered::LinearIR& linear_ir,
+    snippets::lowered::LinearIR::constExprIt& convert_it) {
     const auto& convert_expr = *convert_it;
     const auto& convert = ov::as_type_ptr<ov::op::v0::Convert>(convert_expr->get_node());
     const auto& input_connector = convert_expr->get_input_port_connector(0);
@@ -23,8 +22,7 @@ bool ov::intel_cpu::pass::FuseLoadStoreConvert::fuse_load_convert(snippets::lowe
     const auto& load_output = input_connector->get_source();
     const auto& load_expr = load_output.get_expr();
     const auto load = ov::as_type_ptr<snippets::op::Load>(load_expr->get_node());
-    if (!load ||
-        ov::is_type<snippets::op::LoadReshape>(load_expr->get_node()) ||
+    if (!load || ov::is_type<snippets::op::LoadReshape>(load_expr->get_node()) ||
         ov::is_type<snippets::op::BroadcastLoad>(load_expr->get_node()))
         return false;
 
@@ -33,19 +31,24 @@ bool ov::intel_cpu::pass::FuseLoadStoreConvert::fuse_load_convert(snippets::lowe
         return false;
 
     OPENVINO_ASSERT(convert_expr->get_loop_ids() == load_expr->get_loop_ids(),
-                "The pair of Load and Convert expressions must be in the same loops!");
+                    "The pair of Load and Convert expressions must be in the same loops!");
 
     const auto& parent_source = load_expr->get_input_port_connector(0)->get_source();
     const auto parent_output = parent_source.get_expr()->get_node()->output(parent_source.get_index());
     std::shared_ptr<ov::Node> load_convert = nullptr;
     if (ov::is_type<snippets::op::ConvertSaturation>(convert)) {
-        load_convert = std::make_shared<ov::intel_cpu::LoadConvertSaturation>(parent_output, convert->get_destination_type(),
-                                                                              load->get_count(), load->get_offset());
+        load_convert = std::make_shared<ov::intel_cpu::LoadConvertSaturation>(parent_output,
+                                                                              convert->get_destination_type(),
+                                                                              load->get_count(),
+                                                                              load->get_offset());
     } else if (ov::is_type<snippets::op::ConvertTruncation>(convert)) {
-        load_convert = std::make_shared<ov::intel_cpu::LoadConvertTruncation>(parent_output, convert->get_destination_type(),
-                                                                              load->get_count(), load->get_offset());
+        load_convert = std::make_shared<ov::intel_cpu::LoadConvertTruncation>(parent_output,
+                                                                              convert->get_destination_type(),
+                                                                              load->get_count(),
+                                                                              load->get_offset());
     } else {
-        OPENVINO_THROW("Type of Convert op is undefined. Supports only fusing Load and ConvertTruncation or ConvertSaturation ops");
+        OPENVINO_THROW("Type of Convert op is undefined. Supports only fusing Load and ConvertTruncation or "
+                       "ConvertSaturation ops");
     }
 
     convert_it = linear_ir.replace_with_node({load_expr, convert_expr}, load_convert);
@@ -53,12 +56,14 @@ bool ov::intel_cpu::pass::FuseLoadStoreConvert::fuse_load_convert(snippets::lowe
     return true;
 }
 
-bool ov::intel_cpu::pass::FuseLoadStoreConvert::fuse_store_convert(snippets::lowered::LinearIR& linear_ir,
-                                                                   snippets::lowered::LinearIR::constExprIt& convert_it) {
+bool ov::intel_cpu::pass::FuseLoadStoreConvert::fuse_store_convert(
+    snippets::lowered::LinearIR& linear_ir,
+    snippets::lowered::LinearIR::constExprIt& convert_it) {
     const auto& convert_expr = *convert_it;
     const auto& convert = ov::as_type_ptr<ov::op::v0::Convert>(convert_expr->get_node());
     const auto& output_connector = convert_expr->get_output_port_connector(0);
-    if (convert->get_input_element_type(0) != ov::element::f32 && convert->get_input_element_type(0) != ov::element::i32)
+    if (convert->get_input_element_type(0) != ov::element::f32 &&
+        convert->get_input_element_type(0) != ov::element::i32)
         return false;
 
     const auto consumers = output_connector->get_consumers();
@@ -78,13 +83,18 @@ bool ov::intel_cpu::pass::FuseLoadStoreConvert::fuse_store_convert(snippets::low
     const auto parent_output = parent_source.get_expr()->get_node()->output(parent_source.get_index());
     std::shared_ptr<ov::Node> store_convert = nullptr;
     if (ov::is_type<snippets::op::ConvertSaturation>(convert)) {
-        store_convert = std::make_shared<ov::intel_cpu::StoreConvertSaturation>(parent_output, convert->get_destination_type(),
-                                                                                store->get_count(), store->get_offset());
+        store_convert = std::make_shared<ov::intel_cpu::StoreConvertSaturation>(parent_output,
+                                                                                convert->get_destination_type(),
+                                                                                store->get_count(),
+                                                                                store->get_offset());
     } else if (ov::is_type<snippets::op::ConvertTruncation>(convert)) {
-        store_convert = std::make_shared<ov::intel_cpu::StoreConvertTruncation>(parent_output, convert->get_destination_type(),
-                                                                                store->get_count(), store->get_offset());
+        store_convert = std::make_shared<ov::intel_cpu::StoreConvertTruncation>(parent_output,
+                                                                                convert->get_destination_type(),
+                                                                                store->get_count(),
+                                                                                store->get_offset());
     } else {
-        OPENVINO_THROW("Type of Convert op is undefined. Supports only fusing Store and ConvertTruncation or ConvertSaturation ops");
+        OPENVINO_THROW("Type of Convert op is undefined. Supports only fusing Store and ConvertTruncation or "
+                       "ConvertSaturation ops");
     }
 
     convert_it = linear_ir.replace_with_node({convert_expr, store_expr}, store_convert);
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/fuse_load_store_and_convert.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/fuse_load_store_and_convert.hpp
index a578a7e3cd59a4..33cc9c51bcb5ac 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/fuse_load_store_and_convert.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/fuse_load_store_and_convert.hpp
@@ -18,7 +18,7 @@ namespace pass {
  *        Fuse Store and ConvertTruncation into one op StoreConvertTruncation
  * @ingroup snippets
  */
-class FuseLoadStoreConvert: public snippets::lowered::pass::RangedPass {
+class FuseLoadStoreConvert : public snippets::lowered::pass::RangedPass {
 public:
     FuseLoadStoreConvert() = default;
     OPENVINO_RTTI("FuseLoadStoreConvert", "RangedPass");
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/insert_brgemm_copy_buffers.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/insert_brgemm_copy_buffers.cpp
index 14134b1cd0980f..b2bab35a17c1ad 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/insert_brgemm_copy_buffers.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/insert_brgemm_copy_buffers.cpp
@@ -4,13 +4,11 @@
 
 #include "insert_brgemm_copy_buffers.hpp"
 
-#include "snippets/lowered/loop_manager.hpp"
+#include "expressions/brgemm_copy_b_buffer_expressions.hpp"
 #include "snippets/itt.hpp"
-
-#include "transformations/snippets/x64/op/brgemm_cpu.hpp"
+#include "snippets/lowered/loop_manager.hpp"
 #include "transformations/snippets/x64/op/brgemm_copy_b.hpp"
-#include "expressions/brgemm_copy_b_buffer_expressions.hpp"
-
+#include "transformations/snippets/x64/op/brgemm_cpu.hpp"
 
 using namespace ov::intel_cpu::brgemm_utils::repacking;
 using namespace ov::snippets::lowered;
@@ -24,26 +22,33 @@ bool InsertBrgemmCopyBuffers::run(LinearIR& linear_ir, LinearIR::constExprIt beg
 
     const auto& factory = linear_ir.get_expr_factory();
 
-    auto insert_copy_b_buffer = [&](const ExpressionPtr& copy_b_expr, size_t out_port, LinearIR::constExprIt insertion_pos) {
-        const auto& copy_b = ov::as_type_ptr<ov::intel_cpu::BrgemmCopyB>(copy_b_expr->get_node());
-        const auto& copy_b_out = copy_b_expr->get_output_port_connector(out_port);
-        const auto copy_b_consumers = copy_b_out->get_consumers();
-        OPENVINO_ASSERT(copy_b_consumers.size() == 1, "BufferCopyB must have only one consumer on each out port - Brgemm");
-        const auto& buffer_op = std::make_shared<ov::snippets::op::Buffer>(copy_b->output(out_port));
-        BufferExpressionPtr buffer_expr = nullptr;
-        if (out_port == 0) {
-            buffer_expr = factory->build<RepackedWeightsBufferExpression>(buffer_op, {copy_b_out});
-        } else if (out_port == 1 && with_compensations(copy_b->get_type())) {
-            buffer_expr = factory->build<CompensationsBufferExpression>(buffer_op, {copy_b_out});
-        } else {
-            OPENVINO_THROW("BrgemmCopyB has incorrect output ports");
-        }
-        return linear_ir.insert_expr(buffer_expr, LoopManager::get_common_outer_loops(copy_b_expr, copy_b_consumers.begin()->get_expr()),
-                                     true, insertion_pos, {copy_b_consumers});
-    };
+    auto insert_copy_b_buffer =
+        [&](const ExpressionPtr& copy_b_expr, size_t out_port, LinearIR::constExprIt insertion_pos) {
+            const auto& copy_b = ov::as_type_ptr<ov::intel_cpu::BrgemmCopyB>(copy_b_expr->get_node());
+            const auto& copy_b_out = copy_b_expr->get_output_port_connector(out_port);
+            const auto copy_b_consumers = copy_b_out->get_consumers();
+            OPENVINO_ASSERT(copy_b_consumers.size() == 1,
+                            "BufferCopyB must have only one consumer on each out port - Brgemm");
+            const auto& buffer_op = std::make_shared<ov::snippets::op::Buffer>(copy_b->output(out_port));
+            BufferExpressionPtr buffer_expr = nullptr;
+            if (out_port == 0) {
+                buffer_expr = factory->build<RepackedWeightsBufferExpression>(buffer_op, {copy_b_out});
+            } else if (out_port == 1 && with_compensations(copy_b->get_type())) {
+                buffer_expr = factory->build<CompensationsBufferExpression>(buffer_op, {copy_b_out});
+            } else {
+                OPENVINO_THROW("BrgemmCopyB has incorrect output ports");
+            }
+            return linear_ir.insert_expr(
+                buffer_expr,
+                LoopManager::get_common_outer_loops(copy_b_expr, copy_b_consumers.begin()->get_expr()),
+                true,
+                insertion_pos,
+                {copy_b_consumers});
+        };
 
     auto update_scratchpad = [](const ExpressionPtr& brgemm_expr, const BufferExpressionPtr& scratch_expr) {
-        OPENVINO_ASSERT(scratch_expr && scratch_expr->is_independent_memory(), "Incorrect Scratchpad buffer for Brgemm AMX");
+        OPENVINO_ASSERT(scratch_expr && scratch_expr->is_independent_memory(),
+                        "Incorrect Scratchpad buffer for Brgemm AMX");
         const auto src_dt = brgemm_expr->get_node()->get_input_element_type(0);
         const auto in_subtensor = ov::snippets::utils::get_projected_subtensor(brgemm_expr->get_input_port(0));
         const auto shape0 = ov::snippets::utils::get_planar_vdims(brgemm_expr->get_input_port(0));
@@ -56,7 +61,8 @@ bool InsertBrgemmCopyBuffers::run(LinearIR& linear_ir, LinearIR::constExprIt beg
         const auto tile_scratch_size = BrgemmCPU::SCRATCH_BYTE_SIZE;
         const auto current_scratch_size = scratch_expr->get_byte_size();
         OPENVINO_ASSERT(current_scratch_size == tile_scratch_size,
-                        "Tile scratchpad for BrgemmAMX should have byte size ", tile_scratch_size);
+                        "Tile scratchpad for BrgemmAMX should have byte size ",
+                        tile_scratch_size);
         size_t inner_k_size = 0;
         if (ov::snippets::utils::is_dynamic_value(K_dim)) {
             // In dynamic case we don't know exactly if we need repacking of MatMul first input.
@@ -88,8 +94,8 @@ bool InsertBrgemmCopyBuffers::run(LinearIR& linear_ir, LinearIR::constExprIt beg
             }
 
             if (brgemm_utils::with_amx(brgemm_cpu->get_type())) {
-                const auto& scratch_expr =
-                    ov::as_type_ptr<ov::snippets::lowered::BufferExpression>(brgemm_expr->get_input_port_connector(2)->get_source().get_expr());
+                const auto& scratch_expr = ov::as_type_ptr<ov::snippets::lowered::BufferExpression>(
+                    brgemm_expr->get_input_port_connector(2)->get_source().get_expr());
                 update_scratchpad(brgemm_expr, scratch_expr);
                 modified = true;
             }
@@ -101,4 +107,3 @@ bool InsertBrgemmCopyBuffers::run(LinearIR& linear_ir, LinearIR::constExprIt beg
 }  // namespace pass
 }  // namespace intel_cpu
 }  // namespace ov
-
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/insert_brgemm_copy_buffers.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/insert_brgemm_copy_buffers.hpp
index feca42ca3b8496..6832c4a1694669 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/insert_brgemm_copy_buffers.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/insert_brgemm_copy_buffers.hpp
@@ -14,14 +14,17 @@ namespace pass {
  * @interface InsertBrgemmCopyBuffers
  * @brief Insert Brgemm-specific buffers:
  *          - after BrgemmCopyB with algorithm of allocation size calculation which distinguishes with common algorithm
- *          - update size of `NewMemory` Buffer - add allocation byte size for repacked data from first input of Brgemm in AMX scenario
+ *          - update size of `NewMemory` Buffer - add allocation byte size for repacked data from first input of Brgemm
+ * in AMX scenario
  * @ingroup snippets
  */
-class InsertBrgemmCopyBuffers: public snippets::lowered::pass::RangedPass {
+class InsertBrgemmCopyBuffers : public snippets::lowered::pass::RangedPass {
 public:
     InsertBrgemmCopyBuffers() = default;
     OPENVINO_RTTI("InsertBrgemmCopyBuffers", "0", snippets::lowered::pass::RangedPass);
-    bool run(snippets::lowered::LinearIR& linear_ir, snippets::lowered::LinearIR::constExprIt begin, snippets::lowered::LinearIR::constExprIt end) override;
+    bool run(snippets::lowered::LinearIR& linear_ir,
+             snippets::lowered::LinearIR::constExprIt begin,
+             snippets::lowered::LinearIR::constExprIt end) override;
 };
 
 }  // namespace pass
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/remove_converts.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/remove_converts.cpp
index dca472d2e86e3d..63a08a8f0d9031 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/remove_converts.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/remove_converts.cpp
@@ -4,9 +4,8 @@
 
 #include "remove_converts.hpp"
 
-#include "snippets/itt.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
-
+#include "snippets/itt.hpp"
 #include "snippets/op/convert_saturation.hpp"
 
 ov::intel_cpu::pass::RemoveConverts::RemoveConverts() {
@@ -14,7 +13,8 @@ ov::intel_cpu::pass::RemoveConverts::RemoveConverts() {
     MATCHER_SCOPE(RemoveConverts);
     auto input_m = any_input(type_matches(ov::element::f32));
     auto parent_convert_m = wrap_type<snippets::op::ConvertSaturation>({input_m}, type_matches(ov::element::bf16));
-    auto child_convert_wrap = wrap_type<snippets::op::ConvertSaturation>({parent_convert_m}, type_matches(ov::element::f32));
+    auto child_convert_wrap =
+        wrap_type<snippets::op::ConvertSaturation>({parent_convert_m}, type_matches(ov::element::f32));
 
     auto callback = [=](ov::pass::pattern::Matcher& m) {
         OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "ov::intel_cpu::pass::RemoveConverts")
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/snippets_mark_skipped.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/snippets_mark_skipped.cpp
index cf3bca1a5a3c53..bcffd1841c9c44 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/snippets_mark_skipped.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/snippets_mark_skipped.cpp
@@ -3,36 +3,33 @@
 //
 #include "snippets_mark_skipped.hpp"
 
-#include "snippets/pass/tokenization.hpp"
+#include "cpu/x64/cpu_isa_traits.hpp"
+#include "itt.hpp"
 #include "snippets/op/subgraph.hpp"
+#include "snippets/pass/tokenization.hpp"
 #include "snippets/utils/utils.hpp"
-
-#include "transformations/utils/utils.hpp"
 #include "transformations/utils.hpp"
-#include "utils/general_utils.h"
+#include "transformations/utils/utils.hpp"
 #include "utils/cpu_utils.hpp"
-#include "cpu/x64/cpu_isa_traits.hpp"
-
-#include "itt.hpp"
-
+#include "utils/general_utils.h"
 
 namespace ov {
 namespace intel_cpu {
 
 namespace {
 static const int DEFAULT_AXIS = 1;
-NodeFusingType GetNodeFusingType(const std::shared_ptr<const Node> &node) {
-    auto &rt = node->get_rt_info();
+NodeFusingType GetNodeFusingType(const std::shared_ptr<const Node>& node) {
+    auto& rt = node->get_rt_info();
     const auto rinfo = rt.find("MayBeFusedInPlugin");
     if (rinfo == rt.end())
         return NodeFusingType::NotSet;
     return rinfo->second.as<NodeFusingType>();
 }
-void SetNodeFusingType(const std::shared_ptr<Node> &node, NodeFusingType nodeType) {
-    auto &rt = node->get_rt_info();
+void SetNodeFusingType(const std::shared_ptr<Node>& node, NodeFusingType nodeType) {
+    auto& rt = node->get_rt_info();
     rt["MayBeFusedInPlugin"] = nodeType;
 }
-std::vector<NodeFusingType> getContinuableChains(const std::shared_ptr<const Node> &node) {
+std::vector<NodeFusingType> getContinuableChains(const std::shared_ptr<const Node>& node) {
     std::vector<NodeFusingType> result;
     for (const auto& input : node->inputs()) {
         const auto parent = input.get_source_output().get_node_shared_ptr();
@@ -43,12 +40,12 @@ std::vector<NodeFusingType> getContinuableChains(const std::shared_ptr<const Nod
     }
     return result;
 }
-int getNumNonConstInputs(const std::shared_ptr<const Node> &node) {
+int getNumNonConstInputs(const std::shared_ptr<const Node>& node) {
     int num_non_const_inputs = 0;
-    for (const auto &parent_out : node->input_values()) {
+    for (const auto& parent_out : node->input_values()) {
         const auto parent = parent_out.get_node_shared_ptr();
         if (ov::is_type<ov::op::v1::Reshape>(parent)) {
-            for (const auto &grandparent_out : parent->input_values()) {
+            for (const auto& grandparent_out : parent->input_values()) {
                 const auto grandparent = grandparent_out.get_node_shared_ptr();
                 if (!ov::is_type<ov::op::v0::Constant>(grandparent))
                     num_non_const_inputs++;
@@ -66,28 +63,21 @@ bool isFullyConnected(const std::shared_ptr<const ov::Node>& node) {
     const auto out_weights = node->input_value(1);
     const auto rank_a = out_activations.get_partial_shape().rank();
     const auto rank_w = out_weights.get_partial_shape().rank();
-    return out_weights.get_partial_shape().is_static() &&
-           rank_a.is_static() && rank_w.is_static() &&
-           rank_a.get_length() != 1 && rank_w.get_length() != 1 &&
-           rank_a.get_length() <= 3 && rank_w.get_length() <= 3 &&
-           ov::op::util::is_on_constant_path(out_weights);
+    return out_weights.get_partial_shape().is_static() && rank_a.is_static() && rank_w.is_static() &&
+           rank_a.get_length() != 1 && rank_w.get_length() != 1 && rank_a.get_length() <= 3 &&
+           rank_w.get_length() <= 3 && ov::op::util::is_on_constant_path(out_weights);
 }
-bool SupportsFusingWithConvolution_SumActivation(const std::shared_ptr<const Node> &node) {
+bool SupportsFusingWithConvolution_SumActivation(const std::shared_ptr<const Node>& node) {
     // todo: Do all PReLUs are fused? Not sure about round and softRelu
     // EltwiseRoundHalfToEven, EltwiseRoundHalfAwayFromZero, EltwiseSoftRelu
-    return  ov::is_type<ov::op::v0::Relu>(node) ||
-            ov::is_type<ov::op::v0::PRelu>(node) ||
-            ov::is_type<ov::op::v0::Elu>(node) ||
-            ov::is_type<ov::op::v0::Sigmoid>(node) ||
-            ov::is_type<ov::op::v5::HSigmoid>(node) ||
-            ov::is_type<ov::op::v0::Clamp>(node) ||
-            ov::is_type<ov::op::v4::Swish>(node) ||
-            ov::is_type<ov::op::v4::HSwish>(node) ||
-            ov::is_type<ov::op::v4::Mish>(node) ||
-            ov::is_type<ov::op::v5::Round>(node);
+    return ov::is_type<ov::op::v0::Relu>(node) || ov::is_type<ov::op::v0::PRelu>(node) ||
+           ov::is_type<ov::op::v0::Elu>(node) || ov::is_type<ov::op::v0::Sigmoid>(node) ||
+           ov::is_type<ov::op::v5::HSigmoid>(node) || ov::is_type<ov::op::v0::Clamp>(node) ||
+           ov::is_type<ov::op::v4::Swish>(node) || ov::is_type<ov::op::v4::HSwish>(node) ||
+           ov::is_type<ov::op::v4::Mish>(node) || ov::is_type<ov::op::v5::Round>(node);
 }
 
-bool canBePerformedAsScaleShift(const std::shared_ptr<const Node> &node, const int channelAxis) {
+bool canBePerformedAsScaleShift(const std::shared_ptr<const Node>& node, const int channelAxis) {
     size_t fusingPort = 0;
     size_t numNonConstInputs = 0;
     ov::PartialShape dataShape;
@@ -113,7 +103,10 @@ bool canBePerformedAsScaleShift(const std::shared_ptr<const Node> &node, const i
             if (i == fusingPort)
                 continue;
             const ov::PartialShape weightShape = node->get_input_partial_shape(i);
-            if (!isPerTensorOrPerChannelBroadcastable(dataShape.get_max_shape(), weightShape.get_max_shape(), channelAxis, true))
+            if (!isPerTensorOrPerChannelBroadcastable(dataShape.get_max_shape(),
+                                                      weightShape.get_max_shape(),
+                                                      channelAxis,
+                                                      true))
                 return false;
         }
         return true;
@@ -121,10 +114,8 @@ bool canBePerformedAsScaleShift(const std::shared_ptr<const Node> &node, const i
 
     // Prelu and MulAdd are still ignored
     // isConvertablePowerStatic() is ignored
-    return (ov::is_type<ov::opset1::Add>(node) ||
-            ov::is_type<ov::opset1::Multiply>(node) ||
-            ov::is_type<ov::opset1::Subtract>(node) ||
-            ov::is_type<ov::opset1::Divide>(node)) &&
+    return (ov::is_type<ov::opset1::Add>(node) || ov::is_type<ov::opset1::Multiply>(node) ||
+            ov::is_type<ov::opset1::Subtract>(node) || ov::is_type<ov::opset1::Divide>(node)) &&
            isBroadcastableToDataInput();
 }
 
@@ -132,36 +123,33 @@ inline bool canBeMatMulExecutedInInt8(const ov::element::Type& firstType, const
     return one_of(firstType, ov::element::i8, ov::element::u8) && secondType == ov::element::i8;
 }
 
-bool SupportsFusingWithConvolution_Simple(const std::shared_ptr<const Node> &node, const int channelAxis = DEFAULT_AXIS) {
-    return SupportsFusingWithConvolution_SumActivation(node) ||
-           ov::is_type<ov::op::v0::Tanh>(node) ||
-           ov::is_type<ov::op::v0::Gelu>(node) ||
-           ov::is_type<ov::op::v7::Gelu>(node) ||
-           ov::is_type<ov::op::v0::Abs>(node) ||
-           ov::is_type<ov::op::v0::Sqrt>(node) ||
-           ov::is_type<ov::op::v0::FakeQuantize>(node) ||
-           canBePerformedAsScaleShift(node, channelAxis);
+bool SupportsFusingWithConvolution_Simple(const std::shared_ptr<const Node>& node,
+                                          const int channelAxis = DEFAULT_AXIS) {
+    return SupportsFusingWithConvolution_SumActivation(node) || ov::is_type<ov::op::v0::Tanh>(node) ||
+           ov::is_type<ov::op::v0::Gelu>(node) || ov::is_type<ov::op::v7::Gelu>(node) ||
+           ov::is_type<ov::op::v0::Abs>(node) || ov::is_type<ov::op::v0::Sqrt>(node) ||
+           ov::is_type<ov::op::v0::FakeQuantize>(node) || canBePerformedAsScaleShift(node, channelAxis);
 }
 // Convolution is a special case, since it supports peculiar fusings
-bool isSuitableConvolutionParent(const std::shared_ptr<const Node> &node) {
-    const bool is_suitable_node = ov::is_type<ov::op::v1::Convolution>(node) ||
-                                  ov::is_type<ov::op::v1::GroupConvolution>(node);
+bool isSuitableConvolutionParent(const std::shared_ptr<const Node>& node) {
+    const bool is_suitable_node =
+        ov::is_type<ov::op::v1::Convolution>(node) || ov::is_type<ov::op::v1::GroupConvolution>(node);
     // has a single output, connected to a single child
     const auto out = node->outputs();
     const bool has_only_child = (out.size() == 1) && (out[0].get_target_inputs().size() == 1);
     return is_suitable_node && has_only_child;
 }
-bool isSuitableBinaryConvolutionParent(const std::shared_ptr<const Node> &node) {
+bool isSuitableBinaryConvolutionParent(const std::shared_ptr<const Node>& node) {
     const bool is_suitable_node = ov::is_type<ov::op::v1::BinaryConvolution>(node);
     // has a single output, connected to a single child
     const auto out = node->outputs();
     const bool has_only_child = (out.size() == 1) && (out[0].get_target_inputs().size() == 1);
     return is_suitable_node && has_only_child;
 }
-int getChannelAxis(const ov::AxisSet &axes, bool keep_dims) {
+int getChannelAxis(const ov::AxisSet& axes, bool keep_dims) {
     int channelAxis = DEFAULT_AXIS;
     if (!keep_dims) {
-        for (auto &axis : axes) {
+        for (auto& axis : axes) {
             if (axis == 1) {
                 // channel axis has been reduced and doesn't exist any more
                 channelAxis = -1;
@@ -173,26 +161,22 @@ int getChannelAxis(const ov::AxisSet &axes, bool keep_dims) {
     }
     return channelAxis;
 }
-bool isSuitableMiscParent(const std::shared_ptr<const Node> &node) {
-    const bool is_suitable_node = ov::is_type<ov::op::v0::MVN>(node) ||
-                                  ov::is_type<ov::op::v6::MVN>(node) ||
-                                  ov::is_type<ov::op::v0::NormalizeL2>(node) ||
-                                  ov::is_type<ov::op::v0::Interpolate>(node) ||
-                                  ov::is_type<ov::op::v4::Interpolate>(node) ||
-                                  ov::is_type<ov::op::v0::LSTMCell>(node) ||
-                                  ov::is_type<ov::op::v4::LSTMCell>(node) ||
-                                  ov::is_type<ov::opset1::ConvolutionBackpropData>(node) ||
-                                  ov::is_type<ov::op::util::ArithmeticReductionKeepDims>(node) ||
-                                  ov::is_type<ov::opset1::GroupConvolutionBackpropData>(node) ||
-                                  ov::is_type<ov::opset1::AvgPool>(node) ||
-                                  ov::is_type<ov::op::v14::AvgPool>(node);
+bool isSuitableMiscParent(const std::shared_ptr<const Node>& node) {
+    const bool is_suitable_node =
+        ov::is_type<ov::op::v0::MVN>(node) || ov::is_type<ov::op::v6::MVN>(node) ||
+        ov::is_type<ov::op::v0::NormalizeL2>(node) || ov::is_type<ov::op::v0::Interpolate>(node) ||
+        ov::is_type<ov::op::v4::Interpolate>(node) || ov::is_type<ov::op::v0::LSTMCell>(node) ||
+        ov::is_type<ov::op::v4::LSTMCell>(node) || ov::is_type<ov::opset1::ConvolutionBackpropData>(node) ||
+        ov::is_type<ov::op::util::ArithmeticReductionKeepDims>(node) ||
+        ov::is_type<ov::opset1::GroupConvolutionBackpropData>(node) || ov::is_type<ov::opset1::AvgPool>(node) ||
+        ov::is_type<ov::op::v14::AvgPool>(node);
     // has a single output, connected to a single child
     const auto out = node->outputs();
     const bool has_only_child = (out.size() == 1) && (out[0].get_target_inputs().size() == 1);
     return is_suitable_node && has_only_child;
 }
 // Matmul is a special case, since it supports simple + bias fusings
-bool isSuitableMatMulParent(const std::shared_ptr<const Node> &node) {
+bool isSuitableMatMulParent(const std::shared_ptr<const Node>& node) {
     const bool is_suitable_node = ov::is_type<ov::op::v0::MatMul>(node);
     // has a single output, connected to a single child
     const auto out = node->outputs();
@@ -200,11 +184,11 @@ bool isSuitableMatMulParent(const std::shared_ptr<const Node> &node) {
     return is_suitable_node && has_only_child;
 }
 // From Reduce::canFuse() corner case. CanFuseSimpleOperation is covered by Misc
-inline bool isSuitableReduceParent(const std::shared_ptr<const Node> &node) {
+inline bool isSuitableReduceParent(const std::shared_ptr<const Node>& node) {
     return ov::is_type<ov::op::util::ArithmeticReductionKeepDims>(node) && isSuitableMiscParent(node);
 }
 // Subtract as ZeroPoints for Convolution
-bool isSuitableSubtractAsZeroPointsParent(const std::shared_ptr<const Node> &node) {
+bool isSuitableSubtractAsZeroPointsParent(const std::shared_ptr<const Node>& node) {
     const bool is_suitable_node = ov::is_type<ov::op::v1::Subtract>(node);
     const auto out = node->outputs();
     const bool has_only_child = (out.size() == 1) && (out[0].get_target_inputs().size() == 1);
@@ -240,33 +224,35 @@ bool isSuitableSubtractAsZeroPointsParent(const std::shared_ptr<const Node> &nod
     const bool zp_weights_is_suitable = ov::is_type<ov::op::v0::Constant>(zp_weights) &&
                                         zp_weights->get_element_type() == ov::element::u8 &&
                                         zp_weight_shape.size() >= 2 && correct_shape == zp_weight_shape;
-    const bool first_conv_input_is_suitable = node->get_input_element_type(0) == ov::element::u8 &&
-                                              zp_weights_is_suitable;
+    const bool first_conv_input_is_suitable =
+        node->get_input_element_type(0) == ov::element::u8 && zp_weights_is_suitable;
 
     const auto conv_weights = child->get_input_node_shared_ptr(1);
-    bool second_conv_input_is_suitable = ov::is_type<ov::op::v0::Constant>(conv_weights) &&
-                                         conv_weights->get_output_element_type(0) == ov::element::i8;
+    bool second_conv_input_is_suitable =
+        ov::is_type<ov::op::v0::Constant>(conv_weights) && conv_weights->get_output_element_type(0) == ov::element::i8;
     return first_conv_input_is_suitable && second_conv_input_is_suitable;
 }
-bool isSuitablePoolChild(const std::shared_ptr<const Node> &node) {
+bool isSuitablePoolChild(const std::shared_ptr<const Node>& node) {
     const bool is_suitable_node = ov::is_type<ov::op::v1::MaxPool>(node);
     // has a single output, connected to a single child
     const auto out = node->outputs();
     const bool has_only_child = (out.size() == 1) && (out[0].get_target_inputs().size() == 1);
     return is_suitable_node && has_only_child;
 }
-bool isSuitableChildForFusingSimple(const std::shared_ptr<const Node> &node, const int channelAxis = DEFAULT_AXIS) {
+bool isSuitableChildForFusingSimple(const std::shared_ptr<const Node>& node, const int channelAxis = DEFAULT_AXIS) {
     // Note: Fusing child is allowed to have several users, but that must be the end of the chain
     return SupportsFusingWithConvolution_Simple(node, channelAxis) && getNumNonConstInputs(node) == 1;
 }
 
-bool isSuitableChildForFusingMatMul(const std::shared_ptr<const Node> &node, const bool canMatMulBeExecutedInI8,
-                                    NodeFusingType &updatedChainType, int& fusingAxis) {
+bool isSuitableChildForFusingMatMul(const std::shared_ptr<const Node>& node,
+                                    const bool canMatMulBeExecutedInI8,
+                                    NodeFusingType& updatedChainType,
+                                    int& fusingAxis) {
     // Firsly check for Bias and DQScales fusion
     const bool is_bias = ov::is_type<ov::opset1::Add>(node);
     const bool is_dq_scales = ov::is_type<ov::opset1::Multiply>(node) && canMatMulBeExecutedInI8;
     if (is_bias || is_dq_scales) {
-        for (const auto &in : node->inputs()) {
+        for (const auto& in : node->inputs()) {
             const auto& parent_out = in.get_source_output();
             const auto& parent = parent_out.get_node_shared_ptr();
             const auto& parent_pshape = parent_out.get_partial_shape();
@@ -280,7 +266,7 @@ bool isSuitableChildForFusingMatMul(const std::shared_ptr<const Node> &node, con
                 const auto& bias_pshape = bias_out.get_partial_shape();
                 if (bias_pshape.is_dynamic())
                     break;
-                auto getNormalizedPShape = [](const ov::PartialShape &dims, size_t ndims) ->  ov::PartialShape {
+                auto getNormalizedPShape = [](const ov::PartialShape& dims, size_t ndims) -> ov::PartialShape {
                     if (dims.size() >= ndims)
                         return dims;
                     ov::PartialShape pshape(std::vector<size_t>(ndims, 1));
@@ -288,10 +274,12 @@ bool isSuitableChildForFusingMatMul(const std::shared_ptr<const Node> &node, con
                     return pshape;
                 };
                 const auto bias_pshape_norm = getNormalizedPShape(bias_pshape, parent_pshape.size());
-                if (fusingAxis >= static_cast<int>(bias_pshape_norm.size()) || fusingAxis >= static_cast<int>(parent_pshape.size()) ||
+                if (fusingAxis >= static_cast<int>(bias_pshape_norm.size()) ||
+                    fusingAxis >= static_cast<int>(parent_pshape.size()) ||
                     bias_pshape_norm.size() != parent_pshape.size() || bias_pshape_norm.size() < 2)
                     break;
-                if (((bias_pshape_norm[fusingAxis] == parent_pshape[fusingAxis]) || (is_dq_scales && bias_pshape_norm[fusingAxis] == 1)) &&
+                if (((bias_pshape_norm[fusingAxis] == parent_pshape[fusingAxis]) ||
+                     (is_dq_scales && bias_pshape_norm[fusingAxis] == 1)) &&
                     (bias_pshape_norm[fusingAxis] == static_cast<int64_t>(shape_size(bias_pshape_norm.get_shape()))))
                     return true;
             }
@@ -300,9 +288,9 @@ bool isSuitableChildForFusingMatMul(const std::shared_ptr<const Node> &node, con
 
     // MatMul specific checks from ::canFuse()
     if (one_of(updatedChainType, NodeFusingType::FusedWithMatMul, NodeFusingType::FusedWithMatMulI8)) {
-        const auto is_binary_eltwise =
-            ov::is_type<ov::op::v1::Add>(node) || ov::is_type<ov::op::v1::Multiply>(node) || ov::is_type<ov::op::v1::Subtract>(node) ||
-            ov::is_type<ov::op::v1::Divide>(node) || ov::is_type<ov::op::v0::PRelu>(node);
+        const auto is_binary_eltwise = ov::is_type<ov::op::v1::Add>(node) || ov::is_type<ov::op::v1::Multiply>(node) ||
+                                       ov::is_type<ov::op::v1::Subtract>(node) ||
+                                       ov::is_type<ov::op::v1::Divide>(node) || ov::is_type<ov::op::v0::PRelu>(node);
         const auto rank = node->get_output_partial_shape(0).rank();
         if (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core) && rank.is_static() && is_binary_eltwise) {
             const auto const1 = ov::is_type<ov::op::v0::Constant>(node->get_input_node_shared_ptr(0));
@@ -334,10 +322,13 @@ bool isSuitableChildForFusingMatMul(const std::shared_ptr<const Node> &node, con
     if (SupportsFusingWithConvolution_Simple(node, fusingAxis)) {
         size_t num_non_const_inputs = 0;
         size_t num_mm_inputs = 0;
-        for (const auto &parent_out : node->input_values()) {
+        for (const auto& parent_out : node->input_values()) {
             // To avoid endless check `is_on_constant_path` for MatMul branch
-            if (one_of(GetNodeFusingType(parent_out.get_node_shared_ptr()), NodeFusingType::FusedWithMatMul, NodeFusingType::FusedWithMatMulI8,
-                                                                            NodeFusingType::FusedWithFC, NodeFusingType::FusedWithFCI8))
+            if (one_of(GetNodeFusingType(parent_out.get_node_shared_ptr()),
+                       NodeFusingType::FusedWithMatMul,
+                       NodeFusingType::FusedWithMatMulI8,
+                       NodeFusingType::FusedWithFC,
+                       NodeFusingType::FusedWithFCI8))
                 num_mm_inputs++;
             else if (!ov::op::util::is_on_constant_path(parent_out))
                 num_non_const_inputs++;
@@ -351,22 +342,22 @@ bool isSuitableChildForFusingMatMul(const std::shared_ptr<const Node> &node, con
 
     return false;
 }
-bool isSuitableParentForFusingSumActivation(const std::shared_ptr<const Node> &node) {
+bool isSuitableParentForFusingSumActivation(const std::shared_ptr<const Node>& node) {
     if (!ov::is_type<ov::op::v1::Add>(node))
         return false;
-    auto isFusedBiasNode = [](std::shared_ptr<Node> n){
-        if (!(ov::is_type<ov::op::v1::Add>(n) &&
-              GetNodeFusingType(n) ==  NodeFusingType::FusedWithConvolution))
+    auto isFusedBiasNode = [](std::shared_ptr<Node> n) {
+        if (!(ov::is_type<ov::op::v1::Add>(n) && GetNodeFusingType(n) == NodeFusingType::FusedWithConvolution))
             return false;
         const auto conv = n->get_input_source_output(0);
         const auto bias = n->get_input_source_output(1);
-        if (!(ov::is_type<ov::op::v0::Constant>(bias.get_node_shared_ptr()) && isSuitableConvolutionParent(conv.get_node_shared_ptr())))
+        if (!(ov::is_type<ov::op::v0::Constant>(bias.get_node_shared_ptr()) &&
+              isSuitableConvolutionParent(conv.get_node_shared_ptr())))
             return false;
         const auto& conv_shape = conv.get_partial_shape();
         const auto& bias_shape = bias.get_partial_shape();
         if (conv_shape.rank().is_dynamic())
             return false;
-        auto getNormalizedDims = [](const ov::Shape &dims, size_t ndims) -> ov::Shape {
+        auto getNormalizedDims = [](const ov::Shape& dims, size_t ndims) -> ov::Shape {
             ov::Shape normalizedDims = dims;
             for (size_t i = 0; i < (ndims - dims.size()); i++) {
                 normalizedDims.insert(normalizedDims.begin(), 1);
@@ -377,32 +368,31 @@ bool isSuitableParentForFusingSumActivation(const std::shared_ptr<const Node> &n
         if (conv_shape.size() != bias_norm_dims.size() || bias_norm_dims.size() < 2)
             return false;
         const auto channelAxis = 1;
-        return conv_shape[channelAxis].is_static() && conv_shape[channelAxis].get_length() == static_cast<int64_t>(bias_norm_dims[channelAxis]) &&
+        return conv_shape[channelAxis].is_static() &&
+               conv_shape[channelAxis].get_length() == static_cast<int64_t>(bias_norm_dims[channelAxis]) &&
                bias_norm_dims[channelAxis] == static_cast<size_t>(shape_size(bias_norm_dims));
     };
     auto isFusedFQNode = [&isFusedBiasNode](std::shared_ptr<Node> n) {
-        if (!(ov::is_type<ov::op::v0::FakeQuantize>(n) &&
-            GetNodeFusingType(n) == NodeFusingType::FusedWithConvolution))
+        if (!(ov::is_type<ov::op::v0::FakeQuantize>(n) && GetNodeFusingType(n) == NodeFusingType::FusedWithConvolution))
             return false;
         const auto& parent = n->get_input_node_shared_ptr(0);
-        const bool is_suitable_parent = isSuitableConvolutionParent(parent)
-            || isFusedBiasNode(parent)
-            || (GetNodeFusingType(parent) == NodeFusingType::FusedWithConvolution);
+        const bool is_suitable_parent = isSuitableConvolutionParent(parent) || isFusedBiasNode(parent) ||
+                                        (GetNodeFusingType(parent) == NodeFusingType::FusedWithConvolution);
         return is_suitable_parent;
     };
     int num_conv_parents = 0;
     for (size_t i = 0; i < node->get_input_size(); i++) {
         const auto n = node->get_input_node_shared_ptr(i);
-        //BinaryConvolution allows other ops to be fused before the Add, while Convolution doesn't
+        // BinaryConvolution allows other ops to be fused before the Add, while Convolution doesn't
         num_conv_parents += (isSuitableConvolutionParent(n) || isFusedBiasNode(n) || isFusedFQNode(n) ||
                              GetNodeFusingType(n) == NodeFusingType::FusedWithBinaryConvolution);
     }
-    return getNumNonConstInputs(node) == 2 && num_conv_parents >=1;
+    return getNumNonConstInputs(node) == 2 && num_conv_parents >= 1;
 }
-bool isSuitableChildForFusingSumActivation(const std::shared_ptr<const Node> &node) {
+bool isSuitableChildForFusingSumActivation(const std::shared_ptr<const Node>& node) {
     return SupportsFusingWithConvolution_SumActivation(node);
 }
-bool isSuitableReduceChild(const std::shared_ptr<const Node> &node, const int channelAxis = DEFAULT_AXIS) {
+bool isSuitableReduceChild(const std::shared_ptr<const Node>& node, const int channelAxis = DEFAULT_AXIS) {
     return isSuitableChildForFusingSimple(node, channelAxis);
 }
 bool isSuitableMatMulWithConstantPath(const std::shared_ptr<Node>& node) {
@@ -412,21 +402,23 @@ bool isSuitableMatMulWithConstantPath(const std::shared_ptr<Node>& node) {
 }
 // Continue fusing chain of the passed type if the node has one child
 // Otherwise mark node as FusedTerminator (Fused, but fusing chain is interrupted)
-void PropagateIfHasOnlyChild(const std::shared_ptr<Node> &node, NodeFusingType nodeType) {
+void PropagateIfHasOnlyChild(const std::shared_ptr<Node>& node, NodeFusingType nodeType) {
     const auto out = node->outputs();
     const bool has_only_child = out.size() == 1 && out[0].get_target_inputs().size() == 1;
     SetNodeFusingType(node, has_only_child ? nodeType : NodeFusingType::FusedTerminator);
 }
-// todo: Skipping MultiSubGraphOp such as TensorIterator, Loop and If. Snippets might tokenize their bodies in the future.
-//  Note that the function is recurrent, since there might be multi-level MultiSubGraphOp, if(){if(){}}else{} for example.
-void MarkSubgraphOpAsSkipped(const std::shared_ptr<Node> &node) {
+// todo: Skipping MultiSubGraphOp such as TensorIterator, Loop and If. Snippets might tokenize their bodies in the
+// future.
+//  Note that the function is recurrent, since there might be multi-level MultiSubGraphOp, if(){if(){}}else{} for
+//  example.
+void MarkSubgraphOpAsSkipped(const std::shared_ptr<Node>& node) {
     if (ov::is_type<ov::op::util::MultiSubGraphOp>(node)) {
         std::vector<std::shared_ptr<ov::Model>> models{};
         // Covers TensorIterator and Loop
         if (auto s = ov::as_type_ptr<ov::op::util::SubGraphOp>(node)) {
             models.push_back(s->get_function());
-        // Add new multi-body subgraph op here
-        } else if (auto if_op  = ov::as_type_ptr<ov::op::v8::If>(node)) {
+            // Add new multi-body subgraph op here
+        } else if (auto if_op = ov::as_type_ptr<ov::op::v8::If>(node)) {
             models.push_back(if_op->get_then_body());
             models.push_back(if_op->get_else_body());
         }
@@ -466,16 +458,15 @@ bool isSuitableConvert(const std::shared_ptr<const Node>& node) {
 }
 
 auto is_skipped_op(const std::shared_ptr<ov::Node>& op) -> bool {
-    return ov::is_type<ov::op::v0::Constant>(op) ||
-           ov::is_type<ov::op::v0::Parameter>(op) ||
+    return ov::is_type<ov::op::v0::Constant>(op) || ov::is_type<ov::op::v0::Parameter>(op) ||
            ov::is_type<ov::op::v0::Result>(op);
 }
-} // namespace
+}  // namespace
 
-bool SnippetsMarkSkipped::run_on_model(const std::shared_ptr<ov::Model> &m) {
+bool SnippetsMarkSkipped::run_on_model(const std::shared_ptr<ov::Model>& m) {
     RUN_ON_MODEL_SCOPE(SnippetsMarkSkipped);
     int channelAxis = DEFAULT_AXIS;
-    for (auto &node : m->get_ordered_ops()) {
+    for (auto& node : m->get_ordered_ops()) {
         if (is_skipped_op(node))
             continue;
         // We perform this check separately because we mark here only weights path
@@ -507,7 +498,8 @@ bool SnippetsMarkSkipped::run_on_model(const std::shared_ptr<ov::Model> &m) {
             SetNodeFusingType(node, NodeFusingType::FusedWithMisc);
         } else if (isSuitableMatMulParent(node)) {
             const bool is_fc = isFullyConnected(node);
-            const bool is_i8 = canBeMatMulExecutedInInt8(node->get_input_element_type(0), node->get_input_element_type(1));
+            const bool is_i8 =
+                canBeMatMulExecutedInInt8(node->get_input_element_type(0), node->get_input_element_type(1));
             const auto out_rank = node->get_output_partial_shape(0).rank();
             if (is_fc) {
                 SetNodeFusingType(node, is_i8 ? NodeFusingType::FusedWithFCI8 : NodeFusingType::FusedWithFC);
@@ -519,9 +511,9 @@ bool SnippetsMarkSkipped::run_on_model(const std::shared_ptr<ov::Model> &m) {
         } else if (isSuitableSubtractAsZeroPointsParent(node)) {
             SetSnippetsNodeType(node, snippets::pass::SnippetsNodeType::SkippedByPlugin);
             channelAxis = DEFAULT_AXIS;
-        // CVS-105447
-        // This WA skip convert with same I/O precision in Snippets
-        // Such useless Convert is executed in Snippets
+            // CVS-105447
+            // This WA skip convert with same I/O precision in Snippets
+            // Such useless Convert is executed in Snippets
         } else if (enableBF16 && isSuitableConvert(node)) {
             SetSnippetsNodeType(node, snippets::pass::SnippetsNodeType::SkippedByPlugin);
             channelAxis = DEFAULT_AXIS;
@@ -542,12 +534,16 @@ bool SnippetsMarkSkipped::run_on_model(const std::shared_ptr<ov::Model> &m) {
                     }
                 } else if (fusingChainType == NodeFusingType::FusedWithConvolutionSumActivation &&
                            isSuitableChildForFusingSumActivation(node)) {
-                    // Todo: Chain could be converted from FusedWithBinaryConvolution to FusedWithConvolution at this point
-                    // Set FusedWithConvolution, so the fusing chain could be propagated
+                    // Todo: Chain could be converted from FusedWithBinaryConvolution to FusedWithConvolution at this
+                    // point Set FusedWithConvolution, so the fusing chain could be propagated
                     PropagateIfHasOnlyChild(node, NodeFusingType::FusedWithConvolution);
-                } else if (one_of(fusingChainType, NodeFusingType::FusedWithMatMul, NodeFusingType::FusedWithMatMulI8,
-                                                   NodeFusingType::FusedWithFC, NodeFusingType::FusedWithFCI8)) {
-                    const bool isExecutedInINT8 = one_of(fusingChainType, NodeFusingType::FusedWithMatMulI8, NodeFusingType::FusedWithFCI8);
+                } else if (one_of(fusingChainType,
+                                  NodeFusingType::FusedWithMatMul,
+                                  NodeFusingType::FusedWithMatMulI8,
+                                  NodeFusingType::FusedWithFC,
+                                  NodeFusingType::FusedWithFCI8)) {
+                    const bool isExecutedInINT8 =
+                        one_of(fusingChainType, NodeFusingType::FusedWithMatMulI8, NodeFusingType::FusedWithFCI8);
                     // Handle fusings for both MatMul and FullyConnected
                     NodeFusingType updatedChainType = fusingChainType;
                     if (isSuitableChildForFusingMatMul(node, isExecutedInINT8, updatedChainType, channelAxis))
@@ -565,5 +561,5 @@ bool SnippetsMarkSkipped::run_on_model(const std::shared_ptr<ov::Model> &m) {
     return true;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/snippets_mark_skipped.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/snippets_mark_skipped.hpp
index 856e3e64736899..fc5250defac8cb 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/snippets_mark_skipped.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/pass/snippets_mark_skipped.hpp
@@ -11,14 +11,15 @@ namespace intel_cpu {
 
 /**
  * @interface SnippetsMarkSkipped
- * @brief Mark operations that should be ignored by snippets on tokenization stage. A typical example is eltwise operations
- * that will be fused into convolutions on plugin side.
+ * @brief Mark operations that should be ignored by snippets on tokenization stage. A typical example is eltwise
+ * operations that will be fused into convolutions on plugin side.
  */
 class SnippetsMarkSkipped : public ov::pass::ModelPass {
 public:
     OPENVINO_RTTI("SnippetsMarkSkipped", "0");
     SnippetsMarkSkipped(bool enableBF16 = false) : ModelPass(), enableBF16(enableBF16) {}
-    bool run_on_model(const std::shared_ptr<ov::Model> &) override;
+    bool run_on_model(const std::shared_ptr<ov::Model>&) override;
+
 private:
     bool enableBF16 = false;
 };
@@ -27,19 +28,29 @@ class SnippetsMarkSkipped : public ov::pass::ModelPass {
 NotSet - not part of a fusing chain
 FusedTerminator - the node is fused, but the chain can't be continued
 FusedWithConvolution, FusedWithConvolutionSumActivation, FusedWithMisc - fusing chains with different continuation rules
-IgnoredAfterInputs - node must be skipped, since can't be handled properly at this time. Also a continuable fusing chain.
-Order of SnippetsNodeType is important!:
+IgnoredAfterInputs - node must be skipped, since can't be handled properly at this time. Also a continuable fusing
+chain. Order of SnippetsNodeType is important!:
 * SnippetsNodeType >= FusedTerminator is a Fused chain
 * SnippetsNodeType > FusedTerminator is a Fused chain that may be continued
 */
-// Todo: Snippets currently support only FP32 precision, however network inputs could be converted to another precision by plugin
-//  (in other words after tokenization). To handle this behavior, eltwise chains that start at input are marked as IgnoredAfterInputs.
-//  Tis is not a real plugin-side fusing, but rather a workaround to guarantee that snippets always executed in FP32.
+// Todo: Snippets currently support only FP32 precision, however network inputs could be converted to another precision
+// by plugin
+//  (in other words after tokenization). To handle this behavior, eltwise chains that start at input are marked as
+//  IgnoredAfterInputs. Tis is not a real plugin-side fusing, but rather a workaround to guarantee that snippets always
+//  executed in FP32.
 enum class NodeFusingType : int64_t {
     NotSet,
     FusedTerminator,
-    FusedWithConvolution,  FusedWithBinaryConvolution, FusedWithConvolutionSumActivation,
-    FusedWithMatMul, FusedWithFC, FusedWithMatMulI8, FusedWithFCI8, FusedWithReduce, FusedWithMisc};
+    FusedWithConvolution,
+    FusedWithBinaryConvolution,
+    FusedWithConvolutionSumActivation,
+    FusedWithMatMul,
+    FusedWithFC,
+    FusedWithMatMulI8,
+    FusedWithFCI8,
+    FusedWithReduce,
+    FusedWithMisc
+};
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/shape_inference.cpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/shape_inference.cpp
index 6226a182ba638b..50a2399e93ecc4 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/shape_inference.cpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/shape_inference.cpp
@@ -3,19 +3,21 @@
 //
 
 #include "shape_inference.hpp"
+
 #include <snippets/shape_inference/shape_infer_instances.hpp>
+
 #include "op/brgemm_copy_b.hpp"
 #include "op/brgemm_cpu.hpp"
-#include "transformations/snippets/common/op/fused_mul_add.hpp"
 #include "op/load_convert.hpp"
-#include "op/store_convert.hpp"
 #include "op/perf_count_rdtsc.hpp"
+#include "op/store_convert.hpp"
 #include "transformations/cpu_opset/common/op/swish_cpu.hpp"
+#include "transformations/snippets/common/op/fused_mul_add.hpp"
 #ifdef SNIPPETS_LIBXSMM_TPP
-#include "transformations/tpp/x64/op/brgemm.hpp"
-#include "transformations/tpp/x64/op/equation.hpp"
-#include "transformations/tpp/x64/op/scalar.hpp"
-#include "transformations/tpp/x64/op/reduce.hpp"
+#    include "transformations/tpp/x64/op/brgemm.hpp"
+#    include "transformations/tpp/x64/op/equation.hpp"
+#    include "transformations/tpp/x64/op/reduce.hpp"
+#    include "transformations/tpp/x64/op/scalar.hpp"
 #endif
 
 namespace ov {
@@ -30,37 +32,48 @@ ShapeInferPtr CPUShapeInferSnippetsFactory::get_specific_op_shape_infer(const ov
     return {};
 }
 
+#define SHAPE_INFER_PREDEFINED(OP, InferType)                                \
+    {                                                                        \
+        OP::get_type_info_static(), [](const std::shared_ptr<ov::Node>& n) { \
+            return std::make_shared<InferType>();                            \
+        }                                                                    \
+    }
+#define SHAPE_INFER_OP_SPECIFIC(OP)                                          \
+    {                                                                        \
+        OP::get_type_info_static(), [](const std::shared_ptr<ov::Node>& n) { \
+            return std::make_shared<OP::ShapeInfer>(n);                      \
+        }                                                                    \
+    }
+#define SHAPE_INFER_OP_SPECIFIC_EXTERNAL(OP, InferType)                      \
+    {                                                                        \
+        OP::get_type_info_static(), [](const std::shared_ptr<ov::Node>& n) { \
+            return std::make_shared<InferType>(n);                           \
+        }                                                                    \
+    }
 
-#define SHAPE_INFER_PREDEFINED(OP, InferType) \
-    { OP::get_type_info_static(), [](const std::shared_ptr<ov::Node>& n) { return std::make_shared<InferType>();} }
-#define SHAPE_INFER_OP_SPECIFIC(OP) \
-    { OP::get_type_info_static(), [](const std::shared_ptr<ov::Node>& n) { return std::make_shared<OP::ShapeInfer>(n);} }
-#define SHAPE_INFER_OP_SPECIFIC_EXTERNAL(OP, InferType) \
-    { OP::get_type_info_static(), [](const std::shared_ptr<ov::Node>& n) { return std::make_shared<InferType>(n);} }
-
-const CPUShapeInferSnippetsFactory::TRegistry CPUShapeInferSnippetsFactory::specific_ops_registry {
-        SHAPE_INFER_PREDEFINED(ov::intel_cpu::FusedMulAdd, NumpyBroadcastShapeInfer),
-        SHAPE_INFER_PREDEFINED(ov::intel_cpu::SwishNode, PassThroughShapeInfer),
-        SHAPE_INFER_PREDEFINED(ov::intel_cpu::LoadConvertSaturation, PassThroughShapeInfer),
-        SHAPE_INFER_PREDEFINED(ov::intel_cpu::LoadConvertTruncation, PassThroughShapeInfer),
-        SHAPE_INFER_PREDEFINED(ov::intel_cpu::StoreConvertSaturation, PassThroughShapeInfer),
-        SHAPE_INFER_PREDEFINED(ov::intel_cpu::StoreConvertTruncation, PassThroughShapeInfer),
+const CPUShapeInferSnippetsFactory::TRegistry CPUShapeInferSnippetsFactory::specific_ops_registry{
+    SHAPE_INFER_PREDEFINED(ov::intel_cpu::FusedMulAdd, NumpyBroadcastShapeInfer),
+    SHAPE_INFER_PREDEFINED(ov::intel_cpu::SwishNode, PassThroughShapeInfer),
+    SHAPE_INFER_PREDEFINED(ov::intel_cpu::LoadConvertSaturation, PassThroughShapeInfer),
+    SHAPE_INFER_PREDEFINED(ov::intel_cpu::LoadConvertTruncation, PassThroughShapeInfer),
+    SHAPE_INFER_PREDEFINED(ov::intel_cpu::StoreConvertSaturation, PassThroughShapeInfer),
+    SHAPE_INFER_PREDEFINED(ov::intel_cpu::StoreConvertTruncation, PassThroughShapeInfer),
 #ifdef SNIPPETS_DEBUG_CAPS
-        SHAPE_INFER_PREDEFINED(ov::intel_cpu::PerfCountRdtscBegin, EmptyShapeInfer),
-        SHAPE_INFER_PREDEFINED(ov::intel_cpu::PerfCountRdtscEnd, EmptyShapeInfer),
+    SHAPE_INFER_PREDEFINED(ov::intel_cpu::PerfCountRdtscBegin, EmptyShapeInfer),
+    SHAPE_INFER_PREDEFINED(ov::intel_cpu::PerfCountRdtscEnd, EmptyShapeInfer),
 #endif
 #ifdef SNIPPETS_LIBXSMM_TPP
-        SHAPE_INFER_OP_SPECIFIC_EXTERNAL(ov::intel_cpu::tpp::op::BrgemmTPP, BrgemmShapeInfer),
-        SHAPE_INFER_PREDEFINED(ov::intel_cpu::tpp::op::EquationTPP, NumpyBroadcastShapeInfer),
-        SHAPE_INFER_PREDEFINED(ov::intel_cpu::tpp::op::Scalar, SingleElementShapeInfer),
-        SHAPE_INFER_OP_SPECIFIC_EXTERNAL(ov::intel_cpu::tpp::op::ReduceMax, ReduceShapeInfer),
-        SHAPE_INFER_OP_SPECIFIC_EXTERNAL(ov::intel_cpu::tpp::op::ReduceSum, ReduceShapeInfer),
+    SHAPE_INFER_OP_SPECIFIC_EXTERNAL(ov::intel_cpu::tpp::op::BrgemmTPP, BrgemmShapeInfer),
+    SHAPE_INFER_PREDEFINED(ov::intel_cpu::tpp::op::EquationTPP, NumpyBroadcastShapeInfer),
+    SHAPE_INFER_PREDEFINED(ov::intel_cpu::tpp::op::Scalar, SingleElementShapeInfer),
+    SHAPE_INFER_OP_SPECIFIC_EXTERNAL(ov::intel_cpu::tpp::op::ReduceMax, ReduceShapeInfer),
+    SHAPE_INFER_OP_SPECIFIC_EXTERNAL(ov::intel_cpu::tpp::op::ReduceSum, ReduceShapeInfer),
 #endif
-        SHAPE_INFER_OP_SPECIFIC_EXTERNAL(ov::intel_cpu::BrgemmCPU, BrgemmShapeInfer),
-        SHAPE_INFER_OP_SPECIFIC(ov::intel_cpu::BrgemmCopyB),
+    SHAPE_INFER_OP_SPECIFIC_EXTERNAL(ov::intel_cpu::BrgemmCPU, BrgemmShapeInfer),
+    SHAPE_INFER_OP_SPECIFIC(ov::intel_cpu::BrgemmCopyB),
 };
 #undef SHAPE_INFER_OP_SPECIFIC
 #undef SHAPE_INFER_PREDEFINED
 
-} // namespace snippets
-} // namespace ov
+}  // namespace snippets
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/snippets/x64/shape_inference.hpp b/src/plugins/intel_cpu/src/transformations/snippets/x64/shape_inference.hpp
index bc2eb7684a251e..1e72e193ed078a 100644
--- a/src/plugins/intel_cpu/src/transformations/snippets/x64/shape_inference.hpp
+++ b/src/plugins/intel_cpu/src/transformations/snippets/x64/shape_inference.hpp
@@ -12,17 +12,18 @@ namespace snippets {
 /**
  * \brief Shape infer factory that can create shape-infer instances for cpu-specific operations
  */
-class CPUShapeInferSnippetsFactory : public IShapeInferSnippetsFactory{
+class CPUShapeInferSnippetsFactory : public IShapeInferSnippetsFactory {
     /** \brief Factory makers registry which can be specialized for key and value. */
     static const TRegistry specific_ops_registry;
 
 protected:
     /**
-    * @brief get shape infer instances for operations from backend-specific opset
-    * @return register ShapeInferPtr
-    */
-    ShapeInferPtr get_specific_op_shape_infer(const ov::DiscreteTypeInfo& key, const std::shared_ptr<ov::Node>& op) const override;
+     * @brief get shape infer instances for operations from backend-specific opset
+     * @return register ShapeInferPtr
+     */
+    ShapeInferPtr get_specific_op_shape_infer(const ov::DiscreteTypeInfo& key,
+                                              const std::shared_ptr<ov::Node>& op) const override;
 };
 
-} // namespace snippets
-} // namespace ov
+}  // namespace snippets
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp
index f9fa372030e4cc..909f6b7531d421 100644
--- a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp
+++ b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp
@@ -3,53 +3,56 @@
 //
 
 #include "transformation_pipeline.h"
+
 #include "defs.hpp"
 
 // Operations
+#include <ov_ops/augru_cell.hpp>
+#include <ov_ops/augru_sequence.hpp>
+#include <ov_ops/gather_compressed.hpp>
+
+#include "openvino/op/paged_attention.hpp"
 #include "openvino/opsets/opset1.hpp"
+#include "openvino/opsets/opset10.hpp"
 #include "openvino/opsets/opset2.hpp"
 #include "openvino/opsets/opset3.hpp"
 #include "openvino/opsets/opset4.hpp"
 #include "openvino/opsets/opset5.hpp"
 #include "openvino/opsets/opset6.hpp"
-#include "openvino/opsets/opset10.hpp"
-#include "openvino/op/paged_attention.hpp"
-#include <ov_ops/augru_cell.hpp>
-#include <ov_ops/augru_sequence.hpp>
-#include <ov_ops/gather_compressed.hpp>
 
 // Common transformations
-#include "transformations/common_optimizations/mark_precision_sensitive_shapeof_subgraphs.hpp"
 #include "transformations/common_optimizations/add_fake_quantize_fusion.hpp"
-#include "transformations/common_optimizations/reshape_prelu.hpp"
-#include "transformations/fp16_compression/convert_compression_only_to_legacy.hpp"
+#include "transformations/common_optimizations/augru_cell_fusion.hpp"
+#include "transformations/common_optimizations/common_optimizations.hpp"
 #include "transformations/common_optimizations/convert_quantize_dequantize.hpp"
-#include "transformations/common_optimizations/lstm_cell_fusion.hpp"
 #include "transformations/common_optimizations/fq_mul_fusion.hpp"
+#include "transformations/common_optimizations/fuse_rotary_positional_embeddings.hpp"
+#include "transformations/common_optimizations/lora_subgraph_fusion.hpp"
+#include "transformations/common_optimizations/lstm_cell_fusion.hpp"
+#include "transformations/common_optimizations/mark_precision_sensitive_shapeof_subgraphs.hpp"
+#include "transformations/common_optimizations/mark_rope_input_to_keep_in_mixed_precision.hpp"
+#include "transformations/common_optimizations/matmul_const_transposes_extraction.hpp"
+#include "transformations/common_optimizations/move_eltwise_up_data_movement.hpp"
 #include "transformations/common_optimizations/mul_fake_quantize_fusion.hpp"
 #include "transformations/common_optimizations/nop_elimination.hpp"
+#include "transformations/common_optimizations/reshape_prelu.hpp"
+#include "transformations/common_optimizations/rms_fusion.hpp"
 #include "transformations/common_optimizations/transpose_sinking.hpp"
 #include "transformations/common_optimizations/weights_dequantize_to_fake_quantize.hpp"
-#include "transformations/common_optimizations/augru_cell_fusion.hpp"
-#include "transformations/common_optimizations/common_optimizations.hpp"
 #include "transformations/common_optimizations/wrap_interpolate_into_transposes.hpp"
-#include "transformations/common_optimizations/matmul_const_transposes_extraction.hpp"
-#include "transformations/common_optimizations/fuse_rotary_positional_embeddings.hpp"
-#include "transformations/common_optimizations/move_eltwise_up_data_movement.hpp"
-#include "transformations/common_optimizations/mark_rope_input_to_keep_in_mixed_precision.hpp"
-#include "transformations/common_optimizations/rms_fusion.hpp"
-#include "transformations/common_optimizations/lora_subgraph_fusion.hpp"
 #include "transformations/control_flow/unroll_tensor_iterator.hpp"
+#include "transformations/fp16_compression/convert_compression_only_to_legacy.hpp"
 #include "transformations/fp16_compression/mark_decompression_convert_constant_folding.hpp"
 #include "transformations/fp16_compression/mark_floatpoint_range.hpp"
+#include "transformations/init_node_info.hpp"
 #include "transformations/op_conversions/convert_avgpool_downgrade.hpp"
 #include "transformations/op_conversions/convert_batch_to_space.hpp"
 #include "transformations/op_conversions/convert_bitwise_to_logical_bool.hpp"
 #include "transformations/op_conversions/convert_broadcast_to_tiles.hpp"
 #include "transformations/op_conversions/convert_depth_to_space.hpp"
 #include "transformations/op_conversions/convert_gather_downgrade.hpp"
-#include "transformations/op_conversions/convert_gather_upgrade.hpp"
 #include "transformations/op_conversions/convert_gather_to_compressed.hpp"
+#include "transformations/op_conversions/convert_gather_upgrade.hpp"
 #include "transformations/op_conversions/convert_gelu.hpp"
 #include "transformations/op_conversions/convert_interpolate1_to_interpolate4.hpp"
 #include "transformations/op_conversions/convert_matrix_nms_to_matrix_nms_ie.hpp"
@@ -65,45 +68,44 @@
 #include "transformations/op_conversions/convert_scatter_nd_update15_downgrade.hpp"
 #include "transformations/op_conversions/convert_sequences_to_tensor_iterator.hpp"
 #include "transformations/op_conversions/convert_shuffle_channels3.hpp"
-#include "transformations/op_conversions/convert_slicescatter.hpp"
 #include "transformations/op_conversions/convert_slice_to_strided_slice.hpp"
+#include "transformations/op_conversions/convert_slicescatter.hpp"
 #include "transformations/op_conversions/convert_space_to_batch.hpp"
 #include "transformations/op_conversions/convert_space_to_depth.hpp"
 #include "transformations/op_conversions/convert_subtract.hpp"
 #include "transformations/op_conversions/convert_ti_to_sequences.hpp"
+#include "transformations/op_conversions/convert_topk11_downgrade.hpp"
+#include "transformations/op_conversions/convert_topk3.hpp"
 #include "transformations/op_conversions/detection_output_downgrade.hpp"
 #include "transformations/op_conversions/detection_output_upgrade.hpp"
 #include "transformations/op_conversions/eye_decomposition.hpp"
 #include "transformations/op_conversions/fq_decomposition.hpp"
 #include "transformations/op_conversions/gelu7_downgrade.hpp"
+#include "transformations/op_conversions/group_normalization_decomposition.hpp"
+#include "transformations/op_conversions/gru_cell_decomposition.hpp"
 #include "transformations/op_conversions/hard_sigmoid_decomposition.hpp"
 #include "transformations/op_conversions/hsigmoid_decomposition.hpp"
 #include "transformations/op_conversions/hswish_decomposition.hpp"
-#include "transformations/op_conversions/gru_cell_decomposition.hpp"
 #include "transformations/op_conversions/lstm_cell_decomposition.hpp"
-#include "transformations/op_conversions/group_normalization_decomposition.hpp"
 #include "transformations/op_conversions/mvn6_decomposition.hpp"
 #include "transformations/op_conversions/normalize_l2_decomposition.hpp"
 #include "transformations/op_conversions/reduce_l1_decomposition.hpp"
 #include "transformations/op_conversions/reduce_l2_decomposition.hpp"
 #include "transformations/op_conversions/rnn_cell_decomposition.hpp"
+#include "transformations/op_conversions/scaled_dot_product_attention_decomposition.hpp"
 #include "transformations/op_conversions/simplify_ctc_greedy_decoder_seq_len.hpp"
+#include "transformations/op_conversions/softmax_decomposition.hpp"
 #include "transformations/op_conversions/softplus_decomposition.hpp"
 #include "transformations/op_conversions/softsign_decomposition.hpp"
-#include "transformations/op_conversions/softmax_decomposition.hpp"
 #include "transformations/op_conversions/unique_decomposition.hpp"
-#include "transformations/op_conversions/convert_topk3.hpp"
-#include "transformations/op_conversions/convert_topk11_downgrade.hpp"
-#include "transformations/op_conversions/scaled_dot_product_attention_decomposition.hpp"
 #include "transformations/opset_conversions/convert_opset2_to_opset1.hpp"
 #include "transformations/opset_conversions/convert_opset3_to_opset2.hpp"
+#include "transformations/rt_info/keep_const_precision.hpp"
 #include "transformations/smart_reshape/matmul_sr.hpp"
 #include "transformations/symbolic_transformations/symbolic_optimizations.hpp"
-#include "transformations/init_node_info.hpp"
-#include "transformations/rt_info/keep_const_precision.hpp"
 #include "transformations/transpose_sinking/ts_shape_of.hpp"
-#include "utils/ngraph_transformation.hpp"
 #include "transformations/utils/print_model.hpp"
+#include "utils/ngraph_transformation.hpp"
 
 // LPT transformations
 #include "low_precision/add.hpp"
@@ -121,57 +123,57 @@
 // CPU specific transformations
 #include "transformations/cpu_opset/convert_to_cpu_specific_opset.hpp"
 #if defined(OPENVINO_ARCH_ARM64)
-#include "transformations/snippets/aarch64/pass/snippets_mark_skipped.hpp"
+#    include "transformations/snippets/aarch64/pass/snippets_mark_skipped.hpp"
 #else
-#include "transformations/snippets/x64/pass/snippets_mark_skipped.hpp"
+#    include "transformations/snippets/x64/pass/snippets_mark_skipped.hpp"
 #endif
-#include "transformations/cpu_opset/x64/pass/convert_to_interaction.hpp"
-#include "transformations/cpu_opset/x64/pass/mlp_fusion.hpp"
-#include "transformations/cpu_opset/x64/pass/qkv_proj_fusion.hpp"
 #include "transformations/cpu_opset/arm/pass/convert_group_conv.hpp"
 #include "transformations/cpu_opset/arm/pass/convert_group_conv1d.hpp"
 #include "transformations/cpu_opset/arm/pass/convert_reduce_multi_axis.hpp"
-#include "transformations/cpu_opset/arm/pass/mish_decomposition.hpp"
 #include "transformations/cpu_opset/arm/pass/convert_reduce_no_keep_dims.hpp"
+#include "transformations/cpu_opset/arm/pass/mish_decomposition.hpp"
+#include "transformations/cpu_opset/common/pass/causal_mask_preprocess_fusion.hpp"
+#include "transformations/cpu_opset/common/pass/convert_fq_rnn_to_quantized_rnn.hpp"
 #include "transformations/cpu_opset/common/pass/decompose_integer_divide.hpp"
 #include "transformations/cpu_opset/common/pass/decompose_rms_norm.hpp"
-#include "transformations/cpu_opset/common/pass/convert_fq_rnn_to_quantized_rnn.hpp"
 #include "transformations/cpu_opset/common/pass/insert_convert_after_extension.hpp"
 #include "transformations/cpu_opset/common/pass/ngram_fusion.hpp"
 #include "transformations/cpu_opset/common/pass/permute_slice_n_interpolation.hpp"
-#include "transformations/cpu_opset/common/pass/swap_convert_transpose.hpp"
-#include "transformations/cpu_opset/common/pass/causal_mask_preprocess_fusion.hpp"
 #include "transformations/cpu_opset/common/pass/stateful_sdpa_fusion.hpp"
+#include "transformations/cpu_opset/common/pass/swap_convert_transpose.hpp"
+#include "transformations/cpu_opset/x64/pass/convert_to_interaction.hpp"
+#include "transformations/cpu_opset/x64/pass/mlp_fusion.hpp"
+#include "transformations/cpu_opset/x64/pass/qkv_proj_fusion.hpp"
 #include "transformations/cpu_opset/x64/pass/sdpa_fuse_transpose_reshape.hpp"
 
 // Snippets
-#include "snippets/pass/tokenization.hpp"
-#include "snippets/pass/mha_tokenization.hpp"
-#include "snippets/pass/fc_tokenization.hpp"
 #include "snippets/pass/collapse_subgraph.hpp"
 #include "snippets/pass/common_optimizations.hpp"
-#include "snippets/pass/split_dimension_m.hpp"
-#include "snippets/pass/extract_reshapes_from_mha.hpp"
 #include "snippets/pass/explicit_transpose_matmul_inputs.hpp"
+#include "snippets/pass/extract_reshapes_from_mha.hpp"
+#include "snippets/pass/fc_tokenization.hpp"
+#include "snippets/pass/mha_tokenization.hpp"
+#include "snippets/pass/split_dimension_m.hpp"
+#include "snippets/pass/tokenization.hpp"
 #if defined(SNIPPETS_LIBXSMM_TPP)
-#include "transformations/tpp/x64/pass/brgemm_to_brgemm_tpp.hpp"
+#    include "transformations/tpp/x64/pass/brgemm_to_brgemm_tpp.hpp"
 #endif
 
 // Misc
-#include "nodes/mvn.h"
-#include "nodes/normalize.h"
+#include "dnnl.hpp"
 #include "nodes/fake_quantize.h"
-#include "nodes/mha.h"
-#include "nodes/rnn.h"
-#include "nodes/scaled_attn.h"
 #include "nodes/llm_mlp.h"
+#include "nodes/mha.h"
+#include "nodes/mvn.h"
+#include "nodes/normalize.h"
 #include "nodes/qkv_proj.h"
 #include "nodes/rms_norm.h"
-#include "dnnl.hpp"
+#include "nodes/rnn.h"
+#include "nodes/scaled_attn.h"
 #if defined(OPENVINO_ARCH_ARM64)
-#include "cpu/aarch64/cpu_isa_traits.hpp"
+#    include "cpu/aarch64/cpu_isa_traits.hpp"
 #else
-#include "cpu/x64/cpu_isa_traits.hpp"
+#    include "cpu/x64/cpu_isa_traits.hpp"
 #endif
 #include "openvino/core/validation_util.hpp"
 
@@ -298,16 +300,14 @@ bool Transformations::fuse_type_to_convert(const std::shared_ptr<ov::Node>& node
 
 void Transformations::UpToLpt() {
     using namespace ov::pass::low_precision;
-    static const std::set<levels>& supported_fq_levels = {
-        levels::int4,
-        levels::int4_narrow_range,
-        levels::int8,
-        levels::int8_narrow_range
-    };
+    static const std::set<levels>& supported_fq_levels = {levels::int4,
+                                                          levels::int4_narrow_range,
+                                                          levels::int8,
+                                                          levels::int8_narrow_range};
 
     const bool useLpt = config.lpTransformsMode == Config::LPTransformsMode::On &&
-        LowPrecision::isFunctionQuantized(model, supported_fq_levels) &&
-        CPU_DEBUG_CAP_IS_TRANSFORMATION_ENABLED(config.debugCaps, Lpt);
+                        LowPrecision::isFunctionQuantized(model, supported_fq_levels) &&
+                        CPU_DEBUG_CAP_IS_TRANSFORMATION_ENABLED(config.debugCaps, Lpt);
 
     const auto defaultPrecisions = useLpt ? precision_set::get_int8_support() : std::vector<ov::element::Type>{};
 
@@ -343,10 +343,17 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
                                                      ov::element::i4,
                                                      ov::element::nf4,
                                                      ov::element::f4e2m1};
-    CPU_REGISTER_PASS_X64(decompression_handling_manager, ov::pass::MarkDequantizationSubgraph, decompression_precisions, false, true);
-    CPU_SET_CALLBACK_X64(decompression_handling_manager, [&](const_node_ptr &node) -> bool {
-        return !is_decompression_multiply(node);
-    }, ov::pass::MarkDequantizationSubgraph);
+    CPU_REGISTER_PASS_X64(decompression_handling_manager,
+                          ov::pass::MarkDequantizationSubgraph,
+                          decompression_precisions,
+                          false,
+                          true);
+    CPU_SET_CALLBACK_X64(
+        decompression_handling_manager,
+        [&](const_node_ptr& node) -> bool {
+            return !is_decompression_multiply(node);
+        },
+        ov::pass::MarkDequantizationSubgraph);
 
     CPU_SET_CALLBACK_COMMON(
         decompression_handling_manager,
@@ -375,17 +382,15 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
         CPU_REGISTER_PASS_COMMON(manager, ov::pass::MarkDequantizationSubgraph, defaultPrecisions);
 
     auto get_convert_precisions = [&]() {
-        precisions_map map = {
-            {ov::element::i64,     ov::element::i32},
-            {ov::element::u64,     ov::element::i32},
-            {ov::element::i16,     ov::element::i32},
-            {ov::element::u16,     ov::element::i32},
-            {ov::element::u32,     ov::element::i32},
-            {ov::element::f64,     ov::element::f32},
-            {ov::element::boolean, ov::element::u8},
-            {ov::element::i4,      ov::element::i8},
-            {ov::element::u4,      ov::element::u8}
-        };
+        precisions_map map = {{ov::element::i64, ov::element::i32},
+                              {ov::element::u64, ov::element::i32},
+                              {ov::element::i16, ov::element::i32},
+                              {ov::element::u16, ov::element::i32},
+                              {ov::element::u32, ov::element::i32},
+                              {ov::element::f64, ov::element::f32},
+                              {ov::element::boolean, ov::element::u8},
+                              {ov::element::i4, ov::element::i8},
+                              {ov::element::u4, ov::element::u8}};
 
         // @todo should we always convert to f32 regardless of hardware support, as it is done for f16?
         if (!hasHardwareSupport(ov::element::bf16))
@@ -417,8 +422,9 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
                                  false);
     }
     CPU_REGISTER_PASS_COMMON(manager, ov::pass::KeepConstAndDecompression);
-    CPU_SET_CALLBACK_COMMON(manager,
-        [](const_node_ptr &node) -> bool {
+    CPU_SET_CALLBACK_COMMON(
+        manager,
+        [](const_node_ptr& node) -> bool {
             const auto consumers = node->get_output_target_inputs(0);
             return std::all_of(consumers.begin(), consumers.end(), [](const ov::Input<ov::Node>& consumer) {
                 return !ov::is_type<ov::op::v0::MatMul>(consumer.get_node());
@@ -455,15 +461,21 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
         CPU_REGISTER_PASS_COMMON(manager, ov::pass::low_precision::ConvertSubtractConstant, defaultPrecisions);
     }
     CPU_REGISTER_PASS_COMMON(manager, ov::pass::Validate);
-    // Common ConvertPrecision pass handles only a limited set of opevino operations to match the list of precisions supported by the plugin.
-    // However, if the extension operation produces an output precision that is not natively supported, this may lead to inconsistency during
-    // element type propagation. This transformation is called before the ConvertPrecision pass to align the actual precisions with the list of supported ones.
+    // Common ConvertPrecision pass handles only a limited set of opevino operations to match the list of precisions
+    // supported by the plugin. However, if the extension operation produces an output precision that is not natively
+    // supported, this may lead to inconsistency during element type propagation. This transformation is called before
+    // the ConvertPrecision pass to align the actual precisions with the list of supported ones.
     constexpr bool convert_input_output_precision = false;
     CPU_REGISTER_PASS_COMMON(manager, ov::pass::InsertConvertAfterExtension, convert_input_output_precision);
     // Do not insert pass::Validate between pass::InsertConvertAfterExtension and pass::ConvertPrecision.
     // This may result in the loss of the original Element type of the Output .
     // element type convert is disabled.
-    CPU_REGISTER_PASS_COMMON(manager, ov::pass::ConvertPrecision, precisions, type_to_fuse, false, convert_input_output_precision);
+    CPU_REGISTER_PASS_COMMON(manager,
+                             ov::pass::ConvertPrecision,
+                             precisions,
+                             type_to_fuse,
+                             false,
+                             convert_input_output_precision);
 
     CPU_REGISTER_PASS_COMMON(manager, ov::pass::EliminateConvert);
     CPU_REGISTER_PASS_COMMON(manager, SwapConvertTranspose);
@@ -484,19 +496,23 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
     CPU_REGISTER_PASS_COMMON(manager, ov::pass::Validate);
 
     // SpaceToDepth/ DepthToSpace node implementation supports only equal input/output tensors with rank <= 5
-    CPU_SET_CALLBACK_COMMON(manager,
-        [](const_node_ptr &node) -> bool {
+    CPU_SET_CALLBACK_COMMON(
+        manager,
+        [](const_node_ptr& node) -> bool {
             return node->input_value(0).get_shape().size() <= 5lu &&
-                node->input_value(0).get_shape().size() == node->get_output_shape(0).size();
+                   node->input_value(0).get_shape().size() == node->get_output_shape(0).size();
         },
-        ov::pass::ConvertSpaceToDepth, ov::pass::ConvertDepthToSpace);
+        ov::pass::ConvertSpaceToDepth,
+        ov::pass::ConvertDepthToSpace);
 
-    CPU_SET_CALLBACK_COMMON(manager,
-        [](const_node_ptr &node) -> bool {
-            const auto & rank = node->input(0).get_partial_shape().rank().get_length();
+    CPU_SET_CALLBACK_COMMON(
+        manager,
+        [](const_node_ptr& node) -> bool {
+            const auto& rank = node->input(0).get_partial_shape().rank().get_length();
             return rank == 4lu || rank == 5lu;
         },
-        ov::pass::ConvertBatchToSpace, ov::pass::ConvertSpaceToBatch);
+        ov::pass::ConvertBatchToSpace,
+        ov::pass::ConvertSpaceToBatch);
 
     CPU_SET_CALLBACK_COMMON(
         manager,
@@ -514,8 +530,9 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
         },
         ov::pass::ConvertAvgPool14ToAvgPool1);
 
-    CPU_SET_CALLBACK_COMMON(manager,
-        [](const_node_ptr &node) -> bool {
+    CPU_SET_CALLBACK_COMMON(
+        manager,
+        [](const_node_ptr& node) -> bool {
             std::string msg;
             return node::RNN::isSupportedOperation(node, msg);
         },
@@ -523,8 +540,9 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
         ov::pass::ConvertGRUSequenceToTensorIterator,
         ov::pass::ConvertLSTMSequenceToTensorIterator);
 
-    CPU_SET_CALLBACK_COMMON(manager,
-        [](const_node_ptr &node) -> bool {
+    CPU_SET_CALLBACK_COMMON(
+        manager,
+        [](const_node_ptr& node) -> bool {
             std::string msg;
             return !node::RNN::isSupportedOperation(node, msg);
         },
@@ -532,8 +550,9 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
         ov::pass::FuseReverseLSTMSequence,
         ov::pass::FuseLSTMSequencesToBidirectionalLSTMSequence);
 
-    CPU_SET_CALLBACK_COMMON(manager,
-        [](const_node_ptr &node) -> bool {
+    CPU_SET_CALLBACK_COMMON(
+        manager,
+        [](const_node_ptr& node) -> bool {
             std::string msg;
             return node::RNN::isSupportedOperation(node, msg);
         },
@@ -541,44 +560,54 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
         ov::pass::GRUCellDecomposition,
         ov::pass::LSTMCellDecomposition);
 
-    CPU_SET_CALLBACK_COMMON(manager,
-        [](const_node_ptr &node) -> bool {
+    CPU_SET_CALLBACK_COMMON(
+        manager,
+        [](const_node_ptr& node) -> bool {
             std::string msg;
             return !node::RNN::isSupportedOperation(node, msg);
         },
         ov::pass::LSTMCellFusion);
 
-    CPU_SET_CALLBACK_COMMON(manager,
-        [](const_node_ptr &node) -> bool {
+    CPU_SET_CALLBACK_COMMON(
+        manager,
+        [](const_node_ptr& node) -> bool {
             std::string errorMessage;
             return node::MVN::isSupportedOperation(node, errorMessage);
         },
         ov::pass::MVN6Decomposition);
 
-    CPU_SET_CALLBACK_COMMON(manager,
-        [](const_node_ptr &node) -> bool {
+    CPU_SET_CALLBACK_COMMON(
+        manager,
+        [](const_node_ptr& node) -> bool {
             std::string errorMsg;
             return node::NormalizeL2::isSupportedOperation(node, errorMsg);
         },
         ov::pass::NormalizeL2Decomposition);
 
     if (!useLpt) {
-        CPU_SET_CALLBACK_X64(manager,
-            [this](const_node_ptr &node) -> bool {
-                // This is a callback from snippets. If GroupNorm node is appropriate for snippets execution with higher perf,
-                // then it will not be decomposed to mvn+reshape+eltwises, support it with snippets instead.
-                // Callback is used here, why not call GroupNormalizationDecomposition after snippets transformation pipeline is because
-                // 1. If GN is not tokenized conditionally in snippets transformation pipeline, GroupNormalizationDecomposition will produce
-                //    "reshpae + mvn + reshape + mul + add". these simple ops will not tokenized into subgraph, lead to suboptimal perf.
-                // 2. GroupNormalizationDecomposition produce MVN, and MVN have a conditional pass MVN6Decomposition. If call MVN6Decomposition again after
-                //    snippets pipeline as well, where MVN is decomposed to simple ops, these simple ops will not tokenized into subgraph again.
+        CPU_SET_CALLBACK_X64(
+            manager,
+            [this](const_node_ptr& node) -> bool {
+                // This is a callback from snippets. If GroupNorm node is appropriate for snippets execution with higher
+                // perf, then it will not be decomposed to mvn+reshape+eltwises, support it with snippets instead.
+                // Callback is used here, why not call GroupNormalizationDecomposition after snippets transformation
+                // pipeline is because
+                // 1. If GN is not tokenized conditionally in snippets transformation pipeline,
+                // GroupNormalizationDecomposition will produce
+                //    "reshpae + mvn + reshape + mul + add". these simple ops will not tokenized into subgraph, lead to
+                //    suboptimal perf.
+                // 2. GroupNormalizationDecomposition produce MVN, and MVN have a conditional pass MVN6Decomposition. If
+                // call MVN6Decomposition again after
+                //    snippets pipeline as well, where MVN is decomposed to simple ops, these simple ops will not
+                //    tokenized into subgraph again.
                 // CVS-134277 to fully enable GN as snippets to disable this GroupNormalizationDecomposition entirly.
                 if (node->is_dynamic() || !one_of(config.inferencePrecision, element::f32, element::undefined) ||
                     config.snippetsMode == Config::SnippetsMode::Disable)
                     return false;
                 if (config.snippetsMode != Config::SnippetsMode::IgnoreCallback) {
                     const auto group_norm = ov::as_type_ptr<const ov::op::v12::GroupNormalization>(node);
-                    if (!group_norm || !implication(config.inferencePrecision == element::undefined, group_norm->get_element_type() == element::f32))
+                    if (!group_norm || !implication(config.inferencePrecision == element::undefined,
+                                                    group_norm->get_element_type() == element::f32))
                         return false;
                     const auto num_groups = static_cast<size_t>(group_norm->get_num_groups());
                     const auto shape = group_norm->get_input_partial_shape(0).to_shape();
@@ -602,29 +631,32 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
     }
 
     CPU_ENABLE_PASS_COMMON(manager, ov::pass::SoftmaxDecomposition);
-    CPU_SET_CALLBACK_COMMON(manager,
-            [](const_node_ptr &node) -> bool {
-                return node->input_value(0).get_partial_shape().rank().get_length() <= 5;
-            },
+    CPU_SET_CALLBACK_COMMON(
+        manager,
+        [](const_node_ptr& node) -> bool {
+            return node->input_value(0).get_partial_shape().rank().get_length() <= 5;
+        },
         ov::pass::SoftmaxDecomposition);
 
     // NMS-alike nodes are always transformed to NMSIEInternal node in case of legacy api, for compatibility.
     // And on the other hand in case of api 2.0, keep them internal dynamic for better performance and functionality.
-    auto nmsCallback = [](const_node_ptr &node) -> bool {
+    auto nmsCallback = [](const_node_ptr& node) -> bool {
         // TODO: remove nmsCallback at all
         const bool isLegacyApi = false;
-        return isLegacyApi ?  false : true;
+        return isLegacyApi ? false : true;
     };
 
     CPU_SET_CALLBACK_COMMON(manager, nmsCallback, ov::pass::ConvertNMS9ToNMSIEInternal);
     CPU_SET_CALLBACK_COMMON(manager, nmsCallback, ov::pass::ConvertMulticlassNmsToMulticlassNmsIE);
     CPU_SET_CALLBACK_COMMON(manager, nmsCallback, ov::pass::ConvertMatrixNmsToMatrixNmsIE);
-    CPU_SET_CALLBACK_COMMON(manager,
-        [this](const_node_ptr &node) -> bool {
+    CPU_SET_CALLBACK_COMMON(
+        manager,
+        [this](const_node_ptr& node) -> bool {
             std::string errorMsg;
-            // Current SDPA impl is optimized only for LLM models, so we decompose it for others to avoid perf regression.
-            // Matching the pattern is a little complicated, so we just check if there is any state nodes.
-            return node::ScaledDotProductAttention::isSupportedOperation(node, errorMsg) && model->get_variables().size() > 0;
+            // Current SDPA impl is optimized only for LLM models, so we decompose it for others to avoid perf
+            // regression. Matching the pattern is a little complicated, so we just check if there is any state nodes.
+            return node::ScaledDotProductAttention::isSupportedOperation(node, errorMsg) &&
+                   model->get_variables().size() > 0;
         },
         ov::pass::ScaledDotProductAttentionDecomposition);
 
@@ -673,8 +705,9 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
 
     if (useLpt) {
         CPU_LPT_SCOPE(LowPrecisionTransformations_Part3);
-        CPU_SET_CALLBACK_COMMON(manager,
-            [](const_node_ptr &node) -> bool {
+        CPU_SET_CALLBACK_COMMON(
+            manager,
+            [](const_node_ptr& node) -> bool {
                 std::string errMsg;
                 return !node::FakeQuantize::isSupportedOperation(node, errMsg);
             },
@@ -682,16 +715,20 @@ void Transformations::PreLpt(const std::vector<ov::element::Type>& defaultPrecis
             ov::pass::MulFakeQuantizeFusion,
             ov::pass::FakeQuantizeMulFusion);
 
-        CPU_SET_CALLBACK_COMMON(manager,
-            [&defaultPrecisions](const_node_ptr &node) -> bool {
-                return ov::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForMultiply(node, defaultPrecisions);
+        CPU_SET_CALLBACK_COMMON(
+            manager,
+            [&defaultPrecisions](const_node_ptr& node) -> bool {
+                return ov::pass::low_precision::NetworkHelper::areQuantizeAndDequantizeSupportedForMultiply(
+                    node,
+                    defaultPrecisions);
             },
             ov::pass::ConvertQuantizeDequantize);
     }
 
-    /* In some cases, during the transformation pipeline, some MatMul nodes can be transformed into other nodes. For example, they can become part of
-       AUGRUCell node (see AUGRUCellFusion pass). In such cases, some constant paths will be unfolded, which can lead to crashes in the plugin. To avoid this,
-       we re-mark decompression converts again and finally do CF for those constant paths that are not inputs to MatMul node */
+    /* In some cases, during the transformation pipeline, some MatMul nodes can be transformed into other nodes. For
+       example, they can become part of AUGRUCell node (see AUGRUCellFusion pass). In such cases, some constant paths
+       will be unfolded, which can lead to crashes in the plugin. To avoid this, we re-mark decompression converts again
+       and finally do CF for those constant paths that are not inputs to MatMul node */
     CPU_REGISTER_PASS_COMMON(manager, ov::pass::EnableDecompressionConvertConstantFolding);
     CPU_REGISTER_PASS_COMMON(manager, ov::pass::KeepConstAndDecompression);
     CPU_REGISTER_PASS_COMMON(manager, ov::pass::ConstantFolding);
@@ -716,88 +753,92 @@ void Transformations::Lpt(const std::vector<ov::element::Type>& defaultPrecision
     }
 
     auto supportedPrecisions = std::vector<PrecisionsRestriction>({
-            PrecisionsRestriction::create<ov::opset1::Convolution>({
-                    {{0}, input0LowPrecisionList},
-                    {{1}, {ov::element::i8}},
-                }),
-            PrecisionsRestriction::create<ov::opset1::ConvolutionBackpropData>({
-                    {{0}, {ov::element::u8, ov::element::i8}},
-                    {{1}, {ov::element::i8}}
-                }),
-            PrecisionsRestriction::create<ov::opset1::GroupConvolution>([input0LowPrecisionList](const std::shared_ptr<ov::Node>& node){
-                const auto& input_partial_shape = node->get_input_partial_shape(0);
-                const auto& rank = input_partial_shape.rank();
-                if (rank.is_static() && (rank.get_length() == 5)) {
-                    return PrecisionsRestriction::PrecisionsByPorts{
-                        {{0}, {ov::element::u8, ov::element::i8}},
-                        {{1}, {ov::element::i8}}};
-                }
-
-                return PrecisionsRestriction::PrecisionsByPorts{
-                    {{0}, input0LowPrecisionList},
-                    {{1}, {ov::element::i8}}
-                };
-                }),
-            PrecisionsRestriction::create<ov::opset1::Multiply>({
-                    {{0}, {ov::element::u8}},
-                    {{1}, {ov::element::i8}},
-                }),
-            PrecisionsRestriction::create<ov::opset1::MatMul>({
-                    {{0}, {ov::element::u8, ov::element::i8}},
-                    {{1}, {ov::element::i8}}
-                }),
-            PrecisionsRestriction::create<ov::opset5::LSTMSequence>({
-                    {{0, 1}, {ov::element::u8}}
-                }),
-            PrecisionsRestriction::create<ov::opset6::GRUSequence>({
-                    {{0, 1}, {ov::element::u8}}
-                }),
-        });
+        PrecisionsRestriction::create<ov::opset1::Convolution>({
+            {{0}, input0LowPrecisionList},
+            {{1}, {ov::element::i8}},
+        }),
+        PrecisionsRestriction::create<ov::opset1::ConvolutionBackpropData>(
+            {{{0}, {ov::element::u8, ov::element::i8}}, {{1}, {ov::element::i8}}}),
+        PrecisionsRestriction::create<ov::opset1::GroupConvolution>([input0LowPrecisionList](
+                                                                        const std::shared_ptr<ov::Node>& node) {
+            const auto& input_partial_shape = node->get_input_partial_shape(0);
+            const auto& rank = input_partial_shape.rank();
+            if (rank.is_static() && (rank.get_length() == 5)) {
+                return PrecisionsRestriction::PrecisionsByPorts{{{0}, {ov::element::u8, ov::element::i8}},
+                                                                {{1}, {ov::element::i8}}};
+            }
 
-    auto quantizationRestrictions = std::vector<QuantizationGranularityRestriction>({
-            QuantizationGranularityRestriction::create<ov::opset1::Convolution>({0}),
-            QuantizationGranularityRestriction::create<ov::opset1::ConvolutionBackpropData>({0})
-        });
+            return PrecisionsRestriction::PrecisionsByPorts{{{0}, input0LowPrecisionList}, {{1}, {ov::element::i8}}};
+        }),
+        PrecisionsRestriction::create<ov::opset1::Multiply>({
+            {{0}, {ov::element::u8}},
+            {{1}, {ov::element::i8}},
+        }),
+        PrecisionsRestriction::create<ov::opset1::MatMul>(
+            {{{0}, {ov::element::u8, ov::element::i8}}, {{1}, {ov::element::i8}}}),
+        PrecisionsRestriction::create<ov::opset5::LSTMSequence>({{{0, 1}, {ov::element::u8}}}),
+        PrecisionsRestriction::create<ov::opset6::GRUSequence>({{{0, 1}, {ov::element::u8}}}),
+    });
+
+    auto quantizationRestrictions = std::vector<QuantizationGranularityRestriction>(
+        {QuantizationGranularityRestriction::create<ov::opset1::Convolution>({0}),
+         QuantizationGranularityRestriction::create<ov::opset1::ConvolutionBackpropData>({0})});
 
     ov::pass::Manager lptManager("CPU:LPT");
-    CPU_REGISTER_PASS_COMMON(lptManager, LowPrecision,
-        supportedPrecisions,
-        quantizationRestrictions,
-        LayerTransformation::Params(true, ov::element::f32, defaultPrecisions));
-
-    CPU_SET_CALLBACK_COMMON(lptManager, [](const_node_ptr& node) -> bool {
-        return ov::is_type<ov::opset1::Multiply>(node) &&
-               !MultiplyToGroupConvolutionTransformation::canBeTransformedToGroupConvolution(node);
-    }, MarkupPrecisions);
-    CPU_SET_CALLBACK_COMMON(lptManager, [&defaultPrecisions](const_node_ptr& node) -> bool {
-        return LayerTransformation::isAsymmetricQuantization(node, defaultPrecisions) ||
-               WeightableLayerTransformation::isAsymmetricOnWeights(node, defaultPrecisions);
-    }, ConvolutionBackpropDataTransformation);
-    CPU_SET_CALLBACK_COMMON(lptManager, [](const_node_ptr& node) -> bool {
-        return ov::marked_as_bias(node);
-    }, AddTransformation);
-
-    CPU_SET_CALLBACK_X64(lptManager, [&](const_node_ptr& node) -> bool {
-        const auto& consumers = node->get_output_target_inputs(0);
-        if (consumers.size() == 1) {
-            const auto consumer = consumers.begin()->get_node()->shared_from_this();
-            return ov::is_type<ov::opset1::Multiply>(consumer) && is_decompression_multiply(consumer);
-        }
-        return false;
-    }, FoldConvertTransformation);
+    CPU_REGISTER_PASS_COMMON(lptManager,
+                             LowPrecision,
+                             supportedPrecisions,
+                             quantizationRestrictions,
+                             LayerTransformation::Params(true, ov::element::f32, defaultPrecisions));
+
+    CPU_SET_CALLBACK_COMMON(
+        lptManager,
+        [](const_node_ptr& node) -> bool {
+            return ov::is_type<ov::opset1::Multiply>(node) &&
+                   !MultiplyToGroupConvolutionTransformation::canBeTransformedToGroupConvolution(node);
+        },
+        MarkupPrecisions);
+    CPU_SET_CALLBACK_COMMON(
+        lptManager,
+        [&defaultPrecisions](const_node_ptr& node) -> bool {
+            return LayerTransformation::isAsymmetricQuantization(node, defaultPrecisions) ||
+                   WeightableLayerTransformation::isAsymmetricOnWeights(node, defaultPrecisions);
+        },
+        ConvolutionBackpropDataTransformation);
+    CPU_SET_CALLBACK_COMMON(
+        lptManager,
+        [](const_node_ptr& node) -> bool {
+            return ov::marked_as_bias(node);
+        },
+        AddTransformation);
 
-    CPU_SET_CALLBACK_X64(lptManager, [&](const_node_ptr& node) -> bool {
-        if (ov::is_type<ov::opset1::Multiply>(node)) {
-            return ov::is_type<ov::opset1::Multiply>(node) && is_decompression_multiply(node);
-        } else if (ov::is_type<ov::opset1::Subtract>(node)) {
+    CPU_SET_CALLBACK_X64(
+        lptManager,
+        [&](const_node_ptr& node) -> bool {
             const auto& consumers = node->get_output_target_inputs(0);
             if (consumers.size() == 1) {
                 const auto consumer = consumers.begin()->get_node()->shared_from_this();
                 return ov::is_type<ov::opset1::Multiply>(consumer) && is_decompression_multiply(consumer);
             }
-        }
-        return false;
-    }, FuseConvertTransformation);
+            return false;
+        },
+        FoldConvertTransformation);
+
+    CPU_SET_CALLBACK_X64(
+        lptManager,
+        [&](const_node_ptr& node) -> bool {
+            if (ov::is_type<ov::opset1::Multiply>(node)) {
+                return ov::is_type<ov::opset1::Multiply>(node) && is_decompression_multiply(node);
+            } else if (ov::is_type<ov::opset1::Subtract>(node)) {
+                const auto& consumers = node->get_output_target_inputs(0);
+                if (consumers.size() == 1) {
+                    const auto consumer = consumers.begin()->get_node()->shared_from_this();
+                    return ov::is_type<ov::opset1::Multiply>(consumer) && is_decompression_multiply(consumer);
+                }
+            }
+            return false;
+        },
+        FuseConvertTransformation);
 
     CPU_DISABLE_PASS_ARM(lptManager, RecurrentCellTransformation);
     CPU_DISABLE_PASS_COMMON(lptManager, MultiplyToGroupConvolutionTransformation);
@@ -812,22 +853,26 @@ void Transformations::PostLpt() {
     postLPTPassManager.set_per_pass_validation(false);
     CPU_REGISTER_PASS_COMMON(postLPTPassManager, ov::pass::UnrollTensorIterator);
     CPU_REGISTER_PASS_COMMON(postLPTPassManager, ov::pass::ReshapePRelu);
-    CPU_SET_CALLBACK_COMMON(postLPTPassManager,
-        [](const_node_ptr &node) -> bool {
+    CPU_SET_CALLBACK_COMMON(
+        postLPTPassManager,
+        [](const_node_ptr& node) -> bool {
             // UnrollTI transformation is disabled by default, is turned on by LowLatency transformation
             return node->get_rt_info().count("UNROLL_TI") == 0;
         },
         ov::pass::UnrollTensorIterator);
     CPU_REGISTER_PASS_COMMON(postLPTPassManager, ov::pass::MoveEltwiseUpThroughDataMov);
     CPU_DISABLE_PASS_COMMON(postLPTPassManager, ov::pass::MoveEltwiseUpThroughDataMovPerChannel);
-    CPU_SET_CALLBACK_COMMON(postLPTPassManager,
+    CPU_SET_CALLBACK_COMMON(
+        postLPTPassManager,
         [](const std::shared_ptr<const ov::Node>& node) -> bool {
-            if (!ov::is_type<const ov::op::v0::FakeQuantize>(node) && node->get_output_element_type(0) != node->get_input_element_type(0))
+            if (!ov::is_type<const ov::op::v0::FakeQuantize>(node) &&
+                node->get_output_element_type(0) != node->get_input_element_type(0))
                 return true;
             if (node->get_input_size() >= 2) {
                 return node->get_input_element_type(1) == ov::element::i8 ||
                        node->get_input_element_type(1) == ov::element::u8 ||
-                       (ov::is_type<const ov::op::v0::FakeQuantize>(node) && !ov::is_type<const ov::op::v1::Transpose>(node->get_input_node_shared_ptr(0)));
+                       (ov::is_type<const ov::op::v0::FakeQuantize>(node) &&
+                        !ov::is_type<const ov::op::v1::Transpose>(node->get_input_node_shared_ptr(0)));
             }
             return false;
         },
@@ -848,14 +893,17 @@ void Transformations::PostLpt() {
 
 #if defined(OPENVINO_ARCH_X86_64)
     // MLP & QKV fusion optimizations is focused on throughput, only enabled on AMX-bf16 & LLM serving use cases.
-    auto can_use_amx_bf16_int8 = dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_amx) && (config.inferencePrecision == element::bf16);
-    auto can_use_amx_fp16 = dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_amx_fp16) && (config.inferencePrecision == element::f16);
+    auto can_use_amx_bf16_int8 = dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_amx) &&
+                                 (config.inferencePrecision == element::bf16);
+    auto can_use_amx_fp16 = dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_amx_fp16) &&
+                            (config.inferencePrecision == element::f16);
 
     if (can_use_amx_bf16_int8 || can_use_amx_fp16) {
         const auto fcDynamicQuantizationGroupSize = config.fcDynamicQuantizationGroupSize;
         CPU_REGISTER_PASS_X64(postLPTPassManager, MLPFusion);
-        CPU_SET_CALLBACK_X64(postLPTPassManager,
-            [fcDynamicQuantizationGroupSize](const_node_ptr &node) -> bool {
+        CPU_SET_CALLBACK_X64(
+            postLPTPassManager,
+            [fcDynamicQuantizationGroupSize](const_node_ptr& node) -> bool {
                 std::string errorMsg;
                 return node::LLMMLP::isSupportedOperation(node, errorMsg, fcDynamicQuantizationGroupSize);
             },
@@ -866,29 +914,38 @@ void Transformations::PostLpt() {
             concurrency = parallel_get_max_threads();
 
         CPU_REGISTER_PASS_X64(postLPTPassManager, QKVProjFusion);
-        CPU_SET_CALLBACK_X64(postLPTPassManager,
-            [=](const_node_ptr &node) -> bool {
+        CPU_SET_CALLBACK_X64(
+            postLPTPassManager,
+            [=](const_node_ptr& node) -> bool {
                 std::string errorMsg;
-                return node::QKVProjection::isSupportedOperation(node, errorMsg, concurrency, fcDynamicQuantizationGroupSize);
+                return node::QKVProjection::isSupportedOperation(node,
+                                                                 errorMsg,
+                                                                 concurrency,
+                                                                 fcDynamicQuantizationGroupSize);
             },
             QKVProjFusion);
 
         CPU_REGISTER_PASS_X64(postLPTPassManager, QKVProjFusion2);
-        CPU_SET_CALLBACK_X64(postLPTPassManager,
-            [=](const_node_ptr &node) -> bool {
+        CPU_SET_CALLBACK_X64(
+            postLPTPassManager,
+            [=](const_node_ptr& node) -> bool {
                 std::string errorMsg;
-                return node::QKVProjection::isSupportedOperation(node, errorMsg, concurrency, fcDynamicQuantizationGroupSize);
+                return node::QKVProjection::isSupportedOperation(node,
+                                                                 errorMsg,
+                                                                 concurrency,
+                                                                 fcDynamicQuantizationGroupSize);
             },
             QKVProjFusion2);
     }
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
     CPU_REGISTER_PASS_COMMON(postLPTPassManager, ov::pass::transpose_sinking::TSShapeOfForward);
     CPU_REGISTER_PASS_COMMON(postLPTPassManager, StatefulSDPAFusion);
     CPU_REGISTER_PASS_X64(postLPTPassManager, ov::intel_cpu::SDPAFuseTransposeReshape);
     CPU_REGISTER_PASS_X64(postLPTPassManager, ov::pass::RMSFusion, false);
     CPU_REGISTER_PASS_X64(postLPTPassManager, ov::intel_cpu::DecomposeRMSNorm);
-    CPU_SET_CALLBACK_X64(postLPTPassManager,
+    CPU_SET_CALLBACK_X64(
+        postLPTPassManager,
         [](const std::shared_ptr<const ov::Node>& node) -> bool {
             std::string errorMsg;
             return node::RMSNorm::isSupportedOperation(node, errorMsg);
@@ -901,7 +958,8 @@ void Transformations::PostLpt() {
         CPU_REGISTER_PASS_COMMON(postLPTPassManager, ov::pass::MarkFloatingPointRange);
     }
 
-    // Should be before Snippets pipeline because Ngram pattern contains eltwise nodes that can be tokenized by Snippets.
+    // Should be before Snippets pipeline because Ngram pattern contains eltwise nodes that can be tokenized by
+    // Snippets.
     auto symbolic_pipeline = CPU_REGISTER_PASS_COMMON(postLPTPassManager, ov::pass::SymbolicOptimizations, false);
     symbolic_pipeline->get_manager()->register_pass<NgramFusion>();
 
@@ -909,7 +967,7 @@ void Transformations::PostLpt() {
 }
 
 void Transformations::MainSnippets(void) {
-    auto is_supported_isa = [](){
+    auto is_supported_isa = []() {
 #if defined(OPENVINO_ARCH_X86_64)
         return dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2);
 #elif defined(OPENVINO_ARCH_ARM64)
@@ -924,8 +982,8 @@ void Transformations::MainSnippets(void) {
     // TODO [123659] Implement common logic to split optimization and limitation conditions
     const auto ignoreCallback = config.snippetsMode == Config::SnippetsMode::IgnoreCallback;
 
-    // [111813]: At the moment Snippets supports Transpose on output of MHA pattern only if it is an one node between MatMul and Result.
-    // However there may be Convert [f32->bf16] before Result since:
+    // [111813]: At the moment Snippets supports Transpose on output of MHA pattern only if it is an one node between
+    // MatMul and Result. However there may be Convert [f32->bf16] before Result since:
     //  - bf16 Brgemm has f32 output;
     //  - CPU Node Subgraph requires bf16 on output when inference precision is bf16.
     // To avoid sitations when Transpose is not alone node between MatMul and Result,
@@ -935,13 +993,13 @@ void Transformations::MainSnippets(void) {
     if (concurrency == 0)
         concurrency = parallel_get_max_threads();
 
-    // Runtime caching should be enabled in case of dynamic Subgraphs in CPU Plugin: to reduce overheads of ShapeInference and CodeGeneration
-    // If runtime cache capacity is zero, it means that rtCache won't be used and
-    // we shouldn't tokenize dynamic Subgraphs - it will lead to performance degradations
+    // Runtime caching should be enabled in case of dynamic Subgraphs in CPU Plugin: to reduce overheads of
+    // ShapeInference and CodeGeneration If runtime cache capacity is zero, it means that rtCache won't be used and we
+    // shouldn't tokenize dynamic Subgraphs - it will lead to performance degradations
     bool is_dynamic_mha_token_enabled = config.rtCacheCapacity != 0;
 #if defined(OPENVINO_ARCH_ARM64)
-    // ARM has 32 gprs. After excluding 2 registers for work amounts, 1 register for runtime parameters, 1 platform register,
-    // 3 registers for temporary use, and 2 stack related registers, it has 23 remaining registers.
+    // ARM has 32 gprs. After excluding 2 registers for work amounts, 1 register for runtime parameters, 1 platform
+    // register, 3 registers for temporary use, and 2 stack related registers, it has 23 remaining registers.
     size_t data_ptr_gpr_count = 23;
     // ARM doesn't even support MHA yet
     is_dynamic_mha_token_enabled = false;
@@ -951,12 +1009,16 @@ void Transformations::MainSnippets(void) {
     size_t data_ptr_gpr_count = 11;
 #endif
     // The optimization "SplitDimensionM" depends on target machine (thread count).
-    // To avoid uncontrolled behavior in tests, we disabled the optimization when there is Config::SnippetsMode::IgnoreCallback
+    // To avoid uncontrolled behavior in tests, we disabled the optimization when there is
+    // Config::SnippetsMode::IgnoreCallback
     bool split_m_dimension = !ignoreCallback;
     // [122706] Some 3D MHA Patterns have perf regressions when Transpose op is tokenized
-    std::set<size_t> mha_supported_transpose_ranks = { 4 };
-    snippets::pass::SnippetsTokenization::Config tokenization_config(concurrency, data_ptr_gpr_count, split_m_dimension,
-                                                                     mha_token_enable_transpose_on_output, is_dynamic_mha_token_enabled,
+    std::set<size_t> mha_supported_transpose_ranks = {4};
+    snippets::pass::SnippetsTokenization::Config tokenization_config(concurrency,
+                                                                     data_ptr_gpr_count,
+                                                                     split_m_dimension,
+                                                                     mha_token_enable_transpose_on_output,
+                                                                     is_dynamic_mha_token_enabled,
                                                                      mha_supported_transpose_ranks);
 
     ov::pass::Manager snippetsManager("CPU:Snippets");
@@ -976,12 +1038,12 @@ void Transformations::MainSnippets(void) {
     //   [122494] Need to add support of f16
     const bool isMHASupported =
 #if defined(OPENVINO_ARCH_ARM64)
-            false;
+        false;
 #else
-            (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2) &&
-             one_of(config.inferencePrecision, ov::element::f32, element::undefined)) ||
-            (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core) &&
-             one_of(config.inferencePrecision, ov::element::bf16, ov::element::f32, element::undefined));
+        (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2) &&
+         one_of(config.inferencePrecision, ov::element::f32, element::undefined)) ||
+        (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core) &&
+         one_of(config.inferencePrecision, ov::element::bf16, ov::element::f32, element::undefined));
 #endif
     if (!isMHASupported) {
         CPU_DISABLE_PASS_COMMON(snippetsManager, snippets::pass::TokenizeMHASnippets);
@@ -999,7 +1061,8 @@ void Transformations::MainSnippets(void) {
                               one_of(config.inferencePrecision, element::f32, element::undefined));
         const auto is_fp16 = (in_type0 == ov::element::f16 || in_type1 == ov::element::f16);
         const auto is_bf16 = (in_type0 == ov::element::bf16 && in_type1 == ov::element::bf16) ||
-                             ((in_type0 == element::f32 && in_type1 == ov::element::f32 && config.inferencePrecision == ov::element::bf16));
+                             ((in_type0 == element::f32 && in_type1 == ov::element::f32 &&
+                               config.inferencePrecision == ov::element::bf16));
         const auto is_int8 = in_type0 == ov::element::i8;
         if (is_fp16)
             return false;
@@ -1009,7 +1072,8 @@ void Transformations::MainSnippets(void) {
         if (matmul->is_dynamic())
             return false;
         // [114487] brgemm kernel in oneDNN requires brgemm_copy_b kernel if MatMul node has transposed_b=True
-        // The current solution with ExtractExplicitMatMulTranspose pass is slower for non-f32 cases than using of brgemm_copy_b kernel
+        // The current solution with ExtractExplicitMatMulTranspose pass is slower for non-f32 cases than using of
+        // brgemm_copy_b kernel
         if (matmul->get_transpose_a() || matmul->get_transpose_b())
             return false;
         // [150842] The execution of Brgemm INT8/BF16 on AMX platforms depends on the value of "K % VNNIFactor".
@@ -1017,8 +1081,10 @@ void Transformations::MainSnippets(void) {
         if (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_amx)) {
             const auto& b_shape = matmul->get_input_partial_shape(1);
             const auto K = matmul->get_transpose_b() ? *b_shape.rbegin() : *++b_shape.rbegin();
-            if (is_bf16) return K.is_static() && (K.get_length() % 2 == 0);
-            if (is_int8) return K.is_static();
+            if (is_bf16)
+                return K.is_static() && (K.get_length() % 2 == 0);
+            if (is_int8)
+                return K.is_static();
         }
         if (is_int8)
             return dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_vnni) ||
@@ -1027,70 +1093,58 @@ void Transformations::MainSnippets(void) {
             return dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_bf16);
         return true;
     };
-    auto is_unsupported_parallel_work_amount = [&](const std::shared_ptr<const ov::Node>& n, const ov::PartialShape& shape) {
+    auto is_unsupported_parallel_work_amount = [&](const std::shared_ptr<const ov::Node>& n,
+                                                   const ov::PartialShape& shape) {
         // SplitDimensionM transformation doesn't support dynamic shapes, so M dim is split in runtime configurator
         if (shape.is_dynamic())
             return false;
-        const auto parallel_work_amount = std::accumulate(shape.rbegin() + 2, shape.rend(), ov::Dimension(1), std::multiplies<ov::Dimension>());
+        const auto parallel_work_amount =
+            std::accumulate(shape.rbegin() + 2, shape.rend(), ov::Dimension(1), std::multiplies<ov::Dimension>());
         const auto is_unsupported_parallel_work_amount =
             static_cast<size_t>(parallel_work_amount.get_length()) < tokenization_config.get_concurrency() &&
             !ov::snippets::pass::SplitDimensionM::can_be_optimized(n, tokenization_config.get_concurrency());
         return is_unsupported_parallel_work_amount;
     };
-#endif // OPENVINO_ARCH_X86_64
+#endif  // OPENVINO_ARCH_X86_64
 
-    auto is_supported_op = [](const std::shared_ptr<const ov::Node> &n) -> bool {
+    auto is_supported_op = [](const std::shared_ptr<const ov::Node>& n) -> bool {
 #if defined(OPENVINO_ARCH_ARM64)
-        return (ov::is_type<ov::op::v0::Abs>(n) ||
-                ov::is_type<ov::op::v1::Add>(n) ||
-                ov::is_type<ov::op::v0::Clamp>(n) ||
-                ov::is_type<ov::op::v0::Convert>(n) ||
-                ov::is_type<ov::op::v1::Divide>(n) ||
-                ov::is_type<ov::op::v0::Elu>(n) ||
-                ov::is_type<ov::op::v0::Exp>(n) ||
-                ov::is_type<ov::op::v0::Floor>(n) ||
-                ov::is_type<ov::op::v0::Gelu>(n) ||
-                ov::is_type<ov::op::v7::Gelu>(n) ||
-                ov::is_type<ov::op::v4::HSwish>(n) ||
-                ov::is_type<ov::op::v1::Maximum>(n) ||
-                ov::is_type<ov::op::v1::Minimum>(n) ||
-                ov::is_type<ov::op::v4::Mish>(n) ||
-                ov::is_type<ov::op::v1::Mod>(n) ||
-                ov::is_type<ov::op::v1::Multiply>(n) ||
-                ov::is_type<ov::op::v0::Relu>(n) ||
-                ov::is_type<ov::op::v0::Sigmoid>(n) ||
-                ov::is_type<ov::op::v1::Subtract>(n) ||
-                ov::is_type<ov::op::v4::Swish>(n) ||
+        return (ov::is_type<ov::op::v0::Abs>(n) || ov::is_type<ov::op::v1::Add>(n) ||
+                ov::is_type<ov::op::v0::Clamp>(n) || ov::is_type<ov::op::v0::Convert>(n) ||
+                ov::is_type<ov::op::v1::Divide>(n) || ov::is_type<ov::op::v0::Elu>(n) ||
+                ov::is_type<ov::op::v0::Exp>(n) || ov::is_type<ov::op::v0::Floor>(n) ||
+                ov::is_type<ov::op::v0::Gelu>(n) || ov::is_type<ov::op::v7::Gelu>(n) ||
+                ov::is_type<ov::op::v4::HSwish>(n) || ov::is_type<ov::op::v1::Maximum>(n) ||
+                ov::is_type<ov::op::v1::Minimum>(n) || ov::is_type<ov::op::v4::Mish>(n) ||
+                ov::is_type<ov::op::v1::Mod>(n) || ov::is_type<ov::op::v1::Multiply>(n) ||
+                ov::is_type<ov::op::v0::Relu>(n) || ov::is_type<ov::op::v0::Sigmoid>(n) ||
+                ov::is_type<ov::op::v1::Subtract>(n) || ov::is_type<ov::op::v4::Swish>(n) ||
                 ov::is_type<ov::op::v0::Tanh>(n));
 #else
         // CPU Plugin support Swish in Subgraph via conversion to SwichCPU which assumes second input to be constant,
         // and CPU Plugin does not support Mish for x64
-        auto is_unsupported = [](const std::shared_ptr<const ov::Node> &n) {
+        auto is_unsupported = [](const std::shared_ptr<const ov::Node>& n) {
             return (ov::is_type<const ov::op::v4::Swish>(n) && n->inputs().size() > 1 &&
-                   !ov::is_type<const ov::op::v0::Constant>(n->get_input_node_shared_ptr(1))) ||
+                    !ov::is_type<const ov::op::v0::Constant>(n->get_input_node_shared_ptr(1))) ||
                    ov::is_type<const ov::op::v4::Mish>(n);
         };
         // todo: general tokenization flow is not currently supported for these operations.
         // they can be tokenized only as a part of complex patterns
-        auto is_unsupported_by_common_tokenization = [](const std::shared_ptr<const ov::Node> &n) {
-            return (ov::is_type<const ov::op::v1::Softmax>(n) ||
-                    ov::is_type<const ov::op::v8::Softmax>(n) ||
-                    ov::is_type<const ov::op::v0::MatMul>(n) ||
-                    ov::is_type<const ov::op::v1::Transpose>(n) ||
-                    ov::is_type<const ov::op::v1::Broadcast>(n) ||
-                    ov::is_type<const ov::op::v3::Broadcast>(n) ||
-                    ov::is_type<const ov::op::v1::ReduceMax>(n) ||
-                    ov::is_type<const ov::op::v1::ReduceSum>(n));
+        auto is_unsupported_by_common_tokenization = [](const std::shared_ptr<const ov::Node>& n) {
+            return (ov::is_type<const ov::op::v1::Softmax>(n) || ov::is_type<const ov::op::v8::Softmax>(n) ||
+                    ov::is_type<const ov::op::v0::MatMul>(n) || ov::is_type<const ov::op::v1::Transpose>(n) ||
+                    ov::is_type<const ov::op::v1::Broadcast>(n) || ov::is_type<const ov::op::v3::Broadcast>(n) ||
+                    ov::is_type<const ov::op::v1::ReduceMax>(n) || ov::is_type<const ov::op::v1::ReduceSum>(n));
         };
         return !is_unsupported(n) && !is_unsupported_by_common_tokenization(n);
 #endif
     };
 
-    auto has_supported_tensors = [ignoreCallback](const std::shared_ptr<const ov::Node> &n) -> bool {
+    auto has_supported_tensors = [ignoreCallback](const std::shared_ptr<const ov::Node>& n) -> bool {
         // Check for supported precision
         auto is_supported_tensor = [&n, ignoreCallback](descriptor::Tensor& t, bool is_input) -> bool {
-            // TODO [105804] int32 isn't supported in general because i32 emitters are required for bit-exact i32 calculations in some cases
-            // So i32 is supported exclusively for transposes and broadcast
+            // TODO [105804] int32 isn't supported in general because i32 emitters are required for bit-exact i32
+            // calculations in some cases So i32 is supported exclusively for transposes and broadcast
             static const std::set<ov::element::Type> supported_element_types =
 #if defined(OPENVINO_ARCH_ARM64)
                 {ov::element::f32, ov::element::f16, ov::element::i8, ov::element::u8};
@@ -1105,69 +1159,80 @@ void Transformations::MainSnippets(void) {
                     return false;
             }
 
-            return supported_element_types.count(t.get_element_type()) != 0 || (is_input &&
-                   t.get_element_type() == ov::element::i32 &&
-                   (ov::is_type<const opset1::Transpose>(n) ||
-                    ov::is_type<const opset1::Broadcast>(n) ||
-                    ov::is_type<const opset1::ReduceMax>(n) ||
-                    ov::is_type<const opset1::ReduceSum>(n)));
+            return supported_element_types.count(t.get_element_type()) != 0 ||
+                   (is_input && t.get_element_type() == ov::element::i32 &&
+                    (ov::is_type<const opset1::Transpose>(n) || ov::is_type<const opset1::Broadcast>(n) ||
+                     ov::is_type<const opset1::ReduceMax>(n) || ov::is_type<const opset1::ReduceSum>(n)));
         };
 
         const auto& inputs = n->inputs();
         const auto& outputs = n->outputs();
-        return std::all_of(inputs.begin(), inputs.end(), [&](const Input<const ov::Node>& in) {return  is_supported_tensor(in.get_tensor(), true);}) &&
-               std::all_of(outputs.begin(), outputs.end(), [&](const Output<const ov::Node>& out) {return  is_supported_tensor(out.get_tensor(), false);});
+        return std::all_of(inputs.begin(),
+                           inputs.end(),
+                           [&](const Input<const ov::Node>& in) {
+                               return is_supported_tensor(in.get_tensor(), true);
+                           }) &&
+               std::all_of(outputs.begin(), outputs.end(), [&](const Output<const ov::Node>& out) {
+                   return is_supported_tensor(out.get_tensor(), false);
+               });
     };
 
     if (!ignoreCallback) {
-        CPU_SET_CALLBACK_X64(snippetsManager, [&](const std::shared_ptr<const ov::Node>& n) -> bool {
-            // Tranformation callback is called on MatMul0
-            if (!is_supported_matmul(n))
-                return true;
-            // Search for MatMul1
-            auto child = n->get_output_target_inputs(0).begin()->get_node()->shared_from_this();
-            while (!ov::is_type<const ov::op::v0::MatMul>(child)) {
-                child = child->get_output_target_inputs(0).begin()->get_node()->shared_from_this();
-            }
-            if (!is_supported_matmul(child))
-                return true;
+        CPU_SET_CALLBACK_X64(
+            snippetsManager,
+            [&](const std::shared_ptr<const ov::Node>& n) -> bool {
+                // Tranformation callback is called on MatMul0
+                if (!is_supported_matmul(n))
+                    return true;
+                // Search for MatMul1
+                auto child = n->get_output_target_inputs(0).begin()->get_node()->shared_from_this();
+                while (!ov::is_type<const ov::op::v0::MatMul>(child)) {
+                    child = child->get_output_target_inputs(0).begin()->get_node()->shared_from_this();
+                }
+                if (!is_supported_matmul(child))
+                    return true;
 
-            const auto& pshape = child->get_input_partial_shape(0);
-            return is_unsupported_parallel_work_amount(n, pshape);
-        }, snippets::pass::TokenizeMHASnippets);
-        CPU_SET_CALLBACK_X64(snippetsManager, [&](const std::shared_ptr<const ov::Node>& n) -> bool {
-            return !is_supported_matmul(n) || is_unsupported_parallel_work_amount(n, n->get_output_partial_shape(0));
-        }, snippets::pass::ExtractReshapesFromMHA);
+                const auto& pshape = child->get_input_partial_shape(0);
+                return is_unsupported_parallel_work_amount(n, pshape);
+            },
+            snippets::pass::TokenizeMHASnippets);
+        CPU_SET_CALLBACK_X64(
+            snippetsManager,
+            [&](const std::shared_ptr<const ov::Node>& n) -> bool {
+                return !is_supported_matmul(n) ||
+                       is_unsupported_parallel_work_amount(n, n->get_output_partial_shape(0));
+            },
+            snippets::pass::ExtractReshapesFromMHA);
     }
 
-    CPU_SET_CALLBACK_COMMON(snippetsManager,
-    [&](const std::shared_ptr<const ov::Node>& n) -> bool {
-        if (!ignoreCallback) {
-            if (n->is_dynamic() || !is_supported_op(n))
-                return true;
-        }
+    CPU_SET_CALLBACK_COMMON(
+        snippetsManager,
+        [&](const std::shared_ptr<const ov::Node>& n) -> bool {
+            if (!ignoreCallback) {
+                if (n->is_dynamic() || !is_supported_op(n))
+                    return true;
+            }
 
-        const auto& inputs = n->inputs();
-        // todo: clarify whether we can evaluate snippets on const paths
-        const bool has_only_const_inputs = std::all_of(inputs.begin(), inputs.end(),
-                                                        [](const ov::Input<const ov::Node>& in) {
-                                                            return ov::is_type<ov::op::v0::Constant>(
-                                                                    in.get_source_output().get_node_shared_ptr());
-                                                        });
-        if (has_only_const_inputs)
-            return true;
-        if (!has_supported_tensors(n))
-            return true;
-        return false;
-    },
-    snippets::pass::TokenizeSnippets);
+            const auto& inputs = n->inputs();
+            // todo: clarify whether we can evaluate snippets on const paths
+            const bool has_only_const_inputs =
+                std::all_of(inputs.begin(), inputs.end(), [](const ov::Input<const ov::Node>& in) {
+                    return ov::is_type<ov::op::v0::Constant>(in.get_source_output().get_node_shared_ptr());
+                });
+            if (has_only_const_inputs)
+                return true;
+            if (!has_supported_tensors(n))
+                return true;
+            return false;
+        },
+        snippets::pass::TokenizeSnippets);
 
     auto mm_supports_transpose_b = [this, ignoreCallback](const std::shared_ptr<const ov::Node>& n) {
         MAYBE_UNUSED(config.inferencePrecision);
         if (!ignoreCallback)
             return false;
-        // Note: BrgemmTPP doesn't support transposed KN natively
-        // so we should extract transposes for the corresponding matmul nodes
+            // Note: BrgemmTPP doesn't support transposed KN natively
+            // so we should extract transposes for the corresponding matmul nodes
 #if defined(SNIPPETS_LIBXSMM_TPP)
         // TPP doesn't support dynamic shapes -> there will be BrgemmCPU node
         if (n->is_dynamic())
@@ -1197,11 +1262,12 @@ void Transformations::MainSnippets(void) {
         return true;
     };
 
-    CPU_SET_CALLBACK_COMMON(snippetsManager,
-    [&mm_supports_transpose_b](const std::shared_ptr<const ov::Node>& n) {
-        return mm_supports_transpose_b(n);
-    },
-    snippets::pass::ExplicitTransposeMatMulInputs);
+    CPU_SET_CALLBACK_COMMON(
+        snippetsManager,
+        [&mm_supports_transpose_b](const std::shared_ptr<const ov::Node>& n) {
+            return mm_supports_transpose_b(n);
+        },
+        snippets::pass::ExplicitTransposeMatMulInputs);
 
     snippetsManager.run_passes(model);
 }
@@ -1210,7 +1276,8 @@ void Transformations::PostSnippets(void) {
     ov::pass::Manager postSnippetsManager("CPU:PostSnippets");
     postSnippetsManager.set_per_pass_validation(false);
     CPU_REGISTER_PASS_COMMON(postSnippetsManager, ov::pass::FakeQuantizeDecomposition);
-    CPU_SET_CALLBACK_COMMON(postSnippetsManager,
+    CPU_SET_CALLBACK_COMMON(
+        postSnippetsManager,
         [](const_node_ptr& node) -> bool {
             std::string errMsg;
             return node::FakeQuantize::isSupportedOperation(node, errMsg);
@@ -1222,7 +1289,7 @@ void Transformations::PostSnippets(void) {
 
 void Transformations::Snippets(void) {
     const bool useSnippets = config.snippetsMode != Config::SnippetsMode::Disable &&
-        CPU_DEBUG_CAP_IS_TRANSFORMATION_ENABLED(config.debugCaps, Snippets);
+                             CPU_DEBUG_CAP_IS_TRANSFORMATION_ENABLED(config.debugCaps, Snippets);
     if (!useSnippets)
         return;
 
@@ -1231,5 +1298,5 @@ void Transformations::Snippets(void) {
     PostSnippets();
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.h b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.h
index 33c26ab8aea9e4..1c8991b0e19ed5 100644
--- a/src/plugins/intel_cpu/src/transformations/transformation_pipeline.h
+++ b/src/plugins/intel_cpu/src/transformations/transformation_pipeline.h
@@ -4,28 +4,26 @@
 
 #pragma once
 
-#include "openvino/core/model.hpp"
-#include "utils/debug_capabilities.h"
-#include "low_precision/low_precision.hpp"
-#include "config.h"
-#include "transformations/convert_precision.hpp"
-
-#include "itt.h"
-
 #include <memory>
 #include <vector>
 
+#include "config.h"
+#include "itt.h"
+#include "low_precision/low_precision.hpp"
+#include "openvino/core/model.hpp"
+#include "transformations/convert_precision.hpp"
+#include "utils/debug_capabilities.h"
+
 namespace ov {
 namespace intel_cpu {
 
 class Transformations {
 public:
-    Transformations(const std::shared_ptr<ov::Model>& initialModel,
-                    const Config&                     config)
+    Transformations(const std::shared_ptr<ov::Model>& initialModel, const Config& config)
         : model(initialModel),
           config(config) {
-            CPU_DEBUG_CAPS_MAYBE_UNUSED(this->config);
-          }
+        CPU_DEBUG_CAPS_MAYBE_UNUSED(this->config);
+    }
 
     void UpToLpt();
     void CpuSpecificOpSet();
@@ -51,5 +49,5 @@ class Transformations {
     static bool fuse_type_to_pa(const std::shared_ptr<ov::Node>& node, const precisions_map& precisions);
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/utils.cpp b/src/plugins/intel_cpu/src/transformations/utils.cpp
index 63871868713e02..51323f5b331186 100644
--- a/src/plugins/intel_cpu/src/transformations/utils.cpp
+++ b/src/plugins/intel_cpu/src/transformations/utils.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "utils.hpp"
+
 #include "openvino/opsets/opset1.hpp"
 #include "ov_ops/fully_connected.hpp"
 #include "transformations/rt_info/dequantization_node.hpp"
@@ -40,5 +41,5 @@ bool has_matmul_with_compressed_weights(const std::shared_ptr<const ov::Model>&
     return false;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/transformations/utils.hpp b/src/plugins/intel_cpu/src/transformations/utils.hpp
index 685df5c5b03c55..ec1ff905702d76 100644
--- a/src/plugins/intel_cpu/src/transformations/utils.hpp
+++ b/src/plugins/intel_cpu/src/transformations/utils.hpp
@@ -11,5 +11,5 @@ namespace intel_cpu {
 
 bool has_matmul_with_compressed_weights(const std::shared_ptr<const ov::Model>& model);
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/bfloat16.hpp b/src/plugins/intel_cpu/src/utils/bfloat16.hpp
index 430897521bf5e6..b715a5ca9ac933 100644
--- a/src/plugins/intel_cpu/src/utils/bfloat16.hpp
+++ b/src/plugins/intel_cpu/src/utils/bfloat16.hpp
@@ -5,14 +5,14 @@
 #pragma once
 
 #include <cmath>
-#include <limits>
 #include <cstdint>
+#include <limits>
 
 /**
- * The bfloat16_t class can be used as an arithmetic type. All arithmetic operations goes through conversion to the float data type.
+ * The bfloat16_t class can be used as an arithmetic type. All arithmetic operations goes through conversion to the
+ * float data type.
  */
 
-
 #define BFLOAT16_ROUND_MODE_TO_NEAREST_EVEN
 
 namespace ov {
@@ -21,8 +21,7 @@ namespace intel_cpu {
 class bfloat16_t {
 public:
     bfloat16_t() = default;
-    bfloat16_t(float value) noexcept
-            : m_value{
+    bfloat16_t(float value) noexcept : m_value {
 #if defined BFLOAT16_ROUND_MODE_TO_NEAREST
         round_to_nearest(value)
 #elif defined BFLOAT16_ROUND_MODE_TO_NEAREST_EVEN
@@ -30,18 +29,21 @@ class bfloat16_t {
 #elif defined BFLOAT16_ROUND_MODE_TRUNCATE
         truncate(value)
 #else
-#error                                                                                             \
-    "ROUNDING_MODE must be one of BFLOAT16_ROUND_MODE_TO_NEAREST, BFLOAT16_ROUND_MODE_TO_NEAREST_EVEN, or BFLOAT16_ROUND_MODE_TRUNCATE"
+#    error \
+        "ROUNDING_MODE must be one of BFLOAT16_ROUND_MODE_TO_NEAREST, BFLOAT16_ROUND_MODE_TO_NEAREST_EVEN, or BFLOAT16_ROUND_MODE_TRUNCATE"
 #endif
     }
-    {
-    }
+    {}
 
     operator float() const {
         return F32{uint32_t(m_value) << 16}.vfloat;
     }
-    static constexpr bfloat16_t from_bits(uint16_t bits) { return bfloat16_t(bits, true); }
-    uint16_t to_bits() const { return m_value; }
+    static constexpr bfloat16_t from_bits(uint16_t bits) {
+        return bfloat16_t(bits, true);
+    }
+    uint16_t to_bits() const {
+        return m_value;
+    }
 
     static inline uint16_t round_to_nearest_even(float x) {
         return static_cast<uint16_t>((F32(x).vint + ((F32(x).vint & 0x00010000) >> 1)) >> 16);
@@ -51,29 +53,24 @@ class bfloat16_t {
         return static_cast<uint16_t>((F32(x).vint + 0x8000) >> 16);
     }
 
-    static inline uint16_t truncate(float x) { return static_cast<uint16_t>((F32(x).vint) >> 16); }
+    static inline uint16_t truncate(float x) {
+        return static_cast<uint16_t>((F32(x).vint) >> 16);
+    }
 
 private:
-    constexpr bfloat16_t(uint16_t x, bool)
-            : m_value{x}
-    {
-    }
+    constexpr bfloat16_t(uint16_t x, bool) : m_value{x} {}
     union alignas(16) F32 {
-        F32(float val)
-                : vfloat{val} {
-        }
+        F32(float val) : vfloat{val} {}
 
-        F32(uint32_t val)
-                : vint{val} {
-        }
+        F32(uint32_t val) : vint{val} {}
         float vfloat;
         uint32_t vint;
     };
     uint16_t m_value;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
 /**
  * std::numeric_limits overloaded for better compatibility with template metaprogramming.
@@ -140,5 +137,4 @@ class numeric_limits<ov::intel_cpu::bfloat16_t> {
     static constexpr bool tinyness_before = false;
     static constexpr float_round_style round_style = round_to_nearest;
 };
-} // namespace std
-
+}  // namespace std
diff --git a/src/plugins/intel_cpu/src/utils/blob_dump.cpp b/src/plugins/intel_cpu/src/utils/blob_dump.cpp
index 7f7b1694ac6c1d..d721b8b19f0f5c 100644
--- a/src/plugins/intel_cpu/src/utils/blob_dump.cpp
+++ b/src/plugins/intel_cpu/src/utils/blob_dump.cpp
@@ -3,16 +3,17 @@
 //
 
 #include "blob_dump.h"
+
 #include <cpu_memory.h>
-#include "dnnl_extension_utils.h"
+#include <memory_desc/cpu_memory_desc_utils.h>
 #include <nodes/common/cpu_memcpy.h>
 
+#include <fstream>
+
 #include "common/memory_desc_wrapper.hpp"
+#include "dnnl_extension_utils.h"
 #include "utils/bfloat16.hpp"
 
-#include <fstream>
-#include <memory_desc/cpu_memory_desc_utils.h>
-
 namespace ov {
 namespace intel_cpu {
 
@@ -26,7 +27,7 @@ struct IEB_HEADER {
 
     unsigned char precision;  // 0-8
     unsigned char ndims;
-    unsigned int  dims[7];  // max is 7-D blob
+    unsigned int dims[7];  // max is 7-D blob
 
     unsigned char scaling_axis;  // FF - no scaling
     unsigned char reserved[3];
@@ -55,7 +56,7 @@ static IEB_HEADER prepare_header(const MemoryDesc& desc) {
         OPENVINO_THROW("Dumper support max 7D blobs");
 
     header.ndims = desc.getShape().getRank();
-    const auto &dims = desc.getShape().getStaticDims();
+    const auto& dims = desc.getShape().getStaticDims();
     for (int i = 0; i < header.ndims; i++)
         header.dims[i] = dims[i];
 
@@ -64,15 +65,12 @@ static IEB_HEADER prepare_header(const MemoryDesc& desc) {
     return header;
 }
 
-static DnnlBlockedMemoryDesc parse_header(IEB_HEADER &header) {
-    if (header.magic[0] != IEB_MAGIC[0] ||
-        header.magic[1] != IEB_MAGIC[1] ||
-        header.magic[2] != IEB_MAGIC[2] ||
+static DnnlBlockedMemoryDesc parse_header(IEB_HEADER& header) {
+    if (header.magic[0] != IEB_MAGIC[0] || header.magic[1] != IEB_MAGIC[1] || header.magic[2] != IEB_MAGIC[2] ||
         header.magic[3] != IEB_MAGIC[3])
         OPENVINO_THROW("Dumper cannot parse file. Wrong format.");
 
-    if (header.ver[0] != 0 ||
-        header.ver[1] != 1)
+    if (header.ver[0] != 0 || header.ver[1] != 1)
         OPENVINO_THROW("Dumper cannot parse file. Unsupported IEB format version.");
 
     const auto prc = static_cast<ov::element::Type_t>(header.precision);
@@ -83,8 +81,8 @@ static DnnlBlockedMemoryDesc parse_header(IEB_HEADER &header) {
     return DnnlBlockedMemoryDesc{prc, Shape(dims)};
 }
 
-void BlobDumper::prepare_plain_data(const MemoryPtr &memory, std::vector<uint8_t> &data) const {
-    const auto &desc = memory->getDesc();
+void BlobDumper::prepare_plain_data(const MemoryPtr& memory, std::vector<uint8_t>& data) const {
+    const auto& desc = memory->getDesc();
     size_t data_size = desc.getShape().getElementsCount();
     const auto size = data_size * desc.getPrecision().size();
     data.resize(size);
@@ -96,45 +94,45 @@ void BlobDumper::prepare_plain_data(const MemoryPtr &memory, std::vector<uint8_t
     }
 
     // Copy to plain
-    const void *ptr = memory->getData();
+    const void* ptr = memory->getData();
 
     switch (desc.getPrecision()) {
-        case ov::element::f32:
-        case ov::element::i32: {
-            auto *pln_blob_ptr = reinterpret_cast<int32_t *>(data.data());
-            auto *blob_ptr = reinterpret_cast<const int32_t *>(ptr);
-            for (size_t i = 0; i < data_size; i++)
-                pln_blob_ptr[i] = blob_ptr[desc.getElementOffset(i)];
-            break;
-        }
-        case ov::element::bf16: {
-            auto *pln_blob_ptr = reinterpret_cast<int16_t *>(data.data());
-            auto *blob_ptr = reinterpret_cast<const int16_t *>(ptr);
-            for (size_t i = 0; i < data_size; i++)
-                pln_blob_ptr[i] = blob_ptr[desc.getElementOffset(i)];
-            break;
-        }
-        case ov::element::f16: {
-            auto *pln_blob_ptr = reinterpret_cast<float16 *>(data.data());
-            auto *blob_ptr = reinterpret_cast<const float16 *>(ptr);
-            for (size_t i = 0; i < data_size; i++)
-                pln_blob_ptr[i] = blob_ptr[desc.getElementOffset(i)];
-            break;
-        }
-        case ov::element::i8:
-        case ov::element::u8: {
-            auto *pln_blob_ptr = reinterpret_cast<int8_t*>(data.data());
-            auto *blob_ptr = reinterpret_cast<const int8_t *>(ptr);
-            for (size_t i = 0; i < data_size; i++)
-                pln_blob_ptr[i] = blob_ptr[desc.getElementOffset(i)];
-            break;
-        }
-        default:
-            OPENVINO_THROW("Dumper. Unsupported precision");
+    case ov::element::f32:
+    case ov::element::i32: {
+        auto* pln_blob_ptr = reinterpret_cast<int32_t*>(data.data());
+        auto* blob_ptr = reinterpret_cast<const int32_t*>(ptr);
+        for (size_t i = 0; i < data_size; i++)
+            pln_blob_ptr[i] = blob_ptr[desc.getElementOffset(i)];
+        break;
+    }
+    case ov::element::bf16: {
+        auto* pln_blob_ptr = reinterpret_cast<int16_t*>(data.data());
+        auto* blob_ptr = reinterpret_cast<const int16_t*>(ptr);
+        for (size_t i = 0; i < data_size; i++)
+            pln_blob_ptr[i] = blob_ptr[desc.getElementOffset(i)];
+        break;
+    }
+    case ov::element::f16: {
+        auto* pln_blob_ptr = reinterpret_cast<float16*>(data.data());
+        auto* blob_ptr = reinterpret_cast<const float16*>(ptr);
+        for (size_t i = 0; i < data_size; i++)
+            pln_blob_ptr[i] = blob_ptr[desc.getElementOffset(i)];
+        break;
+    }
+    case ov::element::i8:
+    case ov::element::u8: {
+        auto* pln_blob_ptr = reinterpret_cast<int8_t*>(data.data());
+        auto* blob_ptr = reinterpret_cast<const int8_t*>(ptr);
+        for (size_t i = 0; i < data_size; i++)
+            pln_blob_ptr[i] = blob_ptr[desc.getElementOffset(i)];
+        break;
+    }
+    default:
+        OPENVINO_THROW("Dumper. Unsupported precision");
     }
 }
 
-void BlobDumper::dump(std::ostream &stream) const {
+void BlobDumper::dump(std::ostream& stream) const {
     if (memory == nullptr)
         OPENVINO_THROW("Dumper cannot dump. Memory is not allocated.");
 
@@ -151,94 +149,94 @@ void BlobDumper::dump(std::ostream &stream) const {
     stream.write(reinterpret_cast<char*>(data.data()), data.size());
 }
 
-void BlobDumper::dumpAsTxt(std::ostream &stream) const {
+void BlobDumper::dumpAsTxt(std::ostream& stream) const {
     if (memory == nullptr)
         OPENVINO_THROW("Dumper cannot dump. Memory is not allocated.");
 
-    const auto &desc = memory->getDesc();
+    const auto& desc = memory->getDesc();
     const auto dims = desc.getShape().getStaticDims();
     size_t data_size = desc.getShape().getElementsCount();
 
     // Header like "U8 4D shape: 2 3 224 224 ()
-    stream << memory->getDesc().getPrecision().get_type_name() << " "
-           << dims.size() << "D "
+    stream << memory->getDesc().getPrecision().get_type_name() << " " << dims.size() << "D "
            << "shape: ";
-    for (size_t d : dims) stream << d << " ";
-    stream << "(" << data_size << ")" <<
-    " by address 0x" << std::hex << memory->getDataAs<const long long>() << std::dec <<std::endl;
+    for (size_t d : dims)
+        stream << d << " ";
+    stream << "(" << data_size << ")"
+           << " by address 0x" << std::hex << memory->getDataAs<const long long>() << std::dec << std::endl;
 
-    const void *ptr = memory->getData();
+    const void* ptr = memory->getData();
 
     switch (desc.getPrecision()) {
-        case ov::element::f32 : {
-            auto *blob_ptr = reinterpret_cast<const float*>(ptr);
-            for (size_t i = 0; i < data_size; i++)
-                stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
-            break;
-        }
-        case ov::element::i32: {
-            auto *blob_ptr = reinterpret_cast<const int32_t*>(ptr);
-            for (size_t i = 0; i < data_size; i++)
-                stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
-            break;
-        }
-        case ov::element::bf16: {
-            auto *blob_ptr = reinterpret_cast<const bfloat16_t*>(ptr);
-            for (size_t i = 0; i < data_size; i++) {
-                float fn = static_cast<float>(blob_ptr[desc.getElementOffset(i)]);
-                stream << fn << std::endl;
-            }
-            break;
-        }
-        case ov::element::f16: {
-            auto *blob_ptr = reinterpret_cast<const float16*>(ptr);
-            for (size_t i = 0; i < data_size; i++)
-                stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
-            break;
-        }
-        case ov::element::i8: {
-            auto *blob_ptr = reinterpret_cast<const int8_t*>(ptr);
-            for (size_t i = 0; i < data_size; i++)
-                stream << static_cast<int>(blob_ptr[desc.getElementOffset(i)]) << std::endl;
-            break;
-        }
-        case ov::element::u8: {
-            auto *blob_ptr = reinterpret_cast<const uint8_t*>(ptr);
-            for (size_t i = 0; i < data_size; i++)
-                stream << static_cast<int>(blob_ptr[desc.getElementOffset(i)]) << std::endl;
-            break;
-        }
-        case ov::element::i64: {
-            auto* blob_ptr = reinterpret_cast<const int64_t*>(ptr);
-            for (size_t i = 0; i < data_size; i++)
-                stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
-            break;
-        }
-        case ov::element::u32: {
-            auto* blob_ptr = reinterpret_cast<const uint32_t*>(ptr);
-            for (size_t i = 0; i < data_size; i++)
-                stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
-            break;
-        }
-        case ov::element::u16: {
-            auto* blob_ptr = reinterpret_cast<const uint16_t*>(ptr);
-            for (size_t i = 0; i < data_size; i++)
-                stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
-            break;
-        }
-        case ov::element::i16: {
-            auto* blob_ptr = reinterpret_cast<const int16_t*>(ptr);
-            for (size_t i = 0; i < data_size; i++)
-                stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
-            break;
+    case ov::element::f32: {
+        auto* blob_ptr = reinterpret_cast<const float*>(ptr);
+        for (size_t i = 0; i < data_size; i++)
+            stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
+        break;
+    }
+    case ov::element::i32: {
+        auto* blob_ptr = reinterpret_cast<const int32_t*>(ptr);
+        for (size_t i = 0; i < data_size; i++)
+            stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
+        break;
+    }
+    case ov::element::bf16: {
+        auto* blob_ptr = reinterpret_cast<const bfloat16_t*>(ptr);
+        for (size_t i = 0; i < data_size; i++) {
+            float fn = static_cast<float>(blob_ptr[desc.getElementOffset(i)]);
+            stream << fn << std::endl;
         }
-        default:
-            break;
-            OPENVINO_THROW("Dumper. Unsupported precision");
+        break;
+    }
+    case ov::element::f16: {
+        auto* blob_ptr = reinterpret_cast<const float16*>(ptr);
+        for (size_t i = 0; i < data_size; i++)
+            stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
+        break;
+    }
+    case ov::element::i8: {
+        auto* blob_ptr = reinterpret_cast<const int8_t*>(ptr);
+        for (size_t i = 0; i < data_size; i++)
+            stream << static_cast<int>(blob_ptr[desc.getElementOffset(i)]) << std::endl;
+        break;
+    }
+    case ov::element::u8: {
+        auto* blob_ptr = reinterpret_cast<const uint8_t*>(ptr);
+        for (size_t i = 0; i < data_size; i++)
+            stream << static_cast<int>(blob_ptr[desc.getElementOffset(i)]) << std::endl;
+        break;
+    }
+    case ov::element::i64: {
+        auto* blob_ptr = reinterpret_cast<const int64_t*>(ptr);
+        for (size_t i = 0; i < data_size; i++)
+            stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
+        break;
+    }
+    case ov::element::u32: {
+        auto* blob_ptr = reinterpret_cast<const uint32_t*>(ptr);
+        for (size_t i = 0; i < data_size; i++)
+            stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
+        break;
+    }
+    case ov::element::u16: {
+        auto* blob_ptr = reinterpret_cast<const uint16_t*>(ptr);
+        for (size_t i = 0; i < data_size; i++)
+            stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
+        break;
+    }
+    case ov::element::i16: {
+        auto* blob_ptr = reinterpret_cast<const int16_t*>(ptr);
+        for (size_t i = 0; i < data_size; i++)
+            stream << blob_ptr[desc.getElementOffset(i)] << std::endl;
+        break;
+    }
+    default:
+        break;
+        OPENVINO_THROW("Dumper. Unsupported precision");
     }
 }
 
-BlobDumper BlobDumper::read(std::istream &stream) {
+BlobDumper BlobDumper::read(std::istream& stream) {
     IEB_HEADER header;
     stream.read(reinterpret_cast<char*>(&header), sizeof(header));
 
@@ -246,12 +244,12 @@ BlobDumper BlobDumper::read(std::istream &stream) {
 
     BlobDumper res(desc);
     stream.seekg(header.data_offset, stream.beg);
-    stream.read(reinterpret_cast<char *>(res.getDataPtr()), header.data_size);
+    stream.read(reinterpret_cast<char*>(res.getDataPtr()), header.data_size);
 
     return res;
 }
 
-BlobDumper BlobDumper::read(const std::string &file_path) {
+BlobDumper BlobDumper::read(const std::string& file_path) {
     std::ifstream file;
     file.open(file_path);
     if (!file.is_open())
@@ -262,7 +260,7 @@ BlobDumper BlobDumper::read(const std::string &file_path) {
     return res;
 }
 
-void BlobDumper::dump(const std::string &dump_path) const {
+void BlobDumper::dump(const std::string& dump_path) const {
     std::ofstream dump_file;
     dump_file.open(dump_path, std::ios::binary);
     if (!dump_file.is_open())
@@ -282,5 +280,5 @@ void BlobDumper::dumpAsTxt(const std::string& dump_path) const {
     dump_file.close();
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/blob_dump.h b/src/plugins/intel_cpu/src/utils/blob_dump.h
index c380305e58a854..3676b2e6794d97 100644
--- a/src/plugins/intel_cpu/src/utils/blob_dump.h
+++ b/src/plugins/intel_cpu/src/utils/blob_dump.h
@@ -5,10 +5,11 @@
 #pragma once
 
 #include <cpu_memory.h>
-#include "memory_desc/dnnl_blocked_memory_desc.h"
 
 #include <string>
 
+#include "memory_desc/dnnl_blocked_memory_desc.h"
+
 namespace ov {
 namespace intel_cpu {
 
@@ -23,32 +24,32 @@ namespace intel_cpu {
 class BlobDumper {
     MemoryPtr memory;
 
-    void prepare_plain_data(const MemoryPtr &memory, std::vector<uint8_t> &data) const;
+    void prepare_plain_data(const MemoryPtr& memory, std::vector<uint8_t>& data) const;
 
 public:
     BlobDumper() = default;
-    BlobDumper(const DnnlBlockedMemoryDesc &desc) {
+    BlobDumper(const DnnlBlockedMemoryDesc& desc) {
         dnnl::engine eng(dnnl::engine::kind::cpu, 0);
         memory = std::make_shared<Memory>(eng, desc);
     }
     BlobDumper(const BlobDumper&) = default;
-    BlobDumper& operator = (BlobDumper&&) = default;
+    BlobDumper& operator=(BlobDumper&&) = default;
 
-    explicit BlobDumper(const MemoryPtr &_memory) : memory(_memory) {}
+    explicit BlobDumper(const MemoryPtr& _memory) : memory(_memory) {}
 
-    static BlobDumper read(const std::string &file_path);
-    static BlobDumper read(std::istream &stream);
+    static BlobDumper read(const std::string& file_path);
+    static BlobDumper read(std::istream& stream);
 
-    void dump(const std::string &file_path) const;
-    void dump(std::ostream &stream) const;
+    void dump(const std::string& file_path) const;
+    void dump(std::ostream& stream) const;
 
-    void dumpAsTxt(const std::string &file_path) const;
-    void dumpAsTxt(std::ostream &stream) const;
+    void dumpAsTxt(const std::string& file_path) const;
+    void dumpAsTxt(std::ostream& stream) const;
 
-    void *getDataPtr() const {
+    void* getDataPtr() const {
         return memory->getData();
     }
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/caseless.hpp b/src/plugins/intel_cpu/src/utils/caseless.hpp
index 459fedc7181906..8a82a8c2ca97c7 100644
--- a/src/plugins/intel_cpu/src/utils/caseless.hpp
+++ b/src/plugins/intel_cpu/src/utils/caseless.hpp
@@ -72,5 +72,5 @@ class CaselessHash : public std::hash<T> {
 template <class Key, class Value>
 using caseless_unordered_map = std::unordered_map<Key, Value, CaselessHash<Key>, CaselessEq<Key>>;
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/codec_xor.cpp b/src/plugins/intel_cpu/src/utils/codec_xor.cpp
index 06061fc704e228..01575af0589a8f 100644
--- a/src/plugins/intel_cpu/src/utils/codec_xor.cpp
+++ b/src/plugins/intel_cpu/src/utils/codec_xor.cpp
@@ -3,6 +3,7 @@
 //
 
 #include "utils/codec_xor.hpp"
+
 #include "openvino/core/parallel.hpp"
 
 namespace ov {
@@ -29,5 +30,5 @@ std::string codec_xor_str(const std::string& source_str) {
     return new_str;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov.
+}  // namespace intel_cpu
+}  // namespace ov.
diff --git a/src/plugins/intel_cpu/src/utils/codec_xor.hpp b/src/plugins/intel_cpu/src/utils/codec_xor.hpp
index d99a6d0d52bc37..264fa65b557d0b 100644
--- a/src/plugins/intel_cpu/src/utils/codec_xor.hpp
+++ b/src/plugins/intel_cpu/src/utils/codec_xor.hpp
@@ -13,16 +13,16 @@ void codec_xor(char* dst_str, const char* src_str, size_t len);
 
 std::string codec_xor_str(const std::string& source_str);
 
-typedef std::function<std::string(const std::string&)>               CacheDecryptStr;
+typedef std::function<std::string(const std::string&)> CacheDecryptStr;
 typedef std::function<void(char* dst, const char* src, size_t size)> CacheDecryptChar;
 
 union CacheDecrypt {
     CacheDecryptChar m_decrypt_char = nullptr;
-    CacheDecryptStr  m_decrypt_str;
+    CacheDecryptStr m_decrypt_str;
 
     CacheDecrypt() {}
 
-    CacheDecrypt(CacheDecryptStr fn)  : m_decrypt_str(fn) {}
+    CacheDecrypt(CacheDecryptStr fn) : m_decrypt_str(fn) {}
 
     CacheDecrypt(CacheDecryptChar fn) : m_decrypt_char(fn) {}
 
diff --git a/src/plugins/intel_cpu/src/utils/cpu_utils.hpp b/src/plugins/intel_cpu/src/utils/cpu_utils.hpp
index 8ae9aa67edf9a7..f82a801350d5be 100644
--- a/src/plugins/intel_cpu/src/utils/cpu_utils.hpp
+++ b/src/plugins/intel_cpu/src/utils/cpu_utils.hpp
@@ -25,18 +25,18 @@ struct is_any_of : public std::false_type {};
 // otherwise call is_any_of<T, Rest...> recurrently
 template <class T, class U, class... Rest>
 struct is_any_of<T, U, Rest...>
-        : public std::conditional<std::is_same<T, U>::value, std::true_type, is_any_of<T, Rest...>>::type {};
+    : public std::conditional<std::is_same<T, U>::value, std::true_type, is_any_of<T, Rest...>>::type {};
 
 /**
-* @brief Returns normalized by size dims where missing dimensions are filled with units from the beginning
-* Example: dims = {2, 3, 5}; ndims = 5; result = {1, 1, 2, 3, 5}
-* @param dims
-* shape to normalize
-* @param ndims
-* rank of resulting shape
-* @return normalized vector
-*/
-inline std::vector<size_t> getNormalizedDimsBySize(const VectorDims &dims, size_t ndims) {
+ * @brief Returns normalized by size dims where missing dimensions are filled with units from the beginning
+ * Example: dims = {2, 3, 5}; ndims = 5; result = {1, 1, 2, 3, 5}
+ * @param dims
+ * shape to normalize
+ * @param ndims
+ * rank of resulting shape
+ * @return normalized vector
+ */
+inline std::vector<size_t> getNormalizedDimsBySize(const VectorDims& dims, size_t ndims) {
     if (dims.size() >= ndims)
         return dims;
 
@@ -48,21 +48,21 @@ inline std::vector<size_t> getNormalizedDimsBySize(const VectorDims &dims, size_
 }
 
 /**
-* @brief Checked that secondInputDims unidirectional broadcastable per tensor or per channel to firstInputDims
-* @param firstInputDims
-* shape on which should be broadcastable
-* @param secondInputDims
-* shape which should be broadcastable
-* @param weakComparison
-* flag which specify how we compare C dims if value is undefined (weak or strong)
-* @return true if broadcastable, false otherwise.
-*/
-inline bool isPerTensorOrPerChannelBroadcastable(const VectorDims &firstInputDims,
+ * @brief Checked that secondInputDims unidirectional broadcastable per tensor or per channel to firstInputDims
+ * @param firstInputDims
+ * shape on which should be broadcastable
+ * @param secondInputDims
+ * shape which should be broadcastable
+ * @param weakComparison
+ * flag which specify how we compare C dims if value is undefined (weak or strong)
+ * @return true if broadcastable, false otherwise.
+ */
+inline bool isPerTensorOrPerChannelBroadcastable(const VectorDims& firstInputDims,
                                                  const VectorDims& secondInputDims,
                                                  int channelAxis,
                                                  bool weakComparison = false) {
-    bool (*dimsEqual)(size_t, size_t) = weakComparison ? static_cast<bool (*)(size_t, size_t)>(dimsEqualWeak) :
-                                                         static_cast<bool (*)(size_t, size_t)>(dimsEqualStrong);
+    bool (*dimsEqual)(size_t, size_t) = weakComparison ? static_cast<bool (*)(size_t, size_t)>(dimsEqualWeak)
+                                                       : static_cast<bool (*)(size_t, size_t)>(dimsEqualStrong);
     if (secondInputDims.size() > firstInputDims.size())
         return false;
     if (std::accumulate(secondInputDims.begin(), secondInputDims.end(), size_t(1), std::multiplies<size_t>()) == 1)
@@ -86,61 +86,61 @@ inline bool isPerTensorOrPerChannelBroadcastable(const VectorDims &firstInputDim
 }
 
 /**
-* @brief Return precision to which given precision must be converted to be supported in plug-in
-* @param precision
-* precision for convert
-* @return plug-in supported precision or UNSPECIFIED if precision unsupported
-*/
+ * @brief Return precision to which given precision must be converted to be supported in plug-in
+ * @param precision
+ * precision for convert
+ * @return plug-in supported precision or UNSPECIFIED if precision unsupported
+ */
 inline ov::element::Type normalizeToSupportedPrecision(ov::element::Type precision) {
     switch (precision) {
-        case ov::element::bf16:
-        case ov::element::f16: {
-            if (!hasHardwareSupport(precision))
-                precision = ov::element::f32;
-        }
-        case ov::element::u8:
-        case ov::element::i8:
-        case ov::element::i32:
-        case ov::element::f32: {
-            break;
-        }
-        case ov::element::f64: {
+    case ov::element::bf16:
+    case ov::element::f16: {
+        if (!hasHardwareSupport(precision))
             precision = ov::element::f32;
-            break;
-        }
-        case ov::element::boolean: {
-            precision = ov::element::u8;
-            break;
-        }
-        case ov::element::u16:
-        case ov::element::i16:
-        case ov::element::u32:
-        case ov::element::i64:
-        case ov::element::u64: {
-            precision = ov::element::i32;
-            break;
-        }
-        default: {
-            precision = ov::element::undefined;
-        }
+    }
+    case ov::element::u8:
+    case ov::element::i8:
+    case ov::element::i32:
+    case ov::element::f32: {
+        break;
+    }
+    case ov::element::f64: {
+        precision = ov::element::f32;
+        break;
+    }
+    case ov::element::boolean: {
+        precision = ov::element::u8;
+        break;
+    }
+    case ov::element::u16:
+    case ov::element::i16:
+    case ov::element::u32:
+    case ov::element::i64:
+    case ov::element::u64: {
+        precision = ov::element::i32;
+        break;
+    }
+    default: {
+        precision = ov::element::undefined;
+    }
     }
 
     return precision;
 }
 
 /**
-* @brief Return aligned buffer by targetSize.
-* If buffer has size 1, values are broadcasted with targetSize size.
-* If aligned buffer size > targetSize, other values filled by zero.
-* @param targetSize
-* target size buffer
-* @param buffer
-* buffer to be aligned
-* @param align
-* alignment for targetSize
-* @return aligned buffer
-*/
-inline std::vector<float> makeAlignedBuffer(size_t targetSize, const std::vector<float> &buffer, int align = -1) {
+ * @brief Return aligned buffer by targetSize.
+ * If buffer has size 1, values are broadcasted with targetSize size.
+ * If aligned buffer size > targetSize, other values filled by zero.
+ * @param targetSize
+ * target size buffer
+ * @param buffer
+ * buffer to be aligned
+ * @param align
+ * alignment for targetSize
+ * @return aligned buffer
+ */
+inline std::vector<float> makeAlignedBuffer(size_t targetSize, const std::vector<float>& buffer, int align = -1) {
     if (buffer.empty()) {
         OPENVINO_THROW("Can't align buffer, becuase buffer is empty");
     }
@@ -159,12 +159,12 @@ inline std::vector<float> makeAlignedBuffer(size_t targetSize, const std::vector
 }
 
 /**
-* @brief Reshape a tensor down to a specific rank
-*
-* Examples:
-* - reshapeToRank<2>({1, 2, 3, 4, 5}) == {1*2*3*4, 5}   == {24, 5}
-* - reshapeToRank<4>({1, 2, 3, 4, 5}) == {1*2, 3, 4, 5} == {2, 3, 4, 5}
-*/
+ * @brief Reshape a tensor down to a specific rank
+ *
+ * Examples:
+ * - reshapeToRank<2>({1, 2, 3, 4, 5}) == {1*2*3*4, 5}   == {24, 5}
+ * - reshapeToRank<4>({1, 2, 3, 4, 5}) == {1*2, 3, 4, 5} == {2, 3, 4, 5}
+ */
 template <typename T>
 std::vector<T> reshapeDownToRank(const std::vector<T>& dims, size_t rank) {
     OPENVINO_ASSERT(rank > 0, "Rank greater than zero is expected");
@@ -187,5 +187,5 @@ std::vector<T> reshapeDownToRank(const std::vector<T>& dims) {
     return reshapeDownToRank(dims, rank);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/debug_capabilities.cpp b/src/plugins/intel_cpu/src/utils/debug_capabilities.cpp
index 195d46c70e1c7c..61abbd53e2679d 100644
--- a/src/plugins/intel_cpu/src/utils/debug_capabilities.cpp
+++ b/src/plugins/intel_cpu/src/utils/debug_capabilities.cpp
@@ -5,43 +5,43 @@
 #include "openvino/core/type/element_type.hpp"
 #ifdef CPU_DEBUG_CAPS
 
-#include "cpu_memory.h"
-#include "debug_capabilities.h"
-#include "node.h"
-#include "edge.h"
-#include "graph.h"
-#include <iomanip>
-#include "nodes/input.h"
-#include "nodes/eltwise.h"
-
-#include "openvino/op/util/multi_subgraph_base.hpp"
-#include "common/primitive_desc_iface.hpp"
-#include "memory_desc/cpu_memory_desc.h"
-#include "oneapi/dnnl/dnnl.hpp"
-#include "onednn/iml_type_mapper.h"
-#include "transformations/rt_info/disable_fp16_compression.hpp"
-#include <memory>
+#    include <iomanip>
+#    include <memory>
+
+#    include "common/primitive_desc_iface.hpp"
+#    include "cpu_memory.h"
+#    include "debug_capabilities.h"
+#    include "edge.h"
+#    include "graph.h"
+#    include "memory_desc/cpu_memory_desc.h"
+#    include "node.h"
+#    include "nodes/eltwise.h"
+#    include "nodes/input.h"
+#    include "oneapi/dnnl/dnnl.hpp"
+#    include "onednn/iml_type_mapper.h"
+#    include "openvino/op/util/multi_subgraph_base.hpp"
+#    include "transformations/rt_info/disable_fp16_compression.hpp"
 
 namespace dnnl {
 namespace impl {
-std::ostream &operator<<(std::ostream &ss, const primitive_attr_t *attr);
-std::ostream &operator<<(std::ostream &ss, alg_kind_t alg);
-}
-}
+std::ostream& operator<<(std::ostream& ss, const primitive_attr_t* attr);
+std::ostream& operator<<(std::ostream& ss, alg_kind_t alg);
+}  // namespace impl
+}  // namespace dnnl
 
 namespace ov {
 namespace intel_cpu {
 
 namespace {
-    size_t replace_all(std::string & inout, std::string what, std::string with) {
-        std::size_t count{};
-        for (std::string::size_type pos{}; inout.npos != (pos = inout.find(what.data(), pos, what.length()));
-             pos += with.length(), ++count) {
-            inout.replace(pos, what.length(), with.data(), with.length());
-        }
-        return count;
+size_t replace_all(std::string& inout, std::string what, std::string with) {
+    std::size_t count{};
+    for (std::string::size_type pos{}; inout.npos != (pos = inout.find(what.data(), pos, what.length()));
+         pos += with.length(), ++count) {
+        inout.replace(pos, what.length(), with.data(), with.length());
     }
+    return count;
 }
+}  // namespace
 
 DebugLogEnabled::DebugLogEnabled(const char* file, const char* func, int line, const char* name) {
     // check ENV
@@ -98,36 +98,36 @@ DebugLogEnabled::DebugLogEnabled(const char* file, const char* func, int line, c
         enabled = !filter_match_action;
 }
 
-void DebugLogEnabled::break_at(const std::string & log) {
+void DebugLogEnabled::break_at(const std::string& log) {
     static const char* p_brk = std::getenv("OV_CPU_DEBUG_LOG_BRK");
     if (p_brk && log.find(p_brk) != std::string::npos) {
-        std::cout << "[ DEBUG ] " << " Debug log breakpoint hit" << std::endl;
-#if defined(_MSC_VER)
+        std::cout << "[ DEBUG ] "
+                  << " Debug log breakpoint hit" << std::endl;
+#    if defined(_MSC_VER)
         __debugbreak();
-#elif defined(__APPLE__) || defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64) || defined(OPENVINO_ARCH_RISCV64)
-       __builtin_trap();
-#else
+#    elif defined(__APPLE__) || defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64) || \
+        defined(OPENVINO_ARCH_RISCV64)
+        __builtin_trap();
+#    else
         asm("int3");
-#endif
+#    endif
     }
 }
 
-std::ostream & operator<<(std::ostream & os, const MemoryDesc& desc) {
-    os << desc.getShape().toString()
-       << " " << desc.getPrecision().get_type_name()
-       << " " << desc.serializeFormat();
+std::ostream& operator<<(std::ostream& os, const MemoryDesc& desc) {
+    os << desc.getShape().toString() << " " << desc.getPrecision().get_type_name() << " " << desc.serializeFormat();
     return os;
 }
 
-std::ostream & operator<<(std::ostream & os, const dnnl::primitive_attr& attr) {
+std::ostream& operator<<(std::ostream& os, const dnnl::primitive_attr& attr) {
     return dnnl::impl::operator<<(os, attr.get());
 }
 
-std::ostream & operator<<(std::ostream & os, const dnnl::algorithm& alg) {
+std::ostream& operator<<(std::ostream& os, const dnnl::algorithm& alg) {
     return dnnl::impl::operator<<(os, convert_to_c(alg));
 }
 
-std::ostream & operator<<(std::ostream & os, const PortConfig& config) {
+std::ostream& operator<<(std::ostream& os, const PortConfig& config) {
     const char* sep = ",";
     os << sep << *config.getMemDesc();
     os << " inPlace:" << config.inPlace();
@@ -135,37 +135,38 @@ std::ostream & operator<<(std::ostream & os, const PortConfig& config) {
     return os;
 }
 
-std::ostream & operator<<(std::ostream & os, const NodeConfig& config) {
+std::ostream& operator<<(std::ostream& os, const NodeConfig& config) {
     os << "(";
-    for (auto & conf : config.inConfs)
+    for (auto& conf : config.inConfs)
         os << conf;
     os << ") -> (";
-    for (auto & conf : config.outConfs)
+    for (auto& conf : config.outConfs)
         os << conf;
     os << ")" << '\n';
     return os;
 }
 
-std::ostream & operator<<(std::ostream & os, const NodeDesc& desc) {
+std::ostream& operator<<(std::ostream& os, const NodeDesc& desc) {
     os << "  " << impl_type_to_string(desc.getImplementationType());
     os << desc.getConfig();
     return os;
 }
 
-std::ostream & operator<<(std::ostream & os, const Node &c_node) {
-    Node & node = const_cast<Node &>(c_node);
+std::ostream& operator<<(std::ostream& os, const Node& c_node) {
+    Node& node = const_cast<Node&>(c_node);
     const int align_col = 50;
-    const char * comma = "";
-    auto node_id = [](Node & node) {
+    const char* comma = "";
+    auto node_id = [](Node& node) {
         auto id = node.getName();
         if (id.size() > 50)
             return node.getTypeStr() + "_" + std::to_string(node.getExecIndex());
         return id;
     };
-    auto is_single_output_port = [](Node & node) {
-        for (auto & e : node.getChildEdges()) {
+    auto is_single_output_port = [](Node& node) {
+        for (auto& e : node.getChildEdges()) {
             auto edge = e.lock();
-            if (!edge) continue;
+            if (!edge)
+                continue;
             if (edge->getInputNum() != 0)
                 return false;
         }
@@ -195,7 +196,8 @@ std::ostream & operator<<(std::ostream & os, const Node &c_node) {
     };
 
     if (num_output_port) {
-        if (num_output_port > 1) leftside << "(";
+        if (num_output_port > 1)
+            leftside << "(";
         comma = "";
         for (int i = 0; i < num_output_port; i++) {
             bool b_ouputed = false;
@@ -206,10 +208,8 @@ std::ostream & operator<<(std::ostream & os, const Node &c_node) {
                     auto desc = &(ptr->getDesc());
                     auto shape_str = desc->getShape().toString();
                     replace_all(shape_str, " ", "");
-                    leftside << comma << desc->getPrecision().get_type_name()
-                                << "_" << desc->serializeFormat()
-                                << "_" << shape_str
-                                << "&" << getData(ptr);
+                    leftside << comma << desc->getPrecision().get_type_name() << "_" << desc->serializeFormat() << "_"
+                             << shape_str << "&" << getData(ptr);
                     b_ouputed = true;
                 } else {
                     leftside << "(empty)";
@@ -220,9 +220,8 @@ std::ostream & operator<<(std::ostream & os, const Node &c_node) {
                 auto shape_str = desc->getShape().toString();
                 replace_all(shape_str, "0 - ?", "?");
                 replace_all(shape_str, " ", "");
-                leftside << comma << desc->getPrecision().get_type_name()
-                            << "_" << desc->serializeFormat()
-                            << "_" << shape_str;
+                leftside << comma << desc->getPrecision().get_type_name() << "_" << desc->serializeFormat() << "_"
+                         << shape_str;
                 b_ouputed = true;
             }
             if (!b_ouputed) {
@@ -230,7 +229,8 @@ std::ostream & operator<<(std::ostream & os, const Node &c_node) {
             }
             comma = ",";
         }
-        if (num_output_port > 1) leftside << ")";
+        if (num_output_port > 1)
+            leftside << ")";
     } else if (nodeDesc) {
         // output Desc is enough since input is always in consistent
         // with output.
@@ -249,17 +249,18 @@ std::ostream & operator<<(std::ostream & os, const Node &c_node) {
 
         auto& outConfs = nodeDesc->getConfig().outConfs;
         if (!outConfs.empty()) {
-            if (outConfs.size() > 1) leftside << "(";
+            if (outConfs.size() > 1)
+                leftside << "(";
             comma = "";
             for (auto& c : outConfs) {
                 auto shape_str = c.getMemDesc()->getShape().toString();
                 replace_all(shape_str, "0 - ?", "?");
-                leftside << comma << c.getMemDesc()->getPrecision().get_type_name()
-                            << "_" << c.getMemDesc()->serializeFormat()
-                            << "_" << shape_str;
+                leftside << comma << c.getMemDesc()->getPrecision().get_type_name() << "_"
+                         << c.getMemDesc()->serializeFormat() << "_" << shape_str;
                 comma = ",";
             }
-            if (outConfs.size() > 1) leftside << ")";
+            if (outConfs.size() > 1)
+                leftside << ")";
         }
     } else {
         // no SPD yet, use orginal shapes
@@ -270,8 +271,7 @@ std::ostream & operator<<(std::ostream & os, const Node &c_node) {
             prec_name = node.getOriginalOutputPrecisionAtPort(i).get_type_name();
             auto shape_str = shape.toString();
             replace_all(shape_str, "0 - ?", "?");
-            leftside << comma << prec_name
-                        << "_" << shape_str;
+            leftside << comma << prec_name << "_" << shape_str;
             comma = ",";
         }
     }
@@ -286,11 +286,13 @@ std::ostream & operator<<(std::ostream & os, const Node &c_node) {
     for (size_t port = 0; port < node.getParentEdges().size(); ++port) {
         // find the Parent edge connecting to port
         os << comma;
-        const char * sep2 = "";
-        for (const auto & e : node.getParentEdges()) {
+        const char* sep2 = "";
+        for (const auto& e : node.getParentEdges()) {
             auto edge = e.lock();
-            if (!edge) continue;
-            if (edge->getOutputNum() != static_cast<int>(port)) continue;
+            if (!edge)
+                continue;
+            if (edge->getOutputNum() != static_cast<int>(port))
+                continue;
             auto n = edge->getParent();
             os << sep2;
             os << node_id(*edge->getParent());
@@ -300,15 +302,15 @@ std::ostream & operator<<(std::ostream & os, const Node &c_node) {
             }
             if (!is_single_output_port(*n))
                 os << "[" << edge->getInputNum() << "]";
-            sep2 = "|"; // show all edges at single port(usually indicating bugs)
+            sep2 = "|";  // show all edges at single port(usually indicating bugs)
         }
         comma = ",";
     }
 
     if (node.getType() == intel_cpu::Type::Input && node.isConstant()) {
-        if (auto input_node = reinterpret_cast<intel_cpu::node::Input *>(&node)) {
+        if (auto input_node = reinterpret_cast<intel_cpu::node::Input*>(&node)) {
             auto pmem = input_node->getMemoryPtr();
-            void * data = pmem->getData();
+            void* data = pmem->getData();
             auto shape = pmem->getDesc().getShape().getDims();
 
             if (shape_size(shape) <= 8 && pmem->getDesc().getPrecision() != ov::element::undefined) {
@@ -316,7 +318,7 @@ std::ostream & operator<<(std::ostream & os, const Node &c_node) {
                 auto tensor = ov::Tensor(type, shape, data);
                 auto constop = std::make_shared<ov::op::v0::Constant>(tensor);
                 comma = "";
-                for (auto & v : constop->get_value_strings()) {
+                for (auto& v : constop->get_value_strings()) {
                     os << comma << v;
                     comma = ",";
                 }
@@ -330,21 +332,19 @@ std::ostream & operator<<(std::ostream & os, const Node &c_node) {
 
     // additional properties
     if (node.getType() == intel_cpu::Type::Eltwise) {
-        auto eltwise_node = reinterpret_cast<intel_cpu::node::Eltwise *>(&node);
-        os << " | Alpha=" << eltwise_node->getAlpha()
-        << ", Beta=" << eltwise_node->getBeta()
-        << ", Gamma=" << eltwise_node->getGamma()
-        << ", BroadcastingPolicy=";
+        auto eltwise_node = reinterpret_cast<intel_cpu::node::Eltwise*>(&node);
+        os << " | Alpha=" << eltwise_node->getAlpha() << ", Beta=" << eltwise_node->getBeta()
+           << ", Gamma=" << eltwise_node->getGamma() << ", BroadcastingPolicy=";
 
         switch (eltwise_node->getBroadcastingPolicy()) {
-            case intel_cpu::node::Eltwise::BroadcastingPolicy::PerChannel:
-                os << "PerChannel";
-                break;
-            case intel_cpu::node::Eltwise::BroadcastingPolicy::PerTensor:
-                os << "PerTensor";
-                break;
-            default:
-                os << "?";
+        case intel_cpu::node::Eltwise::BroadcastingPolicy::PerChannel:
+            os << "PerChannel";
+            break;
+        case intel_cpu::node::Eltwise::BroadcastingPolicy::PerTensor:
+            os << "PerTensor";
+            break;
+        default:
+            os << "?";
         }
     }
 
@@ -359,7 +359,7 @@ std::ostream & operator<<(std::ostream & os, const Node &c_node) {
         os << " latency:" << node.PerfCounter().avg() << "(us) x" << node.PerfCounter().count();
     }
 
-    for (auto & fn : node.getFusedWith()) {
+    for (auto& fn : node.getFusedWith()) {
         os << "\n\t  FusedWith: " << *fn;
     }
 
@@ -380,15 +380,15 @@ std::ostream & operator<<(std::ostream & os, const Node &c_node) {
 
     return os;
 }
-std::ostream & operator<<(std::ostream & os, const Shape& shape) {
+std::ostream& operator<<(std::ostream& os, const Shape& shape) {
     os << shape.toString();
     return os;
 }
 
 // Print complex data structures in a textualized form to the console is an efficient way to investigate them
-std::ostream & operator<<(std::ostream & os, const Graph& g) {
+std::ostream& operator<<(std::ostream& os, const Graph& g) {
     os << "ov::intel_cpu::Graph " << g.GetName() << " {" << std::endl;
-    for (auto &graphNode : g.GetNodes()) {
+    for (auto& graphNode : g.GetNodes()) {
         std::cout << *graphNode << std::endl;
     }
     os << "};" << std::endl;
@@ -396,10 +396,10 @@ std::ostream & operator<<(std::ostream & os, const Graph& g) {
 }
 
 class OstreamAttributeVisitor : public ov::AttributeVisitor {
-    std::ostream & os;
+    std::ostream& os;
 
 public:
-    OstreamAttributeVisitor(std::ostream & os) : os(os) {}
+    OstreamAttributeVisitor(std::ostream& os) : os(os) {}
 
     void on_adapter(const std::string& name, ov::ValueAccessor<void>& adapter) override {
         if (auto a = ov::as_type<ov::AttributeAdapter<std::set<std::string>>>(&adapter)) {
@@ -454,14 +454,14 @@ class OstreamAttributeVisitor : public ov::AttributeVisitor {
         append_attribute(name.c_str(), value.c_str());
     }
 
-    void append_attribute(const char * name, const char * value) {
+    void append_attribute(const char* name, const char* value) {
         os << " " << name << "=" << value;
     }
     void on_adapter(const std::string& name, ov::ValueAccessor<std::shared_ptr<ov::Model>>& adapter) override {
         append_attribute(name.c_str(), "Model");
     }
 
-    template<class Container>
+    template <class Container>
     inline std::string join(const Container& strs) {
         std::stringstream ss;
         ss << "[" << ov::intel_cpu::join(strs, ',') << "]";
@@ -469,7 +469,7 @@ class OstreamAttributeVisitor : public ov::AttributeVisitor {
     }
 };
 
-std::ostream & operator<<(std::ostream & os, const PrintableModel& model) {
+std::ostream& operator<<(std::ostream& os, const PrintableModel& model) {
     const ov::Model& f = model.model;
     const std::string& tag = model.tag;
     const std::string& prefix = model.prefix;
@@ -565,21 +565,27 @@ std::ostream& operator<<(std::ostream& os, const PrintableDelta& d) {
     return os;
 }
 
-std::ostream & operator<<(std::ostream & os, const Edge::ReorderStatus reorderStatus) {
+std::ostream& operator<<(std::ostream& os, const Edge::ReorderStatus reorderStatus) {
     switch (reorderStatus) {
-    case Edge::ReorderStatus::Regular: os << "Regular"; break;
-    case Edge::ReorderStatus::Optimized: os << "Optimizer"; break;
-    case Edge::ReorderStatus::No: os << "No"; break;
+    case Edge::ReorderStatus::Regular:
+        os << "Regular";
+        break;
+    case Edge::ReorderStatus::Optimized:
+        os << "Optimizer";
+        break;
+    case Edge::ReorderStatus::No:
+        os << "No";
+        break;
     }
     return os;
 }
 
-std::ostream & operator<<(std::ostream & os, const dnnl::primitive_desc& desc) {
+std::ostream& operator<<(std::ostream& os, const dnnl::primitive_desc& desc) {
     os << desc.get()->info();
     return os;
 }
 
-std::ostream & operator<<(std::ostream & os, const dnnl::memory::desc& desc) {
+std::ostream& operator<<(std::ostream& os, const dnnl::memory::desc& desc) {
     char sep = '(';
     os << "dims:";
     const auto& ndims = desc.get()->ndims;
@@ -599,9 +605,9 @@ std::ostream & operator<<(std::ostream & os, const dnnl::memory::desc& desc) {
     }
     os << ")";
 
-    const auto& inner_blks  = desc.get()->format_desc.blocking.inner_blks;
+    const auto& inner_blks = desc.get()->format_desc.blocking.inner_blks;
     const auto& inner_nblks = desc.get()->format_desc.blocking.inner_nblks;
-    const auto& inner_idxs  = desc.get()->format_desc.blocking.inner_idxs;
+    const auto& inner_idxs = desc.get()->format_desc.blocking.inner_idxs;
 
     for (int i = 0; i < inner_nblks; i++) {
         os << inner_blks[i] << static_cast<char>('a' + inner_idxs[i]);
@@ -613,16 +619,16 @@ std::ostream & operator<<(std::ostream & os, const dnnl::memory::desc& desc) {
 }
 
 std::ostream& operator<<(std::ostream& os, const impl_desc_type impl_type) {
-    os <<  impl_type_to_string(impl_type);
+    os << impl_type_to_string(impl_type);
     return os;
 }
 
-std::ostream & operator<<(std::ostream & os, const dnnl::memory::data_type dtype) {
+std::ostream& operator<<(std::ostream& os, const dnnl::memory::data_type dtype) {
     os << " " << dnnl_dt2str(static_cast<dnnl_data_type_t>(dtype));
     return os;
 }
 
-std::ostream & operator<<(std::ostream & os, const dnnl::memory::format_tag format_tag) {
+std::ostream& operator<<(std::ostream& os, const dnnl::memory::format_tag format_tag) {
     const auto c_format_tag = dnnl::memory::convert_to_c(format_tag);
     os << dnnl_fmt_tag2str(c_format_tag);
     return os;
@@ -676,8 +682,8 @@ void print_dnnl_memory(const dnnl::memory& memory, const size_t size, const int
     std::cout << "\n";
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
 bool getEnvBool(const char* name) {
     static const bool env = ov::util::getenv_bool(name);
diff --git a/src/plugins/intel_cpu/src/utils/debug_capabilities.h b/src/plugins/intel_cpu/src/utils/debug_capabilities.h
index 2646ba817dca9c..e0fe11c8254e96 100644
--- a/src/plugins/intel_cpu/src/utils/debug_capabilities.h
+++ b/src/plugins/intel_cpu/src/utils/debug_capabilities.h
@@ -7,18 +7,19 @@
 #include "openvino/util/env_util.hpp"
 #ifdef CPU_DEBUG_CAPS
 
-#include <string>
-#include <iostream>
-#include <sstream>
-#include <chrono>
-#include <regex>
-
-#include "onednn/dnnl.h"
-#include "nodes/node_config.h"
-#include <dnnl_debug.h>
-#include "onednn/iml_type_mapper.h"
-#include "openvino/core/model.hpp"
-#include "edge.h"
+#    include <dnnl_debug.h>
+
+#    include <chrono>
+#    include <iostream>
+#    include <regex>
+#    include <sstream>
+#    include <string>
+
+#    include "edge.h"
+#    include "nodes/node_config.h"
+#    include "onednn/dnnl.h"
+#    include "onednn/iml_type_mapper.h"
+#    include "openvino/core/model.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -39,9 +40,13 @@ class DebugLogEnabled {
 public:
     DebugLogEnabled(const char* file, const char* func, int line, const char* name = nullptr);
 
-    const std::string & get_tag() const { return tag; }
-    operator bool() const { return enabled; }
-    void break_at(const std::string & log);
+    const std::string& get_tag() const {
+        return tag;
+    }
+    operator bool() const {
+        return enabled;
+    }
+    void break_at(const std::string& log);
 };
 
 class NodeDesc;
@@ -53,13 +58,16 @@ class IMemory;
 
 class PrintableModel {
 public:
-    PrintableModel(const ov::Model& model, std::string tag = "", std::string prefix = "") : model(model), tag(tag), prefix(prefix) {}
+    PrintableModel(const ov::Model& model, std::string tag = "", std::string prefix = "")
+        : model(model),
+          tag(tag),
+          prefix(prefix) {}
     const ov::Model& model;
     const std::string tag;
     const std::string prefix;
 };
 
-template<typename T>
+template <typename T>
 class PrintableVector {
 public:
     PrintableVector(const std::vector<T>& values, int maxsize = 80) : values(values), maxsize(maxsize) {}
@@ -67,7 +75,7 @@ class PrintableVector {
     int maxsize;
 };
 
-template<typename T>
+template <typename T>
 PrintableVector<T> printable(const std::vector<T>& values, int maxsize = 80) {
     return PrintableVector<T>(values, maxsize);
 }
@@ -78,7 +86,7 @@ struct PrintableDelta {
 
 class PrintableTimer {
 public:
-    PrintableTimer(): t0(std::chrono::high_resolution_clock::now()) {
+    PrintableTimer() : t0(std::chrono::high_resolution_clock::now()) {
         t1 = t0;
     }
 
@@ -95,36 +103,36 @@ class PrintableTimer {
     }
 };
 
-template<typename T>
-std::ostream & operator<<(std::ostream & os, const std::vector<T> vec) {
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const std::vector<T> vec) {
     for (const auto& element : vec)
         os << element << "x";
     return os;
 }
-std::ostream & operator<<(std::ostream & os, const PortConfig& desc);
-std::ostream & operator<<(std::ostream & os, const NodeConfig& desc);
-std::ostream & operator<<(std::ostream & os, const NodeDesc& desc);
-std::ostream & operator<<(std::ostream & os, const Node& node);
-std::ostream & operator<<(std::ostream & os, const ov::intel_cpu::Graph& graph);
-std::ostream & operator<<(std::ostream & os, const Shape& shape);
-std::ostream & operator<<(std::ostream & os, const MemoryDesc& desc);
-std::ostream & operator<<(std::ostream & os, const IMemory& mem);
-std::ostream & operator<<(std::ostream & os, const PrintableModel& model);
-std::ostream & operator<<(std::ostream & os, const PrintableDelta& us);
-std::ostream & operator<<(std::ostream & os, const Edge::ReorderStatus reorderStatus);
-
-std::ostream & operator<<(std::ostream & os, const dnnl::primitive_desc& desc);
-std::ostream & operator<<(std::ostream & os, const dnnl::memory::desc& desc);
-std::ostream & operator<<(std::ostream & os, const impl_desc_type impl_type);
-std::ostream & operator<<(std::ostream & os, const dnnl::memory::data_type dtype);
-std::ostream & operator<<(std::ostream & os, const dnnl::memory::format_tag dtype);
-std::ostream & operator<<(std::ostream & os, const dnnl::primitive_attr& attr);
-std::ostream & operator<<(std::ostream & os, const dnnl::algorithm& alg);
+std::ostream& operator<<(std::ostream& os, const PortConfig& desc);
+std::ostream& operator<<(std::ostream& os, const NodeConfig& desc);
+std::ostream& operator<<(std::ostream& os, const NodeDesc& desc);
+std::ostream& operator<<(std::ostream& os, const Node& node);
+std::ostream& operator<<(std::ostream& os, const ov::intel_cpu::Graph& graph);
+std::ostream& operator<<(std::ostream& os, const Shape& shape);
+std::ostream& operator<<(std::ostream& os, const MemoryDesc& desc);
+std::ostream& operator<<(std::ostream& os, const IMemory& mem);
+std::ostream& operator<<(std::ostream& os, const PrintableModel& model);
+std::ostream& operator<<(std::ostream& os, const PrintableDelta& us);
+std::ostream& operator<<(std::ostream& os, const Edge::ReorderStatus reorderStatus);
+
+std::ostream& operator<<(std::ostream& os, const dnnl::primitive_desc& desc);
+std::ostream& operator<<(std::ostream& os, const dnnl::memory::desc& desc);
+std::ostream& operator<<(std::ostream& os, const impl_desc_type impl_type);
+std::ostream& operator<<(std::ostream& os, const dnnl::memory::data_type dtype);
+std::ostream& operator<<(std::ostream& os, const dnnl::memory::format_tag dtype);
+std::ostream& operator<<(std::ostream& os, const dnnl::primitive_attr& attr);
+std::ostream& operator<<(std::ostream& os, const dnnl::algorithm& alg);
 
 void print_dnnl_memory(const dnnl::memory& memory, const size_t size, const int id, const char* message = "");
 
-template<typename T>
-std::ostream & operator<<(std::ostream & os, const PrintableVector<T>& vec) {
+template <typename T>
+std::ostream& operator<<(std::ostream& os, const PrintableVector<T>& vec) {
     std::stringstream ss;
     auto N = vec.values.size();
     for (size_t i = 0; i < N; i++) {
@@ -151,28 +159,28 @@ static inline std::ostream& _write_all_to_stream(std::ostream& os, const T& arg,
     return ov::intel_cpu::_write_all_to_stream(os << arg, std::forward<TS>(args)...);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
-#define DEBUG_ENABLE_NAME debug_enable_##__LINE__
+#    define DEBUG_ENABLE_NAME debug_enable_##__LINE__
 
-#define DEBUG_LOG_EXT(name, ostream, prefix, ...)                        \
-        do {                                                                                               \
-            static DebugLogEnabled DEBUG_ENABLE_NAME(__FILE__, __func__, __LINE__, name);                  \
-            if (DEBUG_ENABLE_NAME) {                                                                       \
-                ::std::stringstream ss___;                                                                 \
+#    define DEBUG_LOG_EXT(name, ostream, prefix, ...)                                                              \
+        do {                                                                                                       \
+            static DebugLogEnabled DEBUG_ENABLE_NAME(__FILE__, __func__, __LINE__, name);                          \
+            if (DEBUG_ENABLE_NAME) {                                                                               \
+                ::std::stringstream ss___;                                                                         \
                 ov::intel_cpu::_write_all_to_stream(ss___, prefix, DEBUG_ENABLE_NAME.get_tag(), " ", __VA_ARGS__); \
-                ostream << ss___.str() << std::endl;                                                     \
-                DEBUG_ENABLE_NAME.break_at(ss___.str());                                                   \
-            }                                                                                              \
+                ostream << ss___.str() << std::endl;                                                               \
+                DEBUG_ENABLE_NAME.break_at(ss___.str());                                                           \
+            }                                                                                                      \
         } while (0)
 
-#define CPU_DEBUG_CAP_ENABLE(...) __VA_ARGS__
+#    define CPU_DEBUG_CAP_ENABLE(...) __VA_ARGS__
 
-#define DEBUG_LOG(...) DEBUG_LOG_EXT(nullptr, std::cout, "[ DEBUG ] ", __VA_ARGS__)
-#define ERROR_LOG(...) DEBUG_LOG_EXT(nullptr, std::cerr, "[ ERROR ] ", __VA_ARGS__)
+#    define DEBUG_LOG(...) DEBUG_LOG_EXT(nullptr, std::cout, "[ DEBUG ] ", __VA_ARGS__)
+#    define ERROR_LOG(...) DEBUG_LOG_EXT(nullptr, std::cerr, "[ ERROR ] ", __VA_ARGS__)
 
-#define CREATE_DEBUG_TIMER(x) PrintableTimer x
+#    define CREATE_DEBUG_TIMER(x) PrintableTimer x
 
 /*
  * important debugging tools for accuracy issues
@@ -269,17 +277,17 @@ struct EnforceInferPrcDebug {
 };
 
 bool getEnvBool(const char* name);
-#else // !CPU_DEBUG_CAPS
+#else  // !CPU_DEBUG_CAPS
 
-#define CPU_DEBUG_CAP_ENABLE(...)
+#    define CPU_DEBUG_CAP_ENABLE(...)
 
-#define DEBUG_LOG(...)
-#define ERROR_LOG(...)
-#define DEBUG_LOG_EXT(name, ...)
+#    define DEBUG_LOG(...)
+#    define ERROR_LOG(...)
+#    define DEBUG_LOG_EXT(name, ...)
 
-#define CREATE_DEBUG_TIMER(x)
+#    define CREATE_DEBUG_TIMER(x)
 
-#endif // CPU_DEBUG_CAPS
+#endif  // CPU_DEBUG_CAPS
 
 // To avoid "unused variable" warnings `when debug caps
 // need more information than non-debug caps version
diff --git a/src/plugins/intel_cpu/src/utils/debug_caps_config.cpp b/src/plugins/intel_cpu/src/utils/debug_caps_config.cpp
index 335137a2a0afc5..7f78cd539bdda7 100644
--- a/src/plugins/intel_cpu/src/utils/debug_caps_config.cpp
+++ b/src/plugins/intel_cpu/src/utils/debug_caps_config.cpp
@@ -3,9 +3,9 @@
 //
 #ifdef CPU_DEBUG_CAPS
 
-#include "debug_caps_config.h"
+#    include "debug_caps_config.h"
 
-#include <string>
+#    include <string>
 
 namespace ov {
 namespace intel_cpu {
@@ -13,7 +13,7 @@ namespace intel_cpu {
 void DebugCapsConfig::readProperties() {
     auto readEnv = [](const char* envVar) {
         const char* env = std::getenv(envVar);
-        if (env && *env) // set and non-empty
+        if (env && *env)  // set and non-empty
             return env;
 
         return (const char*)nullptr;
@@ -68,6 +68,6 @@ void DebugCapsConfig::readProperties() {
         averageCountersPath = envVarValue;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
-#endif // CPU_DEBUG_CAPS
+}  // namespace intel_cpu
+}  // namespace ov
+#endif  // CPU_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/utils/debug_caps_config.h b/src/plugins/intel_cpu/src/utils/debug_caps_config.h
index 096d9b231d07fa..8b047df9085e72 100644
--- a/src/plugins/intel_cpu/src/utils/debug_caps_config.h
+++ b/src/plugins/intel_cpu/src/utils/debug_caps_config.h
@@ -5,14 +5,14 @@
 
 #ifdef CPU_DEBUG_CAPS
 
-#include "openvino/core/except.hpp"
-#include "openvino/util/common_util.hpp"
-#include "utils/enum_class_hash.hpp"
+#    include <bitset>
+#    include <memory>
+#    include <unordered_map>
+#    include <utility>
 
-#include <bitset>
-#include <memory>
-#include <unordered_map>
-#include <utility>
+#    include "openvino/core/except.hpp"
+#    include "openvino/util/common_util.hpp"
+#    include "utils/enum_class_hash.hpp"
 
 namespace ov {
 namespace intel_cpu {
@@ -48,36 +48,35 @@ class DebugCapsConfig {
     std::string summaryPerf = "";
 
     struct TransformationFilter {
-        enum Type : uint8_t {
-            PreLpt = 0, Lpt, PostLpt, Snippets, Specific, NumOfTypes
-        };
+        enum Type : uint8_t { PreLpt = 0, Lpt, PostLpt, Snippets, Specific, NumOfTypes };
         std::bitset<NumOfTypes> filter;
 
         PropertySetterPtr getPropertySetter() {
-            return PropertySetterPtr(new BitsetFilterPropertySetter<NumOfTypes>("transformations", filter,
-                                                                                {{"all", {PreLpt, Lpt, PostLpt, Snippets, Specific}},
-                                                                                 {"common", {PreLpt, PostLpt}},
-                                                                                 {"prelpt", {PreLpt}},
-                                                                                 {"lpt", {Lpt}},
-                                                                                 {"postlpt", {PostLpt}},
-                                                                                 {"snippets", {Snippets}},
-                                                                                 {"specific", {Specific}}
-                                                                                }));
+            return PropertySetterPtr(
+                new BitsetFilterPropertySetter<NumOfTypes>("transformations",
+                                                           filter,
+                                                           {{"all", {PreLpt, Lpt, PostLpt, Snippets, Specific}},
+                                                            {"common", {PreLpt, PostLpt}},
+                                                            {"prelpt", {PreLpt}},
+                                                            {"lpt", {Lpt}},
+                                                            {"postlpt", {PostLpt}},
+                                                            {"snippets", {Snippets}},
+                                                            {"specific", {Specific}}}));
         }
     };
     struct IrFormatFilter {
-        enum Type : uint8_t {
-            Xml = 0, XmlBin, Dot, Svg, NumOfTypes
-        };
+        enum Type : uint8_t { Xml = 0, XmlBin, Dot, Svg, NumOfTypes };
         std::bitset<NumOfTypes> filter;
 
         PropertySetterPtr getPropertySetter() {
-            return PropertySetterPtr(new BitsetFilterPropertySetter<NumOfTypes>("formats", filter,
-                                                                                {{"all", {XmlBin, Dot, Svg}},
-                                                                                 {"xml", {Xml}},
-                                                                                 {"xmlbin", {XmlBin}},
-                                                                                 {"dot", {Dot}},
-                                                                                 {"svg", {Svg}},
+            return PropertySetterPtr(new BitsetFilterPropertySetter<NumOfTypes>("formats",
+                                                                                filter,
+                                                                                {
+                                                                                    {"all", {XmlBin, Dot, Svg}},
+                                                                                    {"xml", {Xml}},
+                                                                                    {"xmlbin", {XmlBin}},
+                                                                                    {"dot", {Dot}},
+                                                                                    {"svg", {Svg}},
                                                                                 }));
         }
     };
@@ -92,7 +91,8 @@ class DebugCapsConfig {
             auto getHelp = [propertySetters]() {
                 std::string help;
                 for (const auto& property : propertySetters)
-                    help.append('\t' + property->getPropertyName() + "=<" + property->getPropertyValueDescription() + ">\n");
+                    help.append('\t' + property->getPropertyName() + "=<" + property->getPropertyValueDescription() +
+                                ">\n");
                 return help;
             };
 
@@ -103,8 +103,11 @@ class DebugCapsConfig {
                     break;
                 }
                 const auto& propertyName = ov::util::to_lower(parts.front());
-                const auto& foundSetter = std::find_if(propertySetters.begin(), propertySetters.end(),
-                                                       [propertyName] (const PropertySetterPtr& setter) { return setter->getPropertyName() == propertyName; });
+                const auto& foundSetter = std::find_if(propertySetters.begin(),
+                                                       propertySetters.end(),
+                                                       [propertyName](const PropertySetterPtr& setter) {
+                                                           return setter->getPropertyName() == propertyName;
+                                                       });
                 if (foundSetter == propertySetters.end() ||
                     !(*foundSetter)->parseAndSet(parts.size() == 1 ? "" : parts.back())) {
                     failed = true;
@@ -127,19 +130,19 @@ class DebugCapsConfig {
         TransformationFilter transformations;
 
         std::vector<PropertySetterPtr> getPropertySetters() override {
-            return { transformations.getPropertySetter() };
+            return {transformations.getPropertySetter()};
         }
     } disable;
 
     struct : PropertyGroup {
         std::string dir = "intel_cpu_dump";
-        IrFormatFilter format = { 1 << IrFormatFilter::Xml };
+        IrFormatFilter format = {1 << IrFormatFilter::Xml};
         TransformationFilter transformations;
 
         std::vector<PropertySetterPtr> getPropertySetters() override {
-            return { PropertySetterPtr(new StringPropertySetter("dir", dir, "path to dumped IRs")),
-                     format.getPropertySetter(),
-                     transformations.getPropertySetter() };
+            return {PropertySetterPtr(new StringPropertySetter("dir", dir, "path to dumped IRs")),
+                    format.getPropertySetter(),
+                    transformations.getPropertySetter()};
         }
     } dumpIR;
 
@@ -152,7 +155,9 @@ class DebugCapsConfig {
 
         virtual ~PropertySetter() = default;
 
-        const std::string& getPropertyName() const { return propertyName; }
+        const std::string& getPropertyName() const {
+            return propertyName;
+        }
 
     private:
         const std::string propertyName;
@@ -160,7 +165,9 @@ class DebugCapsConfig {
 
     struct StringPropertySetter : PropertySetter {
         StringPropertySetter(const std::string& name, std::string& ref, const std::string&& valueDescription)
-            : PropertySetter(name), property(ref), propertyValueDescription(valueDescription) {}
+            : PropertySetter(name),
+              property(ref),
+              propertyValueDescription(valueDescription) {}
 
         ~StringPropertySetter() override = default;
 
@@ -168,13 +175,15 @@ class DebugCapsConfig {
             property = str;
             return true;
         }
-        std::string getPropertyValueDescription() const override { return propertyValueDescription; }
+        std::string getPropertyValueDescription() const override {
+            return propertyValueDescription;
+        }
 
     private:
         std::string& property;
         const std::string propertyValueDescription;
     };
-    template<std::size_t NumOfBits>
+    template <std::size_t NumOfBits>
 
     struct BitsetFilterPropertySetter : PropertySetter {
         struct Token {
@@ -182,20 +191,26 @@ class DebugCapsConfig {
             std::vector<size_t> bits;
         };
 
-        BitsetFilterPropertySetter(const std::string& name, std::bitset<NumOfBits>& ref, const std::vector<Token>&& tokens)
-            : PropertySetter(name), property(ref), propertyTokens(tokens) {}
+        BitsetFilterPropertySetter(const std::string& name,
+                                   std::bitset<NumOfBits>& ref,
+                                   const std::vector<Token>&& tokens)
+            : PropertySetter(name),
+              property(ref),
+              propertyTokens(tokens) {}
 
         ~BitsetFilterPropertySetter() override = default;
 
         bool parseAndSet(const std::string& str) override {
-            const auto& tokens = str.empty() ?
-                std::vector<std::string>{"all"} : ov::util::split(ov::util::to_lower(str), ',');
+            const auto& tokens =
+                str.empty() ? std::vector<std::string>{"all"} : ov::util::split(ov::util::to_lower(str), ',');
             property.reset();
             for (const auto& token : tokens) {
                 const bool tokenVal = (token.front() != '-');
                 const auto& tokenName = tokenVal ? token : token.substr(1);
-                const auto& foundToken = std::find_if(propertyTokens.begin(), propertyTokens.end(),
-                                                      [tokenName] (const Token& token) { return token.name == tokenName; });
+                const auto& foundToken =
+                    std::find_if(propertyTokens.begin(), propertyTokens.end(), [tokenName](const Token& token) {
+                        return token.name == tokenName;
+                    });
                 if (foundToken == propertyTokens.end())
                     return false;
 
@@ -212,7 +227,8 @@ class DebugCapsConfig {
                     supportedTokens.push_back(',');
                 supportedTokens.append(propertyTokens[i].name);
             }
-            supportedTokens.append("; -'token' is used for exclusion, case does not matter, no tokens is treated as 'all'");
+            supportedTokens.append(
+                "; -'token' is used for exclusion, case does not matter, no tokens is treated as 'all'");
             return supportedTokens;
         }
 
@@ -224,7 +240,7 @@ class DebugCapsConfig {
     void readProperties();
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
-#endif // CPU_DEBUG_CAPS
+#endif  // CPU_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/utils/denormals.hpp b/src/plugins/intel_cpu/src/utils/denormals.hpp
index fc41ab76aaa400..1a6798864e9101 100644
--- a/src/plugins/intel_cpu/src/utils/denormals.hpp
+++ b/src/plugins/intel_cpu/src/utils/denormals.hpp
@@ -5,7 +5,7 @@
 #pragma once
 
 #if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64)
-#   include <immintrin.h>
+#    include <immintrin.h>
 #endif
 
 #include "openvino/core/visibility.hpp"
@@ -41,81 +41,86 @@ bool denormals_as_zero(bool on) {
     _mm_setcsr(mxcsr);
     return true;
 }
-#else // OPENVINO_ARCH_X86_64
-    #if defined(__SSE__) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1)
-        bool flush_to_zero(bool on) {
-            unsigned int mxcsr = _mm_getcsr();
-            if (on) {
-                mxcsr |= FTZ_FLAG;
-            } else {
-                mxcsr &= ~FTZ_FLAG;
-            }
-            _mm_setcsr(mxcsr);
-            return true;
-        }
+#else  // OPENVINO_ARCH_X86_64
+#    if defined(__SSE__) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1)
+bool flush_to_zero(bool on) {
+    unsigned int mxcsr = _mm_getcsr();
+    if (on) {
+        mxcsr |= FTZ_FLAG;
+    } else {
+        mxcsr &= ~FTZ_FLAG;
+    }
+    _mm_setcsr(mxcsr);
+    return true;
+}
 
-        bool denormals_as_zero(bool on) {
-        // for some processor, DAZ flag is a reserved bit even SSE is available. Set 1 to this flag will generate #GP exception.
-        struct {
-            char fcw0;
-            char fcw1;
-            char fsw0;
-            char fsw1;
-            char ftw;
-            char rsvd;
-            char fop0;
-            char fop1;
-            unsigned int fpu_ip;             // 8-11
-            unsigned int cs_fpu_ip;          // 12-15
-            unsigned int fpu_dp;             // 16-19
-            unsigned int ds_fpu_dp;          // 20-23
-            unsigned int mxcsr;              // 24-27
-            unsigned int mxcsr_mask;         // 28-31
-            unsigned int st_mm_status_0[8];  // 32 byte
-            unsigned int st_mm_status_1[8];  // 32 byte
-            unsigned int st_mm_status_2[8];  // 32 byte
-            unsigned int st_mm_status_3[8];  // 32 byte
-            unsigned int xmm_status_0[8];
-            unsigned int xmm_status_1[8];
-            unsigned int xmm_status_2[8];
-            unsigned int xmm_status_3[8];
-            unsigned int xmm_status_4[8];
-            unsigned int xmm_status_5[8];
-            unsigned int xmm_status_6[8];
-            unsigned int xmm_status_7[8];    // 8 * 32 byte == 16 * 16 byte == 16 * 128 bit
-            unsigned int padding_0[8];
-            unsigned int padding_1[8];
-            unsigned int padding_2[8];  // 3 * 32 byte
-        } fxsave_area;  // should be at least 16 byte aligned. fxsave_area is 32 byte aligned.
+bool denormals_as_zero(bool on) {
+    // for some processor, DAZ flag is a reserved bit even SSE is available. Set 1 to this flag will generate #GP
+    // exception.
+    struct {
+        char fcw0;
+        char fcw1;
+        char fsw0;
+        char fsw1;
+        char ftw;
+        char rsvd;
+        char fop0;
+        char fop1;
+        unsigned int fpu_ip;             // 8-11
+        unsigned int cs_fpu_ip;          // 12-15
+        unsigned int fpu_dp;             // 16-19
+        unsigned int ds_fpu_dp;          // 20-23
+        unsigned int mxcsr;              // 24-27
+        unsigned int mxcsr_mask;         // 28-31
+        unsigned int st_mm_status_0[8];  // 32 byte
+        unsigned int st_mm_status_1[8];  // 32 byte
+        unsigned int st_mm_status_2[8];  // 32 byte
+        unsigned int st_mm_status_3[8];  // 32 byte
+        unsigned int xmm_status_0[8];
+        unsigned int xmm_status_1[8];
+        unsigned int xmm_status_2[8];
+        unsigned int xmm_status_3[8];
+        unsigned int xmm_status_4[8];
+        unsigned int xmm_status_5[8];
+        unsigned int xmm_status_6[8];
+        unsigned int xmm_status_7[8];  // 8 * 32 byte == 16 * 16 byte == 16 * 128 bit
+        unsigned int padding_0[8];
+        unsigned int padding_1[8];
+        unsigned int padding_2[8];  // 3 * 32 byte
+    } fxsave_area;                  // should be at least 16 byte aligned. fxsave_area is 32 byte aligned.
 
-            fxsave_area.mxcsr_mask = 0;
-        #ifdef _WIN32
-            _fxsave(&fxsave_area);
-        #else
-            __builtin_ia32_fxsave(&fxsave_area);
-        #endif
-            unsigned int mxcsr_mask = fxsave_area.mxcsr_mask;  // 0 value for the bit indicate reserved
+    fxsave_area.mxcsr_mask = 0;
+#        ifdef _WIN32
+    _fxsave(&fxsave_area);
+#        else
+    __builtin_ia32_fxsave(&fxsave_area);
+#        endif
+    unsigned int mxcsr_mask = fxsave_area.mxcsr_mask;  // 0 value for the bit indicate reserved
 
-            unsigned int mxcsr = _mm_getcsr();
-            if (on) {
-                if (mxcsr_mask & DAZ_FLAG) {
-                    mxcsr |= DAZ_FLAG;
-                    _mm_setcsr(mxcsr);
-                    return true;
-                } else {
-                    return false;
-                }
-            } else {
-                mxcsr &= ~DAZ_FLAG;
-                _mm_setcsr(mxcsr);
-                return true;
-            }
+    unsigned int mxcsr = _mm_getcsr();
+    if (on) {
+        if (mxcsr_mask & DAZ_FLAG) {
+            mxcsr |= DAZ_FLAG;
+            _mm_setcsr(mxcsr);
+            return true;
+        } else {
+            return false;
         }
-    #else
-        bool flush_to_zero(bool on) { return false; }
-        bool denormals_as_zero(bool on) { return false; }
-    #endif
-#endif // OPENVINO_ARCH_X86_64
+    } else {
+        mxcsr &= ~DAZ_FLAG;
+        _mm_setcsr(mxcsr);
+        return true;
+    }
+}
+#    else
+bool flush_to_zero(bool on) {
+    return false;
+}
+bool denormals_as_zero(bool on) {
+    return false;
+}
+#    endif
+#endif  // OPENVINO_ARCH_X86_64
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/general_utils.h b/src/plugins/intel_cpu/src/utils/general_utils.h
index 836868eff41d3a..083c8771c1d2ac 100644
--- a/src/plugins/intel_cpu/src/utils/general_utils.h
+++ b/src/plugins/intel_cpu/src/utils/general_utils.h
@@ -4,29 +4,30 @@
 
 #pragma once
 
-#include "cpu_shape.h"
-
 #include <algorithm>
 #include <cassert>
 
+#include "cpu_shape.h"
 #include "openvino/core/type/element_type.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
-template<typename T, typename U>
+template <typename T, typename U>
 inline T div_up(const T a, const U b) {
     assert(b);
     return (a + b - 1) / b;
 }
 
-template<typename T, typename U>
+template <typename T, typename U>
 inline T rnd_up(const T a, const U b) {
     return div_up(a, b) * b;
 }
 
 template <typename T, typename P>
-constexpr bool one_of(T val, P item) { return val == item; }
+constexpr bool one_of(T val, P item) {
+    return val == item;
+}
 
 template <typename T, typename P, typename... Args>
 constexpr bool one_of(T val, P item, Args... item_others) {
@@ -34,7 +35,9 @@ constexpr bool one_of(T val, P item, Args... item_others) {
 }
 
 template <typename T, typename P>
-constexpr bool everyone_is(T val, P item) { return val == item; }
+constexpr bool everyone_is(T val, P item) {
+    return val == item;
+}
 
 template <typename T, typename P, typename... Args>
 constexpr bool everyone_is(T val, P item, Args... item_others) {
@@ -54,8 +57,8 @@ inline std::unique_ptr<T> make_unique(Args&&... args) {
 }
 #endif
 
-template<typename T>
-std::string vec2str(const std::vector<T> &vec) {
+template <typename T>
+std::string vec2str(const std::vector<T>& vec) {
     if (!vec.empty()) {
         std::ostringstream result;
         result << "(";
@@ -86,7 +89,9 @@ inline bool dimsEqualStrong(size_t lhs, size_t rhs) {
  * second shape
  * @return result of comparison
  */
-inline bool dimsEqualStrong(const std::vector<size_t>& lhs, const std::vector<size_t>& rhs, size_t skipAxis = Shape::UNDEFINED_DIM) {
+inline bool dimsEqualStrong(const std::vector<size_t>& lhs,
+                            const std::vector<size_t>& rhs,
+                            size_t skipAxis = Shape::UNDEFINED_DIM) {
     if (lhs.size() != rhs.size())
         return false;
 
@@ -120,7 +125,9 @@ inline bool dimsEqualWeak(size_t lhs, size_t rhs) {
  * marks shape axis which shouldn't be validated
  * @return result of comparison
  */
-inline bool dimsEqualWeak(const std::vector<size_t>& lhs, const std::vector<size_t>& rhs, size_t skipAxis = Shape::UNDEFINED_DIM) {
+inline bool dimsEqualWeak(const std::vector<size_t>& lhs,
+                          const std::vector<size_t>& rhs,
+                          size_t skipAxis = Shape::UNDEFINED_DIM) {
     if (lhs.size() != rhs.size())
         return false;
 
@@ -134,8 +141,9 @@ inline bool dimsEqualWeak(const std::vector<size_t>& lhs, const std::vector<size
 
 inline ov::element::Type getMaxPrecision(std::vector<ov::element::Type> precisions) {
     if (!precisions.empty()) {
-        return *std::max_element(precisions.begin(), precisions.end(),
-                                 [](const ov::element::Type &lhs, const ov::element::Type &rhs) {
+        return *std::max_element(precisions.begin(),
+                                 precisions.end(),
+                                 [](const ov::element::Type& lhs, const ov::element::Type& rhs) {
                                      return lhs.size() > rhs.size();
                                  });
     }
@@ -143,7 +151,7 @@ inline ov::element::Type getMaxPrecision(std::vector<ov::element::Type> precisio
     return ov::element::undefined;
 }
 
-inline std::vector<std::string> split(const std::string &str, char delim) {
+inline std::vector<std::string> split(const std::string& str, char delim) {
     std::stringstream ss(str);
     std::string item;
     std::vector<std::string> elements;
@@ -153,7 +161,7 @@ inline std::vector<std::string> split(const std::string &str, char delim) {
     return elements;
 }
 
-template<class Container>
+template <class Container>
 inline std::string join(const Container& strs, char delim) {
     if (strs.empty())
         return std::string();
@@ -167,5 +175,5 @@ inline std::string join(const Container& strs, char delim) {
     return result.str();
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/multidim_map.hpp b/src/plugins/intel_cpu/src/utils/multidim_map.hpp
index bbf3e7f448237e..c72c35a04e909a 100644
--- a/src/plugins/intel_cpu/src/utils/multidim_map.hpp
+++ b/src/plugins/intel_cpu/src/utils/multidim_map.hpp
@@ -3,9 +3,9 @@
 //
 
 #pragma once
-#include <unordered_map>
-#include <type_traits>
 #include <functional>
+#include <type_traits>
+#include <unordered_map>
 
 namespace ov {
 namespace intel_cpu {
@@ -19,23 +19,23 @@ struct enum_hash {
     }
 };
 
-template<typename K>
+template <typename K>
 using hash_t = typename std::conditional<std::is_enum<K>::value, enum_hash<K>, std::hash<K>>::type;
 
-}   // namespace internal
+}  // namespace internal
 
-template<typename K, typename ...Ts>
+template <typename K, typename... Ts>
 struct multidim_map {
     using key_type = K;
     using mapped_type = multidim_map<Ts...>;
     using hash_type = internal::hash_t<K>;
 
 public:
-    mapped_type & operator[](const key_type & key) {
+    mapped_type& operator[](const key_type& key) {
         return _map[key];
     }
 
-    const mapped_type & at(const key_type & key) const {
+    const mapped_type& at(const key_type& key) const {
         return _map.at(key);
     }
 
@@ -43,18 +43,18 @@ struct multidim_map {
     std::unordered_map<key_type, mapped_type, hash_type> _map;
 };
 
-template<typename K, typename T>
+template <typename K, typename T>
 struct multidim_map<K, T> {
     using key_type = K;
     using mapped_type = T;
     using hash_type = internal::hash_t<K>;
 
 public:
-    mapped_type & operator[](const key_type & key) {
+    mapped_type& operator[](const key_type& key) {
         return _map[key];
     }
 
-    const mapped_type & at(const key_type & key) const {
+    const mapped_type& at(const key_type& key) const {
         return _map.at(key);
     }
 
@@ -62,5 +62,5 @@ struct multidim_map<K, T> {
     std::unordered_map<key_type, mapped_type, hash_type> _map;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/ngraph_transformation.hpp b/src/plugins/intel_cpu/src/utils/ngraph_transformation.hpp
index f7e9ecf30dbd4d..356ca2f1141f82 100644
--- a/src/plugins/intel_cpu/src/utils/ngraph_transformation.hpp
+++ b/src/plugins/intel_cpu/src/utils/ngraph_transformation.hpp
@@ -4,22 +4,25 @@
 #pragma once
 #ifdef CPU_DEBUG_CAPS
 
-#include "debug_caps_config.h"
-#include "openvino/util/file_util.hpp"
-#include <openvino/pass/manager.hpp>
-#include <openvino/pass/serialize.hpp>
-#include <openvino/pass/visualize_tree.hpp>
+#    include <openvino/pass/manager.hpp>
+#    include <openvino/pass/serialize.hpp>
+#    include <openvino/pass/visualize_tree.hpp>
+
+#    include "debug_caps_config.h"
+#    include "openvino/util/file_util.hpp"
 
 namespace ov {
 namespace intel_cpu {
 
 class TransformationDumper {
 public:
-    explicit TransformationDumper(const DebugCapsConfig& config, const DebugCapsConfig::TransformationFilter::Type type,
+    explicit TransformationDumper(const DebugCapsConfig& config,
+                                  const DebugCapsConfig::TransformationFilter::Type type,
                                   const std::shared_ptr<ov::Model>& model)
-        : config(config), model(model), type(type) {
-        for (auto prev = infoMap.at(type).prev; prev != TransformationType::NumOfTypes;
-             prev = infoMap.at(prev).prev) {
+        : config(config),
+          model(model),
+          type(type) {
+        for (auto prev = infoMap.at(type).prev; prev != TransformationType::NumOfTypes; prev = infoMap.at(prev).prev) {
             // no need to serialize input graph if there was no transformations from previous dump
             if (config.disable.transformations.filter[prev])
                 continue;
@@ -45,22 +48,23 @@ class TransformationDumper {
         std::string name;
         TransformationType prev;
     };
-    // std::hash<std::underlying_type<FILTER>::type> is necessary for Ubuntu-16.04 (gcc-5.4 and defect in C++11 standart)
-    const std::unordered_map<TransformationType, TransformationInfo,
-                             std::hash<std::underlying_type<TransformationType>::type>> infoMap =
-        {{TransformationType::PreLpt,     {"preLpt", TransformationType::NumOfTypes}},
-         {TransformationType::Lpt,        {"lpt", TransformationType::PreLpt}},
-         {TransformationType::PostLpt,    {"postLpt", TransformationType::Lpt}},
-         {TransformationType::Snippets,   {"snippets", TransformationType::PostLpt}},
-         {TransformationType::Specific,   {"cpuSpecific", TransformationType::Snippets}}};
+    // std::hash<std::underlying_type<FILTER>::type> is necessary for Ubuntu-16.04 (gcc-5.4 and defect in C++11
+    // standart)
+    const std::
+        unordered_map<TransformationType, TransformationInfo, std::hash<std::underlying_type<TransformationType>::type>>
+            infoMap = {{TransformationType::PreLpt, {"preLpt", TransformationType::NumOfTypes}},
+                       {TransformationType::Lpt, {"lpt", TransformationType::PreLpt}},
+                       {TransformationType::PostLpt, {"postLpt", TransformationType::Lpt}},
+                       {TransformationType::Snippets, {"snippets", TransformationType::PostLpt}},
+                       {TransformationType::Specific, {"cpuSpecific", TransformationType::Snippets}}};
     std::bitset<TransformationType::NumOfTypes>& wasDumped(void) {
         static std::bitset<TransformationType::NumOfTypes> wasDumped;
         return wasDumped;
     }
     void dump(const std::string&& postfix) {
-        static int num = 0; // just to keep dumped IRs ordered in filesystem
-        const auto pathAndName = config.dumpIR.dir + "/ir_" + std::to_string(num) + '_' +
-                                 infoMap.at(type).name + postfix;
+        static int num = 0;  // just to keep dumped IRs ordered in filesystem
+        const auto pathAndName =
+            config.dumpIR.dir + "/ir_" + std::to_string(num) + '_' + infoMap.at(type).name + postfix;
 
         ov::util::create_directory_recursive(config.dumpIR.dir);
 
@@ -71,8 +75,8 @@ class TransformationDumper {
         }
 
         if (config.dumpIR.format.filter[DebugCapsConfig::IrFormatFilter::Xml]) {
-            std::string  xmlFile(pathAndName + ".xml");
-            std::string  binFile("/dev/null"); // @todo make it crossplatform using dummy implementation of std::ostream
+            std::string xmlFile(pathAndName + ".xml");
+            std::string binFile("/dev/null");  // @todo make it crossplatform using dummy implementation of std::ostream
 
             serializer.register_pass<ov::pass::Serialize>(xmlFile, binFile);
         }
@@ -90,27 +94,31 @@ class TransformationDumper {
     }
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
 // 'EXPAND' wrapper is necessary to ensure __VA_ARGS__ behaves the same on all the platforms
-#  define CPU_DEBUG_CAP_EXPAND(x) x
-#  define CPU_DEBUG_CAP_IS_TRANSFORMATION_DISABLED(_config, _type)                      \
-    _config.disable.transformations.filter[DebugCapsConfig::TransformationFilter::Type::_type]
-#  define CPU_DEBUG_CAP_IS_TRANSFORMATION_ENABLED(...) CPU_DEBUG_CAP_EXPAND(!CPU_DEBUG_CAP_IS_TRANSFORMATION_DISABLED(__VA_ARGS__))
-#  define CPU_DEBUG_CAP_TRANSFORMATION_DUMP(_this, _type)                                                      \
-    OPENVINO_ASSERT(CPU_DEBUG_CAP_IS_TRANSFORMATION_ENABLED(_this->config.debugCaps, _type));                                  \
-    auto dumperPtr = _this->config.debugCaps.dumpIR.transformations.filter[DebugCapsConfig::TransformationFilter::Type::_type] ?  \
-        std::unique_ptr<TransformationDumper>(new TransformationDumper(_this->config.debugCaps,                          \
-                                              DebugCapsConfig::TransformationFilter::Type::_type, _this->model)) : \
-        nullptr
-#  define CPU_DEBUG_CAP_TRANSFORMATION_SCOPE(_this, _type)         \
-    if (CPU_DEBUG_CAP_IS_TRANSFORMATION_DISABLED(_this->config.debugCaps, _type))     \
-        return;                                                             \
-    CPU_DEBUG_CAP_TRANSFORMATION_DUMP(_this, _type)
+#    define CPU_DEBUG_CAP_EXPAND(x) x
+#    define CPU_DEBUG_CAP_IS_TRANSFORMATION_DISABLED(_config, _type) \
+        _config.disable.transformations.filter[DebugCapsConfig::TransformationFilter::Type::_type]
+#    define CPU_DEBUG_CAP_IS_TRANSFORMATION_ENABLED(...) \
+        CPU_DEBUG_CAP_EXPAND(!CPU_DEBUG_CAP_IS_TRANSFORMATION_DISABLED(__VA_ARGS__))
+#    define CPU_DEBUG_CAP_TRANSFORMATION_DUMP(_this, _type)                                                           \
+        OPENVINO_ASSERT(CPU_DEBUG_CAP_IS_TRANSFORMATION_ENABLED(_this->config.debugCaps, _type));                     \
+        auto dumperPtr =                                                                                              \
+            _this->config.debugCaps.dumpIR.transformations.filter[DebugCapsConfig::TransformationFilter::Type::_type] \
+                ? std::unique_ptr<TransformationDumper>(                                                              \
+                      new TransformationDumper(_this->config.debugCaps,                                               \
+                                               DebugCapsConfig::TransformationFilter::Type::_type,                    \
+                                               _this->model))                                                         \
+                : nullptr
+#    define CPU_DEBUG_CAP_TRANSFORMATION_SCOPE(_this, _type)                          \
+        if (CPU_DEBUG_CAP_IS_TRANSFORMATION_DISABLED(_this->config.debugCaps, _type)) \
+            return;                                                                   \
+        CPU_DEBUG_CAP_TRANSFORMATION_DUMP(_this, _type)
 #else
-#  define CPU_DEBUG_CAP_IS_TRANSFORMATION_DISABLED(_config, _type) false
-#  define CPU_DEBUG_CAP_IS_TRANSFORMATION_ENABLED(...) true
-#  define CPU_DEBUG_CAP_TRANSFORMATION_DUMP(_this, _type)
-#  define CPU_DEBUG_CAP_TRANSFORMATION_SCOPE(_this, _type)
-#endif // CPU_DEBUG_CAPS
+#    define CPU_DEBUG_CAP_IS_TRANSFORMATION_DISABLED(_config, _type) false
+#    define CPU_DEBUG_CAP_IS_TRANSFORMATION_ENABLED(...)             true
+#    define CPU_DEBUG_CAP_TRANSFORMATION_DUMP(_this, _type)
+#    define CPU_DEBUG_CAP_TRANSFORMATION_SCOPE(_this, _type)
+#endif  // CPU_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/utils/ngraph_utils.hpp b/src/plugins/intel_cpu/src/utils/ngraph_utils.hpp
index 62495f864161bc..df7cac1409fb6d 100644
--- a/src/plugins/intel_cpu/src/utils/ngraph_utils.hpp
+++ b/src/plugins/intel_cpu/src/utils/ngraph_utils.hpp
@@ -21,8 +21,8 @@ inline std::string getRTInfoValue(const std::map<std::string, ov::Any>& rtInfo,
     }
 }
 
-inline std::string getImplPriorityValue(const std::shared_ptr<ov::Node> &node) {
-    const auto &rtInfo = node->get_rt_info();
+inline std::string getImplPriorityValue(const std::shared_ptr<ov::Node>& node) {
+    const auto& rtInfo = node->get_rt_info();
 
     auto it_info = rtInfo.find(ov::PrimitivesPriority::get_type_info_static());
 
@@ -49,5 +49,5 @@ inline bool isDynamicNgraphNode(const std::shared_ptr<const ov::Node>& op) {
     return ret;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/node_dumper.cpp b/src/plugins/intel_cpu/src/utils/node_dumper.cpp
index a63a2348815209..6e8a1a798256ed 100644
--- a/src/plugins/intel_cpu/src/utils/node_dumper.cpp
+++ b/src/plugins/intel_cpu/src/utils/node_dumper.cpp
@@ -3,15 +3,16 @@
 //
 #ifdef CPU_DEBUG_CAPS
 
-#include "node_dumper.h"
-#include "utils/blob_dump.h"
-#include "utils/debug_caps_config.h"
-#include "node.h"
-#include "memory_desc/cpu_memory_desc_utils.h"
+#    include "node_dumper.h"
 
-#include <regex>
-#include <sstream>
-#include <string>
+#    include <regex>
+#    include <sstream>
+#    include <string>
+
+#    include "memory_desc/cpu_memory_desc_utils.h"
+#    include "node.h"
+#    include "utils/blob_dump.h"
+#    include "utils/debug_caps_config.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -29,19 +30,19 @@ static bool shouldBeDumped(const NodePtr& node, const DebugCapsConfig& config, c
     if (dumpFilters.empty())
         return false;
 
-    if (dumpFilters.count(DebugCapsConfig::FILTER::BY_PORTS)) { // filter by ports configured
+    if (dumpFilters.count(DebugCapsConfig::FILTER::BY_PORTS)) {  // filter by ports configured
         if (dumpFilters.at(DebugCapsConfig::FILTER::BY_PORTS) != "ALL" &&
             portsKind != dumpFilters.at(DebugCapsConfig::FILTER::BY_PORTS))
             return false;
     }
 
-    if (dumpFilters.count(DebugCapsConfig::FILTER::BY_EXEC_ID)) { // filter by exec id configured
+    if (dumpFilters.count(DebugCapsConfig::FILTER::BY_EXEC_ID)) {  // filter by exec id configured
         std::stringstream ss(dumpFilters.at(DebugCapsConfig::FILTER::BY_EXEC_ID));
         int id;
         bool matched = false;
 
         while (ss >> id) {
-            if (node->getExecIndex() == id) {// exec id matches
+            if (node->getExecIndex() == id) {  // exec id matches
                 matched = true;
                 break;
             }
@@ -51,13 +52,13 @@ static bool shouldBeDumped(const NodePtr& node, const DebugCapsConfig& config, c
             return false;
     }
 
-    if (dumpFilters.count(DebugCapsConfig::FILTER::BY_TYPE)) { // filter by type configured
+    if (dumpFilters.count(DebugCapsConfig::FILTER::BY_TYPE)) {  // filter by type configured
         std::stringstream ss(dumpFilters.at(DebugCapsConfig::FILTER::BY_TYPE));
         std::string type;
         bool matched = false;
 
         while (ss >> type) {
-            if (NameFromType(node->getType()) == type) {// type does not match
+            if (NameFromType(node->getType()) == type) {  // type does not match
                 matched = true;
                 break;
             }
@@ -67,9 +68,11 @@ static bool shouldBeDumped(const NodePtr& node, const DebugCapsConfig& config, c
             return false;
     }
 
-    if (dumpFilters.count(DebugCapsConfig::FILTER::BY_NAME)) { // filter by name configured
-        if (dumpFilters.at(DebugCapsConfig::FILTER::BY_NAME) != "*" && // to have 'single char' option for matching all the names
-            !std::regex_match(node->getName(), std::regex(dumpFilters.at(DebugCapsConfig::FILTER::BY_NAME)))) // name does not match
+    if (dumpFilters.count(DebugCapsConfig::FILTER::BY_NAME)) {  // filter by name configured
+        if (dumpFilters.at(DebugCapsConfig::FILTER::BY_NAME) !=
+                "*" &&  // to have 'single char' option for matching all the names
+            !std::regex_match(node->getName(),
+                              std::regex(dumpFilters.at(DebugCapsConfig::FILTER::BY_NAME))))  // name does not match
             return false;
     }
 
@@ -175,7 +178,7 @@ void dumpOutputBlobs(const NodePtr& node, const DebugCapsConfig& config, int cou
     }
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
-#endif // CPU_DEBUG_CAPS
+#endif  // CPU_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/utils/node_dumper.h b/src/plugins/intel_cpu/src/utils/node_dumper.h
index 57e34f75208b53..bed94930fa02c4 100644
--- a/src/plugins/intel_cpu/src/utils/node_dumper.h
+++ b/src/plugins/intel_cpu/src/utils/node_dumper.h
@@ -4,14 +4,15 @@
 #pragma once
 
 #ifdef CPU_DEBUG_CAPS
-#include "utils/debug_caps_config.h"
-#include <node.h>
+#    include <node.h>
+
+#    include "utils/debug_caps_config.h"
 
 namespace ov {
 namespace intel_cpu {
 
-void dumpInputBlobs(const NodePtr &node, const DebugCapsConfig& config, int count = -1);
-void dumpOutputBlobs(const NodePtr &node, const DebugCapsConfig& config, int count = -1);
+void dumpInputBlobs(const NodePtr& node, const DebugCapsConfig& config, int count = -1);
+void dumpOutputBlobs(const NodePtr& node, const DebugCapsConfig& config, int count = -1);
 
 class DumpHelper {
     const NodePtr& node;
@@ -19,8 +20,10 @@ class DumpHelper {
     const DebugCapsConfig& config;
 
 public:
-    explicit DumpHelper(const NodePtr& _node, const DebugCapsConfig& _config, int _count = -1):
-        node(_node), count(_count), config(_config) {
+    explicit DumpHelper(const NodePtr& _node, const DebugCapsConfig& _config, int _count = -1)
+        : node(_node),
+          count(_count),
+          config(_config) {
         dumpInputBlobs(node, config, count);
     }
 
@@ -29,9 +32,9 @@ class DumpHelper {
     }
 };
 
-#define DUMP(...) DumpHelper __helper##__node (__VA_ARGS__);
-}   // namespace intel_cpu
-}   // namespace ov
-#else // CPU_DEBUG_CAPS
-#define DUMP(...)
-#endif // CPU_DEBUG_CAPS
+#    define DUMP(...) DumpHelper __helper##__node(__VA_ARGS__);
+}  // namespace intel_cpu
+}  // namespace ov
+#else  // CPU_DEBUG_CAPS
+#    define DUMP(...)
+#endif  // CPU_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/utils/plain_tensor.hpp b/src/plugins/intel_cpu/src/utils/plain_tensor.hpp
index 9de9ba18c1e1cd..e5e29f2144016b 100644
--- a/src/plugins/intel_cpu/src/utils/plain_tensor.hpp
+++ b/src/plugins/intel_cpu/src/utils/plain_tensor.hpp
@@ -5,8 +5,8 @@
 #pragma once
 
 #include <node.h>
-
 #include <stdlib.h>
+
 #include <cassert>
 #include <climits>
 #include <cstdint>
@@ -16,7 +16,7 @@
 #include <vector>
 
 #ifdef _WIN32
-#include <cstdlib>
+#    include <cstdlib>
 #endif
 
 namespace ov {
@@ -98,7 +98,7 @@ struct PlainTensor {
     size_t m_element_size = 0;
     size_t m_offset = 0;
     ov::element::Type_t m_dt = ov::element::Type_t::undefined;
-    MemoryPtr m_mem;        // hold memory ptr reference
+    MemoryPtr m_mem;  // hold memory ptr reference
 
     operator bool() const {
         return m_ptr != nullptr;
@@ -123,7 +123,7 @@ struct PlainTensor {
         return stride(i) * m_element_size;
     }
 
-    template<typename T>
+    template <typename T>
     std::vector<T> get_strides() const {
         std::vector<T> strides(m_rank);
         for (size_t i = 0; i < m_rank; i++)
@@ -160,7 +160,11 @@ struct PlainTensor {
             strides[orders[i]] = mem_desc->getStrides()[i];
         }
         // this reshape_to() can do reshape w/o additional cost
-        resize(mem->getStaticDims(), mem_desc->getPrecision().size(), mem_desc->getPrecision(), mem->getData(), strides.data());
+        resize(mem->getStaticDims(),
+               mem_desc->getPrecision().size(),
+               mem_desc->getPrecision(),
+               mem->getData(),
+               strides.data());
     }
 
     ov::element::Type get_precision() const {
@@ -298,7 +302,10 @@ struct PlainTensor {
         // only valid for dense memory
         PlainTensor new_tensor_view;
         assert(is_dense());
-        new_tensor_view.resize(target_shape, m_element_size, m_dt, static_cast<void*>(m_ptr.get() + m_element_size * m_offset));
+        new_tensor_view.resize(target_shape,
+                               m_element_size,
+                               m_dt,
+                               static_cast<void*>(m_ptr.get() + m_element_size * m_offset));
         return new_tensor_view;
     }
 
@@ -323,7 +330,11 @@ struct PlainTensor {
         return new_tensor_view;
     }
 
-    void resize(const VectorDims& new_dims, size_t element_size, ov::element::Type_t dt, void* data = nullptr, const size_t* strides = nullptr) {
+    void resize(const VectorDims& new_dims,
+                size_t element_size,
+                ov::element::Type_t dt,
+                void* data = nullptr,
+                const size_t* strides = nullptr) {
         m_element_size = element_size;
         m_dt = dt;
         // initialize strides for compact/dense tensor
@@ -340,20 +351,20 @@ struct PlainTensor {
             auto capacity_new = m_strides[0] * m_dims[0] * m_element_size;
             if (capacity_new > m_capacity) {
                 void* ptr;
-                #ifdef _WIN32
-                    ptr = _aligned_malloc(capacity_new, 64);
-                #else
-                    int rc = ::posix_memalign(&ptr, 64, capacity_new);
-                    if (rc) {
-                        OPENVINO_ASSERT(false, "PlainTensor call posix_memalign failed: ", rc);
-                    }
-                #endif
+#ifdef _WIN32
+                ptr = _aligned_malloc(capacity_new, 64);
+#else
+                int rc = ::posix_memalign(&ptr, 64, capacity_new);
+                if (rc) {
+                    OPENVINO_ASSERT(false, "PlainTensor call posix_memalign failed: ", rc);
+                }
+#endif
                 m_ptr = std::shared_ptr<uint8_t>(static_cast<uint8_t*>(ptr), [](uint8_t* ptr) {
-                    #ifdef _WIN32
-                        _aligned_free(ptr);
-                    #else
+#ifdef _WIN32
+                    _aligned_free(ptr);
+#else
                         ::free(ptr);
-                    #endif
+#endif
                 });
                 m_capacity = capacity_new;
                 m_offset = 0;
@@ -365,7 +376,7 @@ struct PlainTensor {
         }
     }
 
-    template<typename DT>
+    template <typename DT>
     void resize(const VectorDims& new_dims, DT* data = nullptr, const size_t* strides = nullptr) {
         resize(new_dims, sizeof(DT), precision_of<DT>::value, data, strides);
     }
diff --git a/src/plugins/intel_cpu/src/utils/precision_support.cpp b/src/plugins/intel_cpu/src/utils/precision_support.cpp
index ecb6d8eb82570b..64c107d578e7a7 100644
--- a/src/plugins/intel_cpu/src/utils/precision_support.cpp
+++ b/src/plugins/intel_cpu/src/utils/precision_support.cpp
@@ -5,13 +5,13 @@
 #include "precision_support.h"
 
 #if defined(OPENVINO_ARCH_X86_64)
-#include "cpu/x64/cpu_isa_traits.hpp"
+#    include "cpu/x64/cpu_isa_traits.hpp"
 #endif
 #include "openvino/core/type/element_type.hpp"
 #include "openvino/core/visibility.hpp"
 
 #if defined(OV_CPU_WITH_ACL)
-#include "arm_compute/core/CPP/CPPTypes.h"
+#    include "arm_compute/core/CPP/CPPTypes.h"
 #endif
 
 namespace ov {
@@ -32,12 +32,12 @@ static bool hasFP16HardwareSupport(const ov::element::Type& precision) {
 
 static bool hasBF16HardwareSupport(const ov::element::Type& precision) {
 #if defined(OPENVINO_ARCH_X86_64)
-        if (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core) ||
-            dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2_vnni_2))
-            return true;
-        return false;
+    if (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core) ||
+        dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx2_vnni_2))
+        return true;
+    return false;
 #else
-        return false;
+    return false;
 #endif
 }
 
diff --git a/src/plugins/intel_cpu/src/utils/precision_support.h b/src/plugins/intel_cpu/src/utils/precision_support.h
index ef381fbf30face..a97b67779ecd7a 100644
--- a/src/plugins/intel_cpu/src/utils/precision_support.h
+++ b/src/plugins/intel_cpu/src/utils/precision_support.h
@@ -12,5 +12,5 @@ namespace intel_cpu {
 bool hasHardwareSupport(const ov::element::Type& precision);
 ov::element::Type defaultFloatPrecision();
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/rt_info/memory_formats_attribute.cpp b/src/plugins/intel_cpu/src/utils/rt_info/memory_formats_attribute.cpp
index 7f5820fc2f4334..728d6d30497cdb 100644
--- a/src/plugins/intel_cpu/src/utils/rt_info/memory_formats_attribute.cpp
+++ b/src/plugins/intel_cpu/src/utils/rt_info/memory_formats_attribute.cpp
@@ -34,5 +34,5 @@ std::string getOutputMemoryFormats(const std::shared_ptr<ov::Node>& node) {
     return {};
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/rt_info/memory_formats_attribute.hpp b/src/plugins/intel_cpu/src/utils/rt_info/memory_formats_attribute.hpp
index c4bf76d2456508..ea2bf9914ee3a2 100644
--- a/src/plugins/intel_cpu/src/utils/rt_info/memory_formats_attribute.hpp
+++ b/src/plugins/intel_cpu/src/utils/rt_info/memory_formats_attribute.hpp
@@ -4,8 +4,8 @@
 
 #pragma once
 
-#include <string>
 #include <set>
+#include <string>
 
 #include "openvino/core/node.hpp"
 #include "openvino/op/util/op_types.hpp"
@@ -13,26 +13,28 @@
 namespace ov {
 namespace intel_cpu {
 
-constexpr const char *InputMemoryFormatsAttr = "InputMemoryFormats";
-constexpr const char *OutputMemoryFormatsAttr = "OutputMemoryFormats";
+constexpr const char* InputMemoryFormatsAttr = "InputMemoryFormats";
+constexpr const char* OutputMemoryFormatsAttr = "OutputMemoryFormats";
 
-template<typename MemoryFormat>
+template <typename MemoryFormat>
 class MemoryFormats : public ov::RuntimeAttribute {
 protected:
     std::string memory_format;
 
 public:
     MemoryFormats() = default;
-    explicit MemoryFormats(const std::string &_memory_format) : memory_format(_memory_format) {}
-    std::string to_string() const override { return memory_format; };
+    explicit MemoryFormats(const std::string& _memory_format) : memory_format(_memory_format) {}
+    std::string to_string() const override {
+        return memory_format;
+    };
     bool is_copyable(const std::shared_ptr<ov::Node>& to) const override {
         return (!ov::op::util::is_constant(to));
     }
 
-    ov::Any merge(const ov::NodeVector & nodes) const override {
+    ov::Any merge(const ov::NodeVector& nodes) const override {
         std::set<std::string> unique_mem_format;
 
-        for (auto &node : nodes) {
+        for (auto& node : nodes) {
             auto it_info = node->get_rt_info().find(MemoryFormat::get_type_info_static());
             if (it_info != node->get_rt_info().end()) {
                 std::string mem_format = it_info->second.template as<MemoryFormat>().to_string();
@@ -43,9 +45,8 @@ class MemoryFormats : public ov::RuntimeAttribute {
         }
 
         if (unique_mem_format.size() > 1) {
-            OPENVINO_THROW(
-                std::string(MemoryFormat::get_type_info_static().name) +
-                " no rule defined for multiple values.");
+            OPENVINO_THROW(std::string(MemoryFormat::get_type_info_static().name) +
+                           " no rule defined for multiple values.");
         }
 
         std::string final_mem_format;
@@ -56,12 +57,11 @@ class MemoryFormats : public ov::RuntimeAttribute {
     }
 };
 
-
 class InputMemoryFormats : public MemoryFormats<InputMemoryFormats> {
 public:
     OPENVINO_RTTI(InputMemoryFormatsAttr);
     InputMemoryFormats() = default;
-    explicit InputMemoryFormats(const std::string &_memory_format) : MemoryFormats(_memory_format) {}
+    explicit InputMemoryFormats(const std::string& _memory_format) : MemoryFormats(_memory_format) {}
     ~InputMemoryFormats() override;
 };
 
@@ -71,11 +71,11 @@ class OutputMemoryFormats : public MemoryFormats<OutputMemoryFormats> {
 public:
     OPENVINO_RTTI(OutputMemoryFormatsAttr);
     OutputMemoryFormats() = default;
-    explicit OutputMemoryFormats(const std::string &_memory_format) : MemoryFormats(_memory_format) {}
+    explicit OutputMemoryFormats(const std::string& _memory_format) : MemoryFormats(_memory_format) {}
     ~OutputMemoryFormats() override;
 };
 
 std::string getOutputMemoryFormats(const std::shared_ptr<ov::Node>& node);
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/serialize.cpp b/src/plugins/intel_cpu/src/utils/serialize.cpp
index 33d8140fbe4a84..55b53116e4ac01 100644
--- a/src/plugins/intel_cpu/src/utils/serialize.cpp
+++ b/src/plugins/intel_cpu/src/utils/serialize.cpp
@@ -14,7 +14,8 @@ namespace intel_cpu {
 ////////// ModelSerializer //////////
 
 ModelSerializer::ModelSerializer(std::ostream& ostream, CacheEncrypt encrypt_fn)
-    : m_ostream(ostream), m_cache_encrypt(std::move(encrypt_fn)) {}
+    : m_ostream(ostream),
+      m_cache_encrypt(std::move(encrypt_fn)) {}
 
 void ModelSerializer::operator<<(const std::shared_ptr<ov::Model>& model) {
     auto serialize_info = [&](std::ostream& stream) {
@@ -35,22 +36,25 @@ ModelDeserializer::ModelDeserializer(std::istream& model_stream,
                                      ModelBuilder fn,
                                      const CacheDecrypt& decrypt_fn,
                                      bool decript_from_string)
-    : m_istream(model_stream), m_model_builder(std::move(fn)), m_decript_from_string(decript_from_string), m_model_buffer(model_buffer) {
-        if (m_decript_from_string) {
-            m_cache_decrypt.m_decrypt_str = decrypt_fn.m_decrypt_str;
-        } else {
-            m_cache_decrypt.m_decrypt_char = decrypt_fn.m_decrypt_char;
-        }
+    : m_istream(model_stream),
+      m_model_builder(std::move(fn)),
+      m_decript_from_string(decript_from_string),
+      m_model_buffer(model_buffer) {
+    if (m_decript_from_string) {
+        m_cache_decrypt.m_decrypt_str = decrypt_fn.m_decrypt_str;
+    } else {
+        m_cache_decrypt.m_decrypt_char = decrypt_fn.m_decrypt_char;
     }
+}
 
-    void ModelDeserializer::set_info(pugi::xml_node& root, std::shared_ptr<ov::Model>& model) {}
+void ModelDeserializer::set_info(pugi::xml_node& root, std::shared_ptr<ov::Model>& model) {}
 
-    void ModelDeserializer::operator>>(std::shared_ptr<ov::Model>& model) {
-        if (m_model_buffer) {
-            process_mmap(model, m_model_buffer);
-        } else {
-            process_stream(model);
-        }
+void ModelDeserializer::operator>>(std::shared_ptr<ov::Model>& model) {
+    if (m_model_buffer) {
+        process_mmap(model, m_model_buffer);
+    } else {
+        process_stream(model);
+    }
 }
 
 void ModelDeserializer::process_mmap(std::shared_ptr<ov::Model>& model,
@@ -77,7 +81,10 @@ void ModelDeserializer::process_mmap(std::shared_ptr<ov::Model>& model,
     // Read model input/output precisions.
     pugi::xml_document xml_in_out_doc;
     if (hdr.custom_data_size > 0lu) {
-        auto res = xml_in_out_doc.load_buffer(buffer_base + hdr.custom_data_offset, hdr.custom_data_size, pugi::parse_default, pugi::encoding_utf8);
+        auto res = xml_in_out_doc.load_buffer(buffer_base + hdr.custom_data_offset,
+                                              hdr.custom_data_size,
+                                              pugi::parse_default,
+                                              pugi::encoding_utf8);
         if (res.status != pugi::status_ok) {
             OPENVINO_THROW("[CPU] Could to deserialize custom data.");
         }
@@ -86,7 +93,10 @@ void ModelDeserializer::process_mmap(std::shared_ptr<ov::Model>& model,
     // Map blob content
     std::shared_ptr<ov::AlignedBuffer> weights_buf;
     if (hdr.consts_size) {
-        weights_buf = std::make_shared<ov::SharedBuffer<std::shared_ptr<ov::AlignedBuffer>>>(buffer_base + hdr.consts_offset, hdr.consts_size, mmemory);
+        weights_buf =
+            std::make_shared<ov::SharedBuffer<std::shared_ptr<ov::AlignedBuffer>>>(buffer_base + hdr.consts_offset,
+                                                                                   hdr.consts_size,
+                                                                                   mmemory);
     }
 
     // XML content
@@ -103,9 +113,7 @@ void ModelDeserializer::process_mmap(std::shared_ptr<ov::Model>& model,
         xml_buff->assign(buffer_base + hdr.model_offset, hdr.model_size);
     }
     std::shared_ptr<ov::AlignedBuffer> model_buf =
-            std::make_shared<ov::SharedBuffer<std::shared_ptr<std::string>>>(&((*xml_buff)[0]),
-                                                                             hdr.model_size,
-                                                                             xml_buff);
+        std::make_shared<ov::SharedBuffer<std::shared_ptr<std::string>>>(&((*xml_buff)[0]), hdr.model_size, xml_buff);
 
     model = m_model_builder(model_buf, weights_buf);
 
@@ -150,7 +158,7 @@ void ModelDeserializer::process_stream(std::shared_ptr<ov::Model>& model) {
     auto data_blob = std::make_shared<ov::Tensor>(ov::element::u8, ov::Shape({hdr.consts_size}));
     m_istream.seekg(hdr.consts_offset);
     if (hdr.consts_size) {
-        m_istream.read(static_cast<char *>(data_blob->data(ov::element::u8)), hdr.consts_size);
+        m_istream.read(static_cast<char*>(data_blob->data(ov::element::u8)), hdr.consts_size);
     }
 
     // read XML content
@@ -162,16 +170,20 @@ void ModelDeserializer::process_stream(std::shared_ptr<ov::Model>& model) {
         if (m_decript_from_string) {
             *xml_string = m_cache_decrypt.m_decrypt_str(*xml_string);
         } else {
-            m_cache_decrypt.m_decrypt_char(const_cast<char*>(xml_string->data()), xml_string->data(), xml_string->size());
+            m_cache_decrypt.m_decrypt_char(const_cast<char*>(xml_string->data()),
+                                           xml_string->data(),
+                                           xml_string->size());
         }
     }
 
-    auto model_buf = std::make_shared<ov::SharedBuffer<std::shared_ptr<std::string>>>(const_cast<char*>(xml_string->data()),
-                                                                                      xml_string->size(),
-                                                                                      xml_string);
-    auto weights_buf = std::make_shared<ov::SharedBuffer<std::shared_ptr<ov::Tensor>>>(reinterpret_cast<char*>(data_blob->data(ov::element::u8)),
-                                                                                       hdr.consts_size,
-                                                                                       data_blob);
+    auto model_buf =
+        std::make_shared<ov::SharedBuffer<std::shared_ptr<std::string>>>(const_cast<char*>(xml_string->data()),
+                                                                         xml_string->size(),
+                                                                         xml_string);
+    auto weights_buf = std::make_shared<ov::SharedBuffer<std::shared_ptr<ov::Tensor>>>(
+        reinterpret_cast<char*>(data_blob->data(ov::element::u8)),
+        hdr.consts_size,
+        data_blob);
 
     model = m_model_builder(model_buf, weights_buf);
 
@@ -180,5 +192,5 @@ void ModelDeserializer::process_stream(std::shared_ptr<ov::Model>& model) {
     set_info(root, model);
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/serialize.hpp b/src/plugins/intel_cpu/src/utils/serialize.hpp
index 4dfdd6b22afbd4..0821b1160c38d7 100644
--- a/src/plugins/intel_cpu/src/utils/serialize.hpp
+++ b/src/plugins/intel_cpu/src/utils/serialize.hpp
@@ -29,7 +29,9 @@ class ModelSerializer {
 
 class ModelDeserializer {
 public:
-    typedef std::function<std::shared_ptr<ov::Model>(const std::shared_ptr<ov::AlignedBuffer>&, const std::shared_ptr<ov::AlignedBuffer>&)> ModelBuilder;
+    typedef std::function<std::shared_ptr<ov::Model>(const std::shared_ptr<ov::AlignedBuffer>&,
+                                                     const std::shared_ptr<ov::AlignedBuffer>&)>
+        ModelBuilder;
 
     ModelDeserializer(std::istream& model,
                       std::shared_ptr<ov::AlignedBuffer> model_buffer,
@@ -55,5 +57,5 @@ class ModelDeserializer {
     std::shared_ptr<ov::AlignedBuffer> m_model_buffer;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/utils/verbose.cpp b/src/plugins/intel_cpu/src/utils/verbose.cpp
index 54a62db2bc86e1..3e5bb7e8ef7930 100644
--- a/src/plugins/intel_cpu/src/utils/verbose.cpp
+++ b/src/plugins/intel_cpu/src/utils/verbose.cpp
@@ -4,20 +4,20 @@
 #include "utils/general_utils.h"
 #ifdef CPU_DEBUG_CAPS
 
-#include "verbose.h"
-#include <node.h>
-#include "cpu_types.h"
-#include "memory_desc/cpu_memory_desc_utils.h"
+#    include <node.h>
 
-#include "dnnl_types.h"
-#include "dnnl_debug.h"
-#include "../src/common/c_types_map.hpp"
-#include "../src/common/verbose.hpp"
+#    include <cstdlib>
+#    include <iostream>
+#    include <sstream>
+#    include <string>
 
-#include <string>
-#include <cstdlib>
-#include <sstream>
-#include <iostream>
+#    include "../src/common/c_types_map.hpp"
+#    include "../src/common/verbose.hpp"
+#    include "cpu_types.h"
+#    include "dnnl_debug.h"
+#    include "dnnl_types.h"
+#    include "memory_desc/cpu_memory_desc_utils.h"
+#    include "verbose.h"
 
 namespace ov {
 namespace intel_cpu {
@@ -42,42 +42,42 @@ bool Verbose::shouldBePrinted() const {
  * Can be rewritten in pure C++ if necessary
  */
 void Verbose::printInfo() {
-    enum Color {
-        RED,
-        GREEN,
-        YELLOW,
-        BLUE,
-        PURPLE,
-        CYAN
-    };
+    enum Color { RED, GREEN, YELLOW, BLUE, PURPLE, CYAN };
 
     auto colorize = [&](const Color color, const std::string& str) {
         if (!colorUp)
             return str;
 
-        const std::string     red("\033[1;31m");
-        const std::string   green("\033[1;32m");
-        const std::string  yellow("\033[1;33m");
-        const std::string    blue("\033[1;34m");
-        const std::string  purple("\033[1;35m");
-        const std::string    cyan("\033[1;36m");
-        const std::string   reset("\033[0m");
+        const std::string red("\033[1;31m");
+        const std::string green("\033[1;32m");
+        const std::string yellow("\033[1;33m");
+        const std::string blue("\033[1;34m");
+        const std::string purple("\033[1;35m");
+        const std::string cyan("\033[1;36m");
+        const std::string reset("\033[0m");
         std::string colorCode;
 
         switch (color) {
-        case RED:    colorCode = red;
+        case RED:
+            colorCode = red;
             break;
-        case GREEN:  colorCode = green;
+        case GREEN:
+            colorCode = green;
             break;
-        case YELLOW: colorCode = yellow;
+        case YELLOW:
+            colorCode = yellow;
             break;
-        case BLUE:   colorCode = blue;
+        case BLUE:
+            colorCode = blue;
             break;
-        case PURPLE: colorCode = purple;
+        case PURPLE:
+            colorCode = purple;
             break;
-        case CYAN:   colorCode = cyan;
+        case CYAN:
+            colorCode = cyan;
             break;
-        default:     colorCode = reset;
+        default:
+            colorCode = reset;
             break;
         }
 
@@ -119,15 +119,17 @@ void Verbose::printInfo() {
 
     for (size_t i = 0; i < node->getParentEdges().size(); i++) {
         std::string prefix("src:" + std::to_string(i) + ':');
-        formatMemDesc(MemoryDescUtils::convertToDnnlMemoryDesc(
-                          node->getParentEdgeAt(i)->getMemory().getDesc().clone())->getDnnlDesc().get(),
+        formatMemDesc(MemoryDescUtils::convertToDnnlMemoryDesc(node->getParentEdgeAt(i)->getMemory().getDesc().clone())
+                          ->getDnnlDesc()
+                          .get(),
                       prefix);
     }
 
     for (size_t i = 0; i < node->getChildEdges().size(); i++) {
         std::string prefix("dst:" + std::to_string(i) + ':');
-        formatMemDesc(MemoryDescUtils::convertToDnnlMemoryDesc(
-                          node->getChildEdgeAt(i)->getMemory().getDesc().clone())->getDnnlDesc().get(),
+        formatMemDesc(MemoryDescUtils::convertToDnnlMemoryDesc(node->getChildEdgeAt(i)->getMemory().getDesc().clone())
+                          ->getDnnlDesc()
+                          .get(),
                       prefix);
     }
 
@@ -135,8 +137,10 @@ void Verbose::printInfo() {
     if (!node->getFusedWith().empty()) {
         post_ops += "post_ops:'";
         for (const auto& fusedNode : node->getFusedWith()) {
-            post_ops.append(colorize(GREEN, fusedNode->getName())).append(":")
-                .append(colorize(CYAN, NameFromType(fusedNode->getType()))).append(":")
+            post_ops.append(colorize(GREEN, fusedNode->getName()))
+                .append(":")
+                .append(colorize(CYAN, NameFromType(fusedNode->getType())))
+                .append(":")
                 .append(algToString(fusedNode->getAlgorithm()))
                 .append(";");
         }
@@ -145,20 +149,16 @@ void Verbose::printInfo() {
 
     std::string nodeImplementer = "cpu";
     if (node->getType() == Type::Reference)
-        nodeImplementer = "ngraph_ref"; // ngraph reference
+        nodeImplementer = "ngraph_ref";  // ngraph reference
 
     const std::string& nodeName = colorize(GREEN, node->getName());
     const std::string& nodeType = colorize(CYAN, NameFromType(node->getType()));
-    const std::string& nodeAlg  = algToString(node->getAlgorithm());
-    const std::string& nodePrimImplType =  impl_type_to_string(node->getSelectedPrimitiveDescriptor()->getImplementationType());
-
-    stream << "ov_cpu_verbose" << ','
-           << "exec" << ','
-           << nodeImplementer << ','
-           << nodeName << ":" << nodeType << ":" << nodeAlg << ','
-           << nodePrimImplType << ','
-           << portsInfo << ','
-           << post_ops << ',';
+    const std::string& nodeAlg = algToString(node->getAlgorithm());
+    const std::string& nodePrimImplType =
+        impl_type_to_string(node->getSelectedPrimitiveDescriptor()->getImplementationType());
+
+    stream << "ov_cpu_verbose" << ',' << "exec" << ',' << nodeImplementer << ',' << nodeName << ":" << nodeType << ":"
+           << nodeAlg << ',' << nodePrimImplType << ',' << portsInfo << ',' << post_ops << ',';
 }
 
 void Verbose::printDuration() {
@@ -170,7 +170,7 @@ void Verbose::flush() const {
     std::cout << stream.rdbuf() << "\n";
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
 
-#endif // CPU_DEBUG_CAPS
+#endif  // CPU_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/utils/verbose.h b/src/plugins/intel_cpu/src/utils/verbose.h
index f5407ec679dd7e..229dd24259fdf6 100644
--- a/src/plugins/intel_cpu/src/utils/verbose.h
+++ b/src/plugins/intel_cpu/src/utils/verbose.h
@@ -5,11 +5,11 @@
 
 #ifdef CPU_DEBUG_CAPS
 
-#include <node.h>
+#    include <node.h>
 
-#include <string>
-#include <cstdlib>
-#include <sstream>
+#    include <cstdlib>
+#    include <sstream>
+#    include <string>
 
 namespace ov {
 namespace intel_cpu {
@@ -47,9 +47,9 @@ class Verbose {
 };
 
 // use heap allocation instead of stack to align with PERF macro (to have proper destruction order)
-#define VERBOSE(...) const auto verbose = std::unique_ptr<Verbose>(new Verbose(__VA_ARGS__));
-}   // namespace intel_cpu
-}   // namespace ov
+#    define VERBOSE(...) const auto verbose = std::unique_ptr<Verbose>(new Verbose(__VA_ARGS__));
+}  // namespace intel_cpu
+}  // namespace ov
 #else
-#define VERBOSE(...)
-#endif // CPU_DEBUG_CAPS
+#    define VERBOSE(...)
+#endif  // CPU_DEBUG_CAPS
diff --git a/src/plugins/intel_cpu/src/weights_cache.cpp b/src/plugins/intel_cpu/src/weights_cache.cpp
index 65fd3644ad4215..39bee2e6eb9786 100644
--- a/src/plugins/intel_cpu/src/weights_cache.cpp
+++ b/src/plugins/intel_cpu/src/weights_cache.cpp
@@ -3,21 +3,20 @@
 //
 
 #include "weights_cache.hpp"
-#include "openvino/runtime/system_conf.hpp"
 
 #include <memory>
 
+#include "openvino/runtime/system_conf.hpp"
+
 namespace ov {
 namespace intel_cpu {
 
-WeightsSharing::SharedMemory::SharedMemory(
-        std::unique_lock<std::mutex> && lock,
-        const MemoryInfo::Ptr & memory,
-        MemoryPtr newPtr)
-    : lock(std::move(lock))
-    , memory(memory)
-    , newPtr(newPtr)
-{}
+WeightsSharing::SharedMemory::SharedMemory(std::unique_lock<std::mutex>&& lock,
+                                           const MemoryInfo::Ptr& memory,
+                                           MemoryPtr newPtr)
+    : lock(std::move(lock)),
+      memory(memory),
+      newPtr(newPtr) {}
 
 WeightsSharing::SharedMemory::operator MemoryPtr() const {
     return memory->sharedMemory.lock();
@@ -31,26 +30,26 @@ void WeightsSharing::SharedMemory::valid(bool b) {
     memory->valid.store(b, std::memory_order_release);
 }
 
-WeightsSharing::SharedMemory::Ptr WeightsSharing::findOrCreate(
-                            const std::string& key,
-                            std::function<MemoryPtr(void)> create,
-                            bool valid) {
+WeightsSharing::SharedMemory::Ptr WeightsSharing::findOrCreate(const std::string& key,
+                                                               std::function<MemoryPtr(void)> create,
+                                                               bool valid) {
     MemoryInfo::Ptr ptr;
     MemoryPtr newPtr;
     {
         std::unique_lock<std::mutex> lock(guard);
         auto found = sharedWeights.find(key);
 
-        if (found == sharedWeights.end()
-            || !((ptr = found->second) && (newPtr = ptr->sharedMemory.lock()))) {
+        if (found == sharedWeights.end() || !((ptr = found->second) && (newPtr = ptr->sharedMemory.lock()))) {
             newPtr = create();
             ptr = std::make_shared<MemoryInfo>(newPtr, valid);
             sharedWeights[key] = ptr;
         }
     }
     return std::make_shared<SharedMemory>(ptr->valid.load(std::memory_order_relaxed)
-                                                ? std::unique_lock<std::mutex>(ptr->guard, std::defer_lock)
-                                                : std::unique_lock<std::mutex>(ptr->guard), ptr, newPtr);
+                                              ? std::unique_lock<std::mutex>(ptr->guard, std::defer_lock)
+                                              : std::unique_lock<std::mutex>(ptr->guard),
+                                          ptr,
+                                          newPtr);
 }
 
 WeightsSharing::SharedMemory::Ptr WeightsSharing::get(const std::string& key) const {
@@ -60,19 +59,20 @@ WeightsSharing::SharedMemory::Ptr WeightsSharing::get(const std::string& key) co
         std::unique_lock<std::mutex> lock(guard);
         auto found = sharedWeights.find(key);
 
-        if (found == sharedWeights.end()
-            || !((ptr = found->second) && (newPtr = ptr->sharedMemory.lock())))
+        if (found == sharedWeights.end() || !((ptr = found->second) && (newPtr = ptr->sharedMemory.lock())))
             OPENVINO_THROW("Unknown shared memory with key ", key);
     }
     return std::make_shared<SharedMemory>(ptr->valid.load(std::memory_order_relaxed)
-                                                ? std::unique_lock<std::mutex>(ptr->guard, std::defer_lock)
-                                                : std::unique_lock<std::mutex>(ptr->guard), ptr, newPtr);
+                                              ? std::unique_lock<std::mutex>(ptr->guard, std::defer_lock)
+                                              : std::unique_lock<std::mutex>(ptr->guard),
+                                          ptr,
+                                          newPtr);
 }
 
 SocketsWeights::SocketsWeights() {
     int num_sockets = get_num_sockets();
     for (int socket_id = 0; socket_id < num_sockets; socket_id++)
-         _cache_map[socket_id] = std::make_shared<WeightsSharing>();
+        _cache_map[socket_id] = std::make_shared<WeightsSharing>();
 }
 
 WeightsSharing::Ptr& SocketsWeights::operator[](int socket_id) {
@@ -89,5 +89,5 @@ const WeightsSharing::Ptr& SocketsWeights::operator[](int socket_id) const {
     return found->second;
 }
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_cpu/src/weights_cache.hpp b/src/plugins/intel_cpu/src/weights_cache.hpp
index f0401700e49719..b823d89b26d9ca 100644
--- a/src/plugins/intel_cpu/src/weights_cache.hpp
+++ b/src/plugins/intel_cpu/src/weights_cache.hpp
@@ -4,15 +4,15 @@
 
 #pragma once
 
-#include "cpu_memory.h"
-
-#include <unordered_map>
+#include <atomic>
 #include <functional>
-#include <string>
+#include <map>
 #include <memory>
-#include <atomic>
 #include <mutex>
-#include <map>
+#include <string>
+#include <unordered_map>
+
+#include "cpu_memory.h"
 
 // TODO: While CPU plugin has no ease way to clone graph object we use weight
 //       caching in global Engine context to avoid tensor memory duplication.
@@ -32,10 +32,7 @@ class WeightsSharing {
     struct MemoryInfo {
         typedef std::shared_ptr<MemoryInfo> Ptr;
 
-        MemoryInfo(MemoryPtr memoryPtr, bool valid)
-            : sharedMemory(memoryPtr)
-            , valid(valid)
-        {}
+        MemoryInfo(MemoryPtr memoryPtr, bool valid) : sharedMemory(memoryPtr), valid(valid) {}
 
         std::mutex guard;
         std::weak_ptr<IMemory> sharedMemory;
@@ -49,9 +46,7 @@ class WeightsSharing {
     public:
         typedef std::shared_ptr<SharedMemory> Ptr;
 
-        SharedMemory(std::unique_lock<std::mutex> && lock,
-                     const MemoryInfo::Ptr & memory,
-                     MemoryPtr newPtr = nullptr);
+        SharedMemory(std::unique_lock<std::mutex>&& lock, const MemoryInfo::Ptr& memory, MemoryPtr newPtr = nullptr);
 
         operator MemoryPtr() const;
         bool isValid() const;
@@ -63,9 +58,7 @@ class WeightsSharing {
         MemoryPtr newPtr;
     };
 
-    SharedMemory::Ptr findOrCreate(const std::string& key,
-                                   std::function<MemoryPtr(void)> create,
-                                   bool valid = true);
+    SharedMemory::Ptr findOrCreate(const std::string& key, std::function<MemoryPtr(void)> create, bool valid = true);
 
     SharedMemory::Ptr get(const std::string& key) const;
 
@@ -90,5 +83,5 @@ class SocketsWeights {
     std::map<int, WeightsSharing::Ptr> _cache_map;
 };
 
-}   // namespace intel_cpu
-}   // namespace ov
+}  // namespace intel_cpu
+}  // namespace ov
diff --git a/src/plugins/intel_gpu/src/kernel_selector/kernels/group_normalization/group_normalization_kernel_bfyx_opt.cpp b/src/plugins/intel_gpu/src/kernel_selector/kernels/group_normalization/group_normalization_kernel_bfyx_opt.cpp
index 806fdfa77755d2..ab65d1ea192c22 100644
--- a/src/plugins/intel_gpu/src/kernel_selector/kernels/group_normalization/group_normalization_kernel_bfyx_opt.cpp
+++ b/src/plugins/intel_gpu/src/kernel_selector/kernels/group_normalization/group_normalization_kernel_bfyx_opt.cpp
@@ -20,6 +20,7 @@ ParamsKey GroupNormalizationKernelBfyx::GetSupportedKey() const {
     k.EnableInputLayout(DataLayout::bfzyx);
     k.EnableOutputLayout(DataLayout::bfyx);
     k.EnableOutputLayout(DataLayout::bfzyx);
+    k.EnableOutputLayout(DataLayout::b_fs_yx_fsv16);
     k.EnableBatching();
     k.EnableTensorOffset();
     k.EnableTensorPitches();
diff --git a/src/plugins/intel_gpu/tests/unit/test_cases/group_normalization_gpu_test.cpp b/src/plugins/intel_gpu/tests/unit/test_cases/group_normalization_gpu_test.cpp
index 63d7bef3f8b948..e877d06beec83a 100644
--- a/src/plugins/intel_gpu/tests/unit/test_cases/group_normalization_gpu_test.cpp
+++ b/src/plugins/intel_gpu/tests/unit/test_cases/group_normalization_gpu_test.cpp
@@ -4,8 +4,13 @@
 
 #include "test_utils.h"
 #include "random_generator.hpp"
+#include "program_wrapper.h"
+#include "pass_manager.h"
+
 #include <intel_gpu/primitives/input_layout.hpp>
 #include <intel_gpu/primitives/group_normalization.hpp>
+#include <intel_gpu/primitives/reorder.hpp>
+#include <intel_gpu/primitives/permute.hpp>
 #include "openvino/reference/group_normalization.hpp"
 #include "intel_gpu/runtime/compilation_context.hpp"
 
@@ -156,3 +161,79 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::ValuesIn({padding(), padding({0, 0, 1, 1})})));
 
 } // anonymous namespace
+
+#ifdef ENABLE_ONEDNN_FOR_GPU
+TEST(group_normalization, input_bfyx_output_fsv16) {
+    auto& engine = get_test_engine();
+
+    auto in_layout = layout{ ov::PartialShape{1, 3, 3, 2}, data_types::f32, format::bfyx };
+    auto scale_layout = layout{ ov::PartialShape{1, 1, 1, 1}, data_types::f32, format::bfyx };
+    auto bias_layout = layout{ ov::PartialShape{1, 1, 1, 1}, data_types::f32, format::bfyx };
+
+    auto input_mem = engine.allocate_memory(in_layout);
+    auto scale_mem = engine.allocate_memory(scale_layout);
+    auto bias_mem = engine.allocate_memory(bias_layout);
+
+    set_values(input_mem,
+               { 0.125, 0.125, 0.875, -0.125, 0.125, 0.750,
+                0.875, -0.375, -0.375, -1.000, -0.625, -1.000,
+                -0.125, -0.750, -0.250, 0.625, -0.500, -0.875 });
+    set_values(scale_mem, { 0.125 });
+    set_values(bias_mem, { 0.75 });
+
+    topology topology_g(
+        input_layout("input", in_layout),
+        input_layout("scale", scale_layout),
+        input_layout("bias", bias_layout),
+        group_normalization("group_normalization", input_info("input"), input_info("scale"), input_info("bias"), static_cast<std::int64_t>(1), 0.0025),
+        permute("output", input_info("group_normalization"), {0, 1, 2, 3})
+    );
+
+    topology topology_t(
+        input_layout("input", in_layout),
+        input_layout("scale", scale_layout),
+        input_layout("bias", bias_layout),
+        reorder("reorder1", input_info("input"), format::b_fs_yx_fsv16, data_types::f32),
+        group_normalization("group_normalization", input_info("reorder1"), input_info("scale"), input_info("bias"), static_cast<std::int64_t>(1), 0.0025),
+        reorder("reorder2", input_info("group_normalization"), format::b_fs_yx_fsv16, data_types::f32),
+        permute("output", input_info("reorder2"), {0, 1, 2, 3})
+    );
+
+    ExecutionConfig config = get_test_default_config(engine);
+    ov::intel_gpu::ImplementationDesc gn_impl = { format::bfyx, "", impl_types::ocl };
+    config.set_property(ov::intel_gpu::force_implementations(ov::intel_gpu::ImplForcingMap{{"group_normalization", gn_impl}}));
+    config.set_property(ov::intel_gpu::allow_new_shape_infer(true));
+    config.set_property(ov::intel_gpu::optimize_data(true));
+
+    network network_g(engine, topology_g, config);
+    network_g.set_input_data("input", input_mem);
+    network_g.set_input_data("scale", scale_mem);
+    network_g.set_input_data("bias", bias_mem);
+
+    auto outputs_g = network_g.execute();
+    auto output_g = outputs_g.at("output").get_memory();
+    cldnn::mem_lock<float> output_mem_g(output_g, get_test_stream());
+
+    auto program = program::build_program(engine, topology_t, config, false, true);
+    auto& reorder_node = program->get_node("reorder1");
+    std::vector<layout> layouts = {in_layout};
+    reorder_node.set_output_layouts(layouts, false);
+    program_wrapper::build(*program);
+
+    network network_t(program);
+    network_t.set_input_data("input", input_mem);
+    network_t.set_input_data("scale", scale_mem);
+    network_t.set_input_data("bias", bias_mem);
+
+    auto outputs_t = network_t.execute();
+    auto output_t = outputs_g.at("output").get_memory();
+    cldnn::mem_lock<float> output_mem_t(output_t, get_test_stream());
+
+    ASSERT_EQ(output_mem_g.size(), output_mem_t.size());
+    ASSERT_EQ(outputs_g.begin()->first, outputs_t.begin()->first);
+
+    for (std::size_t i = 0; i < output_mem_t.size(); i++) {
+        ASSERT_NEAR(output_mem_t[i], output_mem_g[i], 0.0001);
+    }
+}
+#endif // ENABLE_ONEDNN_FOR_GPU
\ No newline at end of file