whispercpp 1.3.6 → 1.3.8

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

@@ -1,6 +1,7 @@
 #pragma once
 
-#include "ggml-quants.h"
+#include "ggml-backend-impl.h"
+#include "ggml-backend.h"
 #include "ggml.h"
 #include "openvino/decoder.h"
 
@@ -14,21 +15,21 @@
 
 struct ModelParams {
     int ctx = -1;
-    int ctx_swa = -1;
     int ctx_per_seq = -1;
     int ctx_per_seq_swa = -1;
     int n_seq = 1;
-    int n_heads = -1;
     int n_heads_kv = -1;
     int head_size = -1;
     int32_t rope_params[15];
+    bool mixed_rope_params = false;
     std::vector<int> swa_layers;
 
     std::vector<std::string> kv_names;
     size_t kv_buffer_ctx_id = 0;
 
     bool same_rope_params(const ModelParams & other) const {
-        return memcmp(rope_params, other.rope_params, sizeof(int32_t) * 15) == 0;
+        return mixed_rope_params == other.mixed_rope_params &&
+               memcmp(rope_params, other.rope_params, sizeof(int32_t) * 15) == 0;
     }
 
     bool can_reuse_dynamically(const ModelParams & other) const { return same_rope_params(other); }
@@ -56,12 +57,14 @@ public:
         std::string node_name;
         std::string node_op_type;
         std::map<std::string, ggml_tensor *> node_inputs;
+        std::map<std::string, std::vector<std::pair<std::string, ggml_tensor *>>> node_inputs_views;
         std::vector<std::string> node_inputs_names;
         ggml_tensor * node_output;
         std::string node_output_name;
         int node_op_case = 0;
         void * data_addr;
     };
+
     // Graph decoder
     GgmlOvDecoder(ggml_cgraph * cgraph,
                   ModelParams & model_params,
@@ -69,6 +72,7 @@ public:
                   std::map<std::string, std::shared_ptr<ov::Node>> & model_weights,
                   bool is_static,
                   bool is_stateful = false,
+                  bool model_is_splitted = false,
                   bool is_prefill = false,
                   int prefill_chunk_size = 256);
 
@@ -84,6 +88,42 @@ public:
 
     virtual std::vector<size_t> get_input_stride(int node_idx, const std::string & name) const override;
 
+    virtual size_t get_view_input_size(int node_idx, const std::string & name) const override;
+
+    virtual size_t get_view_input_offset(int node_idx, const std::string & name, size_t view_index) const override;
+
+    virtual size_t get_view_input_src_offset(int node_idx, const std::string & name, size_t view_index) const override;
+
+    virtual std::vector<size_t> get_view_input_stride(int node_idx,
+                                                      const std::string & name,
+                                                      size_t view_index) const override;
+
+    virtual std::vector<size_t> get_view_input_src_stride(int node_idx,
+                                                          const std::string & name,
+                                                          size_t view_index) const override;
+
+    virtual ov::Shape get_view_input_ggml_shape(int node_idx,
+                                                const std::string & name,
+                                                size_t view_index) const override;
+
+    virtual ov::Shape get_view_input_src_ggml_shape(int node_idx,
+                                                    const std::string & name,
+                                                    size_t view_index) const override;
+
+    virtual ov::PartialShape get_view_input_ov_shape(int node_idx,
+                                                     const std::string & name,
+                                                     size_t view_index) const override;
+
+    virtual ov::PartialShape get_view_input_src_ov_shape(int node_idx,
+                                                         const std::string & name,
+                                                         size_t view_index) const override;
+
+    virtual std::string get_view_input_name(int node_idx, const std::string & name, size_t view_index) const override;
+
+    virtual std::string get_view_input_src_name(int node_idx,
+                                                const std::string & name,
+                                                size_t view_index) const override;
+
     virtual ov::element::Type get_input_type(int node_idx, const std::string & name) const override;
 
     virtual size_t get_input_size() const override;
@@ -106,10 +146,14 @@ public:
 
     virtual ov::element::Type get_output_type(int node_idx) const override;
 
