Fix code style

Author: slyalin

src/common/transformations/include/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.hpp

@@ -23,5 +23,6 @@ class PrevSequenceLengthPattern;
 class ov::pass::PrevSequenceLengthPattern : public ov::pass::MatcherPass {
 public:
     OPENVINO_RTTI("PrevSequenceLengthPattern", "0");
-    explicit PrevSequenceLengthPattern(const std::shared_ptr<ov::op::v1::Subtract>& prev_max_seq_len, std::shared_ptr<ov::Node>);
+    explicit PrevSequenceLengthPattern(const std::shared_ptr<ov::op::v1::Subtract>& prev_max_seq_len,
+                                       std::shared_ptr<ov::Node>);
 };

src/common/transformations/src/transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.cpp

@@ -5,21 +5,21 @@
 #include "transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.hpp"
 
 #include "openvino/cc/pass/itt.hpp"
+#include "openvino/core/validation_util.hpp"
 #include "openvino/op/gather.hpp"
-#include "openvino/op/shape_of.hpp"
 #include "openvino/op/reshape.hpp"
+#include "openvino/op/shape_of.hpp"
 #include "openvino/pass/pattern/op/wrap_type.hpp"
-#include "openvino/core/validation_util.hpp"
 #include "transformations/utils/utils.hpp"
 
 using namespace ov::op;
 
