[GPU] Gated mlp (#34427)

Implement gated_mlp primitive, op for onednn and FuseGatedMLP.
Default fusion is disable. (disable_gated_mlp_fusion: TRUE)
Needs onednn update. Depends on
#34446

### Tickets:
 - [CVS-181656](https://jira.devtools.intel.com/browse/CVS-181656)

---------

Signed-off-by: hyunback <hyunback.kim@intel.com>

Author: hyunback

src/plugins/intel_gpu/include/intel_gpu/op/gated_mlp.hpp

@@ -0,0 +1,65 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "openvino/core/node.hpp"
+#include "openvino/op/op.hpp"
+#include "ov_ops/glu.hpp"
+
+namespace ov::intel_gpu::op {
+
+class GatedMLP : public ov::op::Op {
+public:
+    OPENVINO_OP("GatedMLP", "gpu_opset");
+
+    GatedMLP() = default;
+
+    GatedMLP(const ov::Output<Node>& src,
+             const ov::Output<Node>& w_gate,
+             const ov::Output<Node>& w_up,
+             const ov::Output<Node>& w_down,
+             ov::op::internal::GLU::GluType activation,
+             const ov::element::Type output_type = ov::element::dynamic);
+
+    GatedMLP(const ov::Output<Node>& src,
+             const ov::Output<Node>& w_gate,
+             const ov::Output<Node>& w_up,
+             const ov::Output<Node>& w_down,
+             const ov::Output<Node>& scale_gate,
+             const ov::Output<Node>& scale_up,
+             const ov::Output<Node>& scale_down,
+             ov::op::internal::GLU::GluType activation,
+             const ov::element::Type output_type = ov::element::dynamic);
+
+    GatedMLP(const ov::Output<Node>& src,
+             const ov::Output<Node>& w_gate,
+             const ov::Output<Node>& w_up,
+             const ov::Output<Node>& w_down,
+             const ov::Output<Node>& scale_gate,
+             const ov::Output<Node>& scale_up,
+             const ov::Output<Node>& scale_down,
+             const ov::Output<Node>& zp_gate,
+             const ov::Output<Node>& zp_up,
+             const ov::Output<Node>& zp_down,
+             ov::op::internal::GLU::GluType activation,
+             const ov::element::Type output_type = ov::element::dynamic);
+
+    bool visit_attributes(ov::AttributeVisitor& visitor) override;
+    void validate_and_infer_types() override;
+    std::shared_ptr<Node> clone_with_new_inputs(const ov::OutputVector& new_args) const override;
+
+    ov::op::internal::GLU::GluType get_activation() const { return m_activation; }
+    ov::element::Type get_output_type() const { return m_output_type; }
+    bool is_compressed_weights() const { return m_compressed_weights; }
+    bool has_decompression_zero_points() const { return m_has_decompression_zero_points; }
+
+private:
+    ov::op::internal::GLU::GluType m_activation = ov::op::internal::GLU::GluType::Swish;
+    ov::element::Type m_output_type = ov::element::dynamic;
+    bool m_compressed_weights = false;
+    bool m_has_decompression_zero_points = false;
+};
+
+}  // namespace ov::intel_gpu::op

src/plugins/intel_gpu/include/intel_gpu/plugin/primitives_list.hpp

@@ -302,6 +302,7 @@ REGISTER_FACTORY(internal, ReadValue);
 REGISTER_FACTORY(internal, ReadValues);
 REGISTER_FACTORY(internal, Gemm);
 REGISTER_FACTORY(internal, GLU);
+REGISTER_FACTORY(internal, GatedMLP);
 REGISTER_FACTORY(internal, IndirectGemm);
 REGISTER_FACTORY(internal, Convolution);
 REGISTER_FACTORY(internal, Placeholder);

src/plugins/intel_gpu/include/intel_gpu/primitives/gated_mlp.hpp

@@ -0,0 +1,186 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "ov_ops/glu.hpp"
+#include "primitive.hpp"
+
+namespace cldnn {
+
+struct gated_mlp : public primitive_base<gated_mlp> {
+    CLDNN_DECLARE_PRIMITIVE(gated_mlp)
+
+    gated_mlp() : primitive_base("", {}) {}
+
+    gated_mlp(const primitive_id& id,
+              const input_info& src,
+              const input_info& w_gate,
+              const input_info& w_up,
+              const input_info& w_down,
+              ov::op::internal::GLU::GluType activation,
+              const tensor& output_size,
+              const data_types output_dt)
+        : primitive_base(id, {src}, 1, {optional_data_type{output_dt}}),
+          weights_gate(w_gate),
+          weights_up(w_up),
+          weights_down(w_down),
+          activation(activation),
+          output_size(output_size) {}
+
+    gated_mlp(const primitive_id& id,
+              const input_info& src,
+              const input_info& w_gate,
+              const input_info& w_up,
+              const input_info& w_down,
+              const input_info& scale_gate,
+              const input_info& scale_up,
+              const input_info& scale_down,
+              ov::op::internal::GLU::GluType activation,
+              const tensor& output_size,
+              const data_types output_dt)
+        : primitive_base(id, {src}, 1, {optional_data_type{output_dt}}),
+          weights_gate(w_gate),
+          weights_up(w_up),
+          weights_down(w_down),
+          decompression_scale_gate(scale_gate),
+          decompression_scale_up(scale_up),
+          decompression_scale_down(scale_down),
+          compressed_weights(true),
+          activation(activation),
+          output_size(output_size) {
+        OPENVINO_ASSERT(decompression_scale_gate.is_valid() && decompression_scale_up.is_valid() && decompression_scale_down.is_valid(),
+                        "GatedMLP compressed mode requires decompression scales.");
+    }
+
+    gated_mlp(const primitive_id& id,
+              const input_info& src,
+              const input_info& w_gate,
+              const input_info& w_up,
+              const input_info& w_down,
+              const input_info& scale_gate,
+              const input_info& scale_up,
+              const input_info& scale_down,
+              const input_info& zp_gate,
+              const input_info& zp_up,
+              const input_info& zp_down,
+              ov::op::internal::GLU::GluType activation,
+              const tensor& output_size,
+              const data_types output_dt)
+        : primitive_base(id, {src}, 1, {optional_data_type{output_dt}}),
+          weights_gate(w_gate),
+          weights_up(w_up),
+          weights_down(w_down),
+          decompression_scale_gate(scale_gate),
+          decompression_scale_up(scale_up),
+          decompression_scale_down(scale_down),
+          decompression_zero_point_gate(zp_gate),
+          decompression_zero_point_up(zp_up),
+          decompression_zero_point_down(zp_down),
+          compressed_weights(true),
+          has_decompression_zero_points(true),
+          activation(activation),
+          output_size(output_size) {
+        OPENVINO_ASSERT(decompression_scale_gate.is_valid() && decompression_scale_up.is_valid() && decompression_scale_down.is_valid(),
+                        "GatedMLP compressed mode requires decompression scales.");
+        OPENVINO_ASSERT(decompression_zero_point_gate.is_valid() && decompression_zero_point_up.is_valid() && decompression_zero_point_down.is_valid(),
+                        "GatedMLP compressed mode with zero points requires decompression zero points.");
+    }
+
+    input_info weights_gate;
+    input_info weights_up;
+    input_info weights_down;
+    input_info decompression_scale_gate;
+    input_info decompression_scale_up;
+    input_info decompression_scale_down;
+    input_info decompression_zero_point_gate;
+    input_info decompression_zero_point_up;
+    input_info decompression_zero_point_down;
+    bool compressed_weights = false;
+    bool has_decompression_zero_points = false;
+    ov::op::internal::GLU::GluType activation = ov::op::internal::GLU::GluType::Swish;
+    tensor output_size;
+
+    size_t hash() const override {
+        size_t seed = primitive::hash();
+        seed = hash_combine(seed, compressed_weights);
+        seed = hash_combine(seed, has_decompression_zero_points);
+        seed = hash_combine(seed, static_cast<size_t>(activation));
+        return seed;
+    }
+
+    bool operator==(const primitive& rhs) const override {
+        if (!compare_common_params(rhs))
+            return false;
+        auto rhs_casted = downcast<const gated_mlp>(rhs);
+        return activation == rhs_casted.activation &&
+               compressed_weights == rhs_casted.compressed_weights &&
+               has_decompression_zero_points == rhs_casted.has_decompression_zero_points;
+    }
+
+    void save(BinaryOutputBuffer& ob) const override {
+        primitive_base<gated_mlp>::save(ob);
+        ob << weights_gate;
+        ob << weights_up;
+        ob << weights_down;
+        ob << decompression_scale_gate;
+        ob << decompression_scale_up;
+        ob << decompression_scale_down;
+        ob << decompression_zero_point_gate;
+        ob << decompression_zero_point_up;
+        ob << decompression_zero_point_down;
+        ob << compressed_weights;
+        ob << has_decompression_zero_points;
+        ob << make_data(&activation, sizeof(activation));
+        ob << output_size;
+    }
+
+    void load(BinaryInputBuffer& ib) override {
+        primitive_base<gated_mlp>::load(ib);
+        ib >> weights_gate;
+        ib >> weights_up;
+        ib >> weights_down;
+        ib >> decompression_scale_gate;
+        ib >> decompression_scale_up;
+        ib >> decompression_scale_down;
+        ib >> decompression_zero_point_gate;
+        ib >> decompression_zero_point_up;
+        ib >> decompression_zero_point_down;
+        ib >> compressed_weights;
+        ib >> has_decompression_zero_points;
+        ib >> make_data(&activation, sizeof(activation));
+        ib >> output_size;
+    }
+
+protected:
+    std::map<size_t, const input_info*> get_dependencies_map() const override {
+        auto ret = std::map<size_t, const input_info*>{};
+        auto idx = input.size();
+
+        OPENVINO_ASSERT(weights_gate.is_valid());
+        OPENVINO_ASSERT(weights_up.is_valid());
+        OPENVINO_ASSERT(weights_down.is_valid());
+        ret[idx++] = &weights_gate;
+        ret[idx++] = &weights_up;
+        ret[idx++] = &weights_down;
+
+        if (decompression_scale_gate.is_valid())
+            ret[idx++] = &decompression_scale_gate;
+        if (decompression_scale_up.is_valid())
+            ret[idx++] = &decompression_scale_up;
+        if (decompression_scale_down.is_valid())
+            ret[idx++] = &decompression_scale_down;
+
+        if (decompression_zero_point_gate.is_valid())
+            ret[idx++] = &decompression_zero_point_gate;
+        if (decompression_zero_point_up.is_valid())
+            ret[idx++] = &decompression_zero_point_up;
+        if (decompression_zero_point_down.is_valid())
+            ret[idx++] = &decompression_zero_point_down;
+
+        return ret;
+    }
+};
+
+}  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/runtime/internal_properties.hpp

@@ -164,6 +164,7 @@ static constexpr Property<bool, ov::PropertyMutability::RW> disable_memory_reuse
 static constexpr Property<size_t, ov::PropertyMutability::RW> disable_post_ops_fusions{"GPU_DISABLE_POST_OPS_FUSIONS"};
 static constexpr Property<bool, ov::PropertyMutability::RW> disable_horizontal_fc_fusion{"GPU_DISABLE_HORIZONTAL_FC_FUSION"};
 static constexpr Property<bool, ov::PropertyMutability::RW> disable_fc_swiglu_fusion{"GPU_DISABLE_FC_SWIGLU_FUSION"};
+static constexpr Property<bool, ov::PropertyMutability::RW> disable_gated_mlp_fusion{"GPU_DISABLE_GATED_MLP_FUSION"};
 static constexpr Property<bool, ov::PropertyMutability::RW> disable_fake_alignment{"GPU_DISABLE_FAKE_ALIGNMENT"};
 static constexpr Property<bool, ov::PropertyMutability::RW> disable_moe_opt{"GPU_DISABLE_MOE_OPT"};
 static constexpr Property<bool, ov::PropertyMutability::RW> disable_runtime_skip_reorder{"GPU_DISABLE_RUNTIME_SKIP_REORDER"};

src/plugins/intel_gpu/include/intel_gpu/runtime/options.inl

@@ -90,6 +90,7 @@ OV_CONFIG_DEBUG_OPTION(ov::intel_gpu, disable_runtime_buffer_fusing, false, "Dis
 OV_CONFIG_DEBUG_OPTION(ov::intel_gpu, disable_post_ops_fusions, 0, "Disable fusions of operations as post-ops/fused-ops. Detailed debugging is possible by entering specific numbers. 1 specifies to disable all fusions of post-ops. 2-8 specifies to enable only single fusion sub-module from fuse_reorder() to optimize_fused_opt(). 11-13 specifies to enable only single fusion sub-module in fuse_simple_primitives.")
 OV_CONFIG_DEBUG_OPTION(ov::intel_gpu, disable_horizontal_fc_fusion, false, "Disable pass which merges QKV projections into single MatMul")
 OV_CONFIG_DEBUG_OPTION(ov::intel_gpu, disable_fc_swiglu_fusion, false, "Disable pass which merges FC and SwiGLU ops")
+OV_CONFIG_DEBUG_OPTION(ov::intel_gpu, disable_gated_mlp_fusion, true, "Disable pass which fuses FC+SwiGLU to GatedMLP")
 OV_CONFIG_DEBUG_OPTION(ov::intel_gpu, disable_fake_alignment, false, "Disable fake alignment feature which tries to keep gpu friendly memory alignment for arbitrary tensor shapes")
 OV_CONFIG_DEBUG_OPTION(ov::intel_gpu, disable_moe_opt, false, "Disable mixture of expert optimization")
 OV_CONFIG_DEBUG_OPTION(ov::intel_gpu, disable_memory_reuse, false, "Disable memory reuse for activation tensors")

src/plugins/intel_gpu/src/graph/gated_mlp.cpp

@@ -0,0 +1,89 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "gated_mlp_inst.h"
+
+#include "json_object.h"
+#include "matmul_shape_inference.hpp"
+#include "primitive_type_base.h"
+
+#include <string>
+
+namespace cldnn {
+
+GPU_DEFINE_PRIMITIVE_TYPE_ID(gated_mlp)
+
+layout gated_mlp_inst::calc_output_layout(gated_mlp_node const& node, kernel_impl_params const& impl_param) {
+    auto desc = impl_param.typed_desc<gated_mlp>();
+    auto input_layout = impl_param.get_input_layout();
+    auto output_type = impl_param.desc->output_data_types[0].value_or(input_layout.data_type);
+    auto output_format = input_layout.format;
+
+    return layout(output_type, output_format, desc->output_size);
+}
+
+template <typename ShapeType>
+std::vector<layout> gated_mlp_inst::calc_output_layouts(gated_mlp_node const& node, const kernel_impl_params& impl_param) {
+    auto desc = impl_param.typed_desc<gated_mlp>();
+    auto input_layout = impl_param.get_input_layout();
+    auto output_type = impl_param.desc->output_data_types[0].value_or(input_layout.data_type);
+    auto output_format = input_layout.format;
+
+    std::vector<ShapeType> input_shapes = {
+        impl_param.get_input_layout(0).get<ShapeType>(),
+        impl_param.get_input_layout(1).get<ShapeType>(),
+        impl_param.get_input_layout(2).get<ShapeType>(),
+        impl_param.get_input_layout(3).get<ShapeType>()
+    };
+
+    ov::op::v0::MatMul matmul;
+    matmul.set_transpose_a(false);
+    matmul.set_transpose_b(false);
+
+    auto up_shapes = ov::op::v0::shape_infer(&matmul, std::vector<ShapeType>{input_shapes[0], input_shapes[2]});
+    auto gate_shapes = ov::op::v0::shape_infer(&matmul, std::vector<ShapeType>{input_shapes[0], input_shapes[1]});
+
+    OPENVINO_ASSERT(up_shapes[0].compatible(gate_shapes[0]),
+                    "GatedMLP requires gate/up projection output shapes to match.");
+
+    auto out_shapes = ov::op::v0::shape_infer(&matmul, std::vector<ShapeType>{up_shapes[0], input_shapes[3]});
+
+    return {layout(out_shapes[0], output_type, output_format)};
+}
+
+template std::vector<layout> gated_mlp_inst::calc_output_layouts<ov::PartialShape>(gated_mlp_node const& node,
+                                                                                    const kernel_impl_params& impl_param);
+
+std::string gated_mlp_inst::to_string(gated_mlp_node const& node) {
+    auto desc = node.get_primitive();
+    auto node_info = node.desc_to_json();
+
+    std::stringstream primitive_description;
+    json_composite gated_mlp_info;
+    gated_mlp_info.add("input_id", node.input().id());
+    gated_mlp_info.add("weights_gate_id", node.weights_gate().id());
+    gated_mlp_info.add("weights_up_id", node.weights_up().id());
+    gated_mlp_info.add("weights_down_id", node.weights_down().id());
+    gated_mlp_info.add("compressed_weights", desc->compressed_weights);
+    gated_mlp_info.add("has_decompression_zero_points", desc->has_decompression_zero_points);
+    if (desc->compressed_weights) {
+        gated_mlp_info.add("decompression_scale_gate_id", node.decompression_scale_gate().id());
+        gated_mlp_info.add("decompression_scale_up_id", node.decompression_scale_up().id());
+        gated_mlp_info.add("decompression_scale_down_id", node.decompression_scale_down().id());
+        if (desc->has_decompression_zero_points) {
+            gated_mlp_info.add("decompression_zero_point_gate_id", node.decompression_zero_point_gate().id());
+            gated_mlp_info.add("decompression_zero_point_up_id", node.decompression_zero_point_up().id());
+            gated_mlp_info.add("decompression_zero_point_down_id", node.decompression_zero_point_down().id());
+        }
+    }
+    gated_mlp_info.add("activation", static_cast<int64_t>(desc->activation));
+
+    node_info->add("gated_mlp_info", gated_mlp_info);
+    node_info->dump(primitive_description);
+    return primitive_description.str();
+}
+
+gated_mlp_inst::typed_primitive_inst(network& network, gated_mlp_node const& node) : parent(network, node) {}
+
+}  // namespace cldnn

src/plugins/intel_gpu/src/graph/graph_optimizer/add_required_reorders.cpp

@@ -7,6 +7,7 @@
 #include "program_node.h"
 #include "convert_color_inst.h"
 #include "fully_connected_inst.h"
+#include "gated_mlp_inst.h"
 #include "assign_inst.h"
 #include "mvn_inst.h"
 
@@ -276,7 +277,7 @@ void add_required_reorders::run(program& p) {
             continue;
 
         bool correct_layout_selected = false;
-        bool weights_data = (usr->is_type<convolution>() || usr->is_type<deconvolution>() || usr->is_type<fully_connected>());
+        bool weights_data = (usr->is_type<convolution>() || usr->is_type<deconvolution>() || usr->is_type<fully_connected>() || usr->is_type<gated_mlp>());
 
         layout original_layout = usr->get_output_layout();
 
@@ -339,6 +340,6 @@ void add_required_reorders::run(program& p) {
         OPENVINO_ASSERT(correct_layout_selected,
                         "[GPU] No layout format available for ", usr->id(),  ", impl_type: ", usr->get_preferred_impl_type(),
                         " (format: ", original_layout.format.to_string(),
-                        ", data_type: ", ov::element::Type(original_layout.data_type), ") ");
+                        ", data_type: ", ov::element::Type(original_layout.data_type), ") ", original_layout.to_string(), ", ", correct_layout_selected);
     }
 }