Merge branch 'master' into gha/smart_ci_snippets

.github/dependabot.yml

@@ -141,3 +141,18 @@ updates:
       - "mryzhov"
       - "ilya-lavrenov"
     open-pull-requests-limit: 3
+
+  # Docker images
+  - package-ecosystem: docker
+    directory: "/"
+    schedule:
+      interval: "daily"
+      time: "09:00"
+      timezone: "Asia/Dubai"
+    allow:
+      - dependency-type: "direct"
+    assignees:
+      - "akashchi"
+      - "mryzhov"
+      - "ilya-lavrenov"
+    open-pull-requests-limit: 3

.github/scripts/workflow_rerun/errors_to_look_for.json

@@ -8,7 +8,7 @@
         "ticket": 135715
     },
     {
-        "error_text": "GnuTLS recv error",
+        "error_text": "error: RPC failed",
         "ticket": 131918
     },
     {

.github/workflows/code_style.yml

@@ -38,6 +38,36 @@ jobs:
           level: warning
           fail_on_error: true
 
+  clang-format-aarch64:
+    runs-on: ubuntu-22.04
+    if: ${{ github.repository_owner == 'openvinotoolkit' }}
+    permissions:
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          submodules: 'true'
+
+      - name: Install clang-format-15 and cross-compilation dependencies
+        run: |
+          sudo apt update
+          sudo apt --assume-yes install binutils-aarch64-linux-gnu gcc-aarch64-linux-gnu g++-aarch64-linux-gnu scons clang-format-15
+
+      # Run cmake with -DENABLE_PROFILING_ITT=ON -DSELECTIVE_BUILD=COLLECT in order to enable codestyle check for ITT collector
+      - name: CMake configure
+        run: cmake -DENABLE_CLANG_FORMAT=ON -DENABLE_TESTS=ON -DENABLE_PROFILING_ITT=ON -DSELECTIVE_BUILD=COLLECT -DCMAKE_TOOLCHAIN_FILE=cmake/arm64.toolchain.cmake -B build_arm64
+
+      - name: Create code style diff
+        run: cmake --build build_arm64 --target clang_format_fix_all -j8
+
+      - name: suggester / clang-format
+        if: startsWith(github.event_name, 'pull_request')
+        uses: reviewdog/action-suggester@db4abb16fbaabe386831e5addb7be1485d0d63d3 # v1.18.0
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          level: warning
+          fail_on_error: true
+
   ShellCheck:
     runs-on: ubuntu-22.04
     if: ${{ github.repository_owner == 'openvinotoolkit' }}

.github/workflows/linux_arm64.yml

@@ -97,6 +97,7 @@ jobs:
             -DENABLE_SYSTEM_OPENCL=ON \
             -DCMAKE_VERBOSE_MAKEFILE=ON \
             -DCPACK_GENERATOR=TGZ \
+            -DENABLE_WHEEL=ON \
             -DCMAKE_COMPILE_WARNING_AS_ERROR=ON
 
   Debian_Packages:

.github/workflows/ubuntu_20.yml

@@ -98,6 +98,7 @@ jobs:
             -DENABLE_SYSTEM_OPENCL=ON \
             -DCMAKE_VERBOSE_MAKEFILE=ON \
             -DCPACK_GENERATOR=TGZ \
+            -DENABLE_WHEEL=ON \
             -DCMAKE_COMPILE_WARNING_AS_ERROR=ON
 
   CXX_Unit_Tests:

.github/workflows/ubuntu_22.yml

@@ -101,6 +101,7 @@ jobs:
             -DENABLE_SYSTEM_OPENCL=ON \
             -DCMAKE_VERBOSE_MAKEFILE=ON \
             -DCPACK_GENERATOR=TGZ \
+            -DENABLE_WHEEL=ON \
             -DCMAKE_COMPILE_WARNING_AS_ERROR=ON
 
   Debian_Packages:

.github/workflows/windows_vs2019_release.yml

@@ -63,6 +63,7 @@ jobs:
       cmake-options: |-
             -G "Ninja Multi-Config" `
             -DENABLE_PYTHON=ON `
+            -DENABLE_WHEEL=ON `
             -DENABLE_CPPLINT=OFF `
             -DBUILD_SHARED_LIBS=ON `
             -DENABLE_TESTS=ON `

cmake/developer_package/compile_flags/os_flags.cmake

@@ -4,6 +4,7 @@
 
 include(ProcessorCount)
 include(CheckCXXCompilerFlag)
+include(CheckCXXSourceCompiles)
 
 #
 # ov_disable_deprecated_warnings()
@@ -91,6 +92,50 @@ macro(ov_dev_package_no_errors)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ov_c_cxx_dev_no_errors}")
 endmacro()
 