-
 ov::pass::PrevSequenceLengthPattern::PrevSequenceLengthPattern(
-    const std::shared_ptr<ov::op::v1::Subtract>& prev_max_seq_len, std::shared_ptr<ov::Node> batch_dim) {
+    const std::shared_ptr<ov::op::v1::Subtract>& prev_max_seq_len,
+    std::shared_ptr<ov::Node> batch_dim) {
     MATCHER_SCOPE(PrevSequenceLengthPattern);
-    // The transformation addresses two cases that look similar: (1) previous sequence length, (2) batch size in kv-cache state
-    // In first case it should replace it by prev_max_seq_len. For the second case, connect to batch_dim.
+    // The transformation addresses two cases that look similar: (1) previous sequence length, (2) batch size in
+    // kv-cache state In first case it should replace it by prev_max_seq_len. For the second case, connect to batch_dim.
 
     auto kv_past = pattern::wrap_type<v6::ReadValue>({pattern::any_input()});
     auto kv_gather = pattern::wrap_type<v8::Gather>({kv_past, pattern::any_input(), pattern::any_input()});
@@ -33,23 +33,26 @@ ov::pass::PrevSequenceLengthPattern::PrevSequenceLengthPattern(
         const auto& pattern_map = m.get_pattern_value_map();
         auto gather = m.get_match_root();
         auto gather_index = ov::util::get_constant_from_source(gather->input_value(1));
-        if(!gather_index) {
-            return false;   // cannot detect axis
+        if (!gather_index) {
+            return false;  // cannot detect axis
         }
         auto axis = gather_index->cast_vector<int64_t>().at(0);
         auto kv_init_shape = pattern_map.at(kv_past).get_node()->get_input_partial_shape(0);
         auto target_type = gather->get_output_element_type(0);
-        if(kv_init_shape[axis].is_static() && kv_init_shape[axis].get_length() == 0) {
+        if (kv_init_shape[axis].is_static() && kv_init_shape[axis].get_length() == 0) {
             // this is a sequence dimension based on how the initialization expression is build for stateful models
             std::shared_ptr<ov::Node> replacement;
             if (prev_max_seq_len->get_output_element_type(0) != target_type) {
                 replacement = std::make_shared<v0::Convert>(prev_max_seq_len, target_type);
             } else {
                 replacement = prev_max_seq_len;
             }
-            replace_node(gather, std::make_shared<v1::Reshape>(replacement, v0::Constant::create(element::i64, Shape{1}, {1}), false));
+            replace_node(
+                gather,
+                std::make_shared<v1::Reshape>(replacement, v0::Constant::create(element::i64, Shape{1}, {1}), false));
             return true;
-        } else {  // assumption that any other axis should point to batch dimension, precise reasoning is too complex (TODO)
+        } else {  // assumption that any other axis should point to batch dimension, precise reasoning is too complex
+                  // (TODO)
             // this is a batch dimension
             std::shared_ptr<ov::Node> replacement;
             if (batch_dim->get_output_element_type(0) != target_type) {

src/common/transformations/src/transformations/sdpa_to_paged_attention/state_management_pattern.cpp

@@ -120,12 +120,16 @@ ov::pass::StateManagementPattern::StateManagementPattern(ParameterVector& kv_par
     auto q = pattern::any_input();
     auto scale_input = pattern::any_input();
 
-    auto k_to_sdpa = std::make_shared<pattern::op::Or>(OutputVector{k_concat, k_shaped, k_shaped_transposed, k_simply_shaped});
-    auto v_to_sdpa = std::make_shared<pattern::op::Or>(OutputVector{v_concat, v_shaped, v_shaped_transposed, v_simply_shaped});
+    auto k_to_sdpa =
+        std::make_shared<pattern::op::Or>(OutputVector{k_concat, k_shaped, k_shaped_transposed, k_simply_shaped});
+    auto v_to_sdpa =
+        std::make_shared<pattern::op::Or>(OutputVector{v_concat, v_shaped, v_shaped_transposed, v_simply_shaped});
     auto mask_to_sdpa = std::make_shared<pattern::op::Or>(OutputVector{sdpa_mask, pattern::any_input()});
 
-    auto sdpa_with_4_inputs = pattern::wrap_type<v13::ScaledDotProductAttention>({q, k_to_sdpa, v_to_sdpa, mask_to_sdpa});
-    auto sdpa_with_5_inputs = pattern::wrap_type<v13::ScaledDotProductAttention>({q, k_to_sdpa, v_to_sdpa, mask_to_sdpa, scale_input});
+    auto sdpa_with_4_inputs =
+        pattern::wrap_type<v13::ScaledDotProductAttention>({q, k_to_sdpa, v_to_sdpa, mask_to_sdpa});
+    auto sdpa_with_5_inputs =
+        pattern::wrap_type<v13::ScaledDotProductAttention>({q, k_to_sdpa, v_to_sdpa, mask_to_sdpa, scale_input});
 
     auto sdpa_variants = std::make_shared<pattern::op::Or>(OutputVector{sdpa_with_4_inputs, sdpa_with_5_inputs});
 
@@ -157,13 +161,15 @@ ov::pass::StateManagementPattern::StateManagementPattern(ParameterVector& kv_par
         auto real_k = take_4d(k_current, k_current_reshaped, k_current2);
         auto real_v = take_4d(v_current, v_current_reshaped, v_current2);
 
-        auto sdpa_node =  pattern_map.at(pattern_map.count(sdpa_with_4_inputs) ? sdpa_with_4_inputs : sdpa_with_5_inputs).get_node();
+        auto sdpa_node =
+            pattern_map.at(pattern_map.count(sdpa_with_4_inputs) ? sdpa_with_4_inputs : sdpa_with_5_inputs).get_node();
         // E and Ev are from the SDPA specification at
         // https://docs.openvino.ai/2024/documentation/openvino-ir-format/operation-sets/operation-specs/sequence/scaled-dot-product-attention.html
         auto E = sdpa_node->get_input_tensor(1).get_partial_shape()[-1];
         auto Ev = sdpa_node->get_input_tensor(2).get_partial_shape()[-1];  // in common case may not match E
 
-        auto extract_num_kv_heads = [=, &pattern_map](std::shared_ptr<Node> unsqueeze, const Dimension& default_heads_num) {
+        auto extract_num_kv_heads = [=, &pattern_map](std::shared_ptr<Node> unsqueeze,
+                                                      const Dimension& default_heads_num) {
             // Deduce number of k/v heads from Unsqueeze-Broadcast-Reshape (UBR pattern, if present)
             // pattern that appears in case of MQA/GQA
             // In case if UBR pattern doesn't appear, the default number of heads is used passed as default_heads_num
@@ -197,8 +203,10 @@ ov::pass::StateManagementPattern::StateManagementPattern(ParameterVector& kv_par
             }
         };
 
-        auto num_k_heads = extract_num_kv_heads(k_heads_unsqueeze, sdpa_node->get_input_tensor(1).get_partial_shape()[-3]);
-        auto num_v_heads = extract_num_kv_heads(v_heads_unsqueeze, sdpa_node->get_input_tensor(1).get_partial_shape()[-3]);
+        auto num_k_heads =
+            extract_num_kv_heads(k_heads_unsqueeze, sdpa_node->get_input_tensor(1).get_partial_shape()[-3]);
+        auto num_v_heads =
+            extract_num_kv_heads(v_heads_unsqueeze, sdpa_node->get_input_tensor(1).get_partial_shape()[-3]);
         const ov::element::Type kv_cache_type = real_q.get_element_type();
         std::string layer_index_str = std::to_string(layer_index);
         auto k_parameter = setName(std::make_shared<v0::Parameter>(kv_cache_type, PartialShape{-1, num_k_heads, E}),
@@ -243,12 +251,12 @@ ov::pass::StateManagementPattern::StateManagementPattern(ParameterVector& kv_par
                                                        v0::Constant::create(element::i64, Shape{}, {-1}),
                                                        v0::Constant::create(element::i64, Shape{}, {0}));
         std::shared_ptr<ov::Node> scale;
-        if(pattern_map.count(scale_input)) {
+        if (pattern_map.count(scale_input)) {
             scale = pattern_map.at(scale_input).get_node_shared_ptr();
         } else {
             // most likely `scale` below will always be a constant in real inference, but dynamic dimension
-            // propagation may not always derive it as a constant. That's why a sub-graph computing `scale` is built instead
-            // of just a constant node representing one of the dimensions.
+            // propagation may not always derive it as a constant. That's why a sub-graph computing `scale` is built
+            // instead of just a constant node representing one of the dimensions.
             scale = std::make_shared<v1::Divide>(
                 v0::Constant::create(element::f32, Shape{}, {1}),
                 std::make_shared<v0::Sqrt>(std::make_shared<v0::Convert>(hidden_dim, element::f32)));

src/core/src/pass/sdpa_to_paged_attention.cpp

@@ -7,9 +7,9 @@
 #include "openvino/cc/pass/itt.hpp"
 #include "openvino/op/constant.hpp"
 #include "openvino/op/gather.hpp"
+#include "openvino/op/shape_of.hpp"
 #include "openvino/op/unsqueeze.hpp"
 #include "openvino/pass/manager.hpp"
-#include "openvino/op/shape_of.hpp"
 #include "transformations/sdpa_to_paged_attention/position_ids_replacer.hpp"
 #include "transformations/sdpa_to_paged_attention/prev_sequence_length_pattern.hpp"
 #include "transformations/sdpa_to_paged_attention/state_management_pattern.hpp"
@@ -82,7 +82,8 @@ bool ov::pass::SDPAToPagedAttention::run_on_model(const std::shared_ptr<ov::Mode
 
     int layer_index = 0;
 
-    auto batch_dim = std::make_shared<v3::ShapeOf>(position_ids);   // it is not always required, so will be disposed if not needed
+    auto batch_dim =
+        std::make_shared<v3::ShapeOf>(position_ids);  // it is not always required, so will be disposed if not needed
 
     ov::pass::Manager manager;
     manager.set_per_pass_validation(false);