+    virtual std::vector<size_t> get_output_stride(int node_idx) const override;
+
     virtual int32_t * get_input_op_params(int node_idx, const std::string & name) const override;
 
     virtual int32_t * get_output_op_params(int node_idx) const override;
 
+    virtual size_t get_output_op_offset(int node_idx) const override;
+
     virtual std::vector<std::string> get_output_names(int node_idx) const override;
 
     virtual const std::string & get_op_type() const override;
@@ -120,7 +164,10 @@ public:
 
     virtual const std::string & get_op_name(int node_idx) const override;
 
-    virtual void visit_subgraph(std::function<void(std::shared_ptr<GgmlDecoder>, int node_idx)> node_visitor) const override;
+    virtual int32_t get_op_dynamic_dim(int node_idx) const override;
+
+    virtual void visit_subgraph(
+        std::function<void(std::shared_ptr<GgmlDecoder>, int node_idx)> node_visitor) const override;
 
     ggml_tensor * get_input_ggml_tensor(const std::string & name) const { return m_inputs.at(name); }
 
@@ -142,16 +189,12 @@ public:
         return m_model_weights;
     }
 
-    virtual std::vector<std::string> get_model_output_names() const override {
-        return m_model_output_names;
-    }
+    virtual std::vector<std::string> get_model_output_names() const override { return m_model_output_names; }
 
     const std::map<std::string, ggml_tensor *> & get_model_outputs() const { return m_model_outputs; }
 
     virtual int get_ctx_size() const { return m_model_params.ctx; }
 
-    virtual int get_ctx_swa_size() const { return m_model_params.ctx_swa; }
-
     virtual int get_ctx_per_seq() const { return m_model_params.ctx_per_seq; }
 
     virtual int get_ctx_per_seq_swa() const { return m_model_params.ctx_per_seq_swa; }
@@ -169,13 +212,21 @@ public:
 
     virtual int32_t * get_rope_params() const override { return const_cast<int32_t *>(m_model_params.rope_params); }
 
+    virtual bool has_mixed_rope_params() const override { return m_model_params.mixed_rope_params; }
+
     virtual std::map<std::string, std::string> get_kv_param_res_names() const override;
 
     virtual bool is_static() const override { return m_is_static; }
 
     virtual bool is_stateful() const override { return m_is_stateful; }
 
-    ov::PartialShape get_graph_input_shape(const ggml_tensor * op, const ggml_tensor * input) const;
+    int get_static_n_tokens() const { return m_is_prefill ? m_prefill_chunk_size : 1; }
+
+    virtual bool is_splited_model() const override { return m_model_is_splitted; }
+
+    ov::PartialShape get_graph_input_shape(const ggml_tensor * op,
+                                           const ggml_tensor * input,
+                                           int dynamic_dim_index = -1) const;
 
     static void dump_cgraph(const ggml_cgraph * cgraph, std::string & filename);
 
@@ -205,6 +256,7 @@ public:
     bool m_is_prefill = false;
     bool m_naive = false;
     int m_prefill_chunk_size = 0;
+    bool m_model_is_splitted = false;  // label the cgraph is splited or not
 
     static ov::Shape get_shape(const ggml_tensor * tensor);
     static std::vector<size_t> get_stride(const ggml_tensor * tensor);
