[GGUF FE] Add tests and typed decoder API; Q4_K integer zero-point

Add the frontend's test suite (per-op tests, weight/dequant-vs-ggml tests with
real-ggml reference data) and adopt the typed GgufDecoder API the translators
consume. Includes the Q4_K integer (u8) zero-point so the CPU/GPU plugin fuses
the dequant into the MatMul, matching the original ggml-openvino backend's
performance.

Author: mvafin

.github/workflows/debian_10_arm.yml

@@ -117,6 +117,7 @@ jobs:
         -DENABLE_CONFORMANCE_PGQL=ON
         -DENABLE_LTO=ON
         -DENABLE_TESTS=ON
+        -DENABLE_OV_GGUF_FRONTEND=ON
         -DENABLE_PYTHON=OFF
         -DTHREADING=SEQ
         -DCMAKE_TOOLCHAIN_FILE=cmake/arm.toolchain.cmake

.github/workflows/job_cxx_unit_tests.yml

@@ -128,6 +128,11 @@ jobs:
           ${{ env.SOURCE_COMMAND }} ${{ env.SETUPVARS }}
           ${{ env.INSTALL_TEST_DIR }}/ov_ir_frontend_tests --gtest_print_time=1 --gtest_output=xml:${{ env.INSTALL_TEST_DIR }}/TEST-IRFrontend.xml
 
+      - name: GGUF frontend tests
+        run: |
+          ${{ env.SOURCE_COMMAND }} ${{ env.SETUPVARS }}
+          ${{ env.INSTALL_TEST_DIR }}/ov_gguf_frontend_tests --gtest_print_time=1 --gtest_output=xml:${{ env.INSTALL_TEST_DIR }}/TEST-GGUFFrontend.xml
+
       - name: PaddlePaddle frontend tests
         if: ${{ fromJSON(inputs.affected-components).PDPD_FE.test && runner.os != 'Windows' }} # Ticket: 149651
         run: |

.github/workflows/linux_arm64.yml

@@ -114,6 +114,7 @@ jobs:
             -G 'Ninja Multi-Config'
             -DENABLE_NCC_STYLE=OFF
             -DENABLE_TESTS=ON
+            -DENABLE_OV_GGUF_FRONTEND=ON
             -DENABLE_STRICT_DEPENDENCIES=OFF
             -DENABLE_SYSTEM_OPENCL=ON
             -DCMAKE_EXPORT_COMPILE_COMMANDS=ON

.github/workflows/mac_arm64.yml

@@ -184,6 +184,7 @@ jobs:
             -G "${{ env.CMAKE_GENERATOR }}" \
             -DENABLE_NCC_STYLE=OFF \
             -DENABLE_TESTS=ON \
+            -DENABLE_OV_GGUF_FRONTEND=ON \
             -DENABLE_WHEEL=OFF \
             -DCMAKE_COMPILE_WARNING_AS_ERROR=OFF \
             -DENABLE_STRICT_DEPENDENCIES=OFF \

.github/workflows/ubuntu_22.yml

@@ -138,6 +138,7 @@ jobs:
             -DENABLE_TESTS=ON
             -DENABLE_STRICT_DEPENDENCIES=OFF
             -DENABLE_SYSTEM_OPENCL=ON
+            -DENABLE_OV_GGUF_FRONTEND=ON
             -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
             -DCPACK_GENERATOR=TGZ
             -DENABLE_WHEEL=ON

.github/workflows/ubuntu_24.yml

@@ -117,6 +117,7 @@ jobs:
             -G 'Ninja Multi-Config'
             -DENABLE_NCC_STYLE=OFF
             -DENABLE_TESTS=ON
+            -DENABLE_OV_GGUF_FRONTEND=ON
             -DENABLE_STRICT_DEPENDENCIES=OFF
             -DENABLE_SYSTEM_OPENCL=ON
             -DCMAKE_EXPORT_COMPILE_COMMANDS=ON

.github/workflows/windows_vs2022_debug.yml

@@ -73,6 +73,7 @@ jobs:
         -G 'Ninja'
         -DENABLE_PYTHON=OFF
         -DENABLE_TESTS=ON
+        -DENABLE_OV_GGUF_FRONTEND=ON
         -DCMAKE_COMPILE_WARNING_AS_ERROR=ON
         -DENABLE_STRICT_DEPENDENCIES=OFF
         -DCMAKE_DISABLE_FIND_PACKAGE_PkgConfig=ON

.github/workflows/windows_vs2022_release.yml

@@ -77,6 +77,7 @@ jobs:
             -DENABLE_PYTHON=ON
             -DENABLE_WHEEL=OFF
             -DENABLE_TESTS=ON
+            -DENABLE_OV_GGUF_FRONTEND=ON
             -DCMAKE_COMPILE_WARNING_AS_ERROR=ON
             -DENABLE_STRICT_DEPENDENCIES=OFF
             -DCMAKE_DISABLE_FIND_PACKAGE_PkgConfig=ON

src/frontends/gguf/CMakeLists.txt

@@ -3,3 +3,7 @@
 #
 
 add_subdirectory(src)
+
+if(ENABLE_TESTS)
+    add_subdirectory(tests)
+endif()

src/frontends/gguf/include/openvino/frontend/gguf/decoder.h

@@ -1,3 +1,7 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
 #pragma once
 
 #include <cstdint>
