readability run 1

Author: aobolensk

src/plugins/intel_cpu/src/.clang-tidy

@@ -3,10 +3,6 @@
 ### NOTE:
 # The 'Checks: >' is a multiline string here. Comment must not be moved into the string.
 #
-### Scopes to be enabled:
-#
-# readability-*,
-#
 ### Checks that are turned off for a reason:
 #
 # -cppcoreguidelines-avoid-c-arrays. There are a lot of code which uses C-style arrays
@@ -52,8 +48,18 @@
 # -misc-header-include-cycle,
 # -misc-non-private-member-variables-in-classes,
 # -misc-use-anonymous-namespace,
-# -readability-magic-numbers, cppcoreguidelines-avoid-magic-numbers
+# -readability-avoid-nested-conditional-operator
+# -readability-avoid-return-with-void-value
+# -readability-const-return-type
+# -readability-convert-member-functions-to-static
 # -readability-function-cognitive-complexity. Reasonable way to enforce splitting complex code into simple functions
+# -readability-inconsistent-declaration-parameter-name
+# -readability-isolate-declaration
+# -readability-magic-numbers, cppcoreguidelines-avoid-magic-numbers
+# -readability-simplify-boolean-expr
+# -readability-static-accessed-through-instance
+# -readability-suspicious-call-argument
+# -readability-use-anyofallof
 # Remove warning disablement after CI pipeline migrates to C++17 from C++20 for:
 # -modernize-use-constraints,
 # -modernize-use-std-numbers
@@ -66,10 +72,7 @@ Checks: >
   google-*,
   modernize-*,
   misc-*,
-  readability-container-size-empty,
-  readability-else-after-return,
-  readability-implicit-bool-conversion,
-  readability-qualified-auto,
+  readability-*,
   -bugprone-easily-swappable-parameters,
   -bugprone-exception-escape,
   -bugprone-implicit-widening-of-multiplication-result,
@@ -79,6 +82,7 @@ Checks: >
   -cppcoreguidelines-avoid-c-arrays,
   -cppcoreguidelines-avoid-const-or-ref-data-members,
   -cppcoreguidelines-avoid-do-while,
+  -cppcoreguidelines-avoid-magic-numbers,
   -cppcoreguidelines-avoid-non-const-global-variables,
   -cppcoreguidelines-explicit-virtual-functions,
   -cppcoreguidelines-init-variables,
@@ -111,11 +115,20 @@ Checks: >
   -misc-no-recursion,
   -misc-non-private-member-variables-in-classes,
   -misc-use-anonymous-namespace,
+  -readability-avoid-nested-conditional-operator,
+  -readability-avoid-return-with-void-value,
+  -readability-const-return-type,
+  -readability-convert-member-functions-to-static,
+  -readability-function-cognitive-complexity,
   -readability-identifier-length,
+  -readability-inconsistent-declaration-parameter-name,
+  -readability-isolate-declaration,
   -readability-magic-numbers,
-  -cppcoreguidelines-avoid-magic-numbers,
+  -readability-simplify-boolean-expr,
+  -readability-static-accessed-through-instance,
+  -readability-suspicious-call-argument,
   -readability-uppercase-literal-suffix,
-  -readability-function-cognitive-complexity,
+  -readability-use-anyofallof,
 # Treat warnings as errors
 WarningsAsErrors: '*'
 # Use clang-format for applied fixes
@@ -153,8 +166,7 @@ CheckOptions:
       .*/selective_build.h;
       src/plugins/intel_cpu/src/emitters/plugin/aarch64/jit_emitter.hpp;
       src/plugins/intel_cpu/src/emitters/plugin/aarch64/jit_emitter.cpp;
-### To be considered to enable:
 #  Reasonable way to enforce splitting complex code into simple functions
-#  - key: google-readability-function-size.StatementThreshold
-#    value: "800"
+  - key: readability-function-size.StatementThreshold
+    value: "800"
 ---