@@ -227,7 +279,8 @@ public:
     }
 
     inline static bool is_inp_mask(const ggml_tensor * tensor, const ggml_tensor * op) {
-        return op->op == GGML_OP_CPY || (op->op == GGML_OP_FLASH_ATTN_EXT && tensor == op->src[3]);
+        return op->op == GGML_OP_CPY || (op->op == GGML_OP_FLASH_ATTN_EXT && tensor == op->src[3]) ||
+               (op->op == GGML_OP_SOFT_MAX && tensor == op->src[1]);
     }
 
     inline static bool is_rope_freqs_weight(const ggml_tensor * tensor, const ggml_tensor * op) {
@@ -235,7 +288,8 @@ public:
     }
 
     inline static bool is_kvcache(const ggml_tensor * tensor, const ggml_tensor * op) {
-        return op->op == GGML_OP_SET_ROWS && op->src[2] == tensor;
+        return tensor->buffer->usage == GGML_BACKEND_BUFFER_USAGE_ANY ||
+               (op != nullptr && op->op == GGML_OP_SET_ROWS && op->src[2] == tensor);
     }
 
     inline static bool is_kv_idx(const ggml_tensor * tensor, const ggml_tensor * op) {
@@ -243,23 +297,18 @@ public:
     }
 
     inline static bool is_output_idx(const ggml_tensor * tensor, const ggml_tensor * op) {
-        return op->op == GGML_OP_GET_ROWS && tensor == op->src[1] && op->src[0]->op != GGML_OP_NONE;
+        return op->op == GGML_OP_GET_ROWS && tensor == op->src[1] && op->src[0]->op != GGML_OP_NONE &&
+               op->src[1]->op == GGML_OP_NONE;
     }
 
