Apply clang-format to batched scoring element and tests

Author: dylanneve1

src/plugins/intel_npu/src/plugin/npuw/llm_compiled_model.cpp

@@ -10,7 +10,6 @@
 #include "llm_compiled_model_utils.hpp"
 #include "llm_infer_request.hpp"
 #include "logging.hpp"
-#include "v1/elements/batched.hpp"
 #include "moe_transformations/apply_moe_device_routed_transforms.hpp"
 #include "npuw_transformations/add_position_ids_param.hpp"
 #include "npuw_transformations/convert_kvcache_to_precision.hpp"
@@ -45,6 +44,7 @@
 #include "serialization.hpp"
 #include "transformations/convert_precision.hpp"
 #include "util.hpp"
+#include "v1/elements/batched.hpp"
 #include "whisper/prepare_whisper_model.hpp"
 #include "whisper/whisper_infer_request.hpp"
 
@@ -1576,8 +1576,8 @@ std::shared_ptr<ov::ISyncInferRequest> ov::npuw::LLMCompiledModel::create_sync_i
         return non_const_this->create_whisper_infer_request();
     }
 
-    auto inner = m_is_embedding ? non_const_this->create_embedding_infer_request()
-                                : non_const_this->create_llm_infer_request();
+    auto inner =
+        m_is_embedding ? non_const_this->create_embedding_infer_request() : non_const_this->create_llm_infer_request();
 
     // Batched scoring: wrap the single-sequence request with the batched element so a
     // [N, ...] input is unrolled into N independent [1, ...] inferences (rows are scored

src/plugins/intel_npu/src/plugin/npuw/v1/elements/batched.cpp

@@ -28,11 +28,10 @@ bool has_batch_dim(const ov::SoPtr<ov::ITensor>& tensor) {
 
 }  // namespace
 