@@ -10,42 +14,73 @@ namespace ov {
 namespace frontend {
 namespace gguf {
 
+// Typed RoPE configuration, replacing the raw gguf `op_params`/`rope_params` int32 array
+// the translators used to dereference by byte offset. A decoder is responsible for
+// producing this (the llama.cpp cgraph decoder by parsing ggml's layout, a future
+// gguf-file decoder by construction), so the op translators never need to know ggml's
+// memory layout.
+struct RopeConfig {
+    int n_dims = 0;
+    int n_ctx_orig = 0;
+    float freq_base = 0.0f;
+    float freq_scale = 0.0f;
+    float ext_factor = 0.0f;
+    float attn_factor = 0.0f;
+    float beta_fast = 0.0f;
+    float beta_slow = 0.0f;
+};
+
+// Decoder interface consumed by the gguf frontend translators.
+//
+// This is a typed, ggml-free interface: operation parameters are exposed through
+// get_attribute(node_idx, name) / get_input_view_offset / RopeConfig rather than as raw
+// ggml `op_params` int32 arrays. A concrete decoder (e.g. the llama.cpp cgraph decoder)
+// only has to translate ggml's layout into these typed accessors -- the op translators
+// here never touch ggml memory directly.
 class GgufDecoder : public DecoderBase {
 public:
-    virtual ov::Any get_attribute(const std::string& name) const = 0;
+    ov::Any get_attribute(const std::string& name) const override = 0;
+
+    // Per-node typed attribute access. This is the mechanism the op translators use to
+    // read scalar operation parameters (e.g. "eps", "scale", "bias", "swapped",
+    // "softmax_axis", "rope_config") without dereferencing ggml's raw op_params layout.
+    virtual ov::Any get_attribute(int node_idx, const std::string& name) const = 0;
 
     virtual PartialShape get_input_shape(int node_idx, const std::string& name) const = 0;
 
     virtual std::vector<size_t> get_input_stride(int node_idx, const std::string& name) const = 0;
 
+    // Byte offset of an input that is a gguf VIEW into a larger tensor (0 when the input
+    // is not a view). Replaces the raw `get_input_op_params(...)[0]` read: a view's start
+    // offset is a single semantic scalar the decoder knows (by parsing ggml, or by
+    // construction), so translators never touch ggml's op_params layout. Translators
+    // convert bytes -> elements using get_input_stride as needed.
+    virtual int64_t get_input_view_offset(int node_idx, const std::string& name) const = 0;
+
     virtual element::Type get_input_type(int node_idx, const std::string& name) const = 0;
 
-    virtual size_t get_input_size() const = 0;
+    size_t get_input_size() const override = 0;
 
     virtual size_t get_input_size(int node_idx) const = 0;
 
-    virtual void get_input_node(size_t input_port_idx,
-                                std::string& producer_name,
-                                std::string& producer_output_port_name,
-                                size_t& producer_output_port_index) const = 0;
+    void get_input_node(size_t input_port_idx,
+                        std::string& producer_name,
+                        std::string& producer_output_port_name,
+                        size_t& producer_output_port_index) const override = 0;
 
     virtual std::vector<std::string> get_input_names(int node_idx) const = 0;
 
     virtual PartialShape get_output_shape(int node_idx) const = 0;
 
     virtual element::Type get_output_type(const int node_idx) const = 0;
 
-    virtual int32_t* get_input_op_params(int node_idx, const std::string& name) const = 0;
-
-    virtual int32_t * get_output_op_params(int node_idx) const = 0;
-
     virtual std::vector<std::string> get_output_names(int node_idx) const = 0;
 
-    virtual const std::string& get_op_type() const = 0;
+    const std::string& get_op_type() const override = 0;
 
     virtual const std::string& get_op_type(int node_idx) const = 0;
 
-    virtual const std::string& get_op_name() const = 0;
+    const std::string& get_op_name() const override = 0;
 
     virtual const std::string& get_op_name(int node_idx) const = 0;
 
@@ -55,18 +90,33 @@ class GgufDecoder : public DecoderBase {
 
     virtual const std::map<std::string, std::shared_ptr<ov::Node>>& get_model_inputs() const = 0;
     virtual const std::map<std::string, std::shared_ptr<ov::Node>>& get_model_extra_inputs() const = 0;
-    virtual const std::map<std::string, std::shared_ptr<ov::Node>>& get_model_weights() const = 0;
     virtual std::vector<std::string> get_model_output_names() const = 0;
 
-    virtual int32_t* get_rope_params() const = 0;
+    // NOTE: there is no get_model_weights(). A GGUF weight is surfaced as a regular node in
+    // visit_subgraph with op type "GGML_OP_WEIGHT": the decoder exposes the raw weight bytes
+    // via get_attribute<ov::Tensor>(node_idx, "data"), the ggml quant type name via
+    // get_attribute<std::string>(node_idx, "quant_type") (e.g. "Q4_K", "F16") and the logical
+    // [rows, cols] shape via get_output_shape(node_idx). The frontend's translate_weight does
+    // the dequant / repacking / requantization, so the decoder never builds OV nodes itself.
+
+    // Model-level RoPE configuration, used by TranslateSession::preprocess to pre-build
+    // the shared rope sin/cos. has_rope() == false means the model uses no RoPE.
+    virtual bool has_rope() const = 0;
+
+    // When true, each ROPE op generates its own sin/cos from its per-op rope_config
+    // (e.g. gemma4 where SWA and global layers have different n_dims). The shared
+    // rope_cos/rope_sin tensor is NOT added to the tensor map.
+    virtual bool use_per_op_rope() const = 0;
+
+    virtual RopeConfig get_rope_config() const = 0;
 
     virtual std::map<std::string, std::string> get_kv_param_res_names() const = 0;
 
     virtual bool is_static() const = 0;
 
     virtual bool is_stateful() const = 0;
 
-    virtual int is_swa_layer(int layer) const = 0;
+    virtual bool is_swa_layer(int layer) const = 0;
 };
 
 }  // namespace gguf