-    static std::string get_graph_input_ov_name(const ggml_tensor * tensor, const ggml_tensor * op) {
-        if (is_inp_tok(tensor, op)) {
-            return "inp_tokens";
-        }
+    std::string get_graph_input_ov_name(const ggml_tensor * tensor, const ggml_tensor * op) {
         if (is_inp_pos(tensor, op)) {
             return "inp_pos";
         }
         if (is_inp_emb(tensor, op)) {
             return "embd";
         }
-        if (is_output_idx(tensor, op)) {
-            return "inp_out_ids";
-        }
-        if (is_inp_mask(tensor, op)) {
+        if (is_stateful() && is_inp_mask(tensor, op)) {
             return std::string(tensor->name).find("swa") == std::string::npos ? "self_kq_mask" : "self_kq_mask_swa";
         }
         return tensor->name;
@@ -272,6 +321,9 @@ private:
     void compute_model_inputs();
     void compute_model_outputs();
 
+    // Infer and propagate dynamic-dimension indices for all tensors in the GGML graph.
+    void compute_node_dynamic_dims();
+
     void validate_cgraph() const;
 
     ggml_cgraph * m_cgraph = nullptr;
@@ -284,6 +336,7 @@ private:
     std::map<std::string, ggml_tensor *> m_model_outputs;
     std::vector<std::string> m_model_output_names;
     std::vector<NodeInfo> m_node_info_list;
+    std::map<ggml_tensor *, int> m_node_dynamic_dims;
 
     ModelParams m_model_params;
     ComputeParams m_compute_params;
@@ -291,4 +344,4 @@ private:
 
 void print_tensor_address_map(const ggml_cgraph * cgraph);
 
-int extract_layer_from_name(const std::string & name);
+std::optional<int> extract_layer_from_name(const std::string & name);

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

@@ -3,9 +3,11 @@
 #include "ggml-impl.h"
 #include "ggml.h"
 
+#include <cstdlib>
 #include <cstring>
 #include <openvino/runtime/intel_gpu/ocl/ocl.hpp>
 #include <openvino/runtime/intel_npu/level_zero/level_zero.hpp>
+#include <openvino/runtime/properties.hpp>
 #include <optional>
 
 ov::Core & ov_singleton_core() {
@@ -21,7 +23,38 @@ void ggml_openvino_device_config::init() {
     if (initialized) {
         return;
     }
-    device_name = getenv("GGML_OPENVINO_DEVICE") ? getenv("GGML_OPENVINO_DEVICE") : "CPU";
+
+    // All recognized GGML_OPENVINO_* env vars. Their values are cached here
+    // once at backend init time and read back via ggml_openvino_getenv_str()
+    // (raw string) or ggml_openvino_getenv_int() (integer / boolean toggle).
+    static constexpr const char * env_var_names[] = {
+        // String values (use ggml_openvino_getenv_str)
+        "GGML_OPENVINO_DEVICE",
+        "GGML_OPENVINO_CACHE_DIR",
+        // Integer values (use ggml_openvino_getenv_int)
+        "GGML_OPENVINO_PREFILL_CHUNK_SIZE",
+        // Boolean toggles (treated as int flags via ggml_openvino_getenv_int)
+        "GGML_OPENVINO_STATEFUL_EXECUTION",
+        "GGML_OPENVINO_PROFILING",
+        "GGML_OPENVINO_DUMP_CGRAPH",
+        "GGML_OPENVINO_DUMP_IR",
+        "GGML_OPENVINO_DEBUG_INPUT",
+        "GGML_OPENVINO_DEBUG_OUTPUT",
+        "GGML_OPENVINO_PRINT_CGRAPH_TENSOR_ADDRESS",
+        "GGML_OPENVINO_ENABLE_CACHE",
+        "GGML_OPENVINO_DISABLE_CACHE",
+        "GGML_OPENVINO_DISABLE_KV_SLICE",
+        "GGML_OPENVINO_MANUAL_GQA_ATTN",
+    };
+
+    for (const char * const & env_var : env_var_names) {
+        auto * env = getenv(env_var);
+        if (env) {
+            environment_variables[env_var] = env;
+        }
+    }
+
+    device_name = ggml_openvino_getenv_str("GGML_OPENVINO_DEVICE", "CPU");
     auto available_devices = ov_singleton_core().get_available_devices();
     if (std::find(available_devices.begin(), available_devices.end(), device_name) == available_devices.end()) {
         GGML_LOG_WARN("GGML OpenVINO Backend: device %s is not available, fallback to CPU\n", device_name.c_str());
@@ -29,7 +62,7 @@ void ggml_openvino_device_config::init() {
     }
     is_npu = (device_name == "NPU");
 
-    auto * cache_dir = getenv("GGML_OPENVINO_CACHE_DIR");
+    const char * cache_dir = ggml_openvino_getenv_str("GGML_OPENVINO_CACHE_DIR");
     if (device_name == "NPU") {
         compile_config = {
             {"NPU_COMPILER_DYNAMIC_QUANTIZATION", "YES"   },
@@ -42,11 +75,13 @@ void ggml_openvino_device_config::init() {
             {"NPUW_DQ",                           "YES"   },
             {"NPUW_DQ_FULL",                      "NO"    },
         };
-        if (cache_dir) {
+        if (cache_dir && strlen(cache_dir) > 0) {
             compile_config["NPUW_CACHE_DIR"] = cache_dir;
+            compile_config.insert(ov::cache_mode(ov::CacheMode::OPTIMIZE_SIZE));
         }
-    } else if (cache_dir) {
-        ov_singleton_core().set_property(ov::cache_dir(cache_dir));
+    } else if (cache_dir && strlen(cache_dir) > 0) {
+        compile_config.insert(ov::cache_dir(cache_dir));
+        compile_config.insert(ov::cache_mode(ov::CacheMode::OPTIMIZE_SIZE));
     }
 
     // Initialize remote context with queue sharing for GPU
@@ -116,6 +151,23 @@ const std::string & ggml_openvino_get_device_name() {
     return ggml_openvino_get_device_config().device_name;
 }
 
+// Get the value of a GGML_OPENVINO_* env var as a string. Returns
+// default_value when the var is unset or set to an empty string.
+const char * ggml_openvino_getenv_str(const char * var, const char * default_value) {
+    auto & env_map = ggml_openvino_get_device_config().environment_variables;
+    auto it = env_map.find(var);
+    return (it == env_map.end() || it->second.empty()) ? default_value : it->second.c_str();
+}
+
+// Get the value of a GGML_OPENVINO_* env var as an int (via std::atoi).
+// Returns default_value (0) when the var is unset or empty. Used for both
+// integer settings (e.g. GGML_OPENVINO_PREFILL_CHUNK_SIZE) and boolean
+// toggles: "0" disables, any non-zero integer enables.
+int ggml_openvino_getenv_int(const char * var, int default_value) {
+    const char * v = ggml_openvino_getenv_str(var, nullptr);
+    return v ? std::atoi(v) : default_value;
+}
+
 // Check if running on NPU
 bool ggml_openvino_is_npu() {
     return ggml_openvino_get_device_config().is_npu;
@@ -170,7 +222,8 @@ std::optional<ExtraQuantType> ggml_openvino_get_requant_type(const ggml_tensor *
         return std::nullopt;
     }
     if (strncmp(tensor->name, "token_embd.weight", 17) == 0) {
-        return ((ggml_openvino_is_npu() && tensor->type == GGML_TYPE_Q6_K) ? ExtraQuantType::F16 : ExtraQuantType::Q8_0_C);
+        return ((ggml_openvino_is_npu() && tensor->type == GGML_TYPE_Q6_K) ? ExtraQuantType::F16 :
+                                                                             ExtraQuantType::Q8_0_C);
     }
     if (strncmp(tensor->name, "output.weight", 13) == 0) {
         return ExtraQuantType::Q8_0_C;
@@ -259,10 +312,12 @@ ggml_openvino_extracted_layout ggml_openvino_get_extracted_layout(const ggml_ten
             layout.weights_size = layout.is_u4 ? (n_elements / 2) : n_elements;
             int64_t n_blocks = n_elements / layout.weights_per_block;
             layout.scales_size = n_blocks * sizeof(uint16_t);
-            // For symmetric quantization, we only need one zp value (not one per block)
-            // Zero points are stored in U4 or U8 format matching the weight type
-            size_t n_zp_elements = layout.is_symmetric ? 1 : n_blocks;
-            layout.zp_size = layout.is_u4 ? ((n_zp_elements + 1) / 2) : n_zp_elements;
+            // For symmetric quantization, no zp needed (weights stored as signed)
+            if (layout.is_symmetric) {
+                layout.zp_size = 0;
+            } else {
+                layout.zp_size = layout.is_u4 ? ((n_blocks + 1) / 2) : n_blocks;
+            }
 
             layout.weights_offset = 0;
             layout.scales_offset = ((layout.weights_size + alignment - 1) / alignment) * alignment;
@@ -293,6 +348,10 @@ ggml_openvino_extracted_layout ggml_openvino_get_extracted_layout(const ggml_ten
         layout.is_symmetric = true;
         break;
 
+    case GGML_TYPE_Q5_1:
+        // u8 weights (5-bit values), asymmetric (scale + zero point)
+        break;
+
     case GGML_TYPE_Q6_K:
         layout.weights_per_block = 16;
         layout.is_symmetric = true;
@@ -313,10 +372,12 @@ ggml_openvino_extracted_layout ggml_openvino_get_extracted_layout(const ggml_ten
     // Scales: F16 per block
     int64_t n_blocks = n_elements / layout.weights_per_block;
     layout.scales_size = n_blocks * sizeof(uint16_t);  // F16 = 2 bytes
-    // Zero points: U4 or U8 matching weight type
-    // For symmetric quantization, we only need one zp value (not one per block)
-    size_t n_zp_elements = layout.is_symmetric ? 1 : n_blocks;
-    layout.zp_size = layout.is_u4 ? ((n_zp_elements + 1) / 2) : n_zp_elements;
+    // For symmetric quantization, no zp needed (weights stored as signed)
+    if (layout.is_symmetric) {
+        layout.zp_size = 0;
+    } else {
+        layout.zp_size = layout.is_u4 ? ((n_blocks + 1) / 2) : n_blocks;
+    }
 
     // Layout in buffer: [weights | scales | zp] with alignment
     layout.weights_offset = 0;

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

@@ -64,6 +64,7 @@ struct ggml_openvino_device_config {
     bool initialized = false;
     std::optional<ov::RemoteContext> remote_context;
     ov::AnyMap compile_config;
+    std::unordered_map<std::string, std::string> environment_variables;
     cl_command_queue cl_queue = nullptr;
 
     void init();
@@ -79,6 +80,22 @@ void ggml_openvino_init_device_config();
 // Get the device name
 const std::string & ggml_openvino_get_device_name();
 
+// Environment variable accessors. All GGML_OPENVINO_* env vars are read once
+// during backend init and cached on the device config; consumers must go
+// through these helpers (never call ::getenv directly) so behavior stays
+// consistent and centralized.
+//
+// Use ggml_openvino_getenv_str() for string / path values
+// (e.g. GGML_OPENVINO_DEVICE, GGML_OPENVINO_CACHE_DIR). The optional
+// default_value is returned when the var is unset or empty.
+//
+// Use ggml_openvino_getenv_int() for boolean toggles and integer settings.
+// It returns std::atoi(value) when set, otherwise default_value. For
+// boolean use, `if (ggml_openvino_getenv_int(name))` is true iff the value
+// is a non-zero integer (so "0" disables, "1" enables).
+const char * ggml_openvino_getenv_str(const char * var, const char * default_value = nullptr);
+int ggml_openvino_getenv_int(const char * var, int default_value = 0);
+
 // Check if running on NPU
 bool ggml_openvino_is_npu();
 
@@ -115,9 +132,9 @@ struct ggml_openvino_weight_extra : public ggml_openvino_extra_base {
 
 // Extra data for quantized weight tensors - stores extracted weights/scales/zp and weight node
 struct ggml_openvino_quantized_weight_extra : public ggml_openvino_extra_base {
-    ov::Tensor weights;   // U4 or U8 extracted weights
-    ov::Tensor scales;    // F16 scales
-    ov::Tensor zp;        // U4 or U8 zero points (same type as weights)
+    ov::Tensor weights;                     // U4 or U8 extracted weights
+    ov::Tensor scales;                      // F16 scales
+    ov::Tensor zp;                          // U4 or U8 zero points (same type as weights)
     std::shared_ptr<ov::Node> weight_node;  // Pre-built OpenVINO weight subgraph
 
     ggml_openvino_quantized_weight_extra(ov::Tensor w, ov::Tensor s, ov::Tensor z, std::shared_ptr<ov::Node> n) :
@@ -132,8 +149,9 @@ struct ggml_openvino_quantized_weight_extra : public ggml_openvino_extra_base {
 struct ggml_openvino_tensor_extra : public ggml_openvino_extra_base {
     std::shared_ptr<ov::Tensor> tensor;  // For direct use with infer_request
 
-    explicit ggml_openvino_tensor_extra(std::shared_ptr<ov::Tensor> t)
-        : ggml_openvino_extra_base(Type::TENSOR), tensor(std::move(t)) {}
+    explicit ggml_openvino_tensor_extra(std::shared_ptr<ov::Tensor> t) :
+        ggml_openvino_extra_base(Type::TENSOR),
+        tensor(std::move(t)) {}
 };
 
 // =====================================================
@@ -152,11 +170,11 @@ struct ggml_openvino_extracted_layout {
     size_t zp_size = 0;         // Size of zero points in bytes (U4 or U8)
     bool is_u4;                 // true for U4 weights, false for U8
     int64_t weights_per_block;  // weights per scale/zp block
-    bool is_symmetric;        // true for symmetric quantization
+    bool is_symmetric;          // true for symmetric quantization
 
     // Requantization info
-    bool is_requant = false;                      // true if this tensor needs requantization
-    std::optional<ExtraQuantType> requant_type;   // target requant type if is_requant
+    bool is_requant = false;                     // true if this tensor needs requantization
+    std::optional<ExtraQuantType> requant_type;  // target requant type if is_requant
 };
 
 // Calculate the buffer layout for extracted quantized data
@@ -164,6 +182,9 @@ ggml_openvino_extracted_layout ggml_openvino_get_extracted_layout(const ggml_ten
 
 ggml_openvino_tensor_extra * ggml_openvino_create_tensor_extra(const ggml_tensor * tensor, bool is_remote);
 
+// Check if a tensor's buffer uses remote (device) memory (e.g. GPU USM)
+bool ggml_openvino_buffer_is_remote(const ggml_tensor * tensor);
+
 // Register an extra with the tensor's OpenVINO buffer context for proper lifetime management.
 // This sets tensor->extra and tracks the extra in the buffer context for cleanup.
 void ggml_openvino_buffer_register_extra(ggml_tensor * tensor, ggml_openvino_extra_base * extra);