+#
+# ov_check_compiler_supports_sve(flags)
+#
+# Checks whether CXX compiler for passed language supports SVE code compilation
+#
+macro(ov_check_compiler_supports_sve flags)
+    # Code to compile
+    set(SVE_CODE "
+    #include <arm_sve.h>
+    int main() {
+        svfloat64_t a;
+        a = svdup_n_f64(0);
+        return 0;
+    }")
+
+    # Save the current state of required flags
+    set(CMAKE_REQUIRED_FLAGS_SAVE ${CMAKE_REQUIRED_FLAGS})
+
+    # Set the flags necessary for compiling the test code with SVE support
+    set(CMAKE_REQUIRED_FLAGS "${CMAKE_CXX_FLAGS_INIT} ${flags}")
+
+    # Check if the source code compiles with the given flags for C++
+    CHECK_CXX_SOURCE_COMPILES("${SVE_CODE}" CXX_HAS_SVE)            
+
+    # If the compilation test is successful, set appropriate variables indicating support
+    if(CXX_HAS_SVE)
+        set(CXX_SVE_FOUND TRUE CACHE BOOL "SVE available on host")
+        set(CXX_SVE_FOUND TRUE CACHE BOOL "CXX SVE support")
+        set(CXX_SVE_FLAGS "${flags}" CACHE STRING "CXX SVE flags")
+    endif()
+
+    # Restore the original state of required flags
+    set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS_SAVE})
+
+    # If the compilation test fails, indicate that the support is not found
+    if(NOT CXX_SVE_FOUND)
+        set(CXX_SVE_FOUND FALSE CACHE BOOL "CXX SVE support")
+        set(CXX_SVE_FLAGS "" CACHE STRING "CXX SVE flags")
+    endif()
+
+    # Mark the variables as advanced to hide them in the default CMake GUI
+    mark_as_advanced(CXX_SVE_FOUND CXX_SVE_FLAGS)
+endmacro()
+
 #
 # ov_sse42_optimization_flags(<output flags>)
 #
@@ -208,6 +253,49 @@ macro(ov_arm_neon_fp16_optimization_flags flags)
     endif()
 endmacro()
 
+#
+# ov_arm_sve_optimization_flags(<output flags>)
+#
+macro(ov_arm_sve_optimization_flags flags)
+    # Check for compiler SVE support
+    ov_check_compiler_supports_sve("-march=armv8-a+sve")
+
+    if(OV_COMPILER_IS_INTEL_LLVM)
+        message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+        # nothing should be required here
+    elseif(ANDROID)
+        if(ANDROID_ABI STREQUAL "arm64-v8a")
+            set(${flags} -Wno-unused-command-line-argument)
+            if(CXX_SVE_FOUND)
+                list(APPEND ${flags} -march=armv8-a+sve)
+            else()
+                message(WARNING "SVE is not supported on this Android ABI: ${ANDROID_ABI}")
+            endif()
+        else()
+            message(WARNING "SVE is not supported on this Android ABI: ${ANDROID_ABI}")
+        endif()
+    else()
+        if(AARCH64)
+            set(${flags} -O2)
+
+            # Add flag for SVE if supported
+            if(CXX_SVE_FOUND)
+                list(APPEND ${flags} -march=armv8-a+sve)
+            endif()
+            if(NOT CMAKE_CL_64)
+                list(APPEND ${flags} -ftree-vectorize)
+            endif()
+
+            set(${flags} ${${flags}})
+        elseif(ARM)
+            message(WARNING "SVE is not supported on 32-bit ARM architectures.")
+        else()
+            message(WARNING "SVE is not supported by architecture ${CMAKE_SYSTEM_PROCESSOR}")
+        endif()
+    endif()
+endmacro()
+
 #
 # ov_disable_all_warnings(<target1 [target2 target3 ...]>)
 #

cmake/developer_package/cross_compile/cross_compiled_disp_gen.cmake

@@ -18,6 +18,7 @@ set(_CPU_CHECK_ANY         "true")
 set(_CPU_CHECK_SSE42       "with_cpu_x86_sse42()")
 set(_CPU_CHECK_AVX         "with_cpu_x86_avx()")
 set(_CPU_CHECK_NEON_FP16   "with_cpu_neon_fp16()")