src/plugins/intel_cpu/src/compiled_model.cpp

@@ -192,7 +192,7 @@ CompiledModel::GraphGuard::Lock CompiledModel::get_graph() const {
             try {
                 GraphContext::Ptr ctx;
                 {
-                    std::lock_guard<std::mutex> lock{*m_mutex.get()};
+                    std::lock_guard<std::mutex> lock{*m_mutex};
                     auto isQuantizedFlag = (m_cfg.lpTransformsMode == Config::On) &&
                                            ov::pass::low_precision::LowPrecision::isFunctionQuantized(m_model);
                     ctx = std::make_shared<GraphContext>(m_cfg,

src/plugins/intel_cpu/src/config.cpp

@@ -177,15 +177,15 @@ void Config::readProperties(const ov::AnyMap& prop, const ModelType modelType) {
                                ". Expected only true/false.");
             }
         } else if (key == ov::intel_cpu::sparse_weights_decompression_rate.name()) {
-            float val_f = 0.0f;
+            float val_f = 0.0F;
             try {
                 val_f = val.as<float>();
             } catch (const ov::Exception&) {
                 OPENVINO_THROW("Wrong value for property key ",
                                ov::intel_cpu::sparse_weights_decompression_rate.name(),
                                ". Expected only float numbers");
             }
-            if (val_f < 0.f || val_f > 1.f) {
+            if (val_f < 0.F || val_f > 1.F) {
                 OPENVINO_THROW("Wrong value for property key ",
                                ov::intel_cpu::sparse_weights_decompression_rate.name(),
                                ". Sparse rate must be in range [0.0f,1.0f]");
@@ -523,12 +523,12 @@ void Config::updateProperties() {
         return;
     }
 
-    if (collectPerfCounters == true) {
+    if (collectPerfCounters) {
         _config.insert({ov::enable_profiling.name(), "YES"});
     } else {
         _config.insert({ov::enable_profiling.name(), "NO"});
     }
-    if (exclusiveAsyncRequests == true) {
+    if (exclusiveAsyncRequests) {
         _config.insert({ov::internal::exclusive_async_requests.name(), "YES"});
     } else {
         _config.insert({ov::internal::exclusive_async_requests.name(), "NO"});

src/plugins/intel_cpu/src/cpu_memory.cpp

@@ -58,7 +58,7 @@ BlockedMemoryDescPtr IMemory::getDescWithType<BlockedMemoryDesc, 0, 0>() const {
 namespace {
 inline void setSubnormalsToZeroAndbf16Saturation(float* data, size_t size, bool ftz, bool bf16saturation) {
     auto* u32data = reinterpret_cast<uint32_t*>(data);
-    auto* floatdata = reinterpret_cast<float*>(data);
+    auto* floatdata = data;
     if (ftz && bf16saturation) {
         for (size_t i = 0; i < size; ++i) {
             if ((u32data[i] & (0xFF << 23)) == 0) {
@@ -292,7 +292,7 @@ bool MemoryBlockWithReuse::hasExtBuffer() const noexcept {
 
 void MemoryBlockWithReuse::free() {
     m_data = decltype(m_data)(nullptr, release);
-    m_memUpperBound = 0ul;
+    m_memUpperBound = 0UL;
     m_useExternalStorage = false;
 }
 
@@ -627,7 +627,7 @@ bool mbind_move(void* data, size_t size, int targetNode) {
         mask = -1;
         flags = 0;
     } else {
-        mask = 1ul << realNode;
+        mask = 1UL << realNode;
         flags = MPOL_MF_MOVE | MPOL_MF_STRICT;
     }
 

src/plugins/intel_cpu/src/cpu_streams_calculation.cpp

@@ -52,8 +52,6 @@ void sort_table_by_numa_node_id(const int current_numa_node, std::vector<std::ve
             }
         }
     }
-
-    return;
 };
 
 std::vector<std::vector<int>> get_streams_info_table(
@@ -220,9 +218,8 @@ std::vector<std::vector<int>> get_streams_info_table(
         }
     }
 
-    if (((input_streams_changed == false) &&
-         (input_perf_hint == ov::util::to_string(ov::hint::PerformanceMode::LATENCY))) ||
-        ((input_streams_changed == true) && (input_streams == 1))) {
+    if (((!input_streams_changed) && (input_perf_hint == ov::util::to_string(ov::hint::PerformanceMode::LATENCY))) ||
+        ((input_streams_changed) && (input_streams == 1))) {
         n_streams = 1;
         stream_info[NUMBER_OF_STREAMS] = n_streams;
         for (auto& n : proc_socket_table) {
@@ -301,14 +298,14 @@ std::vector<std::vector<int>> get_streams_info_table(
     } else {
         n_threads =
             input_threads > 0 ? std::min(proc_type_table[0][ALL_PROC], input_threads) : proc_type_table[0][ALL_PROC];
-        if ((input_streams_changed == true) && (input_streams > 0)) {
+        if ((input_streams_changed) && (input_streams > 0)) {
             n_streams = input_infer_requests > 0 ? std::min(input_infer_requests, input_streams) : input_streams;
             if (n_streams >= n_threads) {
                 n_streams = n_threads;
                 n_threads_per_stream = 1;
             } else {
                 n_threads_per_stream =
-                    std::min(static_cast<int>(n_threads / n_streams),
+                    std::min((n_threads / n_streams),
                              proc_type_table[0][MAIN_CORE_PROC] == 0 ? proc_type_table[0][EFFICIENT_CORE_PROC]
                                                                      : proc_type_table[0][MAIN_CORE_PROC]);
                 check_threads_per_stream();
@@ -336,20 +333,20 @@ std::vector<std::vector<int>> get_streams_info_table(
                 } else if (proc_type_table.size() == 1) {
                     n_threads_per_stream = n_proc;
                 } else {
-                    n_threads_per_stream = (n_proc > 16) ? 4 : std::max(1, static_cast<int>(n_proc / 4));
+                    n_threads_per_stream = (n_proc > 16) ? 4 : std::max(1, (n_proc / 4));
                 }
-                n_streams = static_cast<int>(n_threads / n_threads_per_stream);
+                n_streams = (n_threads / n_threads_per_stream);
                 if ((input_infer_requests > 0) && (n_streams > input_infer_requests)) {
                     n_streams = input_infer_requests;
                     if (proc_type_table.size() == 1) {
-                        n_threads_per_stream = std::min(static_cast<int>(n_threads / n_streams), n_proc);
+                        n_threads_per_stream = std::min((n_threads / n_streams), n_proc);
                     } else {
-                        n_threads_per_stream = static_cast<int>(n_threads / n_streams);
+                        n_threads_per_stream = (n_threads / n_streams);
                     }
                 } else {
                     while ((n_streams * 2 <= n_threads_per_stream) && (n_threads_per_stream > 1)) {
-                        n_threads_per_stream = static_cast<int>(n_threads_per_stream / 2);
-                        n_streams = static_cast<int>(n_threads / n_threads_per_stream);
+                        n_threads_per_stream = (n_threads_per_stream / 2);
+                        n_streams = (n_threads / n_threads_per_stream);
                     }
                 }
             } else if ((1 == model_prefer_threads) &&
@@ -358,8 +355,8 @@ std::vector<std::vector<int>> get_streams_info_table(
                        (proc_type_table[0][MAIN_CORE_PROC] > 0) && (n_threads > proc_type_table[0][MAIN_CORE_PROC])) {
                 n_streams = (n_threads >= proc_type_table[0][MAIN_CORE_PROC] + proc_type_table[0][EFFICIENT_CORE_PROC] +
                                               proc_type_table[0][LP_EFFICIENT_CORE_PROC])
-                                ? static_cast<int>(n_threads - proc_type_table[0][EFFICIENT_CORE_PROC] / 2 -
-                                                   proc_type_table[0][LP_EFFICIENT_CORE_PROC] / 2)
+                                ? (n_threads - proc_type_table[0][EFFICIENT_CORE_PROC] / 2 -
+                                   proc_type_table[0][LP_EFFICIENT_CORE_PROC] / 2)
                                 : static_cast<int>(proc_type_table[0][MAIN_CORE_PROC] +
                                                    (n_threads - proc_type_table[0][MAIN_CORE_PROC]) / 2);
                 n_streams = input_infer_requests > 0 ? std::min(n_streams, input_infer_requests) : n_streams;
@@ -371,10 +368,10 @@ std::vector<std::vector<int>> get_streams_info_table(
                 n_streams = ((n_threads + model_threads - 1) / model_threads);
                 if ((input_infer_requests > 0) && (n_streams > input_infer_requests)) {
                     n_streams = input_infer_requests;
-                    n_threads_per_stream = static_cast<int>(n_threads / n_streams);
+                    n_threads_per_stream = (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 : (n_threads / n_streams);
                 }
             }
         }
@@ -592,25 +589,25 @@ int get_model_prefer_threads(const int num_streams,
         }
 #else
         const auto isa = dnnl::get_effective_cpu_isa();
-        float isaSpecificThreshold = 1.0f;
+        float isaSpecificThreshold = 1.0F;
         switch (isa) {
         case dnnl::cpu_isa::sse41:
-            isaSpecificThreshold = 0.5f;
+            isaSpecificThreshold = 0.5F;
             break;
         case dnnl::cpu_isa::avx2:
         case dnnl::cpu_isa::avx512_core:
-            isaSpecificThreshold = 1.0f;
+            isaSpecificThreshold = 1.0F;
             break;
         case dnnl::cpu_isa::avx512_core_vnni:
         case dnnl::cpu_isa::avx2_vnni:
         case dnnl::cpu_isa::avx2_vnni_2:
-            isaSpecificThreshold = 2.0f;
+            isaSpecificThreshold = 2.0F;
             break;
         case dnnl::cpu_isa::avx512_core_amx:
-            isaSpecificThreshold = 4.0f;
+            isaSpecificThreshold = 4.0F;
             break;
         default:
-            isaSpecificThreshold = 1.0f;
+            isaSpecificThreshold = 1.0F;
         }
         // the more "capable" the CPU in general, the more streams we may want to keep to keep it utilized
         const float memThresholdAssumeLimitedForISA = ov::MemBandwidthPressure::LIMITED / isaSpecificThreshold;

src/plugins/intel_cpu/src/dnnl_extension_utils.cpp

@@ -65,7 +65,7 @@ uint8_t DnnlExtensionUtils::sizeOfDataType(dnnl::memory::data_type dataType) {
 
 std::optional<dnnl::memory::data_type> DnnlExtensionUtils::ElementTypeToDataType(
     const ov::element::Type& elementType,
-    DnnlExtensionUtils::nothrow_tag) noexcept {
+    DnnlExtensionUtils::nothrow_tag /*unused*/) noexcept {
     switch (elementType) {
     case ov::element::f32:
         return memory::data_type::f32;
@@ -105,7 +105,7 @@ std::optional<dnnl::memory::data_type> DnnlExtensionUtils::ElementTypeToDataType
 }
 
 dnnl::memory::data_type DnnlExtensionUtils::ElementTypeToDataType(const ov::element::Type& elementType,
-                                                                  DnnlExtensionUtils::throw_tag) {
+                                                                  DnnlExtensionUtils::throw_tag /*unused*/) {
     auto&& result = ElementTypeToDataType(elementType, nothrow_tag{});
     OPENVINO_ASSERT(result, "CPU plugin does not support ", elementType.to_string(), " for use with oneDNN.");
     return result.value();