Merge branch 'master' into singleton_ocl_context

Author: isanghao

.github/dockerfiles/docker_tag

@@ -1 +1 @@
-pr-33859
+pr-29664

.github/dockerfiles/ov_test/ubuntu_22_04_arm64/Dockerfile

@@ -33,6 +33,13 @@ RUN apt-get update && \
         python3.11-distutils \
         libhdf5-dev \
         libgomp1 \
+        # libGL for PyTorch Models tests
+        ffmpeg  \
+        libsm6  \
+        libxext6 \
+        libgl1 \
+        libgl1-mesa-glx \
+        libglib2.0-0 \
         && \
     rm -rf /var/lib/apt/lists/*
 

.github/workflows/job_gpu_tests.yml

@@ -15,6 +15,10 @@ on:
         description: 'Runner labels by which the runner will be chosen. Example: [ "self-hosted", "igpu" ]'
         type: string
         required: true
+      runner-group:
+        description: 'Runner group from which the runner will be chosen'
+        type: string
+        required: true
       image:
         description: 'Docker image in which the tests would run'
         type: string
@@ -31,11 +35,13 @@ permissions: read-all
 jobs:
   GPU:
     timeout-minutes: 80
-    runs-on: ${{ fromJSON(inputs.runner) }}
+    runs-on:
+      group: ${{ inputs.runner-group }}
+      labels: ${{ fromJSON(inputs.runner) }}
     container:
       image: ${{ inputs.image }}
       volumes:
-        - /dev/dri:/dev/dri
+        - /usr/local/share/ca-certificates:/usr/local/share/ca-certificates:ro # Needed to access CA certificates
         - ${{ github.workspace }}:${{ github.workspace }} # Needed as ${{ github.workspace }} is not working correctly when using Docker
       options: ${{ inputs.options }}
     defaults:
@@ -46,6 +52,7 @@ jobs:
       INSTALL_DIR: ${{ github.workspace }}/install
       INSTALL_TEST_DIR: ${{ github.workspace }}/install/tests
       GTEST_PARALLEL_SCRIPT: ${{ github.workspace }}/gtest_parallel.py
+      NODE_EXTRA_CA_CERTS: /usr/local/share/ca-certificates/IntelProxyRootCA-Base64.crt
     steps:
       - name: Download OpenVINO artifacts (package)
         uses: akashchi/download-artifact@d59a9c15fec3fdb7c9adf09464124d00f9c11415
@@ -61,6 +68,7 @@ jobs:
 
       - name: Extract OpenVINO packages
         run: |
+            apt-get update && apt-get install -y pigz
             pigz -dc openvino_package.tar.gz | tar -xf - -v
             pigz -dc openvino_tests.tar.gz | tar -xf - -v
         working-directory: ${{ env.INSTALL_DIR }}
@@ -72,6 +80,7 @@ jobs:
         env:
           DEBIAN_FRONTEND: noninteractive # to prevent apt-get from waiting user input
           TZ: "Europe/London" # to prevent tzdata from waiting user input
+
       - name: Setup Python ${{ env.PYTHON_VERSION }}
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
@@ -96,8 +105,12 @@ jobs:
         run: |
           apt-get update && apt-get install -y \
             libegl-mesa0 libegl1-mesa libegl1-mesa-dev libgbm1 libgl1-mesa-dev libgl1-mesa-dri \
-            libglapi-mesa libgles2-mesa-dev libglx-mesa0 libigdgmm11 libxatracker2 mesa-va-drivers \
+            libglapi-mesa libgles2-mesa-dev libglx-mesa0 libxatracker2 mesa-va-drivers \
             mesa-vdpau-drivers mesa-vulkan-drivers va-driver-all
+            wget -qO - https://repositories.intel.com/gpu/intel-graphics.key |  gpg --yes --dearmor --output /usr/share/keyrings/intel-graphics.gpg
+            echo "deb [arch=amd64,i386 signed-by=/usr/share/keyrings/intel-graphics.gpg] https://repositories.intel.com/gpu/ubuntu jammy unified" | tee /etc/apt/sources.list.d/intel-gpu-jammy.list
+            apt update
+            apt-get install -y libze-intel-gpu1 libze1 intel-opencl-icd libze-dev intel-ocloc intel-level-zero-gpu-raytracing
 
       - name: Verify devices
         run: clinfo
@@ -130,7 +143,7 @@ jobs:
 
 
       - name: Upload Test Results
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2 We are not using newest version v6.0.0 due to very frequent issues with 'Error: Unable to make request: ECONNRESET'
         if: always()
         with:
           name: test-results-${{ inputs.test_type }}-${{ inputs.device }}

.github/workflows/linux_arm64.yml

@@ -270,9 +270,8 @@ jobs:
 
   PyTorch_Models_Tests:
     name: PyTorch Models tests
-    if: ${{ 'false' }} # TODO: Enable once the dependencies are ready for arm (no tensorflow-text available for arm from PyPI)
-    # if: fromJSON(needs.smart_ci.outputs.affected_components).PyTorch_FE.test
-    needs: [ Build, Docker, Smart_CI ]
+    if: fromJSON(needs.smart_ci.outputs.affected_components).PyTorch_FE.test
+    needs: [ Build, Docker, Smart_CI, Openvino_tokenizers ]
     uses: ./.github/workflows/job_pytorch_models_tests.yml
     with:
       runner: 'aks-linux-16-cores-32gb-arm'

.github/workflows/ubuntu_22.yml

@@ -590,10 +590,10 @@ jobs:
       device: 'igpu'
       test_type: ${{ matrix.TEST_TYPE }}
       runner: "[ 'self-hosted', 'igpu' ]"
+      runner-group: 'Intel-GPU'
       image: ubuntu:22.04
-      options: "--group-add 109 --group-add 44 --device /dev/dri:/dev/dri"
-    # if: fromJSON(needs.smart_ci.outputs.affected_components).GPU
-    if: ${{ 'false' }} # Ticket: 143677
+      options: "--group-add 44 --group-add 993 --device /dev/dri/card1:/dev/dri/card1 --device /dev/dri/renderD128:/dev/dri/renderD128"
+    if: fromJSON(needs.smart_ci.outputs.affected_components).GPU
 
   dGPU:
     name: dGPU Tests
@@ -608,8 +608,9 @@ jobs:
       device: 'dgpu'
       test_type: ${{ matrix.TEST_TYPE }}
       runner: "[ 'self-hosted', 'dgpu' ]"
+      runner-group: 'Intel-GPU'
       image: ubuntu:22.04
-      options: "--group-add 109 --group-add 44 --device /dev/dri/card0:/dev/dri/card0 --device /dev/dri/renderD128:/dev/dri/renderD128"
+      options: "--group-add 44 --group-add 993 --device /dev/dri/card2:/dev/dri/card2 --device /dev/dri/renderD129:/dev/dri/renderD129"
     # if: ${{ github.event_name == 'schedule' }}
     if: ${{ 'false' }} # Ticket: 143677
 

docs/articles_en/about-openvino/release-notes-openvino/system-requirements.rst

@@ -19,7 +19,7 @@ CPU
 
    .. tab-item:: Supported Hardware
 
-      * Intel® Core™ Ultra Series 1 and Series 2
+      * Intel® Core™ Ultra Series 1, Series 2 and Series 3
       * Intel® Xeon® 6 processor
       * Intel Atom® Processor X Series
       * Intel Atom® processor with Intel® SSE4.2 support

src/frontends/common_translators/include/unconverted_ops_report.hpp

@@ -0,0 +1,76 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+
+#include "openvino/core/model.hpp"
+#include "openvino/frontend/extension/telemetry.hpp"
+#include "openvino/op/util/framework_node.hpp"
+#include "openvino/op/util/multi_subgraph_base.hpp"
+
+namespace ov {
+namespace frontend {
+
+/// \brief Structure containing information about unconverted operations
+/// Map of operation types with no conversion rule (op_type -> empty string)
+/// or operations that failed during conversion (op_type -> error message)
+struct UnconvertedOpsReport {
+    std::map<std::string, std::string> unconverted_ops;
+
+    bool has_issues() const;
+
+    /// \brief Add an unconverted operation if not already present
+    /// \param op_type Operation type name
+    /// \param error_message Error message (empty if no converter found, non-empty if conversion failed)
+    void add(const std::string& op_type, const std::string& error_message = {});
+
+    /// \brief Merge another report into this one
+    void merge(const UnconvertedOpsReport& other);
+};
+
+/// \brief Callback type for extracting unconverted operation info from framework-specific nodes
+/// \param node The node to check
+/// \return Optional pair of (op_type, error_message) if this is an unconverted framework node
+using FrameworkNodeExtractor =
+    std::function<std::optional<std::pair<std::string, std::string>>(const std::shared_ptr<ov::Node>&)>;
+
+/// \brief Collect unconverted operations from a model
+/// \param model The model to scan
+/// \param extractor Callback to extract info from framework-specific nodes
+/// \return Report containing all unconverted operations found
+UnconvertedOpsReport collect_unconverted_ops(const std::shared_ptr<ov::Model>& model,
+                                             const FrameworkNodeExtractor& extractor);
+
+/// \brief Callback type for adding additional error information
+/// \param unsupported_ops Set of unsupported operation types (those without error messages)
+/// \return Additional message to append to the error report
+using AdditionalErrorCallback = std::function<std::string(const std::set<std::string>&)>;
+
+/// \brief Check conversion result, send telemetry, and optionally throw if there are unconverted operations
+/// \param report The unconverted operations report
+/// \param telemetry Telemetry extension (can be nullptr)
+/// \param telemetry_prefix Frontend name prefix for telemetry events (e.g., "pytorch", "tf", "onnx", "jax")
+/// \param error_message_prefix Prefix for filtering error messages in telemetry (e.g., "[PyTorch Frontend] ")
+///                             If non-empty, error_info telemetry events will be sent
+/// \param additional_error Additional error message (e.g., from normalize step)
+/// \param additional_callback Optional callback for frontend-specific additional error messages
+/// \param throw_on_issues If true (default), throws when there are unconverted ops or additional_error is non-empty
+/// \throws ov::frontend::OpConversionFailure if throw_on_issues is true and there are issues
+void check_unconverted_ops(const UnconvertedOpsReport& report,
+                           const std::shared_ptr<TelemetryExtension>& telemetry,
+                           const std::string& telemetry_prefix,
+                           const std::string& error_message_prefix = {},
+                           const std::string& additional_error = {},
+                           const AdditionalErrorCallback& additional_callback = nullptr,
+                           bool throw_on_issues = true);
+
+}  // namespace frontend
+}  // namespace ov

src/frontends/common_translators/src/unconverted_ops_report.cpp

@@ -0,0 +1,147 @@
+// Copyright (C) 2018-2026 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "unconverted_ops_report.hpp"
+
+#include <sstream>
+
+#include "openvino/frontend/exception.hpp"
+#include "openvino/util/common_util.hpp"
+
+namespace ov {
+namespace frontend {
+
+bool UnconvertedOpsReport::has_issues() const {
+    return !unconverted_ops.empty();
+}
+
+void UnconvertedOpsReport::add(const std::string& op_type, const std::string& error_message) {
+    if (unconverted_ops.find(op_type) == unconverted_ops.end()) {
+        unconverted_ops[op_type] = error_message;
+    }
+}
+
+void UnconvertedOpsReport::merge(const UnconvertedOpsReport& other) {
+    for (const auto& [op_type, msg] : other.unconverted_ops) {
+        add(op_type, msg);
+    }
+}
+
+UnconvertedOpsReport collect_unconverted_ops(const std::shared_ptr<ov::Model>& model,
+                                             const FrameworkNodeExtractor& extractor) {
+    UnconvertedOpsReport report;
+    if (!model) {
+        return report;
+    }
+
+    for (const auto& node : model->get_ordered_ops()) {
+        // Try framework-specific extractor first
+        if (auto result = extractor(node)) {
+            report.add(result->first, result->second);
+        }
+
+        // Handle MultiSubGraphOp (parent of Loop, If, etc.) - common for all frontends
+        if (const auto& subgraph_op = ov::as_type_ptr<ov::op::util::MultiSubGraphOp>(node)) {
+            for (size_t i = 0; i < subgraph_op->get_internal_subgraphs_size(); ++i) {
+                report.merge(collect_unconverted_ops(subgraph_op->get_function(i), extractor));
+            }
+        }
+    }
+    return report;
+}
+
+namespace {
+
+std::string format_unconverted_ops_report(const UnconvertedOpsReport& report,
+                                          const std::string& additional_error,
+                                          const AdditionalErrorCallback& additional_callback) {
+    std::stringstream error_msg;
+    std::stringstream unconverted_ops_msg;
+    std::stringstream failed_ops_msg;
+    std::stringstream failed_ops_short;
+
+    error_msg << "Model wasn't fully converted.";
+    unconverted_ops_msg << "-- No conversion rule found for operations: ";
+    failed_ops_msg << " Failed operations detailed log:";
+    failed_ops_short << "-- Conversion is failed for: ";
+
+    bool has_unsupported = false;
+    bool has_failed = false;
+    std::set<std::string> unsupported_ops_set;
+
+    for (const auto& [op_type, error] : report.unconverted_ops) {
+        if (error.empty()) {
+            // No conversion rule found
+            if (has_unsupported) {
+                unconverted_ops_msg << ", ";
+            }
+            unconverted_ops_msg << op_type;
+            unsupported_ops_set.insert(op_type);
+            has_unsupported = true;
+        } else {
+            // Conversion failed with error
+            if (has_failed) {
+                failed_ops_short << ", ";
+            }
+            failed_ops_short << op_type;
+            failed_ops_msg << "\n-- " << op_type << " with a message:\n" << error;
+            has_failed = true;
+        }
+    }
+
+    if (has_failed) {
+        error_msg << failed_ops_msg.str();
+    }
+
+    error_msg << "\nSummary:" << additional_error;
+
+    if (has_unsupported) {
+        error_msg << '\n' << unconverted_ops_msg.str();
+    }
+
+    if (has_failed) {
+        error_msg << '\n' << failed_ops_short.str();
+    }
+
+    // Add additional callback-provided information
+    if (additional_callback && has_unsupported) {
+        if (auto additional_info = additional_callback(unsupported_ops_set); !additional_info.empty()) {
+            error_msg << '\n' << additional_info;
+        }
+    }
+
+    return error_msg.str();
+}
+
+}  // namespace
+
+void check_unconverted_ops(const UnconvertedOpsReport& report,
+                           const std::shared_ptr<TelemetryExtension>& telemetry,
+                           const std::string& telemetry_prefix,
+                           const std::string& error_message_prefix,
+                           const std::string& additional_error,
+                           const AdditionalErrorCallback& additional_callback,
+                           bool throw_on_issues) {
+    // Send telemetry for all unconverted operations
+    if (telemetry) {
+        const bool send_error_info = !error_message_prefix.empty();
+        for (const auto& [op_type, error] : report.unconverted_ops) {
+            telemetry->send_event("error_cause", telemetry_prefix + "_" + op_type);
+            if (send_error_info && !error.empty()) {
+                auto cropped_message = ov::util::filter_lines_by_prefix(error, error_message_prefix);
+                if (!cropped_message.empty()) {
+                    telemetry->send_event("error_info", cropped_message);
+                }
+            }
+        }
+    }
+
+    if (throw_on_issues && (report.has_issues() || !additional_error.empty())) {
+        FRONT_END_OP_CONVERSION_CHECK(false,
+                                      format_unconverted_ops_report(report, additional_error, additional_callback));
+    }
+}
+
+}  // namespace frontend
+}  // namespace ov