[Snippets][CPU] Replace OPENVINO_ASSERT with C assert in getter-like functions

src/common/snippets/include/snippets/kernel_executor_table.hpp

@@ -131,7 +131,7 @@ class KernelExecutorTable {
         return get_kernel_executor(expr->get_exec_num());
     }
     const std::shared_ptr<KernelExecutorBase>& get_kernel_executor(double expr_exec_num) const {
-        OPENVINO_ASSERT(m_table.count(expr_exec_num), "This expression execution number doesn't have a registered kernel executor");
+        assert(m_table.count(expr_exec_num) && "This expression execution number doesn't have a registered kernel executor");
         return m_table.at(expr_exec_num);
     }
 

src/common/snippets/include/snippets/lowered/linear_ir.hpp

@@ -71,7 +71,7 @@ class LinearIR {
     const std::vector<BufferExpressionPtr>& get_buffers() const { return m_buffer_expressions; }
     const Config& get_config() const {
 #ifdef SNIPPETS_DEBUG_CAPS
-        OPENVINO_ASSERT(m_config.debug_config, "Debug config is not initialized");
+        assert(m_config.debug_config && "Debug config is not initialized");
 #endif  // SNIPPETS_DEBUG_CAPS
         return m_config;
     }

src/common/snippets/include/snippets/lowered/loop_manager.hpp

@@ -35,8 +35,10 @@ class LoopManager {
     std::shared_ptr<T> get_loop_info(size_t index) const {
         const auto it = m_map.find(index);
         OPENVINO_ASSERT(it != m_map.end(), "LoopInfo hasn't been found!");
+        assert(it != m_map.end() && "LoopInfo hasn't been found!");
         const auto loop_info = ov::as_type_ptr<T>(it->second);
         OPENVINO_ASSERT(loop_info, "LoopInfo of specific type hasn't been found!");
+        assert(loop_info && "LoopInfo of specific type hasn't been found!");
         return loop_info;
     }
     /**

src/common/snippets/include/snippets/lowered/reg_manager.hpp

@@ -37,7 +37,7 @@ class RegManager {
     inline std::vector<Reg> get_kernel_call_regs(const std::shared_ptr<snippets::op::Kernel>& kernel) const {
         const auto& abi_regs = m_generator->get_target_machine()->get_abi_arg_regs();
         const auto num_kernel_args = kernel->get_num_call_args();
-        OPENVINO_ASSERT(abi_regs.size() > num_kernel_args, "Too many kernel args requested");
+        assert(abi_regs.size() > num_kernel_args && "Too many kernel args requested");
         return {abi_regs.begin(), abi_regs.begin() + static_cast<int64_t>(num_kernel_args)};
     }
 
@@ -51,7 +51,7 @@ class RegManager {
     }
 
     inline const LiveInterval& get_live_range(const Reg& reg) const {
-        OPENVINO_ASSERT(m_reg_live_range.count(reg), "Live range for this reg was not set");
+        assert(m_reg_live_range.count(reg) && "Live range for this reg was not set");
         return m_reg_live_range.at(reg);
     }
     inline const std::map<Reg, LiveInterval>& get_live_range_map() const {

src/common/snippets/include/snippets/op/reg_spill.hpp

@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include <cassert>
+
 #include "snippets/emitter.hpp"
 
 #include "openvino/op/op.hpp"
@@ -68,7 +70,7 @@ class RegSpillEnd : public RegSpillBase {
     std::shared_ptr<Node> clone_with_new_inputs(const OutputVector& inputs) const override;
     std::shared_ptr<RegSpillBegin> get_reg_spill_begin() const {
         auto reg_spill_begin = ov::as_type_ptr<RegSpillBegin>(get_input_node_shared_ptr(0));
-        OPENVINO_ASSERT(reg_spill_begin, "Can't get reg_spill_begin from reg_spill_end");
+        assert(reg_spill_begin && "Can't get reg_spill_begin from reg_spill_end");
         return reg_spill_begin;
     }
     const std::set<Reg>& get_regs_to_spill() const override {

src/common/snippets/include/snippets/op/subgraph.hpp

@@ -103,7 +103,7 @@ class Subgraph : public ov::op::util::SubGraphOp {
     bool is_quantized() const { return config.m_is_quantized; }
 #ifdef SNIPPETS_DEBUG_CAPS
     DebugCapsConfig& get_debug_config() {
-        OPENVINO_ASSERT(config.m_debug_config, "Debug config is not initialized");
+        assert(config.m_debug_config && "Debug config is not initialized");
         return *config.m_debug_config;
     }
 #endif  // SNIPPETS_DEBUG_CAPS

src/common/snippets/include/snippets/utils/utils.hpp

@@ -8,6 +8,8 @@
  */
 #pragma once
 
+#include <cassert>
+
 #include "snippets/emitter.hpp"
 #include "snippets/shape_types.hpp"
 #include "snippets/lowered/expression.hpp"
@@ -156,12 +158,12 @@ inline size_t dimension_to_size_t(const ov::Dimension& dim) {
 
 // dim_idx starts from the layout end: dim_idx = 0 -> last element in layout (layout.back())
 inline size_t get_input_dim_idx(const std::vector<size_t>& layout, size_t dim_idx) {
-    OPENVINO_ASSERT(dim_idx < layout.size(), "Incorrect dim_idx");
+    assert(dim_idx < layout.size() && "Incorrect dim_idx");
     return *(layout.rbegin() + dim_idx);
 }
 // dim_idx starts from the layout end: dim_idx = 0 -> last index in layout (layout.size() - 1)
 inline size_t get_output_dim_idx(const std::vector<size_t>& layout, size_t dim_idx) {
-    OPENVINO_ASSERT(dim_idx < layout.size(), "Incorrect dim_idx");
+    assert(dim_idx < layout.size() && "Incorrect dim_idx");
     return std::distance(layout.cbegin(), std::find(layout.cbegin(), layout.cend(), layout.size() - 1 - dim_idx));
 }
 

src/common/snippets/src/lowered/expression.cpp

@@ -28,20 +28,20 @@ Expression::Expression(const std::shared_ptr<Node>& n, const std::shared_ptr<ISh
 }
 
 const PortConnectorPtr& Expression::get_input_port_connector(size_t i) const {
-    OPENVINO_ASSERT(i < m_input_port_connectors.size(), "Failed to get input port connector: target input port must be less than input count!");
+    assert(i < m_input_port_connectors.size() && "Failed to get input port connector: target input port must be less than input count!");
     return m_input_port_connectors[i];
 }
 const PortConnectorPtr& Expression::get_output_port_connector(size_t i) const {
-    OPENVINO_ASSERT(i < m_output_port_connectors.size(), "Failed to get output port connector: target output port must be less than output count!");
+    assert(i < m_output_port_connectors.size() && "Failed to get output port connector: target output port must be less than output count!");
     return m_output_port_connectors[i];
 }
 
 const PortDescriptorPtr& Expression::get_input_port_descriptor(size_t i) const {
-    OPENVINO_ASSERT(i < m_input_port_descriptors.size(), "Failed to get input port descriptor: target input port must be less than input count!");
+    assert(i < m_input_port_descriptors.size() && "Failed to get input port descriptor: target input port must be less than input count!");
     return m_input_port_descriptors[i];
 }
 const PortDescriptorPtr& Expression::get_output_port_descriptor(size_t i) const {
-    OPENVINO_ASSERT(i < m_output_port_descriptors.size(), "Failed to get output port descriptor: target output port must be less than output count!");
+    assert(i < m_output_port_descriptors.size() && "Failed to get output port descriptor: target output port must be less than output count!");
     return m_output_port_descriptors[i];
 }
 

src/common/snippets/src/lowered/expression_port.cpp

@@ -20,21 +20,21 @@ std::shared_ptr<ExpressionPort> ExpressionPort::clone_with_new_expr(const std::s
 
 std::shared_ptr<Expression> ExpressionPort::get_expr() const {
     const auto expr_ptr = m_expr.lock();
-    OPENVINO_ASSERT(expr_ptr != nullptr, "ExpressionPort has invalid expression pointer");
+    assert(expr_ptr != nullptr && "ExpressionPort has invalid expression pointer");
     return expr_ptr;
 }
 
 const PortDescriptorPtr& ExpressionPort::get_descriptor_ptr() const {
     const auto& descs = m_type == Type::Input ? get_expr()->m_input_port_descriptors
                                               : get_expr()->m_output_port_descriptors;
-    OPENVINO_ASSERT(m_port_index < descs.size(), "Incorrect index of port");
+    assert(m_port_index < descs.size() && "Incorrect index of port");
     return descs[m_port_index];
 }
 
 const std::shared_ptr<PortConnector>& ExpressionPort::get_port_connector_ptr() const {
     const auto& connectors = m_type == Type::Input ? get_expr()->m_input_port_connectors
                                                    : get_expr()->m_output_port_connectors;
-    OPENVINO_ASSERT(m_port_index < connectors.size(), "Incorrect index of port");
+    assert(m_port_index < connectors.size() && "Incorrect index of port");
     return connectors[m_port_index];
 }
 

src/common/snippets/src/lowered/linear_ir.cpp

@@ -58,12 +58,12 @@ LinearIR::LinearIR(const std::shared_ptr<ov::Model>& model,
 }
 
 const ExpressionFactoryPtr& LinearIR::get_expr_factory() const {
-    OPENVINO_ASSERT(m_expression_factory, "ExpresstionFactory is missed!");
+    assert(m_expression_factory && "ExpresstionFactory is missed!");
     return m_expression_factory;
 }
 
 std::vector<PortConnectorPtr> LinearIR::get_expression_inputs_by_node(const std::shared_ptr<Node>& n) const {
-    OPENVINO_ASSERT(n != nullptr, "Failed expression inputs getting: node is null");
+    assert(n != nullptr && "Failed expression inputs getting: node is null");
     std::vector<PortConnectorPtr> inputs(n->get_input_size(), nullptr);
     for (const auto& input : n->inputs()) {
         const auto input_source = input.get_source_output();

src/common/snippets/src/lowered/loop_info.cpp

@@ -118,7 +118,7 @@ bool LoopInfo::is_loop_port(const ExpressionPort& expr_port) {
 }
 
 const LoopPort& LoopInfo::get_loop_port(const ExpressionPort& expr_port) {
-    OPENVINO_ASSERT(is_loop_port(expr_port), "Failed get_loop_port: expr_port is not a loop port");
+    assert(is_loop_port(expr_port) && "Failed get_loop_port: expr_port is not a loop port");
     return *find_loop_port(expr_port);
 }
 
@@ -283,15 +283,15 @@ const std::vector<UnifiedLoopInfo::LoopPortDesc>& UnifiedLoopInfo::get_output_po
 }
 
 std::vector<UnifiedLoopInfo::LoopPortInfo> UnifiedLoopInfo::get_input_ports_info() const {
-    OPENVINO_ASSERT(m_input_ports.size() == m_input_port_descs.size(), "Incompatible count of input port and descs");
+    assert(m_input_ports.size() == m_input_port_descs.size() && "Incompatible count of input port and descs");
     std::vector<UnifiedLoopInfo::LoopPortInfo> info(get_input_count());
     for (size_t i = 0; i < get_input_count(); ++i)
         info[i] = { m_input_ports[i], m_input_port_descs[i] };
     return info;
 }
 
 std::vector<UnifiedLoopInfo::LoopPortInfo> UnifiedLoopInfo::get_output_ports_info() const {
-    OPENVINO_ASSERT(m_output_ports.size() == m_output_port_descs.size(), "Incompatible count of output port and descs");
+    assert(m_output_ports.size() == m_output_port_descs.size() && "Incompatible count of output port and descs");
     std::vector<UnifiedLoopInfo::LoopPortInfo> info(get_output_count());
     for (size_t i = 0; i < get_output_count(); ++i)
         info[i] = { m_output_ports[i], m_output_port_descs[i] };
@@ -432,7 +432,7 @@ size_t InnerSplittedUnifiedLoopInfo::get_work_amount() const {
 }
 
 LoopInfoPtr InnerSplittedUnifiedLoopInfo::get_outer_splitted_loop_info() const {
-    OPENVINO_ASSERT(m_outer_splitted_loop_info, "Outer Splitted loop info is nullptr!");
+    assert(m_outer_splitted_loop_info && "Outer Splitted loop info is nullptr!");
     return m_outer_splitted_loop_info;
 }
 
@@ -484,7 +484,7 @@ bool ExpandedLoopInfo::is_dynamic() const {
 }
 
 const std::shared_ptr<UnifiedLoopInfo>& ExpandedLoopInfo::get_unified_loop_info() const {
-    OPENVINO_ASSERT(m_unified_loop_info, "Failed to get unified loop info: it's nullptr");
+    assert(m_unified_loop_info && "Failed to get unified loop info: it's nullptr");
     return m_unified_loop_info;
 }
 

src/common/snippets/src/lowered/loop_manager.cpp

@@ -49,7 +49,7 @@ const std::map<size_t, LoopInfoPtr>& LoopManager::get_map() const {
 std::vector<size_t> LoopManager::get_outer_expr_loops(const ExpressionPtr& expr, size_t loop_id) {
     const auto& loop_ids = expr->get_loop_ids();
     const auto it = std::find(loop_ids.cbegin(), loop_ids.cend(), loop_id);
-    OPENVINO_ASSERT(it != loop_ids.cend(), "Loop ID hasn't been found");
+    assert(it != loop_ids.cend() && "Loop ID hasn't been found");
     return std::vector<size_t>(loop_ids.cbegin(), it);
 }
 

src/common/snippets/src/lowered/pass/define_buffer_clusters.cpp

@@ -61,7 +61,7 @@ void DefineBufferClusters::add_buffers_to_cluster(BufferCluster& existing_cluste
 }
 
 size_t DefineBufferClusters::get_cluster_buffer_id(const BufferCluster& cluster) {
-    OPENVINO_ASSERT(!cluster.empty(), "Buffer cluster is empty!");
+    assert(!cluster.empty() && "Buffer cluster is empty!");
     const auto id = cluster.cbegin()->get()->get_reg_group();
     if (std::all_of(cluster.cbegin(), cluster.cend(), [&id](const BufferExpressionPtr& expr) { return expr->get_reg_group() == id; })) {
         return id;

src/common/snippets/src/lowered/pass/mark_invariant_shape_path.cpp

@@ -46,7 +46,7 @@ static bool is_affecting_op(const ExpressionPtr& expr) {
 size_t MarkInvariantShapePath::getInvariantPortShapePath(const ExpressionPort& port) {
     auto& rt = get_rt_info(port);
     const auto rinfo = rt.find("InvariantShapePath");
-    OPENVINO_ASSERT(rinfo != rt.end(), "Invariant path for this expression port has not been marked!");
+    assert(rinfo != rt.end() && "Invariant path for this expression port has not been marked!");
     return rinfo->second.as<size_t>();
 }
 
@@ -60,7 +60,7 @@ ov::RTMap& MarkInvariantShapePath::get_rt_info(const ExpressionPort& port) {
     const auto& source_port = port.get_type() == ExpressionPort::Input ? port.get_port_connector_ptr()->get_source() : port;
     const auto& node = source_port.get_expr()->get_node();
     const auto port_idx = source_port.get_index();
-    OPENVINO_ASSERT(port_idx < node->get_output_size(), "Node has incompatible port count with the expression");
+    assert(port_idx < node->get_output_size() && "Node has incompatible port count with the expression");
     return node->output(port_idx).get_rt_info();
 }
 

src/common/snippets/src/lowered/pass/set_buffer_reg_group.cpp

@@ -23,7 +23,7 @@ inline size_t index(size_t col_num, size_t row, size_t col) {
 
 size_t SetBufferRegGroup::get_buffer_idx(const BufferExpressionPtr& target, const BufferPool& pool) {
     const auto iter = std::find(pool.cbegin(), pool.cend(), target);
-    OPENVINO_ASSERT(iter != pool.cend(), "Buffer wasn't find in Buffer system of Subgraph");
+    assert(iter != pool.cend() && "Buffer wasn't find in Buffer system of Subgraph");
     return std::distance(pool.cbegin(), iter);
 }
 

src/common/snippets/src/lowered/port_descriptor.cpp

@@ -42,7 +42,7 @@ void PortDescriptor::validate_arguments() {
 }
 
 const VectorDims& PortDescriptor::get_shape() const {
-    OPENVINO_ASSERT(m_tensor_shape, "Failed to get_shape: Tensor Shape is nullptr");
+    assert(m_tensor_shape && "Failed to get_shape: Tensor Shape is nullptr");
     return *m_tensor_shape;
 }
 

src/common/snippets/src/op/brgemm.cpp

@@ -110,7 +110,7 @@ ov::element::Type Brgemm::get_output_type() const {
 }
 
 std::vector<ov::PartialShape> Brgemm::get_planar_input_shapes(const std::vector<ov::Input<ov::Node>>& inputs) const {
-    OPENVINO_ASSERT(inputs.size() == 2, "Brgemm::get_planar_input_shapes() expects 2 inputs");
+    assert(inputs.size() == 2 && "Brgemm::get_planar_input_shapes() expects 2 inputs");
     return { utils::get_planar_pshape(inputs[0]), utils::get_planar_pshape(inputs[1]) };
 }
 

src/common/snippets/src/op/loop.cpp

@@ -37,9 +37,9 @@ std::shared_ptr<Node> LoopBegin::clone_with_new_inputs(const OutputVector& input
 
 std::shared_ptr<LoopEnd> LoopBegin::get_loop_end() const {
     const auto& last_output_inputs = get_output_target_inputs(0);
-    OPENVINO_ASSERT(last_output_inputs.size() == 1, "LoopBegin has more than one inputs attached to the last output");
+    assert(last_output_inputs.size() == 1 && "LoopBegin has more than one inputs attached to the last output");
     const auto& loop_end = ov::as_type_ptr<LoopEnd>(last_output_inputs.begin()->get_node()->shared_from_this());
-    OPENVINO_ASSERT(loop_end != nullptr, "LoopBegin must have LoopEnd connected to its last output");
+    assert(loop_end != nullptr && "LoopBegin must have LoopEnd connected to its last output");
     return loop_end;
 }
 
@@ -110,7 +110,7 @@ std::shared_ptr<Node> LoopEnd::clone_with_new_inputs(const OutputVector& inputs)
 
 std::shared_ptr<LoopBegin> LoopEnd::get_loop_begin() {
     const auto& loop_begin = ov::as_type_ptr<LoopBegin>(get_input_source_output(get_input_size() - 1).get_node_shared_ptr());
-    OPENVINO_ASSERT(loop_begin != nullptr, "LoopEnd last input is not connected to LoopBegin");
+    assert(loop_begin != nullptr && "LoopEnd last input is not connected to LoopBegin");
     return loop_begin;
 }
 

src/common/snippets/src/op/memory_access.cpp

@@ -103,7 +103,7 @@ void MemoryAccess::set_output_port_descriptor(const PortDescriptor& desc, const
 
 const MemoryAccess::PortDescriptor& MemoryAccess::get_input_port_descriptor(const size_t i) const {
     const auto it = m_input_ports.find(i);
-    OPENVINO_ASSERT(it != m_input_ports.end(), "Index of input port descriptor should be less than count of input ports");
+    assert(it != m_input_ports.end() && "Index of input port descriptor should be less than count of input ports");
     return it->second;
 }
 
@@ -113,7 +113,7 @@ MemoryAccess::PortDescriptor& MemoryAccess::get_input_port_descriptor(const size
 
 const MemoryAccess::PortDescriptor& MemoryAccess::get_output_port_descriptor(const size_t i) const {
     const auto it = m_output_ports.find(i);
-    OPENVINO_ASSERT(it != m_output_ports.end(), "Index of output port descriptor should be less than count of output ports");
+    assert(it != m_output_ports.end() && "Index of output port descriptor should be less than count of output ports");
     return it->second;
 }
 

src/common/snippets/src/op/reg_spill.cpp

@@ -50,9 +50,9 @@ std::shared_ptr<Node> RegSpillBegin::clone_with_new_inputs(const OutputVector& i
 
 std::shared_ptr<RegSpillEnd> RegSpillBegin::get_reg_spill_end() const {
     const auto& last_output_inputs = get_output_target_inputs(0);
-    OPENVINO_ASSERT(last_output_inputs.size() == 1, "RegSpillBegin has more than one inputs attached to the last output");
+    assert(last_output_inputs.size() == 1 && "RegSpillBegin has more than one inputs attached to the last output");
     const auto& loop_end = ov::as_type_ptr<RegSpillEnd>(last_output_inputs.begin()->get_node()->shared_from_this());
-    OPENVINO_ASSERT(loop_end != nullptr, "RegSpillBegin must have RegSpillEnd connected to its last output");
+    assert(loop_end != nullptr && "RegSpillBegin must have RegSpillEnd connected to its last output");
     return loop_end;
 }
 

src/common/snippets/src/op/subgraph.cpp

@@ -559,7 +559,7 @@ snippets::Schedule Subgraph::generate(const void* compile_params) const {
 }
 
 const std::shared_ptr<RuntimeConfigurator>& Subgraph::get_runtime_configurator() const {
-    OPENVINO_ASSERT(m_generator, "Generator has not been inited!");
+    assert(m_generator && "Generator has not been inited!");
     return m_generator->get_target_machine()->get_runtime_configurator();
 }
 

src/common/snippets/src/pass/mha_tokenization.cpp

@@ -185,7 +185,7 @@ bool update_intermediate_supported_ops(std::shared_ptr<ov::Node>& interm_op, ov:
 }
 
 std::vector<int32_t> get_rank_equivalent_order(std::vector<int32_t> default_order, size_t rank) {
-    OPENVINO_ASSERT(rank > 2, "Incorrect order rank for Transpose tokenization");
+    assert(rank > 2 && "Incorrect order rank for Transpose tokenization");
     auto order = std::vector<int32_t>(rank);
     std::iota(order.begin(), order.end(), 0);
     const auto diff = static_cast<int32_t>(rank - default_order.size());

src/common/snippets/src/utils/utils.cpp

@@ -154,7 +154,7 @@ size_t get_dim_idx(const lowered::ExpressionPort& port, size_t dim_idx) {
 }
 
 int64_t get_stride(size_t dim_idx, const VectorDims& shape) {
-    OPENVINO_ASSERT(dim_idx < shape.size(), "dim_idx should be in range of [0, shape.size()) in get_stride");
+    assert(dim_idx < shape.size() && "dim_idx should be in range of [0, shape.size()) in get_stride");
     int64_t stride = 1;
     for (size_t i = dim_idx + 1; i < shape.size(); ++i) {
         if (utils::is_dynamic_value(shape[i])) {
@@ -203,7 +203,7 @@ VectorDims get_planar_vdims(const snippets::lowered::ExpressionPort& expr_port)
     return get_planar_vdims(expr_port.get_descriptor_ptr()->get_shape(), expr_port.get_descriptor_ptr()->get_layout());
 }
 VectorDims get_preordered_vdims(const snippets::lowered::ExpressionPort& expr_port) {
-    OPENVINO_ASSERT(expr_port.get_type() == snippets::lowered::ExpressionPort::Type::Output, "get_preordered_vdims expects Expression Output port");
+    assert(expr_port.get_type() == snippets::lowered::ExpressionPort::Type::Output && "get_preordered_vdims expects Expression Output port");
     return get_preordered_vdims(expr_port.get_descriptor_ptr()->get_shape(), expr_port.get_descriptor_ptr()->get_layout());
 }
 

src/plugins/intel_cpu/src/emitters/snippets/brgemm_generic.cpp

@@ -137,7 +137,7 @@ std::tuple<int64_t, int64_t, int64_t, float> BrgemmKernelExecutorHelper::get_run
     const auto& loop_ids = expr->get_loop_ids();
     const auto& loop_manager = linear_ir->get_loop_manager();
     auto get_loop_info = [&]() {
-        OPENVINO_ASSERT(loop_idx < loop_ids.size(), "Loop is missed");
+        assert(loop_idx < loop_ids.size() && "Loop is missed");
         return loop_manager->get_loop_info<ov::snippets::lowered::ExpandedLoopInfo>(loop_ids[loop_idx++]);
     };