+set(_CPU_CHECK_SVE         "with_cpu_sve()")
 set(_CPU_CHECK_AVX2        "with_cpu_x86_avx2()")
 set(_CPU_CHECK_AVX512F     "with_cpu_x86_avx512f()")
 

cmake/developer_package/cross_compile/cross_compiled_func.cmake

@@ -3,14 +3,15 @@
 #
 
 ## list of available instruction sets
-set(_ARCH_LIST ANY SSE42 AVX AVX2 AVX512F NEON_FP16)
+set(_ARCH_LIST ANY SSE42 AVX AVX2 AVX512F NEON_FP16 SVE)
 
 set(_ACCEPTED_ARCHS_ANY     "^(ANY)$")
 set(_ACCEPTED_ARCHS_SSE42   "^(ANY|SSE42)$")
 set(_ACCEPTED_ARCHS_AVX     "^(ANY|SSE42|AVX)$")
 set(_ACCEPTED_ARCHS_AVX2    "^(ANY|SSE42|AVX|AVX2)$")
 set(_ACCEPTED_ARCHS_AVX512F "^(ANY|SSE42|AVX|AVX2|AVX512F)$")
 set(_ACCEPTED_ARCHS_NEON_FP16 "^(ANY|NEON_FP16)$")
+set(_ACCEPTED_ARCHS_SVE     "^(ANY|SVE)$")
 
 ## Arch specific definitions
 set(_DEFINE_ANY       "")
@@ -19,12 +20,14 @@ set(_DEFINE_AVX       "HAVE_AVX"      ${_DEFINE_SSE42})
 set(_DEFINE_AVX2      "HAVE_AVX2"     ${_DEFINE_AVX})
 set(_DEFINE_AVX512F   "HAVE_AVX512F"  ${_DEFINE_AVX2})
 set(_DEFINE_NEON_FP16 "HAVE_NEON_FP16" ${_DEFINE_ANY})
+set(_DEFINE_SVE       "HAVE_SVE"      ${_DEFINE_SVE})
 
 ## Arch specific compile options
 ov_avx512_optimization_flags(_FLAGS_AVX512F)
 ov_avx2_optimization_flags  (_FLAGS_AVX2)
 ov_sse42_optimization_flags (_FLAGS_SSE42)
 ov_arm_neon_fp16_optimization_flags(_FLAGS_NEON_FP16)
+ov_arm_sve_optimization_flags(_FLAGS_SVE)
 set(_FLAGS_AVX "")  ## TBD is not defined for OV project yet
 set(_FLAGS_ANY "")  ##
 
@@ -185,6 +188,8 @@ endfunction()
 function(_currently_requested_top_arch VAR)
     if(ENABLE_NEON_FP16)
         set(RES NEON_FP16)
+    elseif(ENABLE_SVE)
+        set(RES SVE)
     elseif(ENABLE_AVX512F)
         set(RES AVX512F)
     elseif(ENABLE_AVX2)

cmake/developer_package/features.cmake

@@ -51,6 +51,8 @@ ov_dependent_option (ENABLE_AVX512F "Enable AVX512 optimizations" ON "X86_64 OR
 
 ov_dependent_option(ENABLE_NEON_FP16 "Enable ARM FP16 optimizations" ON "AARCH64" OFF)
 
+ov_dependent_option(ENABLE_SVE "Enable SVE optimizations" ON "AARCH64" OFF)
+
 # Type of build, we add this as an explicit option to default it to ON
 get_property(BUILD_SHARED_LIBS_DEFAULT GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS)
 ov_option (BUILD_SHARED_LIBS "Build as a shared library" ${BUILD_SHARED_LIBS_DEFAULT})

docs/articles_en/about-openvino/performance-benchmarks/generative-ai-performance.rst

@@ -8,7 +8,6 @@ The current data is as of OpenVINO 2024.4, 20 Nov. 2024.
 The tables below list the key performance indicators for inference on built-in GPUs.
 
 
-
 .. raw:: html
 
    <label><link rel="stylesheet" type="text/css" href="../../_static/css/openVinoDataTables.css"></label>
@@ -20,23 +19,23 @@ The tables below list the key performance indicators for inference on built-in G
 
       .. csv-table::
          :class: modeldata stripe
-         :name: supportedModelsTableOv
+         :name: supportedModelsTable_V1
          :header-rows: 1
          :file:  ../../_static/benchmarks_files/llm_models_9-288V.csv
 
    .. tab-item:: 7-268V
 
       .. csv-table::
          :class: modeldata stripe
-         :name: supportedModelsTableOv
+         :name: supportedModelsTable_V2
          :header-rows: 1
          :file:  ../../_static/benchmarks_files/llm_models_7-258V.csv
 
    .. tab-item:: 7-155H
 
       .. csv-table::
          :class: modeldata stripe
-         :name: supportedModelsTableOv
+         :name: supportedModelsTable_V3
          :header-rows: 1
          :file:  ../../_static/benchmarks_files/llm_models_7-155H.csv
 

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

@@ -26,7 +26,7 @@ OpenVINO Release Notes
 What's new
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-* OpenVINO 2024.6 LTS release includes updates for enhanced stability and improved LLM performance.
+* OpenVINO 2024.6 release includes updates for enhanced stability and improved LLM performance.
 * Introduced support for Intel® Arc™ B-Series Graphics (formerly known as Battlemage)
 * Memory optimizations implemented to improve the inference time memory and LLM performance on NPUs.
 * Improved LLM performance with GenAI API optimizations and bug fixes.

docs/articles_en/assets/snippets/ov_caching.cpp

@@ -90,14 +90,42 @@ auto compiled = core.compile_model(model, device, config);            // Step 5:
     }
 }
 