-ov::SoPtr<ov::ICompiledModel> ov::npuw::batched::CompiledModel::create(
-    const std::shared_ptr<ov::Model>& model,
-    const std::shared_ptr<const ov::IPlugin>& plugin,
-    ov::SoPtr<ov::ICompiledModel> inner_compiled,
-    bool enabled) {
+ov::SoPtr<ov::ICompiledModel> ov::npuw::batched::CompiledModel::create(const std::shared_ptr<ov::Model>& model,
+                                                                       const std::shared_ptr<const ov::IPlugin>& plugin,
+                                                                       ov::SoPtr<ov::ICompiledModel> inner_compiled,
+                                                                       bool enabled) {
     OPENVINO_ASSERT(inner_compiled._ptr != nullptr, "Batched compiled model requires an inner compiled model");
 
     // No-op wrapper: hand back the inner model unchanged for the zero-overhead path.

src/plugins/intel_npu/tests/unit/npuw/batched_element_test.cpp

@@ -60,8 +60,7 @@ class MockState : public ov::IVariableState {
     std::shared_ptr<Recorder> m_rec;
 };
 
-ov::Output<const ov::Node> port_named(const std::vector<ov::Output<const ov::Node>>& ports,
-                                      const std::string& needle) {
+ov::Output<const ov::Node> port_named(const std::vector<ov::Output<const ov::Node>>& ports, const std::string& needle) {
     for (const auto& port : ports) {
         if (port.get_any_name().find(needle) != std::string::npos) {
             return port;
@@ -253,8 +252,7 @@ TEST_F(NPUWBatchedElementTest, EachRowScoredIndependentlyAndStacked) {
     }
 
     // One inner inference per row, each preceded by a state reset, in order.
-    EXPECT_EQ(m_recorder->events,
-              (std::vector<std::string>{"reset", "infer", "reset", "infer", "reset", "infer"}));
+    EXPECT_EQ(m_recorder->events, (std::vector<std::string>{"reset", "infer", "reset", "infer", "reset", "infer"}));
 }
 
 TEST_F(NPUWBatchedElementTest, SingleRowScored) {
@@ -325,8 +323,7 @@ TEST_F(NPUWBatchedElementTest, SyncInnerConstructorScoresEachRow) {
     for (std::size_t r = 0; r < ids.size(); ++r) {
         EXPECT_FLOAT_EQ(row_value(out, r), static_cast<float>(ids[r].front())) << "output row " << r;
     }
-    EXPECT_EQ(m_recorder->events,
-              (std::vector<std::string>{"reset", "infer", "reset", "infer", "reset", "infer"}));
+    EXPECT_EQ(m_recorder->events, (std::vector<std::string>{"reset", "infer", "reset", "infer", "reset", "infer"}));
 }
 
 // A shared/broadcast input (batch 1) is fed to every row unsliced -- the slice guard only fires
@@ -346,8 +343,7 @@ TEST_F(NPUWBatchedElementTest, BroadcastInputSharedAcrossRows) {
     for (std::size_t r = 0; r < ids.size(); ++r) {
         EXPECT_FLOAT_EQ(row_value(out, r), static_cast<float>(ids[r].front())) << "output row " << r;
     }
-    EXPECT_EQ(m_recorder->events,
-              (std::vector<std::string>{"reset", "infer", "reset", "infer", "reset", "infer"}));
+    EXPECT_EQ(m_recorder->events, (std::vector<std::string>{"reset", "infer", "reset", "infer", "reset", "infer"}));
 }
 
 // Regression: a leading batch-1 input (here input_ids, shared) must not pin the batch to 1 when a
@@ -367,8 +363,7 @@ TEST_F(NPUWBatchedElementTest, BatchSizeFromNonLeadingInput) {
     for (std::size_t r = 0; r < 3; ++r) {
         EXPECT_FLOAT_EQ(row_value(out, r), 7.0f) << "output row " << r;  // input_ids broadcast to every row
     }
-    EXPECT_EQ(m_recorder->events,
-              (std::vector<std::string>{"reset", "infer", "reset", "infer", "reset", "infer"}));
+    EXPECT_EQ(m_recorder->events, (std::vector<std::string>{"reset", "infer", "reset", "infer", "reset", "infer"}));
 }
 
 // Each model output is stacked into its own [N, ...] tensor. The mock offsets output k by k, so the
@@ -393,8 +388,7 @@ TEST_F(NPUWBatchedElementTest, MultipleOutputsStackedIndependently) {
         EXPECT_FLOAT_EQ(row_value(score, r), static_cast<float>(ids[r].front()));
         EXPECT_FLOAT_EQ(row_value(hidden, r), static_cast<float>(ids[r].front()) + kOutputChannelOffset);
     }
-    EXPECT_EQ(m_recorder->events,
-              (std::vector<std::string>{"reset", "infer", "reset", "infer", "reset", "infer"}));
+    EXPECT_EQ(m_recorder->events, (std::vector<std::string>{"reset", "infer", "reset", "infer", "reset", "infer"}));
 }
 
 }  // namespace

src/plugins/intel_npu/tests/unit/npuw/llm_test_helpers.hpp

@@ -69,8 +69,7 @@ inline std::shared_ptr<ov::Model> build_dynamic_attention_llm_model() {
     for (const auto& input : model->inputs()) {
         const auto& name = input.get_any_name();
         const auto& pshape = input.get_partial_shape();
-        if (name.find("input_ids") != std::string::npos ||
-            name.find("token_type_ids") != std::string::npos) {
+        if (name.find("input_ids") != std::string::npos || name.find("token_type_ids") != std::string::npos) {
             new_shapes[name] = ov::PartialShape{1, kSeq};
         } else if (name.find("attention_mask") != std::string::npos) {
             new_shapes[name] = ov::PartialShape{1, kSeq + kPast};
@@ -129,8 +128,7 @@ inline std::shared_ptr<ov::Model> build_llm_test_model_with_kv_fake_convert(cons
         auto inject_fake_convert = [&](size_t input_idx, const std::string& suffix) {
             auto fake_convert_1 =
                 std::make_shared<ov::op::v13::FakeConvert>(sdpa->input_value(input_idx), scale, fake_convert_type);
-            auto fake_convert_2 =
-                std::make_shared<ov::op::v13::FakeConvert>(fake_convert_1, scale, fake_convert_type);
+            auto fake_convert_2 = std::make_shared<ov::op::v13::FakeConvert>(fake_convert_1, scale, fake_convert_type);
             fake_convert_1->set_friendly_name(sdpa->get_friendly_name() + "/" + suffix + "_1");
             fake_convert_2->set_friendly_name(sdpa->get_friendly_name() + "/" + suffix + "_2");
             sdpa->input(input_idx).replace_source_output(fake_convert_2);
@@ -280,8 +278,8 @@ class MockSubCompiledModel : public ov::npuw::ICompiledModel_v0 {
 };
 
 struct CompileCall {
-    std::string                friendly_name;
-    ov::AnyMap                 props;
+    std::string friendly_name;
+    ov::AnyMap props;
     std::shared_ptr<ov::Model> model;
 };