[GPU][MLIR] MLIR Graph compiler integration

.github/dockerfiles/docker_tag

@@ -1 +1 @@
-pr-37010
+pr-35336

.github/workflows/graph-compiler.yml

@@ -0,0 +1,79 @@
+name: Graph Compiler GPU Backend
+
+on:
+  push:
+  pull_request:
+
+permissions:
+  contents: read
+
+env:
+  GC_REPO: https://x-access-token:${{ secrets.GC_TOKEN }}@github.com/intel-sandbox/graph-compiler
+  GC_TAG: main
+  BUILD_DIR: ${{ github.workspace }}-gc-build
+  OUTPUT_DIR: ${{ github.workspace }}-gc-bin
+
+jobs:
+  ci:
+    runs-on: ${{ vars.RUNNER }}
+
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          submodules: recursive
+
+      - name: Build
+        run: |
+          mkdir -p $BUILD_DIR
+          run_build() {
+            [ "$1" = '-c' ] && rm -rf $BUILD_DIR
+            mkdir -p $BUILD_DIR
+            cmake -G Ninja -S "$GITHUB_WORKSPACE" -B "$BUILD_DIR" \
+              -DOUTPUT_ROOT="$OUTPUT_DIR" \
+              -DGRAPH_COMPILER_REPO="$GC_REPO" \
+              -DGRAPH_COMPILER_TAG="$GC_TAG" \
+              -DENABLE_INTEL_GPU=ON \
+              -DENABLE_GRAPH_COMPILER=ON \
+              -DENABLE_TESTS=ON \
+              -DENABLE_ONEDNN_FOR_GPU=OFF \
+              -DENABLE_INTEL_CPU=OFF \
+              -DENABLE_INTEL_NPU=OFF \
+              -DCMAKE_CXX_FLAGS="-DOV_GPU_OPENCL_HPP_HAS_UUID -DOV_GPU_OPENCL_HPP_HAS_BUS_INFO" \
+              -DOpenCL_HPP_INCLUDE_DIR="$GITHUB_WORKSPACE/thirdparty/ocl/clhpp_headers/include" \
+              -DOpenCL_HPP="$GITHUB_WORKSPACE/thirdparty/ocl/clhpp_headers/include/CL/opencl.hpp"
+            cmake --build "$BUILD_DIR" --parallel
+          }
+
+          if [ -d "$BUILD_DIR" ]; then
+            # Reuse build artifacts from previous build. If the build fails, clean and rebuild.
+            run_build || run_build -c
+          else
+            run_build
+          fi
+
+      - name: Test
+        run: |
+          # These tests require MLIR patches:
+          # https://github.com/llvm/llvm-project/pull/208932
+          # https://github.com/llvm/llvm-project/pull/197281
+          exclude='.*ScaledAttnLayerGPUMlirTest.CompareWithRefs.*|mlir_Transpose.*|mlir_ReshapeAndTranspose.*'
+
+          export OV_GPU_ENABLE_MLIR=1
+          export OV_GPU_QUEUE_TYPE=out-of-order
+          func_tests="$OUTPUT_DIR/bin/intel64/Release/ov_gpu_func_tests"
+          filter=$(printf '%s:' \
+            'MLIRExecution.SimpleMatmulf16' \
+            'MLIRExecution.SDPABasic' \
+            '*ScaledAttnLayerGPUMlirTest*' \
+            'mlir_*' \
+          )
+          tests=$("$func_tests" --gtest_list_tests --gtest_filter="${filter%:}" \
+            | awk -v exclude="$exclude" '/^  /{print suite $1} /^[^ ]/{suite=$1}' \
+            | grep -v -E "$exclude")
+          start=$SECONDS
+          echo "$tests" | xargs -P 32 -I{} "$func_tests" --gtest_filter='{}'
+          echo "Run $(echo "$tests" | wc -l) tests in $((SECONDS - start))s"
+
+          OV_MLIR_PATTERNS='mart=MatMul,Add,Reshape,Transpose;rms=Power,ReduceMean,Add,Sqrt,Divide' \
+            OV_MLIR_DEBUG=1 "$func_tests" --gtest_filter=mlir_MatMulRmsnormConcatTest* 2>&1 \
+            | grep -E 'func.func @(mart|rms)' | wc -l | xargs test 4 -eq || { echo "MLIR patterns test failed" && exit 1; }