+void part5() {
+    std::string modelPath = "/tmp/myModel.xml";
+    std::string device = "GPU";
+    ov::Core core;                                           // Step 1: create ov::Core object
+    core.set_property(ov::cache_dir("/path/to/cache/dir"));  // Step 1b: Enable caching
+//! [ov:caching:part5]
+static const char codec_key[] = {0x30, 0x60, 0x70, 0x02, 0x04, 0x08, 0x3F, 0x6F, 0x72, 0x74, 0x78, 0x7F};
+auto codec_xor = [&](const std::string& source_str) {
+    auto key_size = sizeof(codec_key);
+    int key_idx = 0;
+    std::string dst_str = source_str;
+    for (char& c : dst_str) {
+        c ^= codec_key[key_idx % key_size];
+        key_idx++;
+    }
+    return dst_str;
+};
+auto compiled = core.compile_model(modelPath,
+                                   device,
+                                   ov::cache_encryption_callbacks(ov::EncryptionCallbacks{codec_xor, codec_xor}),
+                                   ov::cache_mode(ov::CacheMode::OPTIMIZE_SIZE));  // Step 5: Compile model
+//! [ov:caching:part5]
+    if (!compiled) {
+        throw std::runtime_error("error");
+    }
+}
+
 int main() {
     try {
         part0();
         part1();
         part2();
         part3();
         part4();
+        part5();
     } catch (...) {
     }
     return 0;
-}
+}

docs/articles_en/assets/snippets/ov_caching.py

@@ -59,3 +59,20 @@ def decrypt_base64(src):
 model = core.read_model(model=model_path)
 compiled_model = core.compile_model(model=model, device_name=device_name, config=config_cache)
 # ! [ov:caching:part4]
+
+# ! [ov:caching:part5]
+import base64
+
+def encrypt_base64(src):
+    return base64.b64encode(bytes(src, "utf-8"))
+
+def decrypt_base64(src):
+    return base64.b64decode(bytes(src, "utf-8"))
+
+core = ov.Core()
+core.set_property({props.cache_dir: path_to_cache_dir})
+config_cache = {}
+config_cache["CACHE_ENCRYPTION_CALLBACKS"] = [encrypt_base64, decrypt_base64]
+config_cache["CACHE_MODE"] = "OPTIMIZE_SIZE"
+compiled_model = core.compile_model(model=model_path, device_name='GPU', config=config_cache)
+# ! [ov:caching:part5]

docs/articles_en/get-started/install-openvino.rst

@@ -23,11 +23,10 @@ Install OpenVINO™ 2024.6
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <iframe id="selector" src="../_static/selector-tool/selector-2a63478.html" style="width: 100%; border: none" title="Download Intel® Distribution of OpenVINO™ Toolkit"></iframe>
 
-OpenVINO 2024.6, described here, is a Long-Term-Support version!
+OpenVINO 2024.6, described here, is not a Long-Term-Support version!
 All currently supported versions are:
 
-* 2025.0 (in development)
-* 2024.6 (LTS)
+* 2024.6 (development)
 * 2023.3 (LTS)