whispercpp 1.3.6 → 1.3.8

data/ext/sources/ggml/src/ggml-openvino/openvino/op/unary_softplus.cpp

@@ -0,0 +1,38 @@
+#include "../node_context.h"
+#include "../op_table.h"
+#include "../utils.h"
+
+#include <openvino/op/abs.hpp>
+#include <openvino/op/add.hpp>
+#include <openvino/op/constant.hpp>
+#include <openvino/op/exp.hpp>
+#include <openvino/op/log.hpp>
+#include <openvino/op/negative.hpp>
+#include <openvino/op/relu.hpp>
+
+namespace ov {
+namespace frontend {
+namespace ggml {
+namespace op {
+
+OutputVector translate_unary_softplus(const NodeContext & context) {
+    num_inputs_check(context, 1, 1);
+
+    auto input = process_view_input_new(context, 0);
+    const auto element_type = input.get_element_type();
+    auto one = ov::op::v0::Constant::create(element_type, ov::Shape{}, {1.0f});
+
+    auto positive = std::make_shared<ov::op::v0::Relu>(input);
+    auto abs = std::make_shared<ov::op::v0::Abs>(input);
+    auto neg_abs = std::make_shared<ov::op::v0::Negative>(abs);
+    auto exp_neg_abs = std::make_shared<ov::op::v0::Exp>(neg_abs);
+    auto log_term = std::make_shared<ov::op::v0::Log>(std::make_shared<ov::op::v1::Add>(one, exp_neg_abs));
+    auto res = std::make_shared<ov::op::v1::Add>(positive, log_term);
+
+    return rename_outputs_with_suffix({res}, context.get_name());
+}
+
+}  // namespace op
+}  // namespace ggml
+}  // namespace frontend
+}  // namespace ov

data/ext/sources/ggml/src/ggml-openvino/openvino/op/view.cpp

@@ -1,6 +1,11 @@
 #include "../op_table.h"
 #include "../utils.h"
+
+#include <openvino/op/constant.hpp>
 #include <openvino/op/reshape.hpp>