cmake/developer_package/plugins/plugins.cmake

@@ -31,14 +31,15 @@ endif()
 #               [SOURCES <sources>]
 #               [OBJECT_LIBRARIES <object_libs>]
 #               [VERSION_DEFINES_FOR <source>]
+#               [LINKABLE] Build as a shared library so tests can link it
 #               [SKIP_INSTALL]
 #               [SKIP_REGISTRATION] Skip creation of <device>.xml
 #               [ADD_CLANG_FORMAT]
 #               [ADD_CLANG_TIDY]
 #               )
 #
 function(ov_add_plugin)
-    set(options SKIP_INSTALL PSEUDO_DEVICE ADD_CLANG_FORMAT ADD_CLANG_TIDY AS_EXTENSION SKIP_REGISTRATION)
+    set(options SKIP_INSTALL PSEUDO_DEVICE ADD_CLANG_FORMAT ADD_CLANG_TIDY AS_EXTENSION SKIP_REGISTRATION LINKABLE)
     set(oneValueArgs NAME DEVICE_NAME VERSION_DEFINES_FOR PSEUDO_PLUGIN_FOR)
     set(multiValueArgs DEFAULT_CONFIG SOURCES OBJECT_LIBRARIES)
     cmake_parse_arguments(OV_PLUGIN "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
@@ -60,7 +61,11 @@ function(ov_add_plugin)
         endforeach()
 
         if(BUILD_SHARED_LIBS)
-            set(library_type MODULE)
+            if(OV_PLUGIN_LINKABLE)
+                set(library_type SHARED)
+            else()
+                set(library_type MODULE)
+            endif()
         else()
             set(library_type STATIC)
         endif()

cmake/features.cmake

@@ -56,6 +56,8 @@ ov_dependent_option (ENABLE_CM_FOR_GPU "Enable C for Metal (CM) kernels at GPU r
 
 ov_dependent_option (ENABLE_INTEL_NPU "NPU plugin for OpenVINO runtime" ON "X86_64;WIN32 OR LINUX OR ANDROID" OFF)
 ov_dependent_option (ENABLE_INTEL_NPU_INTERNAL "NPU plugin internal components for OpenVINO runtime" ON "ENABLE_INTEL_NPU" OFF)
+ov_option (ENABLE_GRAPH_COMPILER "Enable Graph Compiler" OFF)
+
 
 ov_option (ENABLE_DEBUG_CAPS "enable OpenVINO debug capabilities at runtime" OFF)
 ov_dependent_option (ENABLE_NPU_DEBUG_CAPS "enable NPU debug capabilities at runtime" ON "ENABLE_DEBUG_CAPS;ENABLE_INTEL_NPU" OFF)

cmake/graph-compiler.cmake

@@ -0,0 +1,26 @@
+include_guard()
+include("${CMAKE_CURRENT_LIST_DIR}/llvm.cmake")
+
+find_package(GraphCompiler QUIET CONFIG)
+
+if (NOT GraphCompiler_FOUND)
+  option(GRAPH_COMPILER_DYLINK "Use dynamic linking with GraphCompiler" OFF)
+  set(GRAPH_COMPILER_REPO "https://github.com/dchigarev/graph-compiler" CACHE STRING "GraphCompiler repository URL")
+  set(GRAPH_COMPILER_TAG "ov_pin/0.1.0" CACHE STRING "GraphCompiler git tag/branch")
+  message(STATUS "GraphCompiler not found, fetching from: ${GRAPH_COMPILER_REPO}")
+  include(FetchContent)
+  FetchContent_Declare(
+      GraphCompiler
+      GIT_REPOSITORY ${GRAPH_COMPILER_REPO}
+      GIT_TAG ${GRAPH_COMPILER_TAG}
+      GIT_SHALLOW TRUE
+  )
+  set(GC_ENABLE_TEST OFF CACHE BOOL "" FORCE)
+  set(GC_ENABLE_TOOLS OFF CACHE BOOL "" FORCE)
+  set(GC_ENABLE_PYTHON_BINDINGS OFF CACHE BOOL "" FORCE)
+  set(GC_DYLINK ${GRAPH_COMPILER_DYLINK} CACHE BOOL "" FORCE)
+  set(_ov_build_shared_libs ${BUILD_SHARED_LIBS})
+  set(BUILD_SHARED_LIBS ${GRAPH_COMPILER_DYLINK})
+  FetchContent_MakeAvailable(GraphCompiler)
+  set(BUILD_SHARED_LIBS ${_ov_build_shared_libs})
+endif()

cmake/llvm.cmake

@@ -0,0 +1,17 @@
+include_guard()
+
+set(SUPPORTED_LLVM_VERSION "23" CACHE STRING "")
+
+find_package(LLVM CONFIG QUIET)
+if (NOT LLVM_FOUND)
+    set(LLVM_DIR "/usr/lib/llvm-${SUPPORTED_LLVM_VERSION}/lib/cmake/llvm" CACHE PATH "" FORCE)
+    find_package(LLVM REQUIRED CONFIG)
+endif()
+
+find_package(MLIR CONFIG QUIET)
+if (NOT MLIR_FOUND)
+    get_filename_component(llvm_cmake_path "${LLVM_DIR}" REALPATH)
+    get_filename_component(llvm_cmake_dir "${llvm_cmake_path}" DIRECTORY)
+    set(MLIR_DIR "${llvm_cmake_dir}/mlir" CACHE PATH "" FORCE)
+    find_package(MLIR REQUIRED CONFIG)
+endif()

src/inference/include/openvino/runtime/intel_gpu/properties.hpp

@@ -83,6 +83,18 @@ static constexpr Property<bool> enable_loop_unrolling{"GPU_ENABLE_LOOP_UNROLLING
  */
 static constexpr Property<bool> disable_winograd_convolution{"GPU_DISABLE_WINOGRAD_CONVOLUTION"};
 
+/**
+ * @brief Enables MLIR-based Graph Compiler execution for supported subgraphs.
+ * When on, matching subgraphs (matmul, elementwise, SDPA, reduction, etc.)
+ * are compiled through the MLIR/Graph-Compiler pipeline and executed as a
+ * single fused GPU kernel via cldnn::mlir_primitive.
+ * Requires the plugin to be built with -DENABLE_GRAPH_COMPILER=ON; setting
+ * this to true on a plugin built without Graph Compiler support raises an
+ * exception at compile_model() time.
+ * @ingroup ov_runtime_ocl_gpu_prop_cpp_api
+ */
+static constexpr Property<bool> enable_mlir{"GPU_ENABLE_MLIR"};
+
 namespace hint {
 /**
  * @brief This enum represents the possible value of ov::intel_gpu::hint::queue_throttle property:

src/plugins/intel_gpu/CMakeLists.txt

@@ -134,9 +134,35 @@ add_subdirectory(src/graph)
 
 file(GLOB_RECURSE PLUGIN_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/plugin/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/include/intel_gpu/plugin/*.hpp)
 
+# MLIR sources are always excluded from the main plugin target. When
+# ENABLE_GRAPH_COMPILER=ON they are built into a dedicated OBJECT library
+# (openvino_intel_gpu_mlir_obj) that has MLIR/Graph-Compiler include paths;
+# when OFF they must not be compiled at all.
+set(OV_GPU_MLIR_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src/plugin/transformations/mlir)
+file(GLOB_RECURSE GPU_MLIR_SOURCES ${OV_GPU_MLIR_DIR}/*.cpp)
+list(REMOVE_ITEM PLUGIN_SOURCES ${GPU_MLIR_SOURCES})
+
+if(ENABLE_GRAPH_COMPILER)
+    include(${CMAKE_SOURCE_DIR}/cmake/graph-compiler.cmake)
+
+    set(mlir_lib openvino_intel_gpu_mlir_obj)
+    add_library(${mlir_lib} OBJECT ${GPU_MLIR_SOURCES})
+    target_compile_options(${mlir_lib} PRIVATE -Wno-error)
+    target_compile_definitions(${mlir_lib} PRIVATE GRAPH_COMPILER IMPLEMENT_OPENVINO_API)
+    target_link_libraries(${mlir_lib} PRIVATE openvino::runtime openvino_intel_gpu_graph GraphCompiler)
+    target_include_directories(${mlir_lib} PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}/include/
+            ${OV_GPU_MLIR_DIR})
+
+    set(GPU_PLUGIN_OBJECT_LIBRARIES ${mlir_lib})
+    set(GPU_PLUGIN_OPTIONS LINKABLE)
+endif()
+
 ov_add_plugin(NAME ${TARGET_NAME}
               DEVICE_NAME "GPU"
               SOURCES ${PLUGIN_SOURCES}
+              OBJECT_LIBRARIES ${GPU_PLUGIN_OBJECT_LIBRARIES}
+              ${GPU_PLUGIN_OPTIONS}
               DEFAULT_CONFIG ${PLUGIN_DEFAULT_CONFIG}
               VERSION_DEFINES_FOR src/plugin/plugin.cpp
               # ADD_CLANG_TIDY makes ov_add_plugin apply clang-tidy to this target.
@@ -151,6 +177,11 @@ target_link_libraries(${TARGET_NAME} PRIVATE openvino_intel_gpu_graph openvino::
 target_include_directories(${TARGET_NAME} PRIVATE
         ${CMAKE_CURRENT_SOURCE_DIR}/include/)
 
+if(ENABLE_GRAPH_COMPILER)
+    target_link_libraries(${TARGET_NAME} PRIVATE GraphCompiler)
+    target_compile_definitions(${TARGET_NAME} PRIVATE GRAPH_COMPILER)
+endif()
+
 ov_set_threading_interface_for(${TARGET_NAME})
 ov_gpu_set_runtime_interface_for(${TARGET_NAME})
 

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

@@ -0,0 +1,55 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <memory>
+#include <tuple>
+#include <vector>
+
+#include "openvino/core/any.hpp"
+#include "openvino/core/partial_shape.hpp"
+#include "openvino/core/type/element_type.hpp"
+#include "openvino/op/op.hpp"
+#include "openvino/runtime/tensor.hpp"
+
+namespace ov::intel_gpu {
+namespace mlir {
+class MLIREvaluateBase;
+}  // namespace mlir
+namespace op {
+
+using OVOutputTypes = std::vector<std::tuple<ov::element::Type, ov::PartialShape>>;
+
+// Maps [output index][dimension index] -> [input index][dimension index] to
+// infer shapes for the entire subgraph.
+using DimensionsMap = std::vector<std::vector<std::tuple<size_t, size_t>>>;
+
+class MLIROp : public ov::op::Op {
+    std::shared_ptr<mlir::MLIREvaluateBase> engine;
+    OVOutputTypes output_types;
+    DimensionsMap dimensions_map;
+
+public:
+    OPENVINO_OP("MLIROp");
+
+    MLIROp() = default;
+
+    MLIROp(const ov::OutputVector& args,
+           std::shared_ptr<mlir::MLIREvaluateBase> engine,
+           const OVOutputTypes& output_types,
+           const DimensionsMap& dimensions_map);
+
+    void validate_and_infer_types() override;
+    std::shared_ptr<ov::Node> clone_with_new_inputs(const ov::OutputVector& new_args) const override;
+    bool evaluate(ov::TensorVector& outputs, const ov::TensorVector& inputs) const override;
+    bool evaluate(ov::TensorVector& outputs,
+                  const ov::TensorVector& inputs,
+                  const ov::EvaluationContext& evaluationContext) const override;
+    bool has_evaluate() const override;
+    std::vector<ov::PartialShape> shape_infer(const std::vector<ov::PartialShape>& input_shapes) const;
+};
+
+}  // namespace op
+}  // namespace ov::intel_gpu

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

@@ -328,3 +328,6 @@ REGISTER_FACTORY(internal, GatherMatmul);
 REGISTER_FACTORY(internal, GatherMatmulCompressed);
 REGISTER_FACTORY(internal, GroupedMatMulCompressed);
 REGISTER_FACTORY(internal, Atan2);
+#ifdef GRAPH_COMPILER
+REGISTER_FACTORY(internal, MLIR);
+#endif

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

@@ -0,0 +1,44 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include "openvino/core/partial_shape.hpp"
+#include "primitive.hpp"
+
+namespace ov {
+class Node;  // forward-decl — the underlying op is ov::intel_gpu::op::MLIROp
+}
+
+namespace cldnn {
+
+/// @brief Primitive that wraps an ov::intel_gpu::op::MLIROp node. Its execute_impl
+/// (see impls/common/mlir_primitive.cpp) forwards to MLIROp::evaluate().
+struct mlir_primitive : public primitive_base<mlir_primitive> {
+    CLDNN_DECLARE_PRIMITIVE(mlir_primitive)
+
+    using shape_infer_function =
+        std::function<std::vector<ov::PartialShape>(const std::vector<ov::PartialShape>&)>;
+
+    mlir_primitive() : primitive_base("", {}) {}
+
+    mlir_primitive(const primitive_id& id,
+                   const std::vector<input_info>& inputs,
+                   std::shared_ptr<ov::Node> op,
+                   shape_infer_function shape_infer_f,
+                   size_t num_outputs,
+                   const std::vector<optional_data_type>& out_types)
+        : primitive_base(id, inputs, num_outputs, out_types),
+          op(std::move(op)),
+          shape_infer_f(std::move(shape_infer_f)) {}
+
+    std::shared_ptr<ov::Node> op;
+    shape_infer_function shape_infer_f;
+};
+
+}  // namespace cldnn

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

@@ -45,6 +45,8 @@ struct event {
 
     // returns true if handler has been successfully added
     bool add_event_handler(event_handler handler, void* data);
+    // return a handle to an underlying event implementation (i.e. cl_event for OpenCL)
+    virtual void* get_native_handle() { return nullptr; }
 
     std::vector<instrumentation::profiling_interval> get_profiling_info();
 

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

@@ -55,6 +55,8 @@ struct memory {
     }
     // only supports gpu_usm
     virtual void* buffer_ptr() const { return nullptr; }
+    // Returns the handle to the underlying memory object (e.g. cl_mem for OpenCL)
+    virtual void* get_native_handle() const { return nullptr; }
 
     size_t size() const { return _bytes_count; }
     size_t count() const { return _layout.count(); }

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

@@ -34,6 +34,7 @@ OV_CONFIG_RELEASE_OPTION(ov::intel_gpu::hint, queue_throttle, ov::intel_gpu::hin
 OV_CONFIG_RELEASE_OPTION(ov::intel_gpu::hint, queue_priority, ov::hint::Priority::MEDIUM, "Low-level hint that controls queue priority property")
 OV_CONFIG_RELEASE_OPTION(ov::intel_gpu::hint, enable_sdpa_optimization, true, "Enable/Disable fused SDPA primitive execution")
 OV_CONFIG_RELEASE_OPTION(ov::intel_gpu::hint, enable_lora_operation, true, "Enable/Disable LoRA operation. The separate operation is less versatile, but has better performance")
+OV_CONFIG_RELEASE_OPTION(ov::intel_gpu, enable_mlir, false, "Enable/Disable MLIR/Graph-Compiler execution for supported subgraphs. Requires ENABLE_GRAPH_COMPILER=ON at build time")
 OV_CONFIG_RELEASE_OPTION(ov::intel_gpu::hint, enable_large_allocations, false, "Allow buffer allocations that exceed the device max allocation size. Enabling this option may lead to performance degradation")
 OV_CONFIG_RELEASE_OPTION(ov::intel_gpu, enable_loop_unrolling, true, "Enable/Disable Loop/TensorIterator operation unrolling")
 OV_CONFIG_RELEASE_OPTION(ov::intel_gpu, disable_winograd_convolution, false, "Enable/Disable winograd convolution implementation if available")

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

@@ -67,10 +67,13 @@ class stream {
     virtual void wait_for_events(const std::vector<event::ptr>& events) = 0;
     virtual event::ptr create_user_event(bool set) = 0;
     virtual event::ptr create_base_event() = 0;
+    virtual event::ptr create_base_event(void* /*handle*/) { return nullptr; }
     virtual std::unique_ptr<surfaces_lock> create_surfaces_lock(const std::vector<memory::ptr> &mem) const = 0;
     virtual event::ptr aggregate_events(const std::vector<event::ptr>& events, bool group = false, bool is_output = false);
 
     QueueTypes get_queue_type() const { return m_queue_type; }
+    // Returns the handle to the underlying stream object (e.g. cl_command_queue for OpenCL)
+    virtual void* get_native_handle() const { return nullptr; }
     SyncMethods get_sync_method() const { return m_sync_method; }
 
     static SyncMethods get_expected_sync_method(const ExecutionConfig& config);