[Snippets] LoopManager: error-prone code is removed

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

@@ -46,10 +46,6 @@ class LoopInfo : public std::enable_shared_from_this<LoopInfo> {
              size_t increment,
              const std::vector<LoopPort>& entries,
              const std::vector<LoopPort>& exits);
-    LoopInfo(size_t work_amount,
-             size_t increment,
-             const std::vector<ExpressionPort>& entries,
-             const std::vector<ExpressionPort>& exits);
     virtual ~LoopInfo() = default;
 
     /**
@@ -127,11 +123,6 @@ class LoopInfo : public std::enable_shared_from_this<LoopInfo> {
      * @param increment - step of loop counter increment
      */
     void set_increment(size_t increment);
-    /**
-     * @brief Sets `dim_idx` to all input and output ports
-     * @param dim_idx - index
-     */
-    void set_dim_idx(size_t dim_idx);
 
     /**
      * @brief Replace the current LoopPort `actual_port` with new `target_ports`
@@ -254,12 +245,6 @@ class UnifiedLoopInfo : public LoopInfo {
                     const std::vector<LoopPort>& entries,
                     const std::vector<LoopPort>& exits,
                     SpecificIterationHandlers handlers = SpecificIterationHandlers());
-    UnifiedLoopInfo(size_t work_amount,
-                    size_t increment,
-                    const std::vector<ExpressionPort>& entries,
-                    const std::vector<ExpressionPort>& exits,
-
-                    SpecificIterationHandlers handlers = SpecificIterationHandlers());
 
     /**
      * @brief Clone LoopInfo with new Expressions

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

@@ -80,80 +80,36 @@ class LoopManager {
     static std::vector<size_t> get_common_outer_loops(const std::vector<ExpressionPtr>& exprs);
 
     /**
-     * @brief Create new LoopInfo and mark all expressions in loop bounds by new loop ID
+     * @brief Automatically marks new loops, number of which is defined by `loop_depth` parameter.
+     * Loop increments for the most inner loop is defined by `vector_size` parameter.
+     * The increment for the rest loops is equal to 1.
      * @param loop_begin_pos the first expression iterator
      * @param loop_end_pos the next iterator after last expression
      * @param loop_depth count of loops for marking
-     * @param vector_size increment of loop
+     * @param vector_size increment of most-inner loop
      */
     void mark_loop(LinearIR::constExprIt loop_begin_pos,
                    LinearIR::constExprIt loop_end_pos,
                    size_t loop_depth,
                    size_t vector_size);
     /**
-     * @brief Create new UnifiedLoopInfo and mark all expressions in loop bounds by new loop ID with more manual
-     * parameters
+     * @brief Creates new UnifiedLoopInfo and marks all expressions in loop bounds by new loop ID.
      * @param loop_begin_pos the first expression iterator
      * @param loop_end_pos the next iterator after last expression
      * @param work_amount work amount of the loop
      * @param increment the step of loop counter increment
      * @param entries input loop ports
      * @param exits output loop ports
-     * @param set_default_handlers flag defines whether it is needed to set default set of SpecificIterationHandlers or
-     * not
+     * @param set_default_handlers defines whether default set of SpecificIterationHandlers should be set
      * @return new loop ID
      */