+#include <openvino/op/slice.hpp>
+#include <set>
+
 namespace ov {
 namespace frontend {
 namespace ggml {
@@ -9,42 +14,102 @@ namespace op {
 OutputVector translate_view(const NodeContext & context) {
     num_inputs_check(context, 1, 1);
 
-    if (context.get_op_case() == 2) {
-        auto dst_shape = context.get_output_shape().to_shape();
-        return rename_outputs_with_suffix({process_view_input(context, 0, dst_shape[2] * dst_shape[3])},
-                                          context.get_name());
+    if (!context.is_static()) {
+        return {context.get_input(0)};
     }
-    // op_case 3
-    if (context.get_op_case() == 3) {
-        auto input = context.get_input(0);
-        auto input_ov_shape = input.get_partial_shape();
 
-        auto input_llama_shape = context.get_input_shape(0).to_shape();
+    auto input = context.get_input(0);
+    auto src_shape = context.get_input_shape(0);
+    auto dst_shape = context.get_output_shape();
+
+    if (src_shape.rank().is_dynamic() || dst_shape.rank().is_dynamic()) {
+        return {input};
+    }
 
-        // if the input ov shape size is different from the input llama shape size, it means the input is already reshaped and we need to reshape it back to the original shape before slicing
-        if (input_ov_shape.size() != input_llama_shape.size()) {
-            input = std::make_shared<ov::op::v1::Reshape>(input, ov::op::v0::Constant::create(ov::element::i64, {input_llama_shape.size()}, input_llama_shape), false);
+    int64_t src_elems = 1, dst_elems = 1;
+    for (int64_t i = 0; i < src_shape.rank().get_length(); ++i) {
+        if (src_shape[i].is_dynamic()) {
+            return {input};
         }
+        src_elems *= src_shape[i].get_length();
+    }
+    for (int64_t i = 0; i < dst_shape.rank().get_length(); ++i) {
+        if (dst_shape[i].is_dynamic()) {
+            return {input};
+        }
+        dst_elems *= dst_shape[i].get_length();
+    }
 
-        auto dst_shape = context.get_output_shape().to_shape();
+    if (dst_elems >= src_elems) {
+        return {input};
+    }
+
+    auto src_stride = context.get_input_stride(0);
+    auto dst_stride = context.get_output_stride();
+    size_t view_offset = context.get_output_op_offset();
 
-        // find the index of dst_shape that is different from input shape, and use that index to slice the input
-        int slice_dim = -1;
-        for (size_t i = 0; i < dst_shape.size(); ++i) {
-            if (dst_shape[i] != input_llama_shape[i]) {
-                slice_dim = i;
+    bool same_stride = (src_stride.size() == dst_stride.size());
+    if (same_stride) {
+        for (size_t i = 0; i < src_stride.size(); ++i) {
+            if (src_stride[i] != dst_stride[i]) {
+                same_stride = false;
                 break;
             }
         }
+    }
 
-        auto begin = ov::op::v0::Constant::create(ov::element::i64, {1}, {0});
-        auto end = ov::op::v0::Constant::create(ov::element::i64, {1}, {dst_shape[slice_dim]});
-        auto stride = ov::op::v0::Constant::create(ov::element::i64, {1}, {1});
-        auto axes = ov::op::v0::Constant::create(ov::element::i64, {1}, {slice_dim});
-        auto sliced = std::make_shared<ov::op::v8::Slice>(input, begin, end, stride, axes);
-        return {sliced};
+    if (!same_stride) {
+        return {input};
     }
-    return {context.get_input(0)};
+
+    auto src_ov_shape = src_shape.to_shape();
+    auto dst_ov_shape = dst_shape.to_shape();
+    size_t ndims = src_ov_shape.size();
+    if (dst_ov_shape.size() != ndims) {
+        return {input};
+    }
+
+    std::vector<int> diff_dims;
+    for (size_t i = 0; i < ndims; ++i) {
+        if (src_ov_shape[i] != dst_ov_shape[i]) {
+            diff_dims.push_back(static_cast<int>(i));
+        }
+    }
+
+    if (diff_dims.size() != 1) {
+        return {input};
+    }
+
+    int slice_dim = diff_dims[0];
+    int64_t dim_size = static_cast<int64_t>(src_ov_shape[slice_dim]);
+
+    size_t ov_stride_for_dim = 1;
+    for (size_t i = slice_dim + 1; i < ndims; ++i) {
+        ov_stride_for_dim *= src_ov_shape[i];
+    }
+    size_t elem_size = src_stride.back();
+    if (elem_size == 0) {
+        elem_size = 1;
+    }
+
+    int64_t begin_val = 0;
+    if (ov_stride_for_dim > 0 && elem_size > 0) {
+        begin_val = static_cast<int64_t>((view_offset / elem_size) / ov_stride_for_dim);
+    }
+    int64_t end_val = begin_val + static_cast<int64_t>(dst_ov_shape[slice_dim]);
+
+    if (begin_val < 0 || end_val > dim_size) {
+        return {input};
+    }
+
+    auto sliced =
+        std::make_shared<ov::op::v8::Slice>(input, ov::op::v0::Constant::create(ov::element::i64, {1}, {begin_val}),
+                                            ov::op::v0::Constant::create(ov::element::i64, {1}, {end_val}),
+                                            ov::op::v0::Constant::create(ov::element::i64, {1}, {1}),
+                                            ov::op::v0::Constant::create(ov::element::i64, {1}, {slice_dim}));
+
+    sliced->set_friendly_name(context.get_output_name());
+    return {sliced->output(0)};
 }
 
 }  // namespace op

data/ext/sources/ggml/src/ggml-openvino/openvino/op_table.cpp

@@ -5,9 +5,11 @@
 #include <openvino/op/add.hpp>
 #include <openvino/op/divide.hpp>
 #include <openvino/op/gather.hpp>
+#include <openvino/op/gelu.hpp>
 #include <openvino/op/matmul.hpp>
 #include <openvino/op/multiply.hpp>
 #include <openvino/op/subtract.hpp>
+#include <openvino/op/tanh.hpp>
 
 namespace ov {
 namespace frontend {
@@ -16,28 +18,45 @@ namespace ggml {
 std::unordered_map<std::string, CreatorFunction> get_supported_ops() {
     using namespace ov::op;
     return {
-        {"GGML_OP_ADD",            op::translate_1to1_match_2_inputs<v1::Add>     },
-        {"GGML_OP_ADD1",           op::translate_1to1_match_2_inputs<v1::Add>     },
-        {"GGML_OP_CONT",           op::translate_cont                             },
-        {"GGML_OP_DIV",            op::translate_1to1_match_2_inputs<v1::Divide>  },
-        {"GGML_OP_GET_ROWS",       op::translate_get_rows                         },
-        {"GGML_OP_MUL",            op::translate_1to1_match_2_inputs<v1::Multiply>},
-        {"GGML_OP_MUL_MAT",        op::translate_mulmat                           },
-        {"GGML_OP_PERMUTE",        op::translate_permute                          },
-        {"GGML_OP_RESHAPE",        op::translate_reshape                          },
-        {"GGML_OP_RMS_NORM",       op::translate_rms_norm                         },
-        {"GGML_OP_ROPE",           op::translate_rope                             },
-        {"GGML_OP_SCALE",          op::translate_scale                            },
-        {"GGML_OP_SOFT_MAX",       op::translate_soft_max                         },
-        {"GGML_OP_SUB",            op::translate_1to1_match_2_inputs<v1::Subtract>},
-        {"GGML_OP_TRANSPOSE",      op::translate_transpose                        },
-        {"GGML_UNARY_OP_SILU",     op::translate_unary_silu                       },
-        {"GGML_OP_VIEW",           op::translate_view                             },
-        {"GGML_GLU_OP_SWIGLU",     op::translate_glu_swiglu                       },
-        {"GGML_GLU_OP_GEGLU",      op::translate_glu_geglu                        },
-        {"GGML_OP_SET_ROWS",       op::translate_set_rows                         },
-        {"GGML_OP_CPY",            op::translate_cpy                              },
-        {"GGML_OP_FLASH_ATTN_EXT", op::translate_flash_attn_ext                   },
+        {"GGML_OP_ADD",             op::translate_1to1_match_2_inputs<v1::Add>     },
+        {"GGML_OP_ADD1",            op::translate_1to1_match_2_inputs<v1::Add>     },
+        {"GGML_OP_ADD_ID",          op::translate_add_id                           },
+        {"GGML_OP_CONCAT",          op::translate_concat                           },
+        {"GGML_OP_CONT",            op::translate_cont                             },
+        {"GGML_OP_DIV",             op::translate_div                              },
+        {"GGML_OP_GET_ROWS",        op::translate_get_rows                         },
+        {"GGML_OP_IM2COL",          op::translate_im2col                           },
+        {"GGML_OP_MUL",             op::translate_1to1_match_2_inputs<v1::Multiply>},
+        {"GGML_OP_MUL_MAT",         op::translate_mulmat                           },
+        {"GGML_OP_MUL_MAT_ID",      op::translate_mul_mat_id                       },
+        {"GGML_OP_PERMUTE",         op::translate_permute                          },
+        {"GGML_OP_RESHAPE",         op::translate_reshape                          },
+        {"GGML_OP_RMS_NORM",        op::translate_rms_norm                         },
+        {"GGML_OP_NORM",            op::translate_norm                             },
+        {"GGML_OP_L2_NORM",         op::translate_l2_norm                          },
+        {"GGML_OP_SUM_ROWS",        op::translate_sum_rows                         },
+        {"GGML_OP_ROPE",            op::translate_rope                             },
+        {"GGML_OP_SCALE",           op::translate_scale                            },
+        {"GGML_OP_SOFT_MAX",        op::translate_soft_max                         },
+        {"GGML_OP_ARGSORT",         op::translate_argsort                          },
+        {"GGML_OP_SUB",             op::translate_1to1_match_2_inputs<v1::Subtract>},
+        {"GGML_OP_TRANSPOSE",       op::translate_transpose                        },
+        {"GGML_UNARY_OP_GELU",      op::translate_1to1_match_1_input<v7::Gelu>     },
+        {"GGML_UNARY_OP_SILU",      op::translate_unary_silu                       },
+        {"GGML_UNARY_OP_SOFTPLUS",  op::translate_unary_softplus                   },
+        {"GGML_UNARY_OP_TANH",      op::translate_1to1_match_1_input<v0::Tanh>     },
+        {"GGML_OP_VIEW",            op::translate_view                             },
+        {"GGML_GLU_OP_SWIGLU",      op::translate_glu_swiglu                       },
+        {"GGML_GLU_OP_SWIGLU_OAI",  op::translate_glu_swiglu_oai                   },
+        {"GGML_GLU_OP_GEGLU",       op::translate_glu_geglu                        },
+        {"GGML_OP_SET_ROWS",        op::translate_set_rows                         },
+        {"GGML_OP_CPY",             op::translate_cpy                              },
+        {"GGML_OP_FLASH_ATTN_EXT",  op::translate_flash_attn_ext                   },
+        {"GGML_OP_CLAMP",           op::translate_clamp                            },
+        {"GGML_OP_PAD",             op::translate_pad                              },
+        {"GGML_OP_SSM_CONV",        op::translate_ssm_conv                         },
+        {"GGML_OP_GATED_DELTA_NET", op::translate_gated_delta_net                  },
+        {"GGML_OP_REPEAT",          op::translate_repeat                           },
     };
 }
 

data/ext/sources/ggml/src/ggml-openvino/openvino/op_table.h

@@ -8,29 +8,43 @@ namespace ggml {
 
 namespace op {
 
-#define GGML_OP_CONVERTER(op) OutputVector op(const NodeContext& context)
+#define GGML_OP_CONVERTER(op) OutputVector op(const NodeContext & context)
 
-GGML_OP_CONVERTER(translate_add);
 GGML_OP_CONVERTER(translate_cont);
+GGML_OP_CONVERTER(translate_concat);
+GGML_OP_CONVERTER(translate_add_id);
+GGML_OP_CONVERTER(translate_div);
 GGML_OP_CONVERTER(translate_get_rows);
-GGML_OP_CONVERTER(translate_mul);
+GGML_OP_CONVERTER(translate_im2col);
 GGML_OP_CONVERTER(translate_mulmat);
+GGML_OP_CONVERTER(translate_mul_mat_id);
 GGML_OP_CONVERTER(translate_permute);
 GGML_OP_CONVERTER(translate_reshape);
 GGML_OP_CONVERTER(translate_rms_norm);
+GGML_OP_CONVERTER(translate_norm);
+GGML_OP_CONVERTER(translate_l2_norm);
+GGML_OP_CONVERTER(translate_sum_rows);
 GGML_OP_CONVERTER(translate_rope);
 GGML_OP_CONVERTER(translate_scale);
 GGML_OP_CONVERTER(translate_unary_silu);
+GGML_OP_CONVERTER(translate_unary_softplus);
 GGML_OP_CONVERTER(translate_soft_max);
 GGML_OP_CONVERTER(translate_transpose);
 GGML_OP_CONVERTER(translate_view);
 GGML_OP_CONVERTER(translate_glu_swiglu);
+GGML_OP_CONVERTER(translate_glu_swiglu_oai);
 GGML_OP_CONVERTER(translate_glu_geglu);
 GGML_OP_CONVERTER(translate_set_rows);
 GGML_OP_CONVERTER(translate_cpy);
+GGML_OP_CONVERTER(translate_argsort);
 GGML_OP_CONVERTER(translate_flash_attn_ext);
+GGML_OP_CONVERTER(translate_clamp);
+GGML_OP_CONVERTER(translate_pad);
+GGML_OP_CONVERTER(translate_ssm_conv);
+GGML_OP_CONVERTER(translate_gated_delta_net);
+GGML_OP_CONVERTER(translate_repeat);
 
-} // namespace op
+}  // namespace op
 
 std::unordered_map<std::string, CreatorFunction> get_supported_ops();
 

data/ext/sources/ggml/src/ggml-openvino/openvino/pass/mark_decompression_convert_constant_folding.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "mark_decompression_convert_constant_folding.h"
-#include "openvino/pass/matcher_pass.hpp"
 #include "openvino/core/visibility.hpp"
+#include "openvino/pass/matcher_pass.hpp"
 
 #ifdef OPENVINO_STATIC_LIBRARY
 #    define TRANSFORMATIONS_API

data/ext/sources/ggml/src/ggml-openvino/openvino/rt_info/weightless_caching_attributes.hpp

@@ -0,0 +1,41 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <openvino/core/core_visibility.hpp>
+#include <openvino/core/node.hpp>
+#include <openvino/core/runtime_attribute.hpp>
+
+namespace ov {
+
+/**
+ * @brief Holds weightless caching attributes of a single constant.
+ *
+ * WeightlessCacheAttribute class represents runtime info attribute that holds
+ * the values of original size of the constant in bytes and the binary offset of the
+ * constant's data in the weights file used by the weightless caching mechanism. It's
+ * not copyable in case the data was changed (the original node was replaced by a new
+ * one produced during the tranformation pipeline) - in that case weightless caching
+ * can't be used for that constant.
+ */
+class OPENVINO_API WeightlessCacheAttribute : public RuntimeAttribute {
+public:
+    OPENVINO_RTTI("WeightlessCacheAttribute", "0", RuntimeAttribute)
+
+    WeightlessCacheAttribute() = delete;
+
+    WeightlessCacheAttribute(size_t original_size, size_t bin_offset, ov::element::Type original_dtype)
+        : original_size(original_size),
+          bin_offset(bin_offset),
+          original_dtype(original_dtype) {}
+
+    bool is_copyable() const override;
+
+    size_t original_size;
+    size_t bin_offset;
+    ov::element::Type original_dtype;
+};
+
+}  // namespace ov

data/ext/sources/ggml/src/ggml-openvino/openvino/translate_session.cpp

@@ -3,15 +3,17 @@
 #include "ggml-openvino/openvino/node_context.h"
 #include "ggml-openvino/openvino/utils.h"
 #include "input_model.h"
-#include "pass/eliminate_zp.h"
 #include "pass/mark_decompression_convert_constant_folding.h"
 #include "pass/squeeze_matmul.h"
+#include "rt_info/weightless_caching_attributes.hpp"
 
 #include <cstdint>
 #include <cstdlib>
 #include <map>
 #include <memory>
 #include <openvino/core/node.hpp>
+#include <openvino/core/preprocess/pre_post_process.hpp>
+#include <openvino/core/type/element_type.hpp>
 #include <openvino/op/add.hpp>
 #include <openvino/op/broadcast.hpp>
 #include <openvino/op/concat.hpp>
@@ -33,7 +35,6 @@
 #include <openvino/op/unsqueeze.hpp>
 #include <openvino/pass/constant_folding.hpp>
 #include <openvino/pass/make_stateful.hpp>
-#include <openvino/core/preprocess/pre_post_process.hpp>
 
 namespace ov {
 namespace frontend {
@@ -77,49 +78,48 @@ ov::pass::MakeStateful::ParamResPairs get_kv_param_res_pairs(
     return pairs;
 }
 
-void add_sliced_mask(TensorMap & tensor_map, GgmlDecoder & ggml_model_decoder) {
-
-    auto create_sliced_mask = [&](const std::string & mask_name, const std::string & sliced_name, bool is_static) {
+void add_sliced_mask_stateful(TensorMap & tensor_map) {
+    auto create_sliced_mask = [&](const std::string & mask_name, const std::string & sliced_name) {
         if ((tensor_map.find(mask_name) != tensor_map.end()) &&
             (tensor_map.find("token_len_per_seq") != tensor_map.end())) {
             auto token_len_per_seq = tensor_map.at("token_len_per_seq").get_node_shared_ptr();
             auto mask = tensor_map.at(mask_name).get_node_shared_ptr();
-            std::shared_ptr<ov::Node> mask_sliced;
-            if (is_static) {
-                mask_sliced = mask;
-            } else if (ggml_model_decoder.is_stateful()) {
-                auto zero_2d = ov::op::v0::Constant::create(ov::element::i64, {2}, {0,0});
-                auto one_2d = ov::op::v0::Constant::create(ov::element::i64, {2}, {1,1});
-                auto zero_1d = ov::op::v0::Constant::create(ov::element::i64, {1}, {0});
-                auto three_1d = ov::op::v0::Constant::create(ov::element::i64, {1}, {3});
-                auto neg_one_1d = ov::op::v0::Constant::create(ov::element::i64, {1}, {-1});
-                auto axes = ov::op::v0::Constant::create(ov::element::i64, {2}, {-2,-1});
-                auto inp_pos = tensor_map.at("inp_pos").get_node_shared_ptr();
-                auto gather_inp_pos = std::make_shared<ov::op::v8::Gather>(inp_pos, neg_one_1d, three_1d);
-                auto reshaped_inp_pos = std::make_shared<ov::op::v1::Reshape>(gather_inp_pos, ov::op::v0::Constant::create(ov::element::i64, {1}, {1}), false);
-                auto inp_pos_incremented = std::make_shared<ov::op::v1::Add>(reshaped_inp_pos, ov::op::v0::Constant::create(ov::element::i32, ov::Shape{1}, {1}));
-                auto stop = std::make_shared<ov::op::v0::Concat>(ov::OutputVector{token_len_per_seq, std::make_shared<v1::ConvertLike>(inp_pos_incremented, token_len_per_seq)}, 0);
-                mask_sliced =
-                    std::make_shared<ov::op::v8::Slice>(mask, zero_2d, stop, one_2d, axes);
-                mask_sliced = std::make_shared<ov::op::v0::Convert>(mask_sliced, ov::element::f16);
-                mask_sliced->set_friendly_name(sliced_name);
-            } else {
-                auto zero = ov::op::v0::Constant::create(ov::element::i64, {1}, {0});
-                auto one = ov::op::v0::Constant::create(ov::element::i64, {1}, {1});
-                auto two = ov::op::v0::Constant::create(ov::element::i64, {1}, {2});
-                mask_sliced = std::make_shared<ov::op::v8::Slice>(mask, zero, token_len_per_seq, one, two);
-                mask_sliced = std::make_shared<ov::op::v0::Convert>(mask_sliced, ov::element::f16);
-                mask_sliced->set_friendly_name(sliced_name);
-            }
+            std::shared_ptr<ov::Node> mask_sliced = mask;
+            auto one = ov::op::v0::Constant::create(ov::element::i64, {1}, {1});
+            auto zero = ov::op::v0::Constant::create(ov::element::i64, {1}, {0});
+            auto three = ov::op::v0::Constant::create(ov::element::i64, {1}, {3});
+            auto neg_one = ov::op::v0::Constant::create(ov::element::i64, {1}, {-1});
+
+            auto step = ov::op::v0::Constant::create(ov::element::i64, {1}, {1});
+            auto axes = ov::op::v0::Constant::create(ov::element::i64, {1}, {-1});
+
+            auto inp_pos = tensor_map.at("inp_pos").get_node_shared_ptr();
+            auto last_inp_pos = std::make_shared<ov::op::v8::Gather>(inp_pos, neg_one, three);
+            auto last_inp_pos_1d = std::make_shared<ov::op::v1::Reshape>(
+                last_inp_pos, ov::op::v0::Constant::create(ov::element::i64, {1}, {1}), false);
+            auto last_inp_pos_cvt = std::make_shared<ov::op::v0::Convert>(last_inp_pos_1d, ov::element::i64);
+            auto last_inp_pos_inc = std::make_shared<ov::op::v1::Add>(last_inp_pos_cvt, one);
+
+            mask_sliced = std::make_shared<ov::op::v8::Slice>(mask, zero, last_inp_pos_inc, step, axes);
+            mask_sliced = std::make_shared<ov::op::v0::Convert>(mask_sliced, ov::element::f16);
+            mask_sliced->set_friendly_name(sliced_name);
+
             tensor_map.insert({sliced_name, mask_sliced->output(0)});
         }
     };
 
-    create_sliced_mask("self_kq_mask", "KQ_mask_sliced", ggml_model_decoder.is_static());
-    create_sliced_mask("self_kq_mask_swa", "KQ_mask_swa_sliced", ggml_model_decoder.is_static());
+    create_sliced_mask("self_kq_mask", "KQ_mask_sliced");
+    create_sliced_mask("self_kq_mask_swa", "KQ_mask_swa_sliced");
 }
 
 void add_rope_sin_cos(TensorMap & tensor_map, GgmlDecoder & ggml_model_decoder) {
+    // When ROPE ops in the graph have divergent op_params (e.g. gemma4's mixed
+    // SWA/non-SWA layers with different n_dims or freq_base), a shared sin/cos
+    // precompute cannot broadcast across every ROPE use. Skip it here and let
+    // translate_rope() build sin/cos per-op from its own op_params.
+    if (ggml_model_decoder.has_mixed_rope_params()) {
+        return;
+    }
     int32_t * rope_params = ggml_model_decoder.get_rope_params();
     if (tensor_map.find("inp_pos") == tensor_map.end() || rope_params == nullptr) {
         return;
@@ -142,8 +142,11 @@ void add_rope_sin_cos(TensorMap & tensor_map, GgmlDecoder & ggml_model_decoder)
 
 // Create common patterns
 void preprocess(TensorMap & tensor_map, GgmlDecoder & ggml_model_decoder) {
-    add_sliced_mask(tensor_map, ggml_model_decoder);
-    add_rope_sin_cos(tensor_map, ggml_model_decoder);
+    if (ggml_model_decoder.is_stateful()) {
+        add_sliced_mask_stateful(tensor_map);
+    }
+    // This optimization is error-prone
+    // add_rope_sin_cos(tensor_map, ggml_model_decoder);
 }
 
 }  // namespace
@@ -240,6 +243,31 @@ std::shared_ptr<Model> TranslateSession::translate_graph(const frontend::InputMo
     resulting_model = std::make_shared<Model>(results, used_params);
 
     apply_transformations(resulting_model);
+
+    // Set WeightlessCacheAttribute on large constants to avoid unnecessary memory copies
+    // in the NPUW plugin. Without this attribute, NPUW's LazyTensor constructor
+    // (lazy_tensor.cpp, op::Const::Const) will memcpy every constant "in case export
+    // occurs", doubling memory usage per compile_model call.
+    //
+    // The bin_offset field serves as a unique key (not a real file offset) — this is
+    // the same convention the GPU plugin uses for non-IR models (see
+    // Plugin::set_weightless_cache_attributes in intel_gpu/src/plugin/plugin.cpp).
+    // Each constant must have a distinct bin_offset, otherwise GPU's weightless cache
+    // import will map multiple constants to the same data.
+    //
+    // Small constants (< 16 elements) are excluded since they may be introduced by
+    // optimization patterns and the overhead is negligible.
+    size_t offset = 0;
+    for (auto & node : resulting_model->get_ordered_ops()) {
+        if (auto cnst = ov::as_type_ptr<ov::op::v0::Constant>(node);
+            cnst && cnst->get_byte_size() / cnst->get_element_type().size() >= 16) {
+            auto & rt_info = cnst->get_rt_info();
+            if (rt_info.find(ov::WeightlessCacheAttribute::get_type_info_static()) == rt_info.end()) {
+                rt_info[ov::WeightlessCacheAttribute::get_type_info_static()] =
+                    ov::WeightlessCacheAttribute(cnst->get_byte_size(), offset++, cnst->get_element_type());
+            }
+        }
+    }
     return resulting_model;
 }
 
@@ -257,26 +285,25 @@ std::shared_ptr<Model> TranslateSession::apply_transformations(std::shared_ptr<M
         }
 
         if (ggml_model_decoder->is_static()) {
-            manager.register_pass<pass::EliminateZeroPoints>();
             manager.register_pass<pass::SqueezeMatmul>();
         }
         manager.run_passes(model);
         if (ggml_model_decoder->is_stateful()) {
             auto output_names = ggml_model_decoder->get_model_output_names();
             std::map<std::string, int> model_output_indexes;
-            for (size_t i=0; i<output_names.size(); i++) {
+            for (size_t i = 0; i < output_names.size(); i++) {
                 model_output_indexes.insert(std::make_pair(output_names[i], i));
             }
             ov::preprocess::PrePostProcessor ppp(model);
-            for (size_t i=0; i<model->get_output_size(); i++) {
+            for (size_t i = 0; i < model->get_output_size(); i++) {
                 auto output_friendly_name = model->output(i).get_node_shared_ptr()->get_friendly_name();
                 auto output_id = model_output_indexes[output_friendly_name];
                 auto model_output_shape = model->output(i).get_partial_shape();
                 auto decoder_output_shape = ggml_model_decoder->get_output_shape(output_id);
-                if (model_output_shape.rank().is_static() && decoder_output_shape.rank().is_static()
-                    && model_output_shape.rank().get_length() + 1 == decoder_output_shape.rank().get_length()
-                    && decoder_output_shape[0].is_static() && decoder_output_shape[0].get_length() == 1) {
-                    ppp.output(i).postprocess().custom([](const ov::Output<ov::Node>& node) {
+                if (model_output_shape.rank().is_static() && decoder_output_shape.rank().is_static() &&
+                    model_output_shape.rank().get_length() + 1 == decoder_output_shape.rank().get_length() &&
+                    decoder_output_shape[0].is_static() && decoder_output_shape[0].get_length() == 1) {
+                    ppp.output(i).postprocess().custom([](const ov::Output<ov::Node> & node) {
                         auto axes = ov::op::v0::Constant::create(ov::element::i32, ov::Shape{1}, {0});
                         return std::make_shared<ov::op::v0::Unsqueeze>(node, axes);
                     });

data/ext/sources/ggml/src/ggml-openvino/openvino/translate_session.h

@@ -9,16 +9,17 @@ namespace ggml {
 
 class TranslateSession {
 public:
-    TranslateSession(const frontend::InputModel::Ptr& input_model,
-                     const std::unordered_map<std::string, CreatorFunction>& translator_map, bool naive = false);
+    TranslateSession(const frontend::InputModel::Ptr & input_model,
+                     const std::unordered_map<std::string, CreatorFunction> & translator_map,
+                     bool naive = false);
 
     std::shared_ptr<Model> get_converted_model();
-    std::shared_ptr<Model> translate_graph(const frontend::InputModel::Ptr& input_model);
+    std::shared_ptr<Model> translate_graph(const frontend::InputModel::Ptr & input_model);
 
 private:
     std::shared_ptr<Model> apply_transformations(std::shared_ptr<Model> model);
     const frontend::InputModel::Ptr m_input_model;
-    const std::unordered_map<std::string, CreatorFunction>& m_translator_map;
+    const std::unordered_map<std::string, CreatorFunction> & m_translator_map;
     std::shared_ptr<Model> m_ov_model;
     bool m_naive;
 };