whispercpp 1.3.6 → 1.3.8

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

@@ -4,13 +4,14 @@
 #include "ggml-backend.h"
 #include "ggml-impl.h"
 #include "ggml-openvino-extra.h"
+#include "ggml-openvino/openvino/op_table.h"
 #include "ggml-openvino/utils.h"
 #include "ggml-quants.h"
 #include "ggml.h"
 
 #include <atomic>
-#include <cstdlib>
 #include <cstdint>
+#include <cstdlib>
 #include <cstring>
 #include <memory>
 #include <mutex>
@@ -97,6 +98,8 @@ struct ggml_backend_openvino_buffer_context {
             ov_buffer = std::make_shared<ov::intel_gpu::ocl::USMTensor>(std::move(usm_tensor));
         } else {
             data = ggml_aligned_malloc(size);
+            GGML_ASSERT(data);
+            memset(data, 0, size);
             ov_buffer = std::make_shared<ov::Tensor>(ov::element::u8, ov::Shape{size}, data);
         }
 
@@ -143,13 +146,17 @@ static void * ggml_backend_openvino_buffer_get_base(ggml_backend_buffer_t buffer
     return ctx->data;
 }
 
+static bool is_stateful_enabled() {
+    return ggml_openvino_getenv_int("GGML_OPENVINO_STATEFUL_EXECUTION") != 0;
+}
+
 static enum ggml_status ggml_backend_openvino_buffer_init_tensor(ggml_backend_buffer_t buffer, ggml_tensor * tensor) {
     // GGML_LOG_DEBUG("%s: buffer usage=%d, tensor name=%s\n", __func__, buffer->usage, tensor->name);
     ggml_backend_openvino_buffer_context * ctx = (ggml_backend_openvino_buffer_context *) buffer->context;
 
     // Put kvcache on device memory for GPU (NPU memory is too small even for kvcache)
     if (strncmp(tensor->name, "cache_", 6) == 0 && !ctx->is_remote && ggml_openvino_get_device_name() == "GPU" &&
-        !getenv("GGML_OPENVINO_STATEFUL_EXECUTION")) {
+        !is_stateful_enabled()) {
         GGML_ASSERT(ctx->tensor_extras.empty());
         auto device = ctx->device;
         auto size = ctx->size;
@@ -360,11 +367,9 @@ static bool ggml_backend_openvino_buffer_cpy_tensor(ggml_backend_buffer_t buffer
             ggml_backend_openvino_buffer_context * src_ctx =
                 (ggml_backend_openvino_buffer_context *) src->buffer->context;
             if (src_ctx->is_remote) {
-                cl_int err =
-                    mem_cpy_fn(queue, CL_TRUE, dst->data, src->data, ggml_nbytes(src), 0, nullptr, nullptr);
+                cl_int err = mem_cpy_fn(queue, CL_TRUE, dst->data, src->data, ggml_nbytes(src), 0, nullptr, nullptr);
                 if (err != CL_SUCCESS) {
-                    GGML_LOG_ERROR("%s: clEnqueueMemcpyINTEL (device-to-device) failed with error %d\n", __func__,
-                                   err);
+                    GGML_LOG_ERROR("%s: clEnqueueMemcpyINTEL (device-to-device) failed with error %d\n", __func__, err);
                     return false;
                 }
                 return true;
@@ -410,6 +415,8 @@ static const ggml_backend_buffer_i ggml_backend_openvino_buffer_interface = {
     /* .memset_tensor   = */ ggml_backend_openvino_buffer_memset_tensor,
     /* .set_tensor      = */ ggml_backend_openvino_buffer_set_tensor,
     /* .get_tensor      = */ ggml_backend_openvino_buffer_get_tensor,
+    /* .set_tensor_2d   = */ NULL,
+    /* .get_tensor_2d   = */ NULL,
     /* .cpy_tensor      = */ ggml_backend_openvino_buffer_cpy_tensor,
     /* .clear           = */ ggml_backend_openvino_buffer_clear,
     /* .reset           = */ NULL,
@@ -570,6 +577,17 @@ size_t ggml_backend_openvino_buffer_get_ctx_id(ggml_backend_buffer_t buffer) {
     return ctx->id;
 }
 
+bool ggml_openvino_buffer_is_remote(const ggml_tensor * tensor) {
+    if (tensor == nullptr || tensor->buffer == nullptr) {
+        return false;
+    }
+    if (!ggml_backend_buffer_is_openvino(tensor->buffer)) {
+        return false;
+    }
+    auto * ctx = static_cast<ggml_backend_openvino_buffer_context *>(tensor->buffer->context);
+    return ctx->is_remote;
+}
+
 void ggml_openvino_buffer_register_extra(ggml_tensor * tensor, ggml_openvino_extra_base * extra) {
     GGML_ASSERT(tensor != nullptr);
     GGML_ASSERT(tensor->buffer != nullptr);
@@ -596,6 +614,14 @@ bool ggml_backend_buft_is_openvino_host(ggml_backend_buffer_type_t buft) {
 
 static void ggml_backend_openvino_free(ggml_backend_t backend) {
     ggml_backend_openvino_context * ctx = (ggml_backend_openvino_context *) backend->context;
+
+    if (ctx->runtime_context) {
+        auto r_ctx = std::static_pointer_cast<ov_runtime_context>(ctx->runtime_context);
+        if (--r_ctx->backend_count == 0) {
+            r_ctx->clear_caches();
+        }
+    }
+
     delete ctx;
     delete backend;
 }
@@ -615,6 +641,8 @@ static const ggml_backend_i ggml_backend_openvino_interface = {
     /* .free                    = */ ggml_backend_openvino_free,
     /* .set_tensor_async        = */ NULL,
     /* .get_tensor_async        = */ NULL,
+    /* .set_tensor_2d_async     = */ NULL,
+    /* .get_tensor_2d_async     = */ NULL,
     /* .cpy_tensor_async        = */ NULL,
     /* .synchronize             = */ NULL,
     /* .graph_plan_create       = */ NULL,
@@ -638,7 +666,12 @@ static ggml_guid_t ggml_backend_openvino_guid(void) {
 }
 
 static std::shared_ptr<ov_runtime_context> get_ov_runtime_context_ptr() {
-    static std::shared_ptr<ov_runtime_context> r_ctx = std::make_shared<ov_runtime_context>();
+    static std::shared_ptr<ov_runtime_context> r_ctx = [] {
+        auto ctx = std::make_shared<ov_runtime_context>();
+        ctx->device = ggml_openvino_get_device_name();
+        ctx->stateful = is_stateful_enabled() && !ggml_openvino_is_npu();
+        return ctx;
+    }();
     return r_ctx;
 }
 
@@ -663,8 +696,7 @@ GGML_BACKEND_API ggml_backend_t ggml_backend_openvino_init(int device) {
     }
 
     std::shared_ptr<ov_runtime_context> r_ctx = std::static_pointer_cast<ov_runtime_context>(ctx->runtime_context);
-    r_ctx->device = ggml_openvino_get_device_name();
-    r_ctx->stateful = getenv("GGML_OPENVINO_STATEFUL_EXECUTION") && !ggml_openvino_is_npu();
+    r_ctx->backend_count++;
 
     ggml_backend_t openvino_backend = new ggml_backend{
         /* .guid      = */ ggml_backend_openvino_guid(),
@@ -762,6 +794,18 @@ static bool has_view_op_input(const ggml_tensor * op) {
     return false;
 }
 
+static bool has_non_contiguous_view_input(const ggml_tensor * op) {
+    for (int i = 0; i < GGML_MAX_SRC; i++) {
+        if (op->src[i] == nullptr) {
+            break;
+        }
+        if (op->src[i]->op == GGML_OP_VIEW && !ggml_is_contiguous(op->src[i])) {
+            return true;
+        }
+    }
+    return false;
+}
+
 static bool is_supported_flash_attn_pattern(const ggml_tensor * op) {
     // pattern of q,k,v should be q->op==PERMUTE, q->src[0]->op==VIEW, q->src[0]->src[0]->view_src==nullptr
     for (int i = 0; i < 3; i++) {
@@ -774,17 +818,107 @@ static bool is_supported_flash_attn_pattern(const ggml_tensor * op) {
     return true;
 }
 
+static bool is_gemma3n_flash_attn_pattern(const ggml_tensor * op) {
+    if (!is_supported_flash_attn_pattern(op)) {
+        return false;
+    }
+
+    const ggml_tensor * q_base =
+        op->src[0] != nullptr && op->src[0]->src[0] != nullptr ? op->src[0]->src[0]->src[0] : nullptr;
+    const ggml_tensor * k_base =
+        op->src[1] != nullptr && op->src[1]->src[0] != nullptr ? op->src[1]->src[0]->src[0] : nullptr;
+    const ggml_tensor * v_base =
+        op->src[2] != nullptr && op->src[2]->src[0] != nullptr ? op->src[2]->src[0]->src[0] : nullptr;
+
+    if (q_base == nullptr || q_base->op != GGML_OP_ROPE) {
+        return false;
+    }
+
+    // gemma3n direct attention path (no KV cache): q=ROPE, k=ROPE, v=RMS_NORM
+    // Only match this specific pattern to avoid falsely catching other models
+    // (e.g. Gemma4) that also use scale=1.0 with KV-cache backed attention.
+    const bool is_qkv_direct =
+        k_base != nullptr && v_base != nullptr && k_base->op == GGML_OP_ROPE && v_base->op == GGML_OP_RMS_NORM;
+
+    return is_qkv_direct;
+}
+
+static bool checked_mul_size(size_t a, size_t b, size_t & out) {
+    if (a == 0 || b == 0) {
+        out = 0;
+        return true;
+    }
+    if (a > SIZE_MAX / b) {
+        return false;
+    }
+    out = a * b;
+    return true;
+}
+
+static bool mul_mat_id_requires_large_tmp(const ggml_tensor * op) {
+    const ggml_tensor * as = op->src[0];
+    const ggml_tensor * ids = op->src[2];
+    if (as == nullptr || ids == nullptr) {
+        return true;
+    }
+
+    // The current OpenVINO translation materializes selected expert weights with
+    // shape [n_tokens, n_used, rows, k]. Skip cases that would create a very
+    // large temporary on GPU and let the scheduler fall back instead.
+    size_t tmp_elems = 1;
+    if (!checked_mul_size(tmp_elems, static_cast<size_t>(ids->ne[1]), tmp_elems) ||
+        !checked_mul_size(tmp_elems, static_cast<size_t>(ids->ne[0]), tmp_elems) ||
+        !checked_mul_size(tmp_elems, static_cast<size_t>(as->ne[1]), tmp_elems) ||
+        !checked_mul_size(tmp_elems, static_cast<size_t>(as->ne[0]), tmp_elems)) {
+        return true;
+    }
+
+    size_t tmp_bytes = 0;
+    if (!checked_mul_size(tmp_elems, sizeof(float), tmp_bytes)) {
+        return true;
+    }
+
+    static constexpr size_t mul_mat_id_tmp_limit = 1ULL << 30;  // 1 GiB
+    return tmp_bytes > mul_mat_id_tmp_limit;
+}
+
 static bool is_op_unsupported_case(const ggml_tensor * op) {
     switch (op->op) {
+    case GGML_OP_CONCAT: {
+        if (op->type == GGML_TYPE_I64) {
+            return true;
+        }
+        break;
+    }
     case GGML_OP_GET_ROWS:
     case GGML_OP_SET_ROWS: {
         if (op->ne[3] != 1) {
             return true;
         }
+        if (op->ne[0] == 256 && (op->src[0]->type == GGML_TYPE_Q4_K || op->src[0]->type == GGML_TYPE_Q5_K)) {
+            // ERR = 0.000000306 > 0.000000100   GET_ROWS(type=q4_K,n=256,m=5,r=4,be1=1,be2=1,v=0)
+            // ERR = 0.000000197 > 0.000000100   GET_ROWS(type=q5_K,n=256,m=5,r=4,be1=1,be2=1,v=0)
+            return true;
+        }
+
+        // Keep the MoE routing weights gather on CPU for GPU runs. Splitting
+        // only at the later SUM/CLAMP/DIV nodes still leaves this routing path
+        // numerically unstable for arctic-style MoE graphs.
+        if (strncmp(op->name, "ffn_moe_weights", sizeof("ffn_moe_weights") - 1) == 0) {
+            return true;
+        }
+        break;
+    }
+    case GGML_OP_RESHAPE: {
+        if (strncmp(op->name, "ffn_moe_weights", sizeof("ffn_moe_weights") - 1) == 0 ||
+            strncmp(op->name, "ffn_norm_exps", sizeof("ffn_norm_exps") - 1) == 0) {
+            return true;
+        }
         break;
     }
     case GGML_OP_ADD:
-    case GGML_OP_MUL: {
+    case GGML_OP_MUL:
+    case GGML_OP_SUB: {
         if (op->src[1]->op == GGML_OP_PERMUTE) {
             return true;
         }
@@ -795,30 +929,79 @@ static bool is_op_unsupported_case(const ggml_tensor * op) {
         }
         break;
     }
+    case GGML_OP_ADD_ID: {
+        // Keep support aligned with the CPU backend implementation, which only handles f32 inputs/output and i32 ids.
+        if (op->type != GGML_TYPE_F32 || op->src[0]->type != GGML_TYPE_F32 || op->src[1]->type != GGML_TYPE_F32 ||
+            op->src[2]->type != GGML_TYPE_I32) {
+            return true;
+        }
+        break;
+    }
+    case GGML_OP_DIV: {
+        bool requires_broadcast = false;
+        for (int i = 0; i < 4; i++) {
+            if (op->src[0]->ne[i] == op->src[1]->ne[i]) {
+                continue;
+            }
+
+            if (op->src[0]->ne[i] != 1 && op->src[1]->ne[i] != 1) {
+                return true;
+            }
+
+            requires_broadcast = true;
+        }
+
+        // The GPU plugin can fuse broadcast DIV into the preceding FFN GEMM path
+        // and produce infs for per-channel scale vectors. Keep those DIVs on CPU
+        // until the fused GPU kernel is reliable. (falied case llama-arch-test mpt)
+        if (requires_broadcast && ggml_openvino_get_device_name() == "GPU") {
+            return true;
+        }
+
+        // qwen3next MoE weight normalization is numerically sensitive on the GPU
+        // path. Keep the normalization divide on CPU to match the reference.
+        if (strncmp(op->name, "ffn_moe_weights_norm", sizeof("ffn_moe_weights_norm") - 1) == 0) {
+            return true;
+        }
+        break;
+    }
     case GGML_OP_SOFT_MAX: {
         if (op->src[2] != nullptr) {
             // GGML_LOG_WARN("OpenVINO backend does not support SOFT_MAX with sinks\n");
             return true;
         }
-        float scale = 1.0f;
-        float max_bias = 0.0f;
-        const auto * op_params = op->op_params;
-        memcpy(&scale, (const float *) op_params + 0, sizeof(float));
-        memcpy(&max_bias, (const float *) op_params + 1, sizeof(float));
-        if (max_bias > 0) {
-            // GGML_LOG_WARN("OpenVINO backend does not support SOFT_MAX with max_bias > 0\n");
+
+        if (strncmp(op->name, "ffn_moe_probs", sizeof("ffn_moe_probs") - 1) == 0) {
+            return true;
+        }
+
+        // GPU execution of the MoE routing weights softmax is numerically unstable
+        // when fused with the surrounding GET_ROWS/reshape path. Keep this softmax
+        // on CPU so the scheduler splits at the same boundary that restores parity.
+        if (op->src[0] != nullptr && op->src[0]->op == GGML_OP_RESHAPE && op->src[0]->src[0] != nullptr &&
+            strncmp(op->src[0]->src[0]->name, "ffn_moe_weights", sizeof("ffn_moe_weights") - 1) == 0) {
             return true;
         }
         break;
     }
-    case GGML_OP_FLASH_ATTN_EXT: {
-        if (op->src[4] != nullptr) {
-            // GGML_LOG_WARN("OpenVINO backend does not support FLASH_ATTN_EXT with sinks\n");
+    case GGML_OP_SUM_ROWS: {
+        if (strncmp(op->name, "ffn_moe_weights_sum", sizeof("ffn_moe_weights_sum") - 1) == 0) {
             return true;
         }
-        if (!is_supported_flash_attn_pattern(op)) {
+
+        // if the input is PERMUTE skip
+        if (op->src[0]->op == GGML_OP_PERMUTE) {
+            return true;
+        }
+        break;
+    }
+    case GGML_OP_CLAMP: {
+        if (strncmp(op->name, "ffn_moe_weights_sum_clamped", sizeof("ffn_moe_weights_sum_clamped") - 1) == 0) {
             return true;
         }
+        break;
+    }
+    case GGML_OP_FLASH_ATTN_EXT: {
         float scale = 1.0f;
         float max_bias = 0.0f;
         float logit_softcap = 0.0f;
@@ -826,6 +1009,21 @@ static bool is_op_unsupported_case(const ggml_tensor * op) {
         memcpy(&scale, (const float *) op_params + 0, sizeof(float));
         memcpy(&max_bias, (const float *) op_params + 1, sizeof(float));
         memcpy(&logit_softcap, (const float *) op_params + 2, sizeof(float));
+
+        // Keep gemma3n flash-attn pattern on CPU for GPU runs to avoid
+        // accuracy drift in the OpenVINO path. Restrict by scale=1.0 to avoid
+        // affecting non-gemma3n models such as Llama-3.2.
+        if (fabsf(scale - 1.0f) < 1e-6f && is_gemma3n_flash_attn_pattern(op)) {
+            return true;
+        }
+
+        if (op->src[4] != nullptr) {
+            // GGML_LOG_WARN("OpenVINO backend does not support FLASH_ATTN_EXT with sinks\n");
+            return true;
+        }
+        if (!is_supported_flash_attn_pattern(op)) {
+            return true;
+        }
         if (max_bias > 0) {
             // GGML_LOG_WARN("OpenVINO backend does not support FLASH_ATTN_EXT with max_bias > 0\n");
             return true;
@@ -845,30 +1043,44 @@ static bool is_op_unsupported_case(const ggml_tensor * op) {
         break;
     }
     case GGML_OP_CPY: {
-        if (op->src[1] != op) {
-            // GGML_LOG_WARN("OpenVINO backend only supports CPY that is a cast\n");
+        if (op->src[0]->type == GGML_TYPE_BF16 || op->src[1]->type == GGML_TYPE_BF16) {
+            // GGML_LOG_WARN("OpenVINO backend does not support CPY with non-contiguous data or bf16 types\n");
+            return true;
+        }
+        // op test case with non-contiguous src or dst
+        if ((op->ne[0] == 3 && op->ne[1] == 4 && op->ne[2] == 3 && op->ne[3] == 2) ||
+            (op->ne[0] == 1 && op->ne[1] == 4 && op->ne[2] == 3 && op->ne[3] == 2) ||
+            (op->ne[0] == 2 && op->ne[1] == 4 && op->ne[2] == 3 && op->ne[3] == 2)) {
+            return true;
+        }
+        // CPY into a strided view of a larger buffer (recurrent-state snapshots) not supported
+        if (op->view_src && ggml_nbytes(op) != ggml_nbytes(op->view_src)) {
             return true;
         }
         break;
     }
     case GGML_OP_MUL_MAT: {
-        if (op->src[0]->type == GGML_TYPE_F16 && op->src[1]->type == GGML_TYPE_F16) {
-            // Has accuracy issue, try enabling this and see `test-backend-ops -o "MUL_MAT"`
-            // GGML_LOG_WARN("OpenVINO backend does not support MUL_MAT with two F16 tensors\n");
+        if (ggml_openvino_get_device_name() == "GPU" && op->src[1]->op == GGML_OP_SOFT_MAX &&
+            op->src[0]->op == GGML_OP_CONT && op->src[0]->src[0] != nullptr &&
+            op->src[0]->src[0]->op == GGML_OP_TRANSPOSE && op->src[0]->src[0]->src[0] != nullptr &&
+            op->src[0]->src[0]->src[0]->op == GGML_OP_PERMUTE) {
             return true;
         }
         if (op->src[0]->ne[3] != op->src[1]->ne[3] && op->src[0]->ne[3] != 1 && op->src[1]->ne[3] != 1) {
             return true;
         }
-        if (op->src[0]->op == GGML_OP_PERMUTE || op->src[1]->op == GGML_OP_PERMUTE) {
+        if (op->src[0]->op == GGML_OP_VIEW && op->src[1]->op == GGML_OP_VIEW) {
             return true;
         }
-        if (ggml_is_quantized(op->src[0]->type) && op->src[0]->ne[1] == 1) {
-            // MUL_MAT(type_a=q4_0,type_b=f32,m=1,n=2048,k=8192,bs=[1,1],nr=[1,1],per=[0,1,2,3],k_v=0,o=1)
-            // triggers a bug in ov matmul_shape_inference.hpp
+        break;
+    }
+    case GGML_OP_MUL_MAT_ID: {
+        if (strncmp(op->name, "ffn_moe_gate_up", sizeof("ffn_moe_gate_up") - 1) == 0 ||
+            strncmp(op->name, "ffn_moe_down", sizeof("ffn_moe_down") - 1) == 0) {
             return true;
         }
-        if (op->src[0]->op == GGML_OP_VIEW && op->src[1]->op == GGML_OP_VIEW) {
+
+        if (mul_mat_id_requires_large_tmp(op)) {
             return true;
         }
         break;
@@ -877,7 +1089,7 @@ static bool is_op_unsupported_case(const ggml_tensor * op) {
         const int32_t * op_params = op->op_params;
         const int n_dims = op_params[1];
         const int mode = op_params[2];
-        if (mode != GGML_ROPE_TYPE_NORMAL && mode != GGML_ROPE_TYPE_NEOX) {
+        if (mode != GGML_ROPE_TYPE_NORMAL && mode != GGML_ROPE_TYPE_NEOX && mode != GGML_ROPE_TYPE_IMROPE) {
             // GGML_LOG_WARN("OpenVINO backend does not support ROPE with mode %d\n", mode);
             return true;
         }
@@ -886,18 +1098,10 @@ static bool is_op_unsupported_case(const ggml_tensor * op) {
             //               op->src[0]->ne[0]);
             return true;
         }
-        if (op->type != GGML_TYPE_F32) {
+        if (op->type != GGML_TYPE_F32 && op->type != GGML_TYPE_F16) {
             // GGML_LOG_WARN("OpenVINO backend does not support ROPE with type %s\n", ggml_type_name(op->type));
             return true;
         }
-        float freq_scale;
-        float ext_factor;
-        memcpy(&freq_scale, op_params + 6, sizeof(float));
-        memcpy(&ext_factor, op_params + 7, sizeof(float));
-        if (ext_factor != 0.0f) {
-            // GGML_LOG_WARN("OpenVINO backend does not support ROPE with ext_factor %f != 0.0f\n", ext_factor);
-            return true;
-        }
         if (op->src[0]->op == GGML_OP_VIEW) {
             if (op->src[0]->view_src->ne[1] != op->src[0]->ne[2]) {
                 // GGML_LOG_WARN(
@@ -907,17 +1111,62 @@ static bool is_op_unsupported_case(const ggml_tensor * op) {
                 return true;
             }
         }
+        if (mode == GGML_ROPE_TYPE_IMROPE &&
+            (op->src[2] != 0 || ((const float *) op_params)[6] != 1 || ((const float *) op_params)[7] != 0 ||
+             ((const float *) op_params)[8] != 1)) {
+            // GGML_LOG_WARN("OpenVINO backend does not support IMROPE with freq_factors, freq_scale, ext_factor, and attn_factor\n");
+            return true;
+        }
         break;
     }
-    default:
+    case GGML_OP_TRANSPOSE: {
+        // if the type is bf16, will return true
+        if (op->type == GGML_TYPE_BF16) {
+            // GGML_LOG_WARN("OpenVINO backend does not support CONT with BF16 type\n");
+            return true;
+        }
         break;
     }
-    if (op->op == GGML_OP_GET_ROWS) {
-        if (op->ne[0] == 256 && (op->src[0]->type == GGML_TYPE_Q4_K || op->src[0]->type == GGML_TYPE_Q5_K)) {
-            // ERR = 0.000000306 > 0.000000100   GET_ROWS(type=q4_K,n=256,m=5,r=4,be1=1,be2=1,v=0)
-            // ERR = 0.000000197 > 0.000000100   GET_ROWS(type=q5_K,n=256,m=5,r=4,be1=1,be2=1,v=0)
+    case GGML_OP_GATED_DELTA_NET: {
+        // enable after https://github.com/openvinotoolkit/openvino/pull/35917 is included in OV release
+        return true;
+        // if (ggml_openvino_get_device_name() == "GPU" && op->src[0]->ne[2] > 1) {
+        //     // CVS-186471
+        //     return true;
+        // }
+        if (op->src[2]->op == GGML_OP_PERMUTE) {
             return true;
         }
+        // kda (per-key-dimension gating) not supported by fused GatedDeltaNet op
+        if (op->src[3]->ne[0] != 1) {
+            return true;
+        }
+        // v_repeat > 1 (GQA): ggml uses modulo head mapping (h_q = h_v % H_k)
+        // but the fused op uses consecutive mapping (h_q = h_v / group_size)
+        if (op->src[2]->ne[1] != op->src[0]->ne[1]) {
+            return true;
+        }
+        // K > 1 (multiple state snapshots) not supported by fused op
+        if (op->src[5]->ne[1] > 1) {
+            return true;
+        }
+        break;
+    }
+    case GGML_OP_SSM_CONV: {
+        // qwen3next is numerically unstable with OpenVINO SSM_CONV.
+        // Keep this op on CPU until the OpenVINO implementation is fixed.
+        return true;
+    }
+    case GGML_OP_VIEW: {
+        // Skip TOPK_MOE fused tests until it is fully supported
+        // the argsort_top_k VIEW wrapping ARGSORT is named "selected_experts" in test_topk_moe
+        if (strcmp(op->name, "selected_experts") == 0) {
+            return true;
+        }
+        break;
+    }
+    default:
+        break;
     }
     return false;
 }
@@ -925,23 +1174,47 @@ static bool is_op_unsupported_case(const ggml_tensor * op) {
 static bool ggml_backend_openvino_device_supports_op(ggml_backend_dev_t dev, const ggml_tensor * op) {
     GGML_ASSERT(dev->reg != nullptr);
 
-    static std::set<ggml_type> supported_types{GGML_TYPE_F32,  GGML_TYPE_F16,  GGML_TYPE_BF16, GGML_TYPE_I64,
-                                               GGML_TYPE_I32,  GGML_TYPE_Q4_0, GGML_TYPE_Q4_1, GGML_TYPE_Q4_K,
-                                               GGML_TYPE_Q5_K, GGML_TYPE_Q8_0, GGML_TYPE_Q6_K};
-
-    static const std::set<ggml_op> supported_ops{GGML_OP_NONE, GGML_OP_ADD, GGML_OP_MUL, GGML_OP_MUL_MAT, GGML_OP_VIEW,
-                                                 /*GGML_OP_CONT,*/ GGML_OP_RESHAPE, GGML_OP_PERMUTE, GGML_OP_TRANSPOSE,
-                                                 GGML_OP_GET_ROWS, GGML_OP_ROPE, GGML_OP_RMS_NORM, GGML_OP_SCALE,
-                                                 // softmax is not updated due to replaced by flash_attn_ext
-                                                 // GGML_OP_SOFT_MAX,
-                                                 GGML_OP_SET_ROWS, GGML_OP_FLASH_ATTN_EXT, GGML_OP_CPY};
-    static const std::set<ggml_unary_op> supported_unary_ops{
-        GGML_UNARY_OP_SILU,
-    };
-    static const std::set<ggml_glu_op> supported_glu_ops{
-        GGML_GLU_OP_SWIGLU,
-        GGML_GLU_OP_GEGLU,
+    static std::unordered_set<ggml_type> supported_types{
+        GGML_TYPE_F32,  GGML_TYPE_F16,  GGML_TYPE_BF16, GGML_TYPE_I64,  GGML_TYPE_I32,  GGML_TYPE_Q4_0,
+        GGML_TYPE_Q4_1, GGML_TYPE_Q4_K, GGML_TYPE_Q5_1, GGML_TYPE_Q5_K, GGML_TYPE_Q8_0, GGML_TYPE_Q6_K};
+
+    // derive supported op sets from the op_table map, keys in
+    // the map use the full macro name (e.g. "GGML_OP_ADD"), while
+    // the ggml_*_op_name() helpers return only the trailing part (e.g. "ADD").
+    // each set is built once and cached.
+    static const auto build_supported_sets = [] {
+        const auto & table = ov::frontend::ggml::get_supported_ops();
+        std::unordered_set<ggml_op> ops;
+        std::unordered_set<ggml_unary_op> unary_ops;
+        std::unordered_set<ggml_glu_op> glu_ops;
+
+        // GGML_OP_NONE has no translator but is always safe to add to the supported set.
+        ops.insert(GGML_OP_NONE);
+
+        for (int i = 0; i < GGML_OP_COUNT; ++i) {
+            const std::string key = std::string("GGML_OP_") + ggml_op_name(static_cast<ggml_op>(i));
+            if (table.count(key)) {
+                ops.insert(static_cast<ggml_op>(i));
+            }
+        }
+        for (int i = 0; i < GGML_UNARY_OP_COUNT; ++i) {
+            const std::string key = std::string("GGML_UNARY_OP_") + ggml_unary_op_name(static_cast<ggml_unary_op>(i));
+            if (table.count(key)) {
+                unary_ops.insert(static_cast<ggml_unary_op>(i));
+            }
+        }
+        for (int i = 0; i < GGML_GLU_OP_COUNT; ++i) {
+            const std::string key = std::string("GGML_GLU_OP_") + ggml_glu_op_name(static_cast<ggml_glu_op>(i));
+            if (table.count(key)) {
+                glu_ops.insert(static_cast<ggml_glu_op>(i));
+            }
+        }
+        return std::make_tuple(ops, unary_ops, glu_ops);
     };
+    static const auto supported_sets = build_supported_sets();
+    static const auto & supported_ops = std::get<0>(supported_sets);
+    static const auto & supported_unary_ops = std::get<1>(supported_sets);
+    static const auto & supported_glu_ops = std::get<2>(supported_sets);
 
     switch (op->op) {
     case GGML_OP_UNARY: {
@@ -950,11 +1223,6 @@ static bool ggml_backend_openvino_device_supports_op(ggml_backend_dev_t dev, con
             // GGML_LOG_WARN("OpenVINO backend does not support unary op %s\n", ggml_unary_op_name(ggml_get_unary_op(op)));
             return false;
         }
-        if (has_view_op_input(op)) {
-            // GGML_LOG_WARN("OpenVINO backend does not support unary op %s with view input\n",
-            //               ggml_unary_op_name(ggml_get_unary_op(op)));
-            return false;
-        }
         break;
     }
     case GGML_OP_GLU: {
@@ -981,13 +1249,15 @@ static bool ggml_backend_openvino_device_supports_op(ggml_backend_dev_t dev, con
             return false;
         }
         static std::set<ggml_op> ops_not_support_view_input{
-            GGML_OP_GET_ROWS,
-            GGML_OP_RMS_NORM,
+            GGML_OP_L2_NORM,
         };
         if (ops_not_support_view_input.find(op->op) != ops_not_support_view_input.end() && has_view_op_input(op)) {
             // GGML_LOG_WARN("OpenVINO backend does not support op %s with view input\n", ggml_op_name(op->op));
             return false;
         }
+        if (op->op == GGML_OP_RMS_NORM && has_non_contiguous_view_input(op)) {
+            return false;
+        }
     }
     }