-    template <typename T>
     size_t mark_loop(LinearIR::constExprIt loop_begin_pos,
                      LinearIR::constExprIt loop_end_pos,
                      size_t work_amount,
                      size_t increment,
-                     const std::vector<T>& entries,
-                     const std::vector<T>& exits,
-                     bool set_default_handlers = true) {
-        const auto normalized_increment =
-            utils::is_dynamic_value(work_amount) || work_amount == 0 ? increment : std::min(increment, work_amount);
-        const auto loop_info = std::make_shared<UnifiedLoopInfo>(work_amount, normalized_increment, entries, exits);
-        if (set_default_handlers) {
-            loop_info->set_handlers(
-                SpecificIterationHandlers(work_amount, normalized_increment, loop_info->get_dim_idx()));
-        }
-
-        const auto loop_id = this->add_loop_info(loop_info);
-        for (auto expr_it = loop_begin_pos; expr_it != loop_end_pos; ++expr_it) {
-            insert_loop_id(*expr_it, loop_id);
-        }
-        return loop_id;
-    }
-    /**
-     * @brief Create new UnifiedLoopInfo and mark all expressions in loop bounds by new loop ID with more manual
-     * parameters
-     * @param loop_begin_pos the first expression iterator
-     * @param loop_end_pos the next iterator after last expression
-     * @param work_amount work amount of the loop
-     * @param increment the step of loop counter increment
-     * @param dim_idx loop iterates by this index of dimension
-     * @param entries input loop ports
-     * @param exits output loop ports
-     * @param set_default_handlers flag defines whether it is needed to set default set of SpecificIterationHandlers or
-     *                             not
-     * @return new loop ID
-     */
-    template <typename T>
-    size_t mark_loop(LinearIR::constExprIt loop_begin_pos,
-                     LinearIR::constExprIt loop_end_pos,
-                     size_t work_amount,
-                     size_t increment,
-                     size_t dim_idx,
-                     const std::vector<T>& entries,
-                     const std::vector<T>& exits,
-                     bool set_default_handlers = true) {
-        const auto loop_id =
-            mark_loop(loop_begin_pos, loop_end_pos, work_amount, increment, entries, exits, set_default_handlers);
-        const auto loop_info = get_loop_info<UnifiedLoopInfo>(loop_id);
-        loop_info->set_dim_idx(dim_idx);
-        return loop_id;
-    }
+                     const std::vector<LoopPort>& entries,
+                     const std::vector<LoopPort>& exits,
+                     bool set_default_handlers = true);
     /**
      * @brief Create new Loop and replace with it: add new LoopInfo, update loop IDs in expressions and
      *        remove the old LoopInfo from the map if no one expression isn't mark by this `old_id`

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

@@ -34,7 +34,7 @@ class LoopPort {
 
     template <LoopPort::Type T,
               std::enable_if_t<utils::any_of(T, Type::Incremented, Type::NotIncremented), bool> = true>
-    static LoopPort create(const ExpressionPort& port, size_t dim_idx = 0) {
+    static LoopPort create(const ExpressionPort& port, size_t dim_idx) {
         return {port, dim_idx, T};
     }
 

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

@@ -37,22 +37,6 @@ LoopInfo::LoopInfo(size_t work_amount,
       m_input_ports(entries),
       m_output_ports(exits) {}
 
-LoopInfo::LoopInfo(size_t work_amount,
-                   size_t increment,
-                   const std::vector<ExpressionPort>& entries,
-                   const std::vector<ExpressionPort>& exits)
-    : m_work_amount(work_amount),
-      m_increment(increment) {
-    m_input_ports.reserve(entries.size());
-    m_output_ports.reserve(exits.size());
-    for (const auto& port : entries) {
-        m_input_ports.push_back(LoopPort::create<LoopPort::Type::Incremented>(port));
-    }
-    for (const auto& port : exits) {
-        m_output_ports.push_back(LoopPort::create<LoopPort::Type::Incremented>(port));
-    }
-}
-
 bool LoopInfo::is_dynamic() const {
     return utils::is_dynamic_value(m_work_amount) || utils::is_dynamic_value(m_increment);
 }
@@ -123,16 +107,6 @@ void LoopInfo::set_increment(size_t increment) {
     m_increment = increment;
 }
 
-void LoopInfo::set_dim_idx(size_t dim_idx) {
-    auto setter = [dim_idx](LoopPort& port) {
-        if (port.is_processed()) {
-            port.set_dim_idx(dim_idx);
-        }
-    };
-    std::for_each(m_input_ports.begin(), m_input_ports.end(), setter);
-    std::for_each(m_output_ports.begin(), m_output_ports.end(), setter);
-}
-
 template <>
 std::vector<LoopPort>::iterator LoopInfo::find_loop_port(const LoopPort& loop_port) {
     auto& ports = loop_port.get_expr_port()->get_type() == ExpressionPort::Input ? m_input_ports : m_output_ports;
@@ -262,18 +236,6 @@ UnifiedLoopInfo::UnifiedLoopInfo(size_t work_amount,
     sort_ports();
 }
 
-UnifiedLoopInfo::UnifiedLoopInfo(size_t work_amount,
-                                 size_t increment,
-                                 const std::vector<ExpressionPort>& entries,
-                                 const std::vector<ExpressionPort>& exits,
-                                 SpecificIterationHandlers handlers)
-    : LoopInfo(work_amount, increment, entries, exits),
-      m_handlers(std::move(handlers)),
-      m_input_port_descs(std::vector<LoopPortDesc>(entries.size())),
-      m_output_port_descs(std::vector<LoopPortDesc>(exits.size())) {
-    sort_ports();
-}
-
 UnifiedLoopInfo::UnifiedLoopInfo(size_t work_amount,
                                  size_t increment,
                                  const std::vector<LoopPort>& entries,

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

@@ -245,8 +245,36 @@ void LoopManager::mark_loop(LinearIR::constExprIt loop_begin_pos,
         OPENVINO_ASSERT(dim_idx < loop_tensor.size(), "Incorrect indexes of Loop for markup");
         const auto work_amount = *(loop_tensor.rbegin() + dim_idx);
         const auto increment = subtensor_value;
-        mark_loop(loop_begin_pos, loop_end_pos, work_amount, increment, dim_idx, loop_input_ports, loop_output_ports);
+        std::vector<LoopPort> entries, exits;
+        for (const auto& port : loop_input_ports) {
+            entries.push_back(LoopPort::create<LoopPort::Type::Incremented>(port, dim_idx));
+        }
+        for (const auto& port : loop_output_ports) {
+            exits.push_back(LoopPort::create<LoopPort::Type::Incremented>(port, dim_idx));
+        }
+        mark_loop(loop_begin_pos, loop_end_pos, work_amount, increment, entries, exits);
+    }
+}
+
+size_t LoopManager::mark_loop(LinearIR::constExprIt loop_begin_pos,
+                              LinearIR::constExprIt loop_end_pos,
+                              size_t work_amount,
+                              size_t increment,
+                              const std::vector<LoopPort>& entries,
+                              const std::vector<LoopPort>& exits,
+                              bool set_default_handlers) {
+    const auto normalized_increment =
+        utils::is_dynamic_value(work_amount) || work_amount == 0 ? increment : std::min(increment, work_amount);
+    const auto loop_info = std::make_shared<UnifiedLoopInfo>(work_amount, normalized_increment, entries, exits);
+    if (set_default_handlers) {
+        loop_info->set_handlers(SpecificIterationHandlers(work_amount, normalized_increment, loop_info->get_dim_idx()));
     }
+
+    const auto loop_id = this->add_loop_info(loop_info);
+    for (auto expr_it = loop_begin_pos; expr_it != loop_end_pos; ++expr_it) {
+        insert_loop_id(*expr_it, loop_id);
+    }
+    return loop_id;
 }
 
 size_t LoopManager::replace_with_new_loop(const LinearIR& linear_ir,

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

@@ -150,8 +150,8 @@ bool BrgemmBlockingBase::mark_blocking_loops(LinearIR& linear_ir,
     }
     if (!is_full_dim_value(n_block)) {
         const std::vector<LoopPort> entries{LoopPort::create<PortType::NotProcessed>(brgemm_expr->get_input_port(0)),
-                                            LoopPort::create<PortType::Incremented>(brgemm_expr->get_input_port(1))};
-        const std::vector<LoopPort> exits{LoopPort::create<PortType::Incremented>(brgemm_expr->get_output_port(0))};
+                                            LoopPort::create<PortType::Incremented>(brgemm_expr->get_input_port(1), 0)};
+        const std::vector<LoopPort> exits{LoopPort::create<PortType::Incremented>(brgemm_expr->get_output_port(0), 0)};
         mark_n_blocking(loop_manager, brgemm_it, std::next(brgemm_it), entries, exits, n_block);
     }
     if (!is_full_dim_value(m_block)) {

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

@@ -22,6 +22,7 @@
 #include "snippets/lowered/linear_ir.hpp"
 #include "snippets/lowered/loop_info.hpp"
 #include "snippets/lowered/loop_manager.hpp"
+#include "snippets/lowered/loop_port.hpp"
 #include "snippets/lowered/pass/iter_handler.hpp"
 #include "snippets/lowered/pass/pass.hpp"
 #include "snippets/lowered/specific_loop_iter_types.hpp"
@@ -112,9 +113,9 @@ bool ReduceDecomposition::run(LinearIR& linear_ir, LinearIR::constExprIt begin,
             expr_it,
             work_amount,
             increment,
-            0,
-            std::vector<ExpressionPort>{(*fill.first)->get_input_port(0), (*accumulation.first)->get_input_port(1)},
-            std::vector<ExpressionPort>{(*accumulation.first)->get_output_port(0)});
+            {LoopPort::create<LoopPort::Type::Incremented>((*fill.first)->get_input_port(0), 0),
+             LoopPort::create<LoopPort::Type::Incremented>((*accumulation.first)->get_input_port(1), 0)},
+            {LoopPort::create<LoopPort::Type::Incremented>((*accumulation.first)->get_output_port(0), 0)});
         const auto tail_size = utils::is_dynamic_value(work_amount) ? 1LU : work_amount % increment;
         if (tail_size != 0) {
             const auto loop_info = loop_manager->get_loop_info<UnifiedLoopInfo>(reduce_loop_id);

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

@@ -103,7 +103,6 @@ void SplitLoops::split(LinearIR& linear_ir, size_t loop_to_split_id, size_t oute
                                                        loop_end,
                                                        inner_loop_info->get_work_amount(),
                                                        outer_increment,
-                                                       inner_loop_info->get_dim_idx(),
                                                        inner_loop_info->get_input_ports(),
                                                        inner_loop_info->get_output_ports(),
                                                        false);