Revert reorder WR.

fix CPU 'ConvolutionBackpropDataLayerTest' fail issue

.ci/azure/android_arm64.yml

@@ -13,6 +13,7 @@ resources:
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/openvino_contrib
+    ref: master
 
 jobs:
 - job: android_arm64

.ci/azure/linux.yml

@@ -13,11 +13,13 @@ resources:
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/openvino_contrib
+    ref: master
 
   - repository: testdata
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/testdata
+    ref: master
 
 jobs:
 - job: Lin
@@ -109,7 +111,8 @@ jobs:
       set -e
       $(REPO_DIR)/install_build_dependencies.sh
       # Move jdk into contrib
-      sudo apt --assume-yes install openjdk-11-jdk
+      # 'clang' compiler is to check that samples can be built using it
+      sudo apt --assume-yes install openjdk-11-jdk clang
       # For opencv-python: python3-setuptools and pip upgrade
       python3 -m pip install --upgrade pip
       python3 -m pip install -r $(REPO_DIR)/src/bindings/python/src/compatibility/openvino/requirements.txt
@@ -223,6 +226,14 @@ jobs:
     displayName: 'Build cpp samples'
     continueOnError: false
 
+  - script: |
+      export CC=clang
+      export CXX=clang++
+      $(INSTALL_DIR)/samples/cpp/build_samples.sh -i $(INSTALL_DIR)
+    workingDirectory: $(BUILD_SAMPLES_DIR)
+    displayName: 'Build cpp samples - clang'
+    continueOnError: false
+
   - script: $(INSTALL_DIR)/samples/c/build_samples.sh -i $(INSTALL_DIR)
     workingDirectory: $(BUILD_SAMPLES_DIR)
     displayName: 'Build c samples'
@@ -288,6 +299,10 @@ jobs:
     displayName: 'VPU UT'
     continueOnError: false
 
+  - script: . $(SETUPVARS) && $(INSTALL_TEST_DIR)/XLinkTests --gtest_output=xml:TEST-XLinkTests.xml
+    displayName: 'XLink Tests'
+    continueOnError: false
+
   - script: . $(SETUPVARS) && $(INSTALL_TEST_DIR)/ieMultiPluginUnitTests --gtest_output=xml:TEST-ieMultiPluginUnitTests.xml
     displayName: 'MULTI UT'
     continueOnError: false
@@ -336,6 +351,7 @@ jobs:
   - script: |
       export PATH=$HOME/.local/bin:$PATH
       export IE_APP_PATH=$(INSTALL_DIR)/samples_bin
+      export LD_LIBRARY_PATH=$IE_APP_PATH:$LD_LIBRARY_PATH
       export IE_APP_PYTHON_PATH=$(INSTALL_DIR)/samples/python/
       export SHARE=$(INSTALL_DIR)/tests/smoke_tests/samples_smoke_tests_data/
       export WORKSPACE=$(INSTALL_DIR)

.ci/azure/linux_arm64.yml

@@ -13,6 +13,7 @@ resources:
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/openvino_contrib
+    ref: master
 
 jobs:
 - job: linux_arm64
@@ -34,13 +35,13 @@ jobs:
     OPENVINO_REPO_DIR: $(Build.Repository.LocalPath)
     OPENVINO_CONTRIB_REPO_DIR: $(OPENVINO_REPO_DIR)/../openvino_contrib
     OPENCV_REPO_DIR: $(OPENVINO_REPO_DIR)/../opencv
-    BUILD_PYTHON: $(WORK_DIR)/build_python 
+    BUILD_PYTHON: $(WORK_DIR)/build_python
     BUILD_OPENCV: $(WORK_DIR)/build_opencv
     BUILD_OPENVINO: $(WORK_DIR)/build
     BUILD_OPENVINO_PYTHON: $(WORK_DIR)/build_python
     BUILD_OPEN_MODEL_ZOO: $(WORK_DIR)/build_open_model_zoo
     INSTALL_OPENVINO: $(WORK_DIR)/install_openvino
-    INSTALL_PYTHON: $(INSTALL_OPENVINO)/extras/python 
+    INSTALL_PYTHON: $(INSTALL_OPENVINO)/extras/python
     INSTALL_OPENCV: $(INSTALL_OPENVINO)/extras/opencv
     INSTALL_OPEN_MODEL_ZOO: $(INSTALL_OPENVINO)/extras/open_model_zoo
     WORK_DIR: $(Pipeline.Workspace)/_w
@@ -125,20 +126,20 @@ jobs:
       cmakeArgs: >
         -GNinja
         -DVERBOSE_BUILD=ON
-        -DOpenCV_DIR=$(INSTALL_OPENCV)/cmake 
-        -DENABLE_OPENCV=OFF 
-        -DPYTHON_INCLUDE_DIRS=$(INSTALL_PYTHON)/include/python3.8 
-        -DPYTHON_LIBRARY=$(INSTALL_PYTHON)/lib/libpython3.8.so 
-        -DENABLE_PYTHON=ON 
-        -DPYTHON_MODULE_EXTENSION=".so" 
-        -DENABLE_TESTS=ON 
-        -DENABLE_FUNCTIONAL_TESTS=ON 
-        -DENABLE_GAPI_TESTS=OFF 
-        -DENABLE_GAPI_PREPROCESSING=OFF 
-        -DENABLE_DATA=OFF 
-        -DCMAKE_EXE_LINKER_FLAGS=-Wl,-rpath-link,$(INSTALL_OPENCV)/lib 
-        -DTHREADING=SEQ -DENABLE_LTO=ON 
-        -DCMAKE_TOOLCHAIN_FILE=$(OPENVINO_REPO_DIR)/cmake/arm64.toolchain.cmake 
+        -DOpenCV_DIR=$(INSTALL_OPENCV)/cmake
+        -DENABLE_OPENCV=OFF
+        -DPYTHON_INCLUDE_DIRS=$(INSTALL_PYTHON)/include/python3.8
+        -DPYTHON_LIBRARY=$(INSTALL_PYTHON)/lib/libpython3.8.so
+        -DENABLE_PYTHON=ON
+        -DPYTHON_MODULE_EXTENSION=".so"
+        -DENABLE_TESTS=ON
+        -DENABLE_FUNCTIONAL_TESTS=ON
+        -DENABLE_GAPI_TESTS=OFF
+        -DENABLE_GAPI_PREPROCESSING=OFF
+        -DENABLE_DATA=OFF
+        -DCMAKE_EXE_LINKER_FLAGS=-Wl,-rpath-link,$(INSTALL_OPENCV)/lib
+        -DTHREADING=SEQ -DENABLE_LTO=ON
+        -DCMAKE_TOOLCHAIN_FILE=$(OPENVINO_REPO_DIR)/cmake/arm64.toolchain.cmake
         -DCMAKE_BUILD_TYPE=$(BUILD_TYPE)
         -DENABLE_SAMPLES=ON
         -DBUILD_java_api=OFF
@@ -173,19 +174,19 @@ jobs:
       cmakeArgs: >
         -GNinja
         -DInferenceEngineDeveloperPackage_DIR=$(BUILD_OPENVINO)
-        -DENABLE_PYTHON=ON 
-        -DPYTHON_EXECUTABLE=$(INSTALL_PYTHON)/bin/python3.8 
-        -DPYTHON_INCLUDE_DIRS=$(INSTALL_PYTHON)/include/python3.8 
+        -DENABLE_PYTHON=ON
+        -DPYTHON_EXECUTABLE=$(INSTALL_PYTHON)/bin/python3.8
+        -DPYTHON_INCLUDE_DIRS=$(INSTALL_PYTHON)/include/python3.8
         -DPYTHON_LIBRARIES=$(INSTALL_PYTHON)/lib
-        -DPYTHON3_NUMPY_INCLUDE_DIRS=/usr/local/lib/python3.8/site-packages/numpy/core/include 
+        -DPYTHON3_NUMPY_INCLUDE_DIRS=/usr/local/lib/python3.8/site-packages/numpy/core/include
         -DPYTHON_MODULE_EXTENSION=".so"
         -DPYBIND11_FINDPYTHON=OFF
         -DPYBIND11_NOPYTHON=OFF
         -DPYTHONLIBS_FOUND=TRUE
         -DCMAKE_BUILD_TYPE=$(BUILD_TYPE)
         -DENABLE_DATA=OFF
-        -DCMAKE_EXE_LINKER_FLAGS=-Wl,-rpath-link,$(INSTALL_OPENCV)/lib 
-        -DCMAKE_TOOLCHAIN_FILE=$(OPENVINO_REPO_DIR)/cmake/arm64.toolchain.cmake 
+        -DCMAKE_EXE_LINKER_FLAGS=-Wl,-rpath-link,$(INSTALL_OPENCV)/lib
+        -DCMAKE_TOOLCHAIN_FILE=$(OPENVINO_REPO_DIR)/cmake/arm64.toolchain.cmake
         -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
         -DCMAKE_C_COMPILER_LAUNCHER=ccache
         -DCMAKE_INSTALL_PREFIX=$(INSTALL_OPENVINO)
@@ -211,15 +212,15 @@ jobs:
     inputs:
       cmakeArgs: >
         -GNinja
-        -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) 
-        -DENABLE_PYTHON=ON 
+        -DCMAKE_BUILD_TYPE=$(BUILD_TYPE)
+        -DENABLE_PYTHON=ON
         -DPYTHON_EXECUTABLE=/usr/local/bin/python3.8
-        -DPYTHON_INCLUDE_DIR=$(INSTALL_PYTHON)/include/python3.8 
+        -DPYTHON_INCLUDE_DIR=$(INSTALL_PYTHON)/include/python3.8
         -DPYTHON_LIBRARY=$(INSTALL_PYTHON)/lib
         -DCMAKE_TOOLCHAIN_FILE=$(OPENVINO_REPO_DIR)/cmake/arm64.toolchain.cmake
         -DOpenVINO_DIR=$(BUILD_OPENVINO)
         -DInferenceEngine_DIR=$(BUILD_OPENVINO)
-        -DOpenCV_DIR=$(INSTALL_OPENCV)/cmake 
+        -DOpenCV_DIR=$(INSTALL_OPENCV)/cmake
         -Dngraph_DIR=$(BUILD_OPENVINO)
         -DIE_EXTRA_MODULES=$(OPENVINO_CONTRIB_REPO_DIR)/modules
         -DCMAKE_INSTALL_PREFIX=$(INSTALL_OPEN_MODEL_ZOO)

.ci/azure/linux_coverity.yml

@@ -4,6 +4,7 @@ resources:
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/openvino_contrib
+    ref: master
 
 jobs:
 - job: Lin

.ci/azure/linux_lohika.yml

@@ -4,6 +4,7 @@
 #    type: github
 #    endpoint: openvinotoolkit
 #    name: openvinotoolkit/testdata
+#    ref: master
 
 jobs:
 - job: Lin_lohika

.ci/azure/mac.yml

@@ -13,11 +13,13 @@ resources:
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/openvino_contrib
+    ref: master
 
   - repository: testdata
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/testdata
+    ref: master
 
 jobs:
 - job: Mac

.ci/azure/windows.yml

@@ -13,11 +13,13 @@ resources:
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/openvino_contrib
+    ref: master
 
   - repository: testdata
     type: github
     endpoint: openvinotoolkit
     name: openvinotoolkit/testdata
+    ref: master
 
 jobs:
 - job: Win
@@ -30,7 +32,7 @@ jobs:
     maxParallel: 2
 
   # About 150% of total time
-  timeoutInMinutes: 150
+  timeoutInMinutes: 180
 
   pool:
     name: WIN_VMSS_VENV_D8S_WU2
@@ -133,7 +135,7 @@ jobs:
 
   - script: |
       set PATH=$(WORK_DIR)\ninja-win;%PATH%
-      call "$(MSVS_VARS_PATH)" && $(CMAKE_CMD) -G "Ninja Multi-Config" -DENABLE_WHEEL=ON -DENABLE_ONEDNN_FOR_GPU=$(CMAKE_BUILD_SHARED_LIBS) -DENABLE_GAPI_PREPROCESSING=$(CMAKE_BUILD_SHARED_LIBS) -DBUILD_SHARED_LIBS=$(CMAKE_BUILD_SHARED_LIBS) -DENABLE_REQUIREMENTS_INSTALL=OFF -DENABLE_FASTER_BUILD=ON -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) -DENABLE_TESTS=ON -DENABLE_STRICT_DEPENDENCIES=OFF -DENABLE_PYTHON=ON -DPYTHON_EXECUTABLE="C:\hostedtoolcache\windows\Python\3.7.6\x64\python.exe" -DPYTHON_INCLUDE_DIR="C:\hostedtoolcache\windows\Python\3.7.6\x64\include" -DPYTHON_LIBRARY="C:\hostedtoolcache\windows\Python\3.7.6\x64\libs\python37.lib" -DIE_EXTRA_MODULES=$(OPENVINO_CONTRIB_REPO_DIR)\modules -DCMAKE_C_COMPILER:PATH="$(MSVC_COMPILER_PATH)" -DCMAKE_CXX_COMPILER:PATH="$(MSVC_COMPILER_PATH)" $(REPO_DIR)
+      call "$(MSVS_VARS_PATH)" && $(CMAKE_CMD) -G "Ninja Multi-Config" -DENABLE_WHEEL=ON -DENABLE_ONEDNN_FOR_GPU=$(CMAKE_BUILD_SHARED_LIBS) -DBUILD_SHARED_LIBS=$(CMAKE_BUILD_SHARED_LIBS) -DENABLE_REQUIREMENTS_INSTALL=OFF -DENABLE_FASTER_BUILD=ON -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) -DENABLE_TESTS=ON -DENABLE_STRICT_DEPENDENCIES=OFF -DENABLE_PYTHON=ON -DPYTHON_EXECUTABLE="C:\hostedtoolcache\windows\Python\3.7.6\x64\python.exe" -DPYTHON_INCLUDE_DIR="C:\hostedtoolcache\windows\Python\3.7.6\x64\include" -DPYTHON_LIBRARY="C:\hostedtoolcache\windows\Python\3.7.6\x64\libs\python37.lib" -DIE_EXTRA_MODULES=$(OPENVINO_CONTRIB_REPO_DIR)\modules -DCMAKE_C_COMPILER:PATH="$(MSVC_COMPILER_PATH)" -DCMAKE_CXX_COMPILER:PATH="$(MSVC_COMPILER_PATH)" $(REPO_DIR)
     workingDirectory: $(BUILD_DIR)
     displayName: 'CMake'
 
@@ -167,13 +169,6 @@ jobs:
     workingDirectory: $(BUILD_SAMPLES_TESTS_DIR)
     displayName: 'Install Samples Tests'
 
-  - script: $(CMAKE_CMD) -DCMAKE_INSTALL_PREFIX=$(INSTALL_DIR) -DCOMPONENT=tests -P cmake_install.cmake && xcopy $(REPO_DIR)\temp\opencv_4.5.2\opencv\* $(INSTALL_DIR)\opencv\ /e /h /y
-    workingDirectory: $(BUILD_DIR)
-    displayName: 'Install tests'
-
-  - script: dir $(INSTALL_DIR) /s
-    displayName: 'List install files'
-
   - script: $(INSTALL_DIR)\samples\cpp\build_samples_msvc.bat -i $(INSTALL_DIR)
     workingDirectory: $(BUILD_SAMPLES_DIR)
     displayName: 'Build cpp samples'
@@ -198,9 +193,15 @@ jobs:
       python -m pytest $(INSTALL_DIR)\tests\smoke_tests\  --env_conf $(INSTALL_DIR)\tests\smoke_tests\env_config.yml -s --junitxml=TEST-SamplesSmokeTests.xml
     workingDirectory: $(INSTALL_DIR)
     displayName: 'Samples Smoke Tests'
-    condition: eq(variables['CMAKE_BUILD_SHARED_LIBS'], 'ON')
     continueOnError: false
 
+  - script: $(CMAKE_CMD) -DCMAKE_INSTALL_PREFIX=$(INSTALL_DIR) -DCOMPONENT=tests -P cmake_install.cmake && xcopy $(REPO_DIR)\temp\opencv_4.5.2\opencv\* $(INSTALL_DIR)\opencv\ /e /h /y
+    workingDirectory: $(BUILD_DIR)
+    displayName: 'Install tests'
+
+  - script: dir $(INSTALL_DIR) /s
+    displayName: 'List install files'
+
   - script: rd /Q /S $(BUILD_DIR)
     displayName: 'Clean build dir'
     continueOnError: false
@@ -240,6 +241,10 @@ jobs:
     displayName: 'VPU UT'
     continueOnError: false
 
+  - script: call $(SETUPVARS) && $(INSTALL_TEST_DIR)\XLinkTests --gtest_output=xml:TEST-XLinkTests.xml
+    displayName: 'XLink Tests'
+    continueOnError: false
+
   - script: call $(SETUPVARS) && $(INSTALL_TEST_DIR)\onnxImporterUnitTests --gtest_output=xml:TEST-onnxImporterUnitTests.xml
     displayName: 'ONNX Importer UT'
     continueOnError: false

.ci/openvino-onnx/Jenkinsfile

@@ -1,213 +0,0 @@
-// Copyright (C) 2018-2020 Intel Corporation
-// SPDX-License-Identifier: Apache-2.0
-
-DOCKER_CONTAINER_NAME= "openvino-onnx-ci-container"
-DOCKER_IMAGE_TAG = "openvino-onnx-ci-image"
-ONNX_MODEL_ZOO_SHA = "d58213534f2a4d1c4b19ba62b3bb5f544353256e"
-
-BACKEND_CONFIGURATIONS = [
-    [ name: "Release", build_type: "Release" ],
-    [ name: "Debug", build_type: "Debug" ],
-]
-
-// workaround for aborting previous builds on PR update
-@NonCPS
- def stopPreviousRunningBuilds() {
-     def jobname = env.JOB_NAME
-     if (jobname.startsWith("onnx-ci/openvino onnx ci/openvino/PR")){
-         def buildnum = env.BUILD_NUMBER.toInteger()
-         def job = Jenkins.instance.getItemByFullName(jobname)
-         def job_newest = job.builds.first()
-         for (build in job.builds.reverse()[0..<-1]) {
-             if (build.isBuilding()){
-                 echo "Stop task = ${build} because newest #${job_newest} is on the way"
-                 build.doStop();
-                 continue;
-             }
-         }
-     }
-
- }
-
-def getGitPrInfo(String project, String workdir) {
-    def gitPrInfo = [
-        prAuthorEmail : "",
-        commitAuthorEmail : "",
-        commitHash : "",
-        commitSubject : ""
-    ]
-    try {
-        dir ("${workdir}/${project}") {
-            gitPrInfo.prAuthorEmail = sh (script: 'git log -1 --pretty="format:%ae" ', returnStdout: true).trim()
-            gitPrInfo.commitAuthorEmail = sh (script: 'git log -1 --pretty="format:%ce" ', returnStdout: true).trim()
-            gitPrInfo.commitSubject = sh (script: 'git log -1 --pretty="format:%H" ', returnStdout: true).trim()
-            gitPrInfo.commitHash = sh (script: 'git log -1 --pretty="format:%s" ', returnStdout: true).trim()
-        }
-    }
-    catch(e) {
-        echo "Failed to retrieve ${project} git repository information!"
-        echo "ERROR: ${e}"
-    }
-    return gitPrInfo
-}
-
-def notifyByEmail(def gitPrInfo) {
-    stage('Notify') {
-        String notifyPeople = "${gitPrInfo.prAuthorEmail}, ${gitPrInfo.commitAuthorEmail}"
-        emailext (
-            subject: "OpenVino CI: PR ${CHANGE_ID} ${currentBuild.result}!",
-            body: """
-                    Status: ${currentBuild.result}
-                    Pull Request Title: ${CHANGE_TITLE}
-                    Pull Request: ${CHANGE_URL}
-                    Branch: ${CHANGE_BRANCH}
-                    Commit Hash: ${gitPrInfo.commitSubject}
-                    Commit Subject: ${gitPrInfo.commitHash}
-                    Jenkins Build: ${RUN_DISPLAY_URL}
-            """,
-            to: "${notifyPeople}"
-        )
-    }
-}
-
-def gitSubmoduleUpdate(String repository_name, String workdir) {
-    dir ("${workdir}/${repository_name}") {
-        sh  label: "Init ${repository_name} submodules",
-            script:
-        """
-            git submodule init && git submodule update \
-                --init \
-                --no-fetch \
-                --recursive
-        """
-    }
-}
-
-def prepare_repository(String workdir) {
-    dir("${workdir}") {
-        println "Preparing repository in directory: ${workdir}"
-        checkout scm
-        gitSubmoduleUpdate(PROJECT_NAME, workdir)
-    }
-}
-
-def updateModels() {
-    sh """
-        ./src/bindings/python/tests/test_onnx/model_zoo_preprocess.sh -d ${HOME}/ONNX_CI/models_data -o -s ${ONNX_MODEL_ZOO_SHA}
-    """
-}
-
-def get_docker_container_name(Map configuration){
-    println "RUN get_docker_container_name for ${configuration.name}"
-    String docker_container_name = "${DOCKER_CONTAINER_NAME}_${BUILD_NUMBER}_${env.CHANGE_ID}_${configuration.name}"
-    return docker_container_name
-}
-
-def buildDockerImage(Map configuration, String workdir) {
-    String docker_image_tag = "${DOCKER_IMAGE_TAG}_${BUILD_NUMBER}_${env.CHANGE_ID}_${configuration.name}".toLowerCase()
-    println "docker_image_tag: ${docker_image_tag}"
-    updateModels()
-    sh """
-        docker build --tag=${docker_image_tag} \
-        --build-arg BUILD_TYPE=${configuration.build_type} \
-        --file=.ci/openvino-onnx/Dockerfile \
-        --build-arg http_proxy=${HTTP_PROXY}  \
-        --build-arg https_proxy=${HTTPS_PROXY} .
-    """
-}
-
-def runTests(Map configuration, String workdir) {
-    println "Run tests for ${configuration.name}"
-    String docker_image_tag = "${DOCKER_IMAGE_TAG}_${BUILD_NUMBER}_${env.CHANGE_ID}_${configuration.name}".toLowerCase()
-
-    String docker_container_name = get_docker_container_name(configuration)
-
-    // Run only basic unit tests in Debug configuration
-    if (configuration.build_type == "Debug") {
-        sh """
-            docker run --name ${docker_container_name} ${docker_image_tag}
-        """
-    }
-
-    // Run unit-tests AND large model tests by default
-    else {
-        sh """
-            docker run --name ${docker_container_name} \
-            --volume ${HOME}/ONNX_CI/models_data/model_zoo/onnx_model_zoo_${ONNX_MODEL_ZOO_SHA}:/root/.onnx/model_zoo/onnx_model_zoo \
-            --volume ${HOME}/ONNX_CI/data/model_zoo/MSFT:/root/.onnx/model_zoo/MSFT \
-            ${docker_image_tag} /bin/bash -c "tox && tox -e zoo_models"
-        """
-    }
-}
-
-def getConfigurationsMap() {
-    def configurationsMap = [:]
-    for (backend in BACKEND_CONFIGURATIONS) {
-        def configuration = backend.clone()
-        configurationsMap[configuration.name] = {
-            stage(configuration.name) { CONFIGURATION_WORKFLOW(configuration) }
-        }
-    }
-    return configurationsMap
-}
-
-CONFIGURATION_WORKFLOW = { configuration ->
-    node("OpenVINO") {
-        String workdir = "${HOME}/workspace/${BUILD_NUMBER}_${env.CHANGE_ID}_${configuration.name}"
-        try {
-            PROJECT_NAME = "openvino"
-            stage("Clone repository") {
-                    prepare_repository(workdir)
-            }
-            stage("Prepare Docker environment") {
-              dir("${workdir}") {
-                    buildDockerImage(configuration, workdir)
-                }
-            }
-            stage("Run tests") {
-                timeout(time: 60, unit: 'MINUTES') {
-                    runTests(configuration, workdir)
-                }
-            }
-        }
-        catch(e) {
-                // Set result to ABORTED if exception contains exit code of a process interrupted by SIGTERM
-                if ("$e".contains("143")) {
-                    currentBuild.result = "ABORTED"
-                } else {
-                    currentBuild.result = "FAILURE"
-                }
-                def gitPrInfo = getGitPrInfo(PROJECT_NAME, workdir)
-                notifyByEmail(gitPrInfo)
-        }
-        finally {
-            stage("Cleanup") {
-                String docker_container_name = get_docker_container_name(configuration)
-                sh """
-                    docker rm -f ${docker_container_name}
-                    rm -rf ${workdir}
-                """
-            }
-        }
-    }
-}
-
-pipeline {
-    agent none
-    options {
-        skipDefaultCheckout true
-        timeout(activity: true, time: 120, unit: 'MINUTES')
-    }
-    stages {
-        stage('Parallel CI') {
-            steps {
-                stopPreviousRunningBuilds()
-                script {
-                    parallelStagesMap = getConfigurationsMap()
-                    parallel parallelStagesMap
-                }
-            }
-
-        }
-    }
-}

.ci/openvino-onnx/watchdog/Jenkinsfile

@@ -1,65 +0,0 @@
-// Copyright (C) 2018-2020 Intel Corporation
-// SPDX-License-Identifier: Apache-2.0
-
-timeout(30)
-{
-    node(LABEL) {
-
-        BUILD_WORKSPACE = "$WORKSPACE/$BUILD_NUMBER"
-        WATCHDOG_ROOT = "$BUILD_WORKSPACE/.ci/openvino-onnx/watchdog"
-        VENV_PATH = "${BUILD_WORKSPACE}/.wdvenv"
-
-        try {
-                stage("Clone repository") {
-                    dir ("$BUILD_WORKSPACE") {
-                        checkout([$class: 'GitSCM', branches: [[name: "*/$BRANCH"]],
-                                doGenerateSubmoduleConfigurations: false, extensions: [[$class: 'CloneOption', timeout: 30]],  submoduleCfg: [],
-                                userRemoteConfigs: [[credentialsId: "${GITHUB_KEY}", url: "${OPEN_VINO_URL}"]]])
-                    }
-                }
-                stage("Prepare environment") {
-                    sh """#!/bin/bash
-                        if [ ! -d ${VENV_PATH} ]; then
-                            python3 -m venv ${VENV_PATH}
-                            source ${VENV_PATH}/bin/activate
-                            pip install -r ${WATCHDOG_ROOT}/requirements.txt
-                        fi
-                    """
-                }
-                stage("Run script") {
-                    withCredentials([
-                        usernamePassword(credentialsId: '7157091e-bc04-42f0-99fd-dc4da2922a55',
-                        usernameVariable: 'username',
-                        passwordVariable: 'password')])
-                    {
-                        dir ("$BUILD_WORKSPACE") {
-                            sh """#!/bin/bash
-                                source ${VENV_PATH}/bin/activate
-                                export PYTHONHTTPSVERIFY=0
-                                python ${WATCHDOG_ROOT}/src/main.py \
-                                    --msteams-url=${MSTEAMS_URL_FILE} \
-                                    --github-credentials '${username}' '${password}' \
-                                    --github-org=${GITHUB_ORG} \
-                                    --github-project=${GITHUB_PROJECT} \
-                                    --jenkins-token=${JENKINS_TOKEN_FILE} \
-                                    --jenkins-server=${JENKINS_SERVER} \
-                                    --jenkins-user=${JENKINS_USER} \
-                                    --ci-job=${CI_JOB_NAME} \
-                                    --watchdog-job=${WATCHDOG_JOB_NAME}
-                            """
-                        }
-                    }
-                }
-        } catch (e) {
-            echo "$e"
-            currentBuild.result = "FAILURE"
-        } finally {
-            stage("Cleanup") {
-                sh """
-                    cd $BUILD_WORKSPACE
-                    rm -rf ..?* .[!.]* *
-                """
-            }
-        }
-    }
-}

.ci/openvino-onnx/watchdog/requirements.txt

@@ -1,6 +0,0 @@
-python-jenkins==1.7.0
-retrying==1.3.3
-pygithub==1.51
-timeout-decorator==0.4.1
-requests==2.23.0
-wheel

.ci/openvino-onnx/watchdog/src/git_wrapper.py

@@ -1,108 +0,0 @@
-#!/usr/bin/python3
-
-# Copyright (C) 2018-2021 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import logging
-import timeout_decorator
-from datetime import datetime
-from retrying import retry
-from github import Github, GithubException
-
-# Logging
-logging.basicConfig(format='%(name)s - %(levelname)s - %(message)s')
-log = logging.getLogger(__name__)
-log.setLevel(logging.INFO)
-
-_RETRY_LIMIT = 3
-_RETRY_COOLDOWN_MS = 2000
-_REQUEST_TIMEOUT_S = 10
-
-
-class GitWrapper:
-    """Class wrapping PyGithub API.
-
-    The purpose of this class is to wrap methods from PyGithub API used in Watchdog, for less error-prone and
-    more convenient use. Docs for used API, including wrapped methods can be found at:
-    https://pygithub.readthedocs.io/en/latest/introduction.html
-
-    :param github_credentials:       Credentials used for GitHub
-    :param repository:            GitHub repository name
-    :param project:               GitHub project name
-    :type github_credentials:        String
-    :type repository:             String
-    :type project:                String
-    """
-
-    def __init__(self, github_credentials, repository, project):
-        self.git = Github(*github_credentials)
-        self.repository = repository
-        self.project = project
-        self.github_credentials = github_credentials
-
-    @retry(stop_max_attempt_number=_RETRY_LIMIT, wait_fixed=_RETRY_COOLDOWN_MS)
-    def get_git_time(self):
-        """Retrieve time from GitHub.
-
-        Used to reliably determine time during Watchdog run.
-
-        :return:                    Datetime object describing current time
-        :rtype:                     datetime
-        """
-        try:
-            datetime_object = self._get_git_time()
-        except ValueError as e:
-            raise GitWrapperError(str(e))
-        except GithubException as e:
-            message = 'GitHub Exception during API status retrieval. Exception: {}'.format(str(e))
-            raise GitWrapperError(message)
-        except timeout_decorator.TimeoutError:
-            message = 'GitHub Exception during API status retrieval. Timeout during API request.'
-            raise GitWrapperError(message)
-        return datetime_object
-
-    @retry(stop_max_attempt_number=_RETRY_LIMIT, wait_fixed=_RETRY_COOLDOWN_MS)
-    def get_pull_requests(self):
-        """Retrieve paginated list of pull requests from GitHub.
-
-        :return:                    Paginated list of Pull Requests in GitHub repo
-        :rtype:                     github.PaginatedList.PaginatedList of github.PullRequest.PullRequest
-        """
-        try:
-            prs = self._get_pull_requests()
-        except GithubException as e:
-            message = 'GitHub Exception during API status retrieval. Exception: {}'.format(str(e))
-            raise GitWrapperError(message)
-        return prs
-
-    @timeout_decorator.timeout(_REQUEST_TIMEOUT_S)
-    def _get_git_time(self):
-        """Private method retrieving time from GitHub.
-
-        :return:                    Datetime object describing current time
-        :rtype:                     datetime
-        """
-        datetime_string = self.git.get_api_status().raw_headers.get('date', '')
-        datetime_format = '%a, %d %b %Y %H:%M:%S %Z'
-        datetime_object = datetime.strptime(datetime_string, datetime_format)
-        return datetime_object
-
-    @timeout_decorator.timeout(_REQUEST_TIMEOUT_S)
-    def _get_pull_requests(self):
-        """Private method retrieving pull requests from GitHub.
-
-        :return:                    Paginated list of Pull Requests in GitHub repo
-        :rtype:                     github.PaginatedList.PaginatedList of github.PullRequest.PullRequest
-        """
-        return self.git.get_organization(self.repository).get_repo(self.project).get_pulls()
-
-
-class GitWrapperError(Exception):
-    """Base class for exceptions raised in GitWrapper.
-
-    :param message                   Explanation of the error
-    """
-
-    def __init__(self, message):
-        self.message = message
-        log.exception(message)

.ci/openvino-onnx/watchdog/src/jenkins_wrapper.py

@@ -1,91 +0,0 @@
-#!/usr/bin/python3
-
-# Copyright (C) 2018-2021 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import requests
-import jenkins
-import logging
-from retrying import retry
-
-# Logging
-logging.basicConfig(format='%(name)s - %(levelname)s - %(message)s')
-log = logging.getLogger(__name__)
-log.setLevel(logging.INFO)
-
-_RETRY_LIMIT = 3
-_RETRY_COOLDOWN_MS = 5000
-
-
-class JenkinsWrapper:
-    """Class wrapping Python-Jenkins API.
-
-    The purpose of this class is to wrap methods from Python-Jenkins API used in Watchdog, for less error-prone and
-    more convenient use. Docs for used API, including wrapped methods can be found at:
-    https://python-jenkins.readthedocs.io/en/latest/
-
-        :param jenkins_token:       Token used for Jenkins
-        :param jenkins_user:        Username used to connect to Jenkins
-        :param jenkins_server:      Jenkins server address
-        :type jenkins_token:        String
-        :type jenkins_user:         String
-        :type jenkins_server:       String
-    """
-
-    def __init__(self, jenkins_token, jenkins_user, jenkins_server):
-        self.jenkins_server = jenkins_server
-        self.jenkins = jenkins.Jenkins(jenkins_server, username=jenkins_user,
-                                       password=jenkins_token)
-
-    @retry(stop_max_attempt_number=_RETRY_LIMIT, wait_fixed=_RETRY_COOLDOWN_MS)
-    def get_build_console_output(self, job_name, build_number):
-        return self.jenkins.get_build_console_output(job_name, build_number)
-
-    @retry(stop_max_attempt_number=_RETRY_LIMIT, wait_fixed=_RETRY_COOLDOWN_MS)
-    def get_job_info(self, job_name):
-        return self.jenkins.get_job_info(job_name)
-
-    @retry(stop_max_attempt_number=_RETRY_LIMIT, wait_fixed=_RETRY_COOLDOWN_MS)
-    def get_build_info(self, job_name, build_number):
-        return self.jenkins.get_build_info(job_name, build_number)
-
-    @retry(stop_max_attempt_number=_RETRY_LIMIT, wait_fixed=_RETRY_COOLDOWN_MS)
-    def get_queue_item(self, queue_id):
-        """Attempt to retrieve Jenkins job queue item.
-
-        Exception communicating queue doesn't exist is expected,
-        in that case method returns empty dict.
-
-            :param queue_id:            Jenkins job queue ID number
-            :type queue_id:             int
-            :return:                    Dictionary representing Jenkins job queue item
-            :rtype:                     dict
-        """
-        try:
-            return self.jenkins.get_queue_item(queue_id)
-        except Exception as e:
-            # Exception 'queue does not exist' is expected behaviour when job is running
-            if 'queue' in str(e) and 'does not exist' in str(e):
-                return {}
-            else:
-                raise
-
-    @retry(stop_max_attempt_number=_RETRY_LIMIT, wait_fixed=_RETRY_COOLDOWN_MS)
-    def get_idle_ci_hosts(self):
-        """Query Jenkins for idle servers.
-
-        Send GET request to Jenkins server, querying for idle servers labeled
-        for OpenVino-ONNX CI job.
-
-            :return:     Number of idle hosts delegated to OpenVino-ONNX CI
-            :rtype:      int
-        """
-        jenkins_request_url = self.jenkins_server + 'label/ci&&onnx/api/json?pretty=true'
-        try:
-            log.info('Sending request to Jenkins: %s', jenkins_request_url)
-            r = requests.Request(method='GET', url=jenkins_request_url, verify=False)
-            response = self.jenkins.jenkins_request(r).json()
-            return int(response['totalExecutors']) - int(response['busyExecutors'])
-        except Exception as e:
-            log.exception('Failed to send request to Jenkins!\nException message: %s', str(e))
-            raise

.ci/openvino-onnx/watchdog/src/main.py

@@ -1,89 +0,0 @@
-#!/usr/bin/python3
-
-# Copyright (C) 2018-2021 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import argparse
-import sys
-from watchdog import Watchdog
-
-DEFAULT_MSTEAMS_URL_FILE = '/home/lab_nerval/tokens/msteams_url'
-DEFAULT_GITHUB_ORGANIZATION = 'openvinotoolkit'
-DEFAULT_GITHUB_PROJECT = 'openvino'
-DEFAULT_JENKINS_TOKEN_FILE = '/home/lab_nerval/tokens/crackerjack'
-DEFAULT_JENKINS_SERVER = 'https://crackerjack.intel.com/'
-DEFAULT_JENKINS_USER = 'lab_nerval'
-DEFAULT_CI_JOB_NAME = 'onnx/OpenVino_CI'
-DEFAULT_WATCHDOG_JOB_NAME = 'onnx/ci_watchdog'
-
-
-def main(args):
-    """
-    Read args passed to script, load tokens and run watchdog.
-
-    Keyword arguments:
-    :param args:    arguments parsed by argparse ArgumentParser
-
-    :return:        returns status code 0 on successful completion
-
-    """
-    jenkins_server = args.jenkins_server.strip()
-    jenkins_user = args.jenkins_user.strip()
-    jenkins_token = open(args.jenkins_token).read().replace('\n', '').strip()
-    msteams_url = open(args.msteams_url).read().replace('\n', '').strip()
-    github_credentials = args.github_credentials
-    github_org = args.github_org
-    github_project = args.github_project
-    ci_job = args.ci_job.strip()
-    watchdog_job = args.watchdog_job.strip()
-    quiet = args.quiet
-
-    wd = Watchdog(jenkins_token=jenkins_token,
-                  jenkins_server=jenkins_server,
-                  jenkins_user=jenkins_user,
-                  github_credentials=github_credentials,
-                  git_org=github_org,
-                  git_project=github_project,
-                  msteams_url=msteams_url,
-                  ci_job_name=ci_job,
-                  watchdog_job_name=watchdog_job)
-    wd.run(quiet=quiet)
-
-    return 0
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument('--msteams-url', help='Path to MS Teams channel url to communicate messages.',
-                        default=DEFAULT_MSTEAMS_URL_FILE, action='store', required=False)
-
-    parser.add_argument('--github-credentials', help='GitHub user credentials to access repo.',
-                        nargs="+", required=True)
-
-    parser.add_argument('--github-org', help='Name of organization on GitHub.',
-                        default=DEFAULT_GITHUB_ORGANIZATION, action='store', required=False)
-
-    parser.add_argument('--github-project', help='Name of project on GitHub.',
-                        default=DEFAULT_GITHUB_PROJECT, action='store', required=False)
-
-    parser.add_argument('--jenkins-token', help='Path to Jenkins user token to access build info.',
-                        default=DEFAULT_JENKINS_TOKEN_FILE, action='store', required=False)
-
-    parser.add_argument('--jenkins-server', help='Jenkins server address.',
-                        default=DEFAULT_JENKINS_SERVER, action='store', required=False)
-
-    parser.add_argument('--jenkins-user', help='Jenkins user used to log in.',
-                        default=DEFAULT_JENKINS_USER, action='store', required=False)
-
-    parser.add_argument('--ci-job', help='Jenkins CI job name.',
-                        default=DEFAULT_CI_JOB_NAME, action='store', required=False)
-
-    parser.add_argument('--watchdog-job', help='Jenkins CI Watchdog job name.',
-                        default=DEFAULT_WATCHDOG_JOB_NAME, action='store', required=False)
-
-    parser.add_argument('--quiet', help="Quiet mode - doesn\'t send message to communicator.",
-                        action='store_true', required=False)
-
-    args = parser.parse_args()
-    sys.exit(main(args))

.ci/openvino-onnx/watchdog/src/ms_teams_communicator.py

@@ -1,128 +0,0 @@
-#!/usr/bin/python3
-
-# Copyright (C) 2018-2021 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import requests
-
-
-class MSTeamsCommunicator:
-    """Class communicating with MSTeams using Incoming Webhook.
-
-    The purpose of this class is to use MSTeams API to send message.
-    Docs for used API, including wrapped methods can be found at:
-    https://docs.microsoft.com/en-us/outlook/actionable-messages/send-via-connectors
-    """
-
-    def __init__(self, _ci_alerts_channel_url):
-        self._ci_alerts_channel_url = _ci_alerts_channel_url
-        self._queued_messages = {
-            self._ci_alerts_channel_url: [],
-        }
-
-    @property
-    def messages(self):
-        """
-        Get list of queued messages.
-
-            :return:           List of queued messages
-            :return type:      List[String]
-        """
-        return self._queued_messages.values()
-
-    def queue_message(self, message):
-        """
-        Queue message to be sent later.
-
-            :param message:     Message content
-            :type message:      String
-        """
-        self._queued_messages[self._ci_alerts_channel_url].append(message)
-
-    def _parse_text(self, watchdog_log, message):
-        """
-        Parse text to display as alert.
-
-            :param watchdog_log:     Watchdog log content
-            :param message:          Unparsed message content
-            :type watchdog_log:      String
-            :type message:           String
-        """
-        message_split = message.split('\n')
-        log_url = None
-        if len(message_split) == 3:
-            log_url = message_split[-1]
-        title = message_split[0]
-        text = message_split[1]
-        header = watchdog_log.split(' - ')
-        header_formatted = '{} - [Watchdog Log]({})'.format(header[0], header[1])
-        return title, log_url, '{}\n\n{}'.format(header_formatted, text)
-
-    def _json_request_content(self, title, log_url, text_formatted):
-        """
-        Create final json request to send message to MS Teams channel.
-
-            :param title:            Title of alert
-            :param log_url:          URL to PR
-            :param text_formatted:   General content of alert - finally formatted
-            :type title:             String
-            :type title:             String
-            :type title:             String
-        """
-        data = {
-            '@context': 'https://schema.org/extensions',
-            '@type': 'MessageCard',
-            'themeColor': '0072C6',
-            'title': title,
-            'text': text_formatted,
-            'potentialAction':
-                [
-                    {
-                        '@type': 'OpenUri',
-                        'name': 'Open PR',
-                        'targets':
-                            [
-                                {
-                                    'os': 'default',
-                                    'uri': log_url,
-                                },
-                            ],
-                    },
-                ],
-        }
-        return data
-
-    def _send_to_channel(self, watchdog_log, message_queue, channel_url):
-        """
-        Send MSTeams message to specified channel.
-
-            :param watchdog_log:            Watchdog log content
-            :param message_queue:           Queued messages to send
-            :param channel_url:             Channel url
-            :type watchdog_log:             String
-            :type message_queue:            String
-            :type channel_url:              String
-
-        """
-        for message in message_queue:
-            title, log_url, text_formatted = self._parse_text(watchdog_log, message)
-            data = self._json_request_content(title, log_url, text_formatted)
-
-            try:
-                requests.post(url=channel_url, json=data)
-            except Exception as ex:
-                raise Exception('!!CRITICAL!! MSTeamsCommunicator: Could not send message '
-                                'due to {}'.format(ex))
-
-    def send_message(self, watchdog_log, quiet=False):
-        """
-        Send queued messages as single communication.
-
-            :param watchdog_log:     Watchdog log content
-            :param quiet:            Flag for disabling sending report through MS Teams
-            :type watchdog_log:      String
-            :type quiet:             Boolean
-        """
-        for channel, message_queue in self._queued_messages.items():
-            if not quiet and message_queue:
-                self._send_to_channel(watchdog_log, message_queue, channel)

.ci/openvino-onnx/watchdog/src/watchdog.py

@@ -1,505 +0,0 @@
-#!/usr/bin/python3
-
-# Copyright (C) 2018-2021 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-import datetime
-import time
-import re
-import logging
-import requests
-from ms_teams_communicator import MSTeamsCommunicator
-from jenkins_wrapper import JenkinsWrapper
-from jenkins import NotFoundException
-from git_wrapper import GitWrapper, GitWrapperError
-import os
-import json
-
-# Logging
-logging.basicConfig(format='%(name)s - %(levelname)s - %(message)s')
-log = logging.getLogger(__name__)
-log.setLevel(logging.INFO)
-
-# Watchdog static constant variables
-_SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
-_BUILD_DURATION_THRESHOLD = datetime.timedelta(minutes=60)
-_CI_START_THRESHOLD = datetime.timedelta(minutes=30)
-_AWAITING_JENKINS_THRESHOLD = datetime.timedelta(minutes=5)
-_WATCHDOG_DIR = os.path.expanduser('~')
-_PR_REPORTS_CONFIG_KEY = 'pr_reports'
-_CI_BUILD_FAIL_MESSAGE = 'ERROR:   py3: commands failed'
-_CI_BUILD_SUCCESS_MESSAGE = 'py3: commands succeeded'
-_GITHUB_CI_CHECK_NAME = 'OpenVINO-ONNX'
-
-INTERNAL_ERROR_MESSAGE_HEADER = '!!! --- !!! INTERNAL WATCHDOG ERROR !!! --- !!!'
-ERROR_MESSAGE_HEADER = '!!! OpenVino-ONNX CI Error !!!'
-WARNING_MESSAGE_HEADER = 'OpenVino-ONNX CI WARNING'
-INFO_MESSAGE_HEADER = 'OpenVino-ONNX CI INFO'
-
-
-class Watchdog:
-    """Class describing OpenVino-ONNX-CI Watchdog.
-
-    Watchdog connects to GitHub and retrieves the list of current pull requests (PRs) in
-    OpenVino repository. Then it connects to specified Jenkins server to
-    check CI jobs associated with every PR. Watchdog verifies time durations for Jenkins
-    initial response, job queue and execution against time treshold constants. Every fail
-    is logged and reported through MS Teams communicators.
-
-    :param jenkins_token:       Token used for Jenkins
-    :param jenkins_server:      Jenkins server address
-    :param jenkins_user:        Username used to connect to Jenkins
-    :param github_credentials:  Credentials used to connect to GitHub
-    :param msteams_url:         URL used to connect to MS Teams channel
-    :param ci_job_name:         OpenVino-ONNX CI job name used in Jenkins
-    :param watchdog_job_name:   Watchdog job name used in Jenkins
-    :type jenkins_token:        String
-    :type jenkins_server:       String
-    :type jenkins_user:         String
-    :type github_credentials:   String
-    :type msteams_url:          String
-    :type ci_job_name:          String
-    :type watchdog_job_name:    String
-
-    .. note::
-        Watchdog and OpenVino-ONNX CI job must be placed on the same Jenkins server.
-    """
-
-    def __init__(self, jenkins_token, jenkins_server, jenkins_user, github_credentials, git_org,
-                 git_project, msteams_url, ci_job_name, watchdog_job_name):
-        self._config_path = os.path.join(_WATCHDOG_DIR, '{}/.{}_ci_watchdog.json'.format(_WATCHDOG_DIR, git_project))
-        # Jenkins Wrapper object for CI job
-        self._jenkins = JenkinsWrapper(jenkins_token,
-                                       jenkins_user=jenkins_user,
-                                       jenkins_server=jenkins_server)
-        # Load GitHub token and log in, retrieve pull requests
-        self._git = GitWrapper(github_credentials, repository=git_org, project=git_project)
-        # Create MS Teams api object
-        self._msteams_hook = MSTeamsCommunicator(msteams_url)
-        self._ci_job_name = ci_job_name.lower()
-        self._watchdog_job_name = watchdog_job_name
-        # Read config file
-        self._config = self._read_config_file()
-        # Time at Watchdog initiation
-        self._now_time = datetime.datetime.now()
-        self._current_prs = {}
-        self._ms_teams_enabled = True
-
-    def run(self, quiet=False):
-        """Run main watchdog logic.
-
-        Retrieve list of pull requests and pass it to the method responsible for checking them.
-
-        :param quiet:   Flag for disabling sending report through communicator
-        :type quiet:    Boolean
-        """
-        try:
-            pull_requests = self._git.get_pull_requests()
-        except GitWrapperError:
-            message = 'Failed to retrieve Pull Requests!'
-            log.exception(message)
-            self._queue_message(message, message_severity='internal')
-        # Check all pull requests
-        for pr in pull_requests:
-            try:
-                self._check_pr(pr)
-            except Exception as e:
-                log.exception(str(e))
-                self._queue_message(str(e), message_severity='internal', pr=pr)
-        self._update_config()
-        self._send_message(quiet=quiet)
-
-    def _read_config_file(self):
-        """Read Watchdog config file stored on the system.
-
-        The file stores every fail already reported along with timestamp. This
-        mechanism is used to prevent Watchdog from reporting same failure
-        multiple times. In case there's no config under the expected path,
-        appropriate data structure is created and returned.
-
-        :return:            Returns dict of dicts with reported fails with their timestamps
-        :rtype:             dict of dicts
-        """
-        if os.path.isfile(self._config_path):
-            log.info('Reading config file in: {}'.format(self._config_path))
-            file = open(self._config_path, 'r')
-            data = json.load(file)
-        else:
-            log.info('No config file found in: {}'.format(self._config_path))
-            data = {_PR_REPORTS_CONFIG_KEY: {}}
-        return data
-
-    def _check_pr(self, pr):
-        """Check pull request (if there's no reason to skip).
-
-        Retrieve list of statuses for every PR's last commit and interpret them. Filters out statuses
-        unrelated to OpenVino-ONNX Jenkins CI and passes relevant statuses to method that interprets them.
-        If no commit statuses related to Jenkins are available after time defined by
-        **_AWAITING_JENKINS_THRESHOLD** calls appropriate method to check for builds waiting in queue.
-
-        :param pr:       GitHub Pull Requests
-        :type pr:        github.PullRequest.PullRequest
-        """
-        log.info('===============================================')
-        log.info('Checking PR#{}'.format(pr.number))
-        # Get last Jenkins status
-        last_status = self._get_last_status(pr)
-        # Append PR checked in current run for Watchdog config
-        self._current_prs[str(pr.number)] = self._get_pr_timestamps(pr, last_status)
-        if self._should_ignore(pr) or self._updated_since_last_run(pr):
-            log.info('Ignoring PR#{}'.format(pr.number))
-
-            return
-
-        # Calculate time passed since PR update (any commit, merge or comment)
-        pr_time_delta = self._now_time - pr.updated_at
-        if last_status:
-            # Interpret found CI statuses
-            log.info('Last status: {} at {}'.format(last_status.description, last_status.updated_at))
-            self._interpret_status(last_status, pr)
-        elif pr_time_delta > _CI_START_THRESHOLD:
-            # If there's no status after assumed time - check if build is waiting in queue
-            log.info('CI for PR {}: NO JENKINS STATUS YET'.format(pr.number))
-            self._check_missing_status(pr)
-
-    @staticmethod
-    def _get_pr_timestamps(pr, last_status):
-        """Get dict containing PR timestamp and last status timestamp.
-
-        :param pr:          Single PR being currently checked
-        :type pr:           github.PullRequest.PullRequest
-
-        :return:            Dictionary with PR and last status update timestamps
-        :rtype:             dict
-        """
-        pr_timestamp = time.mktime(pr.updated_at.timetuple())
-        if last_status:
-            status_timestamp = time.mktime(last_status.updated_at.timetuple())
-        else:
-            status_timestamp = None
-        pr_dict = {'pr_timestamp': pr_timestamp,
-                   'status_timestamp': status_timestamp}
-        return pr_dict
-
-    @staticmethod
-    def _get_last_status(pr):
-        """Get last commit status posted from Jenkins.
-
-        :param pr:          Single PR being currently checked
-        :type pr:           github.PullRequest.PullRequest
-
-        :return:            Either last PR status posted from Jenkins or None
-        :rtype:             github.CommitStatus.CommitStatus
-        """
-        # Find last commit in PR
-        last_commit = pr.get_commits().reversed[0]
-        # Get statuses and filter them to contain only those related to Jenkins CI
-        # and check if CI in Jenkins started
-        statuses = last_commit.get_statuses()
-        jenk_statuses = [stat for stat in statuses if
-                         _GITHUB_CI_CHECK_NAME in stat.context]
-        try:
-            last_status = jenk_statuses[0]
-        except IndexError:
-            last_status = None
-        return last_status
-
-    @staticmethod
-    def _should_ignore(pr):
-        """Determine if PR should be ignored.
-
-        :param pr:          Single PR being currently checked
-        :type pr:           github.PullRequest.PullRequest
-
-        :return:            Returns True if PR should be ignored
-        :rtype:             Bool
-        """
-        # Ignore PR if it has WIP label or WIP in title
-        if 'WIP' in pr.title:
-            log.info('PR#{} should be ignored. WIP tag in title.'.format(pr.number))
-            return True
-
-        label_names = [label.name for label in pr.labels]
-        if 'WIP' in label_names:
-            log.info('PR#{} should be ignored. WIP label present.'.format(pr.number))
-            return True
-
-        # Ignore PR if base ref is not master
-        if 'master' not in pr.base.ref:
-            log.info('PR#{} should be ignored. Base ref is not master'.format(pr.number))
-            return True
-
-        # Ignore PR if mergeable state is 'dirty' or 'behind'.
-        # Practically this ignores PR in case of merge conflicts
-        ignored_mergeable_states = ['behind', 'dirty', 'draft']
-        if pr.mergeable_state in ignored_mergeable_states:
-            log.info('PR#{} should be ignored. Mergeable state is {}. '.format(pr.number, pr.mergeable_state))
-            return True
-
-        # If no criteria for ignoring PR are met - return false
-        return False
-
-    def _updated_since_last_run(self, pr):
-        # Ignore if PR was already checked and there was no update in meantime
-        pr_number = str(pr.number)
-        current_pr_timestamps = self._current_prs.get(pr_number)
-        last_pr_timestamps = self._config[_PR_REPORTS_CONFIG_KEY].get(pr_number)
-        if current_pr_timestamps == last_pr_timestamps:
-            log.info('PR#{} - No update since last check'.format(pr.number))
-            return True
-        else:
-            return False
-
-    def _check_missing_status(self, pr):
-        """Verify if missing status is expected.
-
-        This method checks if CI build for last was scheduled and still waits in queue for
-        executor.
-
-        :param pr:                  Single PR being currently checked
-        :type pr:                   github.PullRequest.PullRequest
-        """
-        pr_time_delta = self._now_time - pr.updated_at
-        try:
-            build_number = self._build_scheduled(pr)
-            if self._build_in_queue(pr, build_number):
-                message = ('PR# {}: build waiting in queue after {} minutes.'
-                           .format(pr.number, pr_time_delta.seconds / 60))
-                severity = 'warning'
-            else:
-                message = ('PR# {}: missing status on GitHub after {} minutes.'
-                           .format(pr.number, pr_time_delta.seconds / 60))
-                severity = 'error'
-            self._queue_message(message, message_severity=severity, pr=pr)
-        except TypeError:
-            log.info('Committer outside of OpenVino organization')
-
-    def _build_scheduled(self, pr):
-        """Check if Jenkins build corresponding to PR was scheduled.
-
-        This method takes last Jenkins build for given PR and compares hash from Jenkins console output
-        and sha from PR object to determine if CI build for appropriate commit was scheduled.
-
-        :param pr:          Single PR being currently checked
-        :type pr:           github.PullRequest.PullRequest
-
-        :return:            Returns build number or -1 if no build found
-        :rtype:             int
-        """
-        pr_number = str(pr.number)
-        project_name_full = self._ci_job_name + '/PR-' + pr_number
-
-        try:
-            # Retrieve console output from last Jenkins build for job corresponding to this PR
-            last_build_number = self._jenkins.get_job_info(project_name_full)['lastBuild']['number']
-            console_output = self._jenkins.get_build_console_output(project_name_full, last_build_number)
-            # Check if CI build was scheduled - commit hash on GH must match hash in last Jenkins build console output
-            # Retrieve hash from Jenkins output
-            match_string = '(?:Obtained .ci/[a-zA-Z/]+Jenkinsfile from ([a-z0-9]{40}))'
-            retrieved_sha = re.search(match_string, console_output).group(1)
-            if retrieved_sha == pr.get_commits().reversed[0].sha:
-                return last_build_number
-            else:
-                return -1
-        except (NotFoundException, AttributeError, requests.exceptions.HTTPError):
-            message = ('PR #{}: Jenkins build corresponding to commit {} not found!'
-                       .format(pr_number, pr.get_commits().reversed[0].sha))
-            self._queue_message(message, message_severity='error', pr=pr)
-            return -1
-
-    def _build_in_queue(self, pr, build_number):
-        """Check if Jenkins build waits in queue.
-
-        This method verifies if CI build is waiting in queue based on console output.
-
-        :param pr:                  Single PR being currently checked
-        :param build_number:        Jenkins build number to retrieve console output from
-        :type pr:                   github.PullRequest.PullRequest
-        :type build_number:         int
-
-        :return:            Returns True if CI build is waiting in queue
-        :rtype:             Bool
-        """
-        pr_number = str(pr.number)
-        project_name_full = self._ci_job_name + '/PR-' + pr_number
-        # Retrieve console output
-        try:
-            console_output = self._jenkins.get_build_console_output(project_name_full, build_number)
-        except NotFoundException:
-            return False
-        # Check if build is waiting in queue (and not already running on an executor)
-        if 'Waiting for next available executor on' in console_output \
-                and 'Running on' not in console_output:
-            log.info('CI for PR %s: WAITING IN QUEUE', pr_number)
-            return True
-        else:
-            return False
-
-    def _interpret_status(self, status, pr):
-        """
-        Verify GitHub status passed to the method.
-
-        This method verifies last commit status for given PR, calling appropriate methods
-        to further validate the status.
-
-        :param status:              GitHub commit status
-        :param pr:                  Single PR being currently checked
-        :type status:               github.CommitStatus.CommitStatus
-        :type pr:                   github.PullRequest.PullRequest
-        """
-        try:
-            # Retrieve build number for Jenkins build related to this PR
-            build_number = self._retrieve_build_number(status.target_url)
-            # CI build finished - verify if expected output is present
-            finished_statuses = ['Build finished', 'This commit cannot be built', 'This commit looks good']
-            pending_statuses = ['This commit is being built', 'Testing in progress',
-                                'This commit is scheduled to be built']
-            if any(phrase in status.description for phrase in finished_statuses):
-                self._check_finished(pr, build_number)
-            # CI build in progress - verify timeouts for build queue and duration
-            elif any(phrase in status.description for phrase in pending_statuses):
-                self._check_in_progress(pr, build_number)
-            else:
-                message = 'ONNX CI job for PR# {}: unrecognized status: {}'.format(pr.number, status.description)
-                self._queue_message(message, message_severity='error', pr=pr)
-        except Exception:
-            # Log Watchdog internal error in case any status can't be properly verified
-            message = 'Failed to verify status "{}" for PR# {}'.format(status.description, pr.number)
-            log.exception(message)
-            self._queue_message(message, message_severity='internal', pr=pr)
-
-    def _retrieve_build_number(self, url):
-        """Retrieve Jenkins CI job build number from URL address coming from GitHub commit status.
-
-        :param url:         URL address from GitHub commit status
-        :type url:          String
-
-        :return:            Returns build number
-        :rtype:             int
-        """
-        # Retrieve the build number from url string
-        match_obj = re.search('(?:/PR-[0-9]+/)([0-9]+)', url)
-        try:
-            number = int(match_obj.group(1))
-            return number
-        except Exception:
-            log.exception('Failed to retrieve build number from url link: %s', url)
-            raise
-
-    def _queue_message(self, message, message_severity='info', pr=None):
-        """Add a message to message queue in communicator object.
-
-        The queued message is constructed based on message string passed as
-        a method argument and message header. Message header is mapped to message severity
-        also passed as an argument.
-
-        :param message:                 Message content
-        :param message_severity:        Message severity level
-        :type message:                  String
-        :type message_severity:         int
-        """
-        log.info(message)
-        internal = False
-        if 'internal' in message_severity:
-            message_header = INTERNAL_ERROR_MESSAGE_HEADER
-            internal = True
-        elif 'error' in message_severity:
-            message_header = ERROR_MESSAGE_HEADER
-        elif 'warning' in message_severity:
-            message_header = WARNING_MESSAGE_HEADER
-        else:
-            message_header = INFO_MESSAGE_HEADER
-        # If message is related to PR attatch url
-        if pr:
-            message = message + '\n' + pr.html_url
-
-        send = message_header + '\n' + message
-        if self._ms_teams_enabled:
-            self._msteams_hook.queue_message(send)
-
-    def _check_finished(self, pr, build_number):
-        """Verify if finished build output contains expected string for either fail or success.
-
-        :param pr:                  Single PR being currently checked
-        :param build_number:        Jenkins CI job build number
-        :type pr:                   github.PullRequest.PullRequest
-        :type build_number:         int
-        """
-        pr_number = str(pr.number)
-        log.info('CI for PR %s: FINISHED', pr_number)
-        # Check if FINISH was valid FAIL / SUCCESS
-        project_name_full = self._ci_job_name + '/PR-' + pr_number
-        build_output = self._jenkins.get_build_console_output(project_name_full, build_number)
-        if _CI_BUILD_FAIL_MESSAGE not in build_output \
-                and _CI_BUILD_SUCCESS_MESSAGE not in build_output:
-            message = ('ONNX CI job for PR #{}: finished but no tests success or fail '
-                       'confirmation is present in console output!'.format(pr_number))
-            self._queue_message(message, message_severity='error', pr=pr)
-
-    def _send_message(self, quiet=False):
-        """Send messages queued in MS Teams objects to designated channel.
-
-        Queued messages are being sent as a single communication.
-
-        :param quiet:   Flag for disabling sending report through communicator
-        :type quiet:    Boolean
-        """
-        if any(messages for messages in self._msteams_hook.messages):
-            try:
-                watchdog_build = self._jenkins.get_job_info(self._watchdog_job_name)['lastBuild']
-                watchdog_build_number = watchdog_build['number']
-                watchdog_build_link = watchdog_build['url']
-            except Exception:
-                watchdog_build_number = 'UNKNOWN'
-                watchdog_build_link = self._jenkins.jenkins_server
-            send = self._watchdog_job_name + '- build ' + str(
-                watchdog_build_number) + ' - ' + watchdog_build_link
-
-            if self._ms_teams_enabled:
-                self._msteams_hook.send_message(send, quiet=quiet)
-        else:
-            log.info('Nothing to report.')
-
-    def _check_in_progress(self, pr, build_number):
-        """Check if CI build succesfully started.
-
-        Checks if build started within designated time threshold, and job is
-        currently running - it didn't cross the time threshold.
-
-        :param pr:                  Single PR being currently checked
-        :param build_number:        Jenkins CI job build number
-        :type pr:                   github.PullRequest.PullRequest
-        :type build_number:         int
-        """
-        pr_number = str(pr.number)
-        log.info('CI for PR %s: TESTING IN PROGRESS', pr_number)
-        project_name_full = self._ci_job_name + '/PR-' + pr_number
-        build_info = self._jenkins.get_build_info(project_name_full, build_number)
-        build_datetime = datetime.datetime.fromtimestamp(build_info['timestamp'] / 1000.0)
-        build_delta = self._now_time - build_datetime
-        log.info('Build %s: IN PROGRESS, started: %s minutes ago', str(build_number),
-                 str(build_delta))
-        # If build still waiting in queue
-        if build_delta > _CI_START_THRESHOLD and self._build_in_queue(pr, build_number):
-            message = ('ONNX CI job build #{}, for PR #{} waiting in queue after {} '
-                       'minutes'.format(build_number, pr_number, str(build_delta.seconds / 60)))
-            self._queue_message(message, message_severity='warning', pr=pr)
-        elif build_delta > _BUILD_DURATION_THRESHOLD:
-            # CI job take too long, possibly froze - communicate failure
-            message = ('ONNX CI job build #{}, for PR #{} started, '
-                       'but did not finish in designated time of {} '
-                       'minutes!'.format(build_number, pr_number,
-                                         str(_BUILD_DURATION_THRESHOLD.seconds / 60)))
-            self._queue_message(message, message_severity='error', pr=pr)
-
-    def _update_config(self):
-        """Update Watchdog config file with PRs checked in current Watchdog run, remove old entries.
-
-        :param current_prs:        List of PR numbers checked during current Watchdog run
-        :type current_prs:         list of ints
-        """
-        # Cleanup config of old reports
-        log.info('Writing to config file at: {}'.format(self._config_path))
-        new_config = {_PR_REPORTS_CONFIG_KEY: self._current_prs}
-        file = open(self._config_path, 'w+')
-        json.dump(new_config, file)

.github/dependabot.yml

@@ -7,7 +7,7 @@ updates:
     directory: "/src/bindings/python"
     schedule:
       interval: weekly
-      day: monday
+      day: sunday
       time: "13:00"
     open-pull-requests-limit: 0
     reviewers:
@@ -15,4 +15,3 @@ updates:
       - akuporos
     labels:
       - "category: dependencies"
-      

.github/github_org_control/config.json

@@ -5,11 +5,10 @@
     "IGNORE_LOGINS": [
         "openvino-ci",
         "openvino-pushbot",
-        "lab-nerval",
-        "lab-nerval-onnx-ci",
-        "onnx-watchdog-agent",
         "workbench-ci-bot",
-        "openvino-pot-ci"
+        "openvino-pot-ci",
+        "sysicvvpux",
+        "ote-ci-bot"
     ],
     "MAX_MEMBERS_TO_REMOVE": 15,
     "EMAILS_FILE_PATH": "dev_emails-test.txt",
@@ -28,7 +27,7 @@
         "openvino-ie-gna-maintainers": "category: GNA",
         "openvino-ie-gpu-maintainers": "category: GPU",
         "openvino-ie-lpt-maintainers": "category: LP transformations",
-        "openvino-ie-multi-maintainers": "category: MULTI",
+        "openvino-ie-auto-multi-maintainers": "category: MULTI",
         "openvino-ie-python-api-maintainers": "category: python api",
         "openvino-ie-template-maintainers": "category: TEMPLATE",
         "openvino-ie-tests-maintainers": "category: IE Tests",

.github/github_org_control/github_api.py

@@ -157,7 +157,7 @@ class GithubOrgApi:
                 self.github_users_by_email[email] = org_member
                 if not is_valid_name(org_member.name):
                     self.members_to_fix_name.add(org_member)
-            elif not is_user_ignored(org_member):
+            else:
                 self.members_to_remove.add(org_member)
 
         print("\nOrg members - no Intel emails:")

.github/workflows/py_checks.yml

@@ -1,4 +1,4 @@
-name: IE Python Checks
+name: Python API Checks
 
 on:
   workflow_dispatch:
@@ -23,8 +23,9 @@ jobs:
         with:
           python-version: '3.6'
       - name: Install dependencies
-        run: python -m pip install -r src/bindings/python/src/compatibility/openvino/requirements_dev.txt
-      - name: Run Flake on samples
+        run: python -m pip install -r src/bindings/python/requirements_test.txt
+      # samples code-style
+      - name: Run flake8 on samples
         run: python -m flake8 ./ --config=setup.cfg
         working-directory: samples/python
       - name: Create code style diff for samples
@@ -38,21 +39,53 @@ jobs:
         with:
           name: samples_diff
           path: samples_diff.diff
-      - name: Run Flake on src
+      # IE Python API Flake code-style
+      - name: Run flake8 on IE Python API
         run: python -m flake8 ./ --config=setup.cfg
         working-directory: src/bindings/python/src/compatibility/openvino
-      - name: Create code style diff for Python src
+      - name: Create code style diff for IE Python API
         if: failure()
         run: |
           python -m black -l 160 -S ./
-          git diff > src_diff.diff
+          git diff > ie_python_diff.diff
         working-directory: src/bindings/python/src/compatibility/openvino
       - uses: actions/upload-artifact@v2
         if: failure()
         with:
-          name: src_diff
-          path: src_diff.diff
-      - name: Run Flake on wheel
+          name: ie_python_diff
+          path: ie_python_diff.diff
+      # nGraph Python API Flake code-style
+      - name: Run flake8 on nGraph Python API
+        run: python -m flake8 ./src/compatibility/ngraph --config=setup.cfg
+        working-directory: src/bindings/python
+      - name: Create code style diff for nGraph Python API
+        if: failure()
+        run: |
+          python -m black -l 160 -S ./
+          git diff > pyngraph_diff.diff
+        working-directory: src/bindings/python/src/compatibility/ngraph
+      - uses: actions/upload-artifact@v2
+        if: failure()
+        with:
+          name: pyngraph_diff
+          path: pyngraph_diff.diff
+      # Python API 2.0 Flake code-style
+      - name: Run flake8 on Python API 2.0
+        run: python -m flake8 ./src/openvino --config=setup.cfg
+        working-directory: src/bindings/python
+      - name: Create code style diff for Python API 2.0
+        if: failure()
+        run: |
+          python -m black -l 160 -S ./
+          git diff > pyopenvino_diff.diff
+        working-directory: src/bindings/python/src/openvino
+      - uses: actions/upload-artifact@v2
+        if: failure()
+        with:
+          name: pyopenvino_diff
+          path: pyopenvino_diff.diff
+      # wheel Flake code-style
+      - name: Run flake8 on wheel
         run: python -m flake8 ./ --config=../setup.cfg
         working-directory: src/bindings/python/wheel
       - name: Create code style diff for wheel
@@ -66,10 +99,24 @@ jobs:
         with:
           name: wheel_diff
           path: wheel_diff.diff
-      
-      - name: Run MyPy
+      # Python API 2.0 tests Flake code-style
+      - name: Run flake8 on python tests
+        # ignore lack of docs in tests
+        run: python -m flake8 tests/ --config=setup.cfg
+        working-directory: src/bindings/python
+      # IE Python API mypy check
+      - name: Run mypy on IE Python API
         run: python -m mypy ./ --config-file ./setup.cfg
         working-directory: src/bindings/python/src/compatibility/openvino
+      # nGraph Python API mypy check
+      - name: Run mypy on nGraph Python API
+        run: python -m mypy ./src/compatibility/ngraph --config-file ./setup.cfg
+        working-directory: src/bindings/python
+      # Python API 2.0 mypy check
+      - name: Run mypy on Python API 2.0
+        run: python -m mypy ./src/openvino --config-file ./setup.cfg
+        working-directory: src/bindings/python
+
       - name: Run Bandit
         run: python -m bandit -r ./ -f screen
         working-directory: src/bindings/python/src/compatibility/openvino

.gitmodules

@@ -1,6 +1,6 @@
-[submodule "src/plugins/intel_cpu/thirdparty/mkl-dnn"]
-	path = src/plugins/intel_cpu/thirdparty/mkl-dnn
-	url = https://github.com/openvinotoolkit/oneDNN.git
+[submodule "src/plugins/intel_cpu/thirdparty/onednn"]
+	path = src/plugins/intel_cpu/thirdparty/onednn
+	url = https://github.com/luo-cheng2021/oneDNN.git
 	ignore = dirty
 [submodule "thirdparty/xbyak"]
 	path = thirdparty/xbyak

CMakeLists.txt

@@ -4,7 +4,7 @@
 
 if(DEFINED BUILD_SHARED_LIBS AND NOT BUILD_SHARED_LIBS)
     # 'target_link_libraries' does not work correctly when called from
-    # different directly where 'add_library' is called: CMake generates
+    # different directory where 'add_library' is called: CMake generates
     # incorrect OpenVINOConfig.cmake in this case
     cmake_minimum_required(VERSION 3.17)
 else()
@@ -13,7 +13,9 @@ endif()
 
 project(OpenVINO DESCRIPTION "OpenVINO toolkit")
 
-set(IE_MAIN_SOURCE_DIR ${OpenVINO_SOURCE_DIR}/inference-engine)
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "CMake build type" FORCE)
+endif()
 
 find_package(IEDevScripts REQUIRED
              PATHS "${OpenVINO_SOURCE_DIR}/cmake/developer_package"
@@ -49,6 +51,7 @@ file(REMOVE "${CMAKE_BINARY_DIR}/InferenceEngineTargets.cmake")
 file(REMOVE "${CMAKE_BINARY_DIR}/OpenVINOTargets.cmake")
 foreach(component IN LISTS openvino_export_components)
     file(REMOVE "${CMAKE_BINARY_DIR}/${component}_dev_targets.cmake")
+    file(REMOVE "${CMAKE_BINARY_DIR}/ov_${component}_dev_targets.cmake")
     unset(${component} CACHE)
 endforeach()
 unset(openvino_export_components CACHE)

CODEOWNERS

@@ -39,14 +39,19 @@ Jenkinsfile  @openvinotoolkit/openvino-admins
 
 # IE CPU:
 /src/plugins/intel_cpu/  @openvinotoolkit/openvino-ie-cpu-maintainers @openvinotoolkit/openvino-ie-cpu-developers
-/src/common/low_precision_transformations/  @openvinotoolkit/openvino-ie-cpu-maintainers @openvinotoolkit/openvino-ie-cpu-developers
-/src/plugins/intel_cpu/thirdparty/mkl-dnn/  @openvinotoolkit/openvino-ie-cpu-maintainers @openvinotoolkit/openvino-ie-cpu-developers
+/src/plugins/intel_cpu/thirdparty/onednn/  @openvinotoolkit/openvino-ie-cpu-maintainers @openvinotoolkit/openvino-ie-cpu-developers
+
+#IE LPT
+/src/common/low_precision_transformations/  @openvinotoolkit/openvino-ie-lpt-maintainers
 
 # IE GPU:
 /src/inference/include/ie/gpu/  @openvinotoolkit/openvino-ie-gpu-maintainers @openvinotoolkit/openvino-ie-gpu-developers
 /src/inference/include/ie/cldnn/  @openvinotoolkit/openvino-ie-gpu-maintainers @openvinotoolkit/openvino-ie-gpu-developers
 /src/inference/include/openvino/runtime/intel_gpu/  @openvinotoolkit/openvino-ie-gpu-maintainers @openvinotoolkit/openvino-ie-gpu-developers
 /src/plugins/intel_gpu/  @openvinotoolkit/openvino-ie-gpu-maintainers @openvinotoolkit/openvino-ie-gpu-developers
+/docs/snippets/gpu/  @openvinotoolkit/openvino-ie-gpu-maintainers @openvinotoolkit/openvino-ie-gpu-developers
+/docs/OV_Runtime_UG/supported_plugins/GPU.md  @openvinotoolkit/openvino-ie-gpu-maintainers @openvinotoolkit/openvino-ie-gpu-developers
+/docs/OV_Runtime_UG/supported_plugins/GPU_RemoteTensor_API.md  @openvinotoolkit/openvino-ie-gpu-maintainers @openvinotoolkit/openvino-ie-gpu-developers
 
 # IE VPU:
 /src/plugins/intel_myriad  @openvinotoolkit/openvino-ie-vpu-maintainers
@@ -63,6 +68,9 @@ Jenkinsfile  @openvinotoolkit/openvino-admins
 /src/plugins/intel_gna/  @openvinotoolkit/openvino-ie-gna-maintainers
 /src/inference/include/ie/gna/  @openvinotoolkit/openvino-ie-gna-maintainers
 
+# IE ARM CPU:
+/docs/OV_Runtime_UG/supported_plugins/ARM_CPU.md  @openvinotoolkit/openvino_contrib-arm_plugin-maintainers
+
 # IE Auto (MULTI) plugin:
 /src/plugins/auto/  @openvinotoolkit/openvino-ie-auto-multi-maintainers
 /src/inference/include/ie/multi-device/  @openvinotoolkit/openvino-ie-auto-multi-maintainers
@@ -71,8 +79,8 @@ Jenkinsfile  @openvinotoolkit/openvino-admins
 /src/frontends/paddle/  @openvinotoolkit/openvino-ie-paddle-maintainers
 
 # IE Tests:
-/src/tests/  @openvinotoolkit/openvino-ie-tests-maintainers
-/src/tests_deprecated/  @openvinotoolkit/openvino-ie-tests-maintainers
+/src/tests/  @openvinotoolkit/openvino-ie-tests-maintainers @openvinotoolkit/openvino-ie-test-developers
+/src/tests_deprecated/  @openvinotoolkit/openvino-ie-tests-maintainers @openvinotoolkit/openvino-ie-test-developers
 /src/tests/functional/inference_engine/ngraph_reader/  @openvinotoolkit/openvino-ie-tests-maintainers @openvinotoolkit/openvino-ngraph-maintainers
 /src/tests/functional/inference_engine/transformations/  @openvinotoolkit/openvino-ie-tests-maintainers @openvinotoolkit/openvino-ngraph-maintainers
 
@@ -82,6 +90,6 @@ Jenkinsfile  @openvinotoolkit/openvino-admins
 *.md  @openvinotoolkit/openvino-docs-maintainers
 
 # Control 3d party dependencies
-**/*requirements*.*  @openvino-configuration-mgmt
-**/setup.py  @openvino-configuration-mgmt
-/scripts/install_dependencies/  @openvino-configuration-mgmt
+**/*requirements*.*  @openvinotoolkit/openvino-configuration-mgmt
+**/setup.py  @openvinotoolkit/openvino-configuration-mgmt
+/scripts/install_dependencies/  @openvinotoolkit/openvino-configuration-mgmt

CONTRIBUTING.md

@@ -1,68 +1,55 @@
 # How to contribute to the OpenVINO repository
 
-We suppose that you are an enthusiastic coder, want to contribute some code. For that purpose OpenVINO project now has a repository on the GitHub, to simplify everybody's life! All the bug fixes, new functionality, new tutorials etc. should be submitted via the GitHub's mechanism of pull requests.
+We welcome community contributions to OpenVINO™. Please read the following guide to learn how to find ideas for contribution, practices for good pull requests, checking your changes with our tests and more.
 
-If you are not familiar with the mechanism - do not worry, it's very simple. Keep reading.
 
 ## Before you start contributing you should
 
--   Make sure you agree to contribute your code under  [OpenVINO (Apache 2.0)](https://github.com/openvinotoolkit/openvino/blob/master/LICENSE)  license.
--   If you are submitting a new module, you should go into  [openvino_contrib](https://github.com/openvinotoolkit/openvino_contrib)  repository by default.
--   If you are going to fix a bug, check that it's still exists. This can be done by building the latest  [releases/2020/3](https://github.com/openvinotoolkit/openvino/tree/releases/2020/3)  branch (LTS release) or the latest master branch, and make sure that the error is still reproducible there. We do not fix bugs that only affect older non-LTS releases like 2020.2 for example (more details about  [branching strategy](https://github.com/openvinotoolkit/openvino/wiki/Branches))
--   Make sure that nobody beat you into fixing or reporting the issue by doing a search on the  [Github OpenVINO issues](https://github.com/openvinotoolkit/openvino/issues)  page, and making sure that there isn't someone working on it. In the latter case you might provide support or suggestion in the issue or in the linked pull request.
--   If you have a question about the software, then this is  **NOT**  the right place. You should open up a question at the  [OpenVINO forum](https://community.intel.com/t5/Intel-Distribution-of-OpenVINO/bd-p/distribution-openvino-toolkit). In order to post a decent question from the start, feel free to read the official forum guidelines.
+-   Make sure you agree to contribute your code under  [OpenVINO™ (Apache 2.0)](https://github.com/openvinotoolkit/openvino/blob/master/LICENSE)  license.
+-   Figure out what you’re going to contribute. If you don’t know what you are going to work on, navigate to the   [Github "Issues" tab](https://github.com/openvinotoolkit/openvino/issues). Make sure that there isn't someone working on it. In the latter case you might provide support or suggestion in the issue or in the linked pull request.
+-   If you are going to fix a bug, check that it's still exists in the latest release. This can be done by building the latest master branch, and make sure that the error is still reproducible there. We do not fix bugs that only affect older non-LTS releases like 2020.2 for example (more details about  [branching strategy](https://github.com/openvinotoolkit/openvino/wiki/Branches)).
 
-Before you open up anything on the OpenVINO GitHub page, be sure that you are at the right place with your problem.
 
 ## "Fork & Pull Request model" for code contribution
 
-### [](https://github.com/openvinotoolkit/openvino/wiki/Contribute#the-instruction-in-brief)The instruction in brief
+### [](https://github.com/openvinotoolkit/openvino/blob/master/CONTRIBUTING.md#the-instruction-in-brief)The instruction in brief
 
--   Register at GitHub. Create your fork of OpenVINO repository  [https://github.com/openvinotoolkit/openvino](https://github.com/openvinotoolkit/openvino)  (see  [https://help.github.com/articles/fork-a-repo](https://help.github.com/articles/fork-a-repo)  for details).
+-   Register at GitHub. Create your fork of OpenVINO™ repository  [https://github.com/openvinotoolkit/openvino](https://github.com/openvinotoolkit/openvino)  (see  [https://help.github.com/articles/fork-a-repo](https://help.github.com/articles/fork-a-repo)  for details).
 -   Install Git.
     -   Set your user name and email address in a Git configuration according to GitHub account (see  [https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup](https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup)  for details).
 -   Choose a task for yourself. It could be a bugfix or some new code.
 -   Choose a base branch for your work. More details about branches and policies are here:  [Branches](https://github.com/openvinotoolkit/openvino/wiki/Branches)
 -   Clone your fork to your computer.
 -   Create a new branch (with a meaningful name) from the base branch you chose.
--   Modify / add the code following our  [Coding Style Guide](https://github.com/openvinotoolkit/openvino/wiki/CodingStyleGuideLines)  and  [Documentation guidelines](https://github.com/openvinotoolkit/openvino/wiki/CodingStyleGuideLinesDocumentation).
+-   Modify / add the code following our  [Coding Style Guide](https://github.com/openvinotoolkit/openvino/wiki/CodingStyleGuideLines).
 -   If you want to add a new sample, please look at this  [Guide for contributing to C++/C/Python IE samples](https://github.com/openvinotoolkit/openvino/wiki/SampleContribute)
+-   If you want to contribute to the documentation and want to add a new guide, follow that instruction [Documentation guidelines](https://github.com/openvinotoolkit/openvino/wiki/CodingStyleGuideLinesDocumentation)
 -   Run testsuite locally:
     -   execute each test binary from the artifacts directory, e.g.  `<source dir>/bin/intel64/Release/ieFuncTests`
--   If you contribute to the documentation and want to add a new guide:
-    -   Create a new markdown file in an appropriate folder.
-    -   **REQUIRED:**  The document title must contain a document label in a form:  `{#openvino_docs_<name>}`. For example:  `Deep Learning Network Intermediate Representation and Operation Sets in OpenVINO™ {#openvino_docs_MO_DG_IR_and_opsets}`.
-    -   Add your file to the documentation structure. Open the documentation structure file  [`docs/doxygen/ie_docs.xml`](https://github.com/openvinotoolkit/openvino/blob/master/docs/doxygen/ie_docs.xml)  and add your file path to the appropriate section.
 -   When you are done, make sure that your branch is to date with latest state of the branch you want to contribute to (e.g.  `git fetch upstream && git merge upstream/master`), push your branch to your GitHub fork; then create a pull request from your branch to the base branch (see  [https://help.github.com/articles/using-pull-requests](https://help.github.com/articles/using-pull-requests)  for details).
 
 ## Making a good pull request
 
 Following these guidelines will increase the likelihood of your pull request being accepted:
 
--   Before pushing your PR to the repository, make sure that it builds perfectly fine on your local system.
--   Add enough information, like a meaningful title, the reason why you made the commit and a link to the issue page if you opened one for this PR.
--   Scope your PR to one issue. Before submitting, make sure the diff contains no unrelated changes. If you want to cover more than one issue, submit your changes for each as separate pull requests.
--   If you have added new functionality, you should update/create the relevant documentation, as well as add tests for it to the testsuite.
--   Try not to include "oops" commits - ones that just fix an error in the previous commit. If you have those, then before submitting  [squash](https://github.com/openvinotoolkit/openvino/wiki/Contribute#https://git-scm.com/book/en/v2/Git-Tools-Rewriting-History#Squashing-Commits)  those fixes directly into the commits where they belong.
--   Make sure to choose the right base branch and to follow the  [Coding Style Guide](https://github.com/openvinotoolkit/openvino/wiki/CodingStyleGuideLines)  for your code or  [Documentation guidelines](https://github.com/openvinotoolkit/openvino/wiki/CodingStyleGuideLinesDocumentation)  you are changing documentation files.
--   Make sure to add test for new functionality or test that reproduces fixed bug with related test data. Please do not add extra images or videos, if some of existing media files are suitable.
+-   One PR – one issue.
+-   Build perfectly on your local system.
+-   Choose the right base branch [Branches](https://github.com/openvinotoolkit/openvino/wiki/Branches).
+-   Follow the  [Coding Style Guide](https://github.com/openvinotoolkit/openvino/wiki/CodingStyleGuideLines) for your code.
+-   Update documentation using [Documentation guidelines](https://github.com/openvinotoolkit/openvino/wiki/CodingStyleGuideLinesDocumentation) if needed.
+-   Cover your changes with test. 
+-   Add license at the top of new files [C++ example](https://github.com/openvinotoolkit/openvino/blob/master/samples/cpp/classification_sample_async/main.cpp#L1-L2), [Python example](https://github.com/openvinotoolkit/openvino/blob/master/samples/python/hello_classification/hello_classification.py#L3-L4). 
+-   Add enough information: a meaningful title, the reason why you made the commit and a link to the issue page if exists.
+-   Remove unrelated to PR changes.
+-   If it is still WIP and you want to check CI test results early then use  _Draft_  PR.
+-   Submit your PR and become an OpenVINO™ contributor! 
+
 
 ## Testing and merging pull requests
 
--   Your pull request will be automatically tested by OpenVINO's precommit (testing status are automatically reported as "green" or "red" circles in precommit steps on PR's page). If any builders have failed, you should fix the issue. To rerun the automatic builds just push changes to your branch on GitHub. No need to close pull request and open a new one!
--   Once all the builders are "green", one of OpenVINO developers will review your code. Reviewer could ask you to modify your pull request. Please provide timely response for reviewers (within weeks, not months), otherwise you submission could be postponed or even rejected.
+Your pull request will be automatically tested by OpenVINO™'s precommit (testing status are automatically reported as "green" or "red" circles in precommit steps on PR's page). If any builders have failed, you need fix the issue. To rerun the automatic builds just push changes to your branch on GitHub. No need to close pull request and open a new one!
 
-## PR review good practices
-
--   Originator is responsible for driving the review of changes and should ping reviewers periodically.
--   Originator should close comments from the Reviewer when it is resolved. The Reviewer may re-open the comment if he does not agree with the resolution.
--   Originator should request re-review from the Reviewer when all comments are resolved by pushing the button in the “Reviewers” section.
--   If it is still WIP and you want to check CI test results early then use  _Draft_  PR.
--   Do  **NOT**  rewrite history (push -f) once you converted draft PR into regular one, add new commits instead. Looking at diffs makes review easier.
--   Write meaningful description of commits resulting from review.  _"Addressing review comments"_  is  **NOT**  a good description! Having a quick look at good descriptions can tell you much what is going on in PR without a need to go through all of resolved comments.
 
 ## Merging PR
 
-As soon as the reviewer is fine with the pull request and Precommit likes your code and shows "green" status, the "Approved" review status is put, which signals OpenVINO maintainers that they can merge your pull request.
-
-© Copyright 2018-2022, OpenVINO team
+As soon as the reviewer is fine with the pull request and precommit shows "green" status, the "Approved" review status is put, which signals OpenVINO™ maintainers that they can merge your pull request.

README.md

@@ -1,50 +1,208 @@
-# OpenVINO™ Toolkit
-[![Stable release](https://img.shields.io/badge/version-2021.4.2-green.svg)](https://github.com/openvinotoolkit/openvino/releases/tag/2021.4.2)
+<div align="center">
+
+<img src="docs/img/openvino-logo-purple-black.png" width="400px">
+
+[![Stable release](https://img.shields.io/badge/version-2022.1-green.svg)](https://github.com/openvinotoolkit/openvino/releases/tag/2022.1)
 [![Apache License Version 2.0](https://img.shields.io/badge/license-Apache_2.0-green.svg)](LICENSE)
 ![GitHub branch checks state](https://img.shields.io/github/checks-status/openvinotoolkit/openvino/master?label=GitHub%20checks)
 ![Azure DevOps builds (branch)](https://img.shields.io/azure-devops/build/openvinoci/b2bab62f-ab2f-4871-a538-86ea1be7d20f/13?label=Public%20CI)
+[![PyPI Status](https://badge.fury.io/py/openvino.svg)](https://badge.fury.io/py/openvino)
 [![PyPI Downloads](https://pepy.tech/badge/openvino)](https://pepy.tech/project/openvino)
+ 
+ </div>
 
-This toolkit allows developers to deploy pre-trained deep learning models
-through a high-level OpenVINO™ Runtime C++ and Python APIs integrated with application logic.
+## Contents:
 
-This open source version includes several components: namely [Model Optimizer], [OpenVINO™ Runtime], [Post-Training Optimization Tool], as well as CPU, GPU, MYRIAD, multi device and heterogeneous plugins to accelerate deep learning inferencing on Intel® CPUs and Intel® Processor Graphics.
+ - [What is OpenVINO?](#what-is-openvino-toolkit)
+    - [Components](#components)
+ - [Supported Hardware matrix](#supported-hardware-matrix)
+ - [License](#license)
+ - [Documentation](#documentation)
+ - [Tutorials](#tutorials)
+ - [Products which use OpenVINO](#products-which-use-openvino)
+ - [System requirements](#system-requirements)
+ - [How to build](#how-to-build)
+ - [How to contribute](#how-to-contribute)
+ - [Get a support](#get-a-support)
+ - [See also](#see-also)
+
+## What is OpenVINO toolkit?
+
+OpenVINO™ is an open-source toolkit for optimizing and deploying AI inference.
+ - Boost deep learning performance in computer vision, automatic speech recognition, natural language processing and other common tasks
+ - Use models trained with popular frameworks like TensorFlow, PyTorch and more
+ - Reduce resource demands and efficiently deploy on a range of Intel® platforms from edge to cloud
+
+
+This open-source version includes several components: namely [Model Optimizer], [OpenVINO™ Runtime], [Post-Training Optimization Tool], as well as CPU, GPU, MYRIAD, multi device and heterogeneous plugins to accelerate deep learning inferencing on Intel® CPUs and Intel® Processor Graphics.
 It supports pre-trained models from the [Open Model Zoo], along with 100+ open
 source and public models in popular formats such as TensorFlow, ONNX, PaddlePaddle, MXNet, Caffe, Kaldi.
 
-## Repository components
-* [OpenVINO™ Runtime]
-* [Model Optimizer]
-* [Post-Training Optimization Tool]
-* [Samples]
+### Components
+* [OpenVINO™ Runtime] - is a set of C++ libraries with C and Python bindings providing a common API to deliver inference solutions on the platform of your choice.
+    * [core](https://github.com/openvinotoolkit/openvino/tree/master/src/core) - provides the base API for model representation and modification.
+    * [inference](https://github.com/openvinotoolkit/openvino/tree/master/src/inference) - provides an API to infer models on device.
+    * [transformations](https://github.com/openvinotoolkit/openvino/tree/master/src/common/transformations) - contains the set of common transformations which are used in OpenVINO plugins.
+    * [low precision transformations](https://github.com/openvinotoolkit/openvino/tree/master/src/common/low_precision_transformations) - contains the set of transformations which are used in low precision models
+    * [bindings](https://github.com/openvinotoolkit/openvino/tree/master/src/bindings) - contains all awailable OpenVINO bindings which are maintained by OpenVINO team.
+        * [c](https://github.com/openvinotoolkit/openvino/tree/master/src/bindings/c) - provides C API for OpenVINO™ Runtime
+        * [python](https://github.com/openvinotoolkit/openvino/tree/master/src/bindings/python) - Python API for OpenVINO™ Runtime
+* [Plugins](https://github.com/openvinotoolkit/openvino/tree/master/src/plugins) - contains OpenVINO plugins which are maintained in open-source by OpenVINO team. For more information please taje a look to the [list of supported devices](#supported-hardware-matrix).
+* [Frontends](https://github.com/openvinotoolkit/openvino/tree/master/src/frontends) - contains available OpenVINO frontends which allow to read model from native framework format.
+* [Model Optimizer] - is a cross-platform command-line tool that facilitates the transition between training and deployment environments, performs static model analysis, and adjusts deep learning models for optimal execution on end-point target devices.
+* [Post-Training Optimization Tool] - is designed to accelerate the inference of deep learning models by applying special methods without model retraining or fine-tuning, for example, post-training 8-bit quantization. 
+* [Samples] - applications on C, C++ and Python languages which shows basic use cases of OpenVINO usages.
+
+## Supported Hardware matrix
+
+The OpenVINO™ Runtime can infer models on different hardware devices. This section provides the list of supported devices.
+
+<table>
+    <thead>
+        <tr>
+            <th>Device</th>
+            <th>Plugin</th>
+            <th>Library</th>
+            <th>ShortDescription</th>
+        </tr>
+    </thead>
+    <tbody>
+        <tr>
+            <td rowspan=2>CPU</td>
+            <td> <a href="https://docs.openvino.ai/nightly/openvino_docs_OV_UG_supported_plugins_CPU.html#doxid-openvino-docs-o-v-u-g-supported-plugins-c-p-u">Intel CPU</a></tb>
+            <td><b><i><a href="https://github.com/openvinotoolkit/openvino/tree/master/src/plugins/intel_cpu">openvino_intel_cpu_plugin</a></i></b></td>
+            <td>Intel Xeon with Intel® Advanced Vector Extensions 2 (Intel® AVX2), Intel® Advanced Vector Extensions 512 (Intel® AVX-512), and AVX512_BF16, Intel Core Processors with Intel AVX2, Intel Atom Processors with Intel® Streaming SIMD Extensions (Intel® SSE)</td>
+        </tr>
+        <tr>
+            <td> <a href="https://docs.openvino.ai/nightly/openvino_docs_OV_UG_supported_plugins_ARM_CPU.html">ARM CPU</a></tb>
+            <td><b><i><a href="https://github.com/openvinotoolkit/openvino_contrib/tree/master/modules/arm_plugin">openvino_arm_cpu_plugin</a></i></b></td>
+            <td>Raspberry Pi™ 4 Model B, Apple® Mac mini with M1 chip, NVIDIA® Jetson Nano™, Android™ devices
+        </tr>
+        <tr>
+            <td>GPU</td>
+            <td><a href="https://docs.openvino.ai/nightly/openvino_docs_OV_UG_supported_plugins_GPU.html#doxid-openvino-docs-o-v-u-g-supported-plugins-g-p-u">Intel GPU</a></td>
+            <td><b><i><a href="https://github.com/openvinotoolkit/openvino/tree/master/src/plugins/intel_gpu">openvino_intel_gpu_plugin</a></i></b></td>
+            <td>Intel Processor Graphics, including Intel HD Graphics and Intel Iris Graphics</td>
+        </tr>
+        <tr>
+            <td>GNA</td>
+            <td><a href="https://docs.openvino.ai/nightly/openvino_docs_OV_UG_supported_plugins_GNA.html#doxid-openvino-docs-o-v-u-g-supported-plugins-g-n-a">Intel GNA</a></td>
+            <td><b><i><a href="https://github.com/openvinotoolkit/openvino/tree/master/src/plugins/intel_gna">openvino_intel_gna_plugin</a></i></b></td>
+            <td>Intel Speech Enabling Developer Kit, Amazon Alexa* Premium Far-Field Developer Kit, Intel Pentium Silver J5005 Processor, Intel Pentium Silver N5000 Processor, Intel Celeron J4005 Processor, Intel Celeron J4105 Processor, Intel Celeron Processor N4100, Intel Celeron Processor N4000, Intel Core i3-8121U Processor, Intel Core i7-1065G7 Processor, Intel Core i7-1060G7 Processor, Intel Core i5-1035G4 Processor, Intel Core i5-1035G7 Processor, Intel Core i5-1035G1 Processor, Intel Core i5-1030G7 Processor, Intel Core i5-1030G4 Processor, Intel Core i3-1005G1 Processor, Intel Core i3-1000G1 Processor, Intel Core i3-1000G4 Processor</td>
+        </tr>
+        <tr>
+            <td>VPU</td>
+            <td><a href="https://docs.openvino.ai/nightly/openvino_docs_IE_DG_supported_plugins_VPU.html#doxid-openvino-docs-i-e-d-g-supported-plugins-v-p-u">Myriad plugin</a></td>
+            <td><b><i><a href="https://github.com/openvinotoolkit/openvino/tree/master/src/plugins/intel_myriad">openvino_intel_myriad_plugin</a></i></b></td>
+            <td>Intel® Neural Compute Stick 2 powered by the Intel® Movidius™ Myriad™ X</td>
+        </tr>
+    </tbody>
+</table>
+
+Also OpenVINO™ Toolkit contains several plugins which should simplify to load model on several hardware devices:
+<table>
+    <thead>
+        <tr>
+            <th>Plugin</th>
+            <th>Library</th>
+            <th>ShortDescription</th>
+        </tr>
+    </thead>
+    <tbody>
+        <tr>
+            <td><a href="https://docs.openvino.ai/nightly/openvino_docs_IE_DG_supported_plugins_AUTO.html#doxid-openvino-docs-i-e-d-g-supported-plugins-a-u-t-o">Auto</a></td>
+            <td><b><i><a href="https://github.com/openvinotoolkit/openvino/tree/master/src/plugins/auto">openvino_auto_plugin</a></i></b></td>
+            <td>Auto plugin enables selecting Intel device for inference automatically</td>
+        </tr>
+        <tr>
+            <td><a href="https://docs.openvino.ai/nightly/openvino_docs_OV_UG_Automatic_Batching.html">Auto Batch</a></td>
+            <td><b><i><a href="https://github.com/openvinotoolkit/openvino/tree/master/src/plugins/auto_batch">openvino_auto_batch_plugin</a></i></b></td>
+            <td>Auto batch plugin performs on-the-fly automatic batching (i.e. grouping inference requests together) to improve device utilization, with no programming effort from the user</td>
+        </tr>
+        <tr>
+            <td><a href="https://docs.openvino.ai/nightly/openvino_docs_OV_UG_Hetero_execution.html#doxid-openvino-docs-o-v-u-g-hetero-execution">Hetero</a></td>
+            <td><b><i><a href="https://github.com/openvinotoolkit/openvino/tree/master/src/plugins/hetero">openvino_hetero_plugin</a></i></b></td>
+            <td>Heterogeneous execution enables automatic inference splitting between several devices</td>
+        </tr>
+        <tr>
+            <td><a href="https://docs.openvino.ai/nightly/openvino_docs_OV_UG_Running_on_multiple_devices.html#doxid-openvino-docs-o-v-u-g-running-on-multiple-devices">Multi</a></td>
+            <td><b><i><a href="https://github.com/openvinotoolkit/openvino/tree/master/src/plugins/auto">openvino_auto_plugin</a></i></b></td>
+            <td>Multi plugin enables simultaneous inference of the same model on several devices in parallel</td>
+        </tr>
+    </tbody>
+</table>
 
 ## License
 OpenVINO™ Toolkit is licensed under [Apache License Version 2.0](LICENSE).
 By contributing to the project, you agree to the license and copyright terms therein and release your contribution under these terms.
 
-## Resources
-* Docs: https://docs.openvino.ai/
-* Wiki: https://github.com/openvinotoolkit/openvino/wiki
-* Issue tracking: https://github.com/openvinotoolkit/openvino/issues
-* Storage: https://storage.openvinotoolkit.org/
-* Additional OpenVINO™ toolkit modules: https://github.com/openvinotoolkit/openvino_contrib
-* [Intel® Distribution of OpenVINO™ toolkit Product Page](https://software.intel.com/content/www/us/en/develop/tools/openvino-toolkit.html)
-* [Intel® Distribution of OpenVINO™ toolkit Release Notes](https://software.intel.com/en-us/articles/OpenVINO-RelNotes)
+## Documentation
+
+### User documentation
+
+The latest documentation for OpenVINO™ Toolkit is availabe [here](https://docs.openvino.ai/). This documentation contains detailed information about all OpenVINO components and provides all important information which could be needed if you create an application which is based on binary OpenVINO distribution or own OpenVINO version without source code modification.
+
+### Developer documentation
+
+[Developer documentation](#todo-add) contains information about architectural decisions which are applied inside the OpenVINO components. This documentation has all necessary information which could be needed in order to contribute to OpenVINO.
+
+## Tutorials
+
+The list of OpenVINO tutorials:
+
+- [Jupiter notebooks](https://github.com/openvinotoolkit/openvino_notebooks)
+
+## Products which use OpenVINO
+
+- [OpenCV](https://opencv.org/)
+- [ONNX Runtime](https://onnxruntime.ai/)
+- [OpenVINO™ Integration with TensorFlow](https://www.intel.com/content/www/us/en/developer/tools/devcloud/edge/build/ovtfoverview.html)
+- [TNN](https://github.com/Tencent/TNN/tree/master)
+
+## System requirements
+
+The full information about system requirements depends on platform and available in section `System requirement` on dedicated pages:
+- [Linux](https://docs.openvino.ai/latest/openvino_docs_install_guides_installing_openvino_linux.html)
+- [Windows](https://docs.openvino.ai/latest/openvino_docs_install_guides_installing_openvino_windows.html)
+- [macOS](https://docs.openvino.ai/latest/openvino_docs_install_guides_installing_openvino_macos.html)
+- [Raspbian](https://docs.openvino.ai/latest/openvino_docs_install_guides_installing_openvino_raspbian.html)
+
+## How to build
+
+Please take a look to [OpenVINO Wiki](https://github.com/openvinotoolkit/openvino/wiki#how-to-build) to get more information about OpenVINO build process.
+
+## How to contribute
+
+See [CONTRIBUTING](./CONTRIBUTING.md) for details. Thank you!
+
+## Get a support
 
-## Support
 Please report questions, issues and suggestions using:
 
-* The [`openvino`](https://stackoverflow.com/questions/tagged/openvino) tag on StackOverflow\*
 * [GitHub* Issues](https://github.com/openvinotoolkit/openvino/issues)
+* The [`openvino`](https://stackoverflow.com/questions/tagged/openvino) tag on StackOverflow\*
 * [Forum](https://software.intel.com/en-us/forums/computer-vision)
 
+## See also
+
+* [OpenVINO Wiki](https://github.com/openvinotoolkit/openvino/wiki)
+* [OpenVINO Storage](https://storage.openvinotoolkit.org/)
+* Additional OpenVINO™ toolkit modules: 
+    * [openvino_contrib](https://github.com/openvinotoolkit/openvino_contrib)
+* [Intel® Distribution of OpenVINO™ toolkit Product Page](https://software.intel.com/content/www/us/en/develop/tools/openvino-toolkit.html)
+* [Intel® Distribution of OpenVINO™ toolkit Release Notes](https://software.intel.com/en-us/articles/OpenVINO-RelNotes)
+* [Neural Network Compression Framework (NNCF)](https://github.com/openvinotoolkit/nncf) - a suite of advanced algorithms for model inference optimization including quantization, filter pruning, binarization and sparsity
+* [OpenVINO™ Training Extensions (OTE)](https://github.com/openvinotoolkit/training_extensions) - convenient environment to train Deep Learning models and convert them using OpenVINO for optimized inference.
+* [OpenVINO™ Model Server (OVMS)](https://github.com/openvinotoolkit/model_server) - a scalable, high-performance solution for serving deep learning models optimized for Intel architectures
+* [DL Workbench](https://docs.openvino.ai/nightly/workbench_docs_Workbench_DG_Introduction.html) - An alternative, web-based version of OpenVINO designed to make production of pretrained deep learning models significantly easier.
+* [Computer Vision Annotation Tool (CVAT)](https://github.com/openvinotoolkit/cvat) - an online, interactive video and image annotation tool for computer vision purposes.
+* [Dataset Management Framework (Datumaro)](https://github.com/openvinotoolkit/datumaro) - a framework and CLI tool to build, transform, and analyze datasets.
+
 ---
 \* Other names and brands may be claimed as the property of others.
 
 [Open Model Zoo]:https://github.com/openvinotoolkit/open_model_zoo
-[OpenVINO™ Runtime]:https://docs.openvino.ai/latest/openvino_docs_OV_Runtime_User_Guide.html
+[OpenVINO™ Runtime]:https://docs.openvino.ai/latest/openvino_docs_OV_UG_OV_Runtime_User_Guide.html
 [Model Optimizer]:https://docs.openvino.ai/latest/openvino_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html
-[Post-Training Optimization Tool]:https://docs.openvino.ai/latest/pot_README.html
+[Post-Training Optimization Tool]:https://docs.openvino.ai/latest/pot_introduction.html
 [Samples]:https://github.com/openvinotoolkit/openvino/tree/master/samples
-[tag on StackOverflow]:https://stackoverflow.com/search?q=%23openvino
-

cmake/arm.toolchain.cmake

@@ -7,6 +7,7 @@ set(CMAKE_SYSTEM_PROCESSOR armv7l)
 
 set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc)
 set(CMAKE_CXX_COMPILER arm-linux-gnueabihf-g++)
+set(PKG_CONFIG_EXECUTABLE arm-linux-gnueabihf-pkg-config CACHE PATH "Path to ARM pkg-config")
 
 set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
 set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)

cmake/arm64.toolchain.cmake

@@ -7,6 +7,7 @@ set(CMAKE_SYSTEM_PROCESSOR aarch64)
 
 set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)
 set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)
+set(PKG_CONFIG_EXECUTABLE aarch64-linux-gnu-pkg-config CACHE PATH "Path to ARM64 pkg-config")
 
 set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
 set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)

cmake/dependencies.cmake

@@ -23,9 +23,7 @@ message(STATUS "MODELS_PATH=" ${MODELS_PATH})
 
 fetch_models_and_validation_set()
 
-if(COMMAND get_linux_name)
-    get_linux_name(LINUX_OS_NAME)
-endif()
+get_linux_name(LINUX_OS_NAME)
 
 if(CMAKE_CROSSCOMPILING AND CMAKE_HOST_SYSTEM_NAME MATCHES Linux AND CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*")
     set(protoc_version "3.18.2")
@@ -93,7 +91,19 @@ if(THREADING STREQUAL "OMP")
 endif()
 
 ## TBB package
-if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO")
+unset(_ov_download_tbb_done CACHE)
+
+#
+# The function downloads prebuilt TBB package
+# NOTE: the function should be used if system TBB is not found
+# or ENABLE_SYSTEM_TBB is OFF
+#
+function(ov_download_tbb)
+    if(_ov_download_tbb_done OR NOT THREADING MATCHES "^(TBB|TBB_AUTO)$")
+        return()
+    endif()
+    set(_ov_download_tbb_done ON CACHE BOOL "Whether prebuilt TBB is already downloaded")
+
     reset_deps_cache(TBBROOT TBB_DIR)
 
     if(DEFINED ENV{THIRDPARTY_SERVER_PATH})
@@ -109,16 +119,6 @@ if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO")
                 TARGET_PATH "${TEMP}/tbb"
                 ENVIRONMENT "TBBROOT"
                 SHA256 "f1c9b9e2861efdaa01552bd25312ccbc5feeb45551e5f91ae61e29221c5c1479")
-        if(ENABLE_TBBBIND_2_5)
-            RESOLVE_DEPENDENCY(TBBBIND_2_5
-                    ARCHIVE_WIN "tbbbind_2_5_static_win_v1.zip"
-                    TARGET_PATH "${TEMP}/tbbbind_2_5"
-                    ENVIRONMENT "TBBBIND_2_5_ROOT"
-                    SHA256 "a67afeea8cf194f97968c800dab5b5459972908295242e282045d6b8953573c1")
-        else()
-            message(WARNING "prebuilt TBBBIND_2_5 is not available.
-    Build oneTBB from sources and set TBBROOT environment var before OpenVINO cmake configure")
-        endif()
     elseif(ANDROID)  # Should be before LINUX due LINUX is detected as well
         RESOLVE_DEPENDENCY(TBB
                 ARCHIVE_ANDROID "tbb2020_20200404_android.tgz"
@@ -131,16 +131,6 @@ if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO")
                 TARGET_PATH "${TEMP}/tbb"
                 ENVIRONMENT "TBBROOT"
                 SHA256 "95b2f3b0b70c7376a0c7de351a355c2c514b42c4966e77e3e34271a599501008")
-        if(ENABLE_TBBBIND_2_5)
-            RESOLVE_DEPENDENCY(TBBBIND_2_5
-                    ARCHIVE_LIN "tbbbind_2_5_static_lin_v2.tgz"
-                    TARGET_PATH "${TEMP}/tbbbind_2_5"
-                    ENVIRONMENT "TBBBIND_2_5_ROOT"
-                    SHA256 "865e7894c58402233caf0d1b288056e0e6ab2bf7c9d00c9dc60561c484bc90f4")
-        else()
-            message(WARNING "prebuilt TBBBIND_2_5 is not available.
-    Build oneTBB from sources and set TBBROOT environment var before OpenVINO cmake configure")
-        endif()
     elseif(LINUX AND AARCH64)
         RESOLVE_DEPENDENCY(TBB
                 ARCHIVE_LIN "keembay/tbb2020_38404_kmb_lic.tgz"
@@ -160,18 +150,68 @@ if(THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO")
     update_deps_cache(TBBROOT "${TBB}" "Path to TBB root folder")
     if(EXISTS "${TBBROOT}/lib/cmake/TBB/TBBConfig.cmake")
         # oneTBB case
-        update_deps_cache(TBB_DIR "${TBB}/lib/cmake/TBB" "Path to TBB cmake folder")
+        update_deps_cache(TBB_DIR "${TBBROOT}/lib/cmake/TBB" "Path to TBB cmake folder")
+    elseif(EXISTS "${TBBROOT}/lib64/cmake/TBB/TBBConfig.cmake")
+        # 64-bits oneTBB case
+        update_deps_cache(TBB_DIR "${TBBROOT}/lib64/cmake/TBB" "Path to TBB cmake folder")
+    elseif(EXISTS "${TBBROOT}/cmake/TBBConfig.cmake")
+        # custom downloaded or user provided TBB
+        update_deps_cache(TBB_DIR "${TBBROOT}/cmake" "Path to TBB cmake folder")
     else()
-        update_deps_cache(TBB_DIR "${TBB}/cmake" "Path to TBB cmake folder")
+        message(WARNING "Failed to find TBBConfig.cmake in ${TBBROOT} tree. Custom TBBConfig.cmake will be used")
+    endif()
+
+    debug_message(STATUS "tbb=" ${TBB})
+    debug_message(STATUS "tbb_dir=" ${TBB_DIR})
+    debug_message(STATUS "tbbroot=" ${TBBROOT})
+
+    set(TBB "${TBB}" PARENT_SCOPE)
+endfunction()
+
+## TBBBind_2_5 package
+unset(_ov_download_tbbbind_2_5_done CACHE)
+
+#
+# The function downloads static prebuilt TBBBind_2_5 package
+# NOTE: the function should be called only we have TBB with version less 2021
+#
+function(ov_download_tbbbind_2_5)
+    if(_ov_download_tbbbind_2_5_done OR NOT ENABLE_TBBBIND_2_5)
+        return()
+    endif()
+    set(_ov_download_tbbbind_2_5_done ON CACHE BOOL "Whether prebuilt TBBBind_2_5 is already downloaded")
+
+    reset_deps_cache(TBBBIND_2_5_DIR)
+
+    if(DEFINED ENV{THIRDPARTY_SERVER_PATH})
+        set(IE_PATH_TO_DEPS "$ENV{THIRDPARTY_SERVER_PATH}")
+    elseif(DEFINED THIRDPARTY_SERVER_PATH)
+        set(IE_PATH_TO_DEPS "${THIRDPARTY_SERVER_PATH}")
+    endif()
+
+    if(WIN32 AND X86_64)
+        RESOLVE_DEPENDENCY(TBBBIND_2_5
+                ARCHIVE_WIN "tbbbind_2_5_static_win_v1.zip"
+                TARGET_PATH "${TEMP}/tbbbind_2_5"
+                ENVIRONMENT "TBBBIND_2_5_ROOT"
+                SHA256 "a67afeea8cf194f97968c800dab5b5459972908295242e282045d6b8953573c1")
+    elseif(ANDROID)
+        # don't have TBBBIND_2_5
+    elseif(LINUX AND X86_64)
+        RESOLVE_DEPENDENCY(TBBBIND_2_5
+                ARCHIVE_LIN "tbbbind_2_5_static_lin_v2.tgz"
+                TARGET_PATH "${TEMP}/tbbbind_2_5"
+                ENVIRONMENT "TBBBIND_2_5_ROOT"
+                SHA256 "865e7894c58402233caf0d1b288056e0e6ab2bf7c9d00c9dc60561c484bc90f4")
+    else()
+        message(WARNING "prebuilt TBBBIND_2_5 is not available.
+Build oneTBB from sources and set TBBROOT environment var before OpenVINO cmake configure")
     endif()
 
     update_deps_cache(TBBBIND_2_5_DIR "${TBBBIND_2_5}/cmake" "Path to TBBBIND_2_5 cmake folder")
-    debug_message(STATUS "tbb=" ${TBB})
 
-    if(DEFINED IE_PATH_TO_DEPS)
-        unset(IE_PATH_TO_DEPS)
-    endif()
-endif()
+    set(TBBBIND_2_5 "${TBBBIND_2_5}" PARENT_SCOPE)
+endfunction()
 
 ## OpenCV
 if(ENABLE_OPENCV)
@@ -265,8 +305,6 @@ else()
     reset_deps_cache(OpenCV_DIR)
 endif()
 
-include(${OpenVINO_SOURCE_DIR}/src/cmake/ie_parallel.cmake)
-
 if(ENABLE_INTEL_GNA)
     reset_deps_cache(
             GNA_EXT_DIR
@@ -276,8 +314,8 @@ if(ENABLE_INTEL_GNA)
             GNA_LIB_DIR
             libGNA_INCLUDE_DIRS
             libGNA_LIBRARIES_BASE_PATH)
-        set(GNA_VERSION "03.00.00.1455.0")
-        set(GNA_HASH "99891696269d8fa10116c96e6b7bda4362736881f0df8df8b56c751ee18e5820")
+        set(GNA_VERSION "03.00.00.1455.2")
+        set(GNA_HASH "e52785d3f730fefb4e794bb7ab40c8676537ef2f7c69c5b4bb89a5d3cc0bbe60")
 
         set(FILES_TO_EXTRACT_LIST gna_${GNA_VERSION}/include)
         if(WIN32)

cmake/developer_package/IEDevScriptsConfig.cmake

@@ -14,8 +14,8 @@ set(CMAKE_MODULE_PATH "${IEDevScripts_DIR}")
 function(set_ci_build_number)
     set(repo_root "${CMAKE_SOURCE_DIR}")
     include(version)
-    foreach(var CI_BUILD_NUMBER IE_VERSION IE_VERSION_BUILD
-                IE_VERSION_MAJOR IE_VERSION_MINOR IE_VERSION_PATCH)
+    foreach(var CI_BUILD_NUMBER OpenVINO_VERSION OpenVINO_VERSION_BUILD
+                OpenVINO_VERSION_MAJOR OpenVINO_VERSION_MINOR OpenVINO_VERSION_PATCH)
         if(NOT DEFINED ${var})
             message(FATAL_ERROR "${var} version component is not defined")
         endif()
@@ -186,6 +186,8 @@ endif()
 # Use solution folders
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
+# cmake_dependent_option() supports full Condition Syntax
+set(CMAKE_POLICY_DEFAULT_CMP0127 NEW)
 # Enable CMAKE_<LANG>_COMPILER_ID AppleClang
 set(CMAKE_POLICY_DEFAULT_CMP0025 NEW)
 

cmake/developer_package/TBBConfig.cmake

@@ -23,13 +23,13 @@ else()
     unset(IE_OWN_TBB_CONFIG)
 endif()
 
+unset(TBB_DIR)
+unset(TBB_DIR CACHE)
+
 find_package(TBB
     CONFIG
     PATHS ${TBBROOT}/cmake
-          ${TBBROOT}/lib/cmake/TBB # oneTBB case
           ${IEDevScripts_DIR}/${IE_OWN_TBB_CONFIG}
-    NO_CMAKE_FIND_ROOT_PATH
-    NO_DEFAULT_PATH
-)
+    NO_DEFAULT_PATH)
 
 find_package_handle_standard_args(TBB CONFIG_MODE)

cmake/developer_package/add_ie_target.cmake

@@ -76,8 +76,8 @@ function(addIeTarget)
 
     # remove unnecessary directories
     foreach(excludedDir ${ARG_EXCLUDED_SOURCE_PATHS})
-        list(FILTER includes EXCLUDE REGEX "${excludedDir}*")
-        list(FILTER sources EXCLUDE REGEX "${excludedDir}*")
+        list(FILTER includes EXCLUDE REGEX "${excludedDir}.*")
+        list(FILTER sources EXCLUDE REGEX "${excludedDir}.*")
     endforeach()
 
     source_group("include" FILES ${includes})

cmake/developer_package/features.cmake

@@ -7,7 +7,7 @@ include(target_flags)
 
 # FIXME: there are compiler failures with LTO and Cross-Compile toolchains. Disabling for now, but
 #        this must be addressed in a proper way
-ie_dependent_option (ENABLE_LTO "Enable Link Time Optimization" OFF "LINUX;NOT CMAKE_CROSSCOMPILING; CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.9" OFF)
+ie_dependent_option (ENABLE_LTO "Enable Link Time Optimization" OFF "LINUX;NOT CMAKE_CROSSCOMPILING;CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.9" OFF)
 
 ie_option (OS_FOLDER "create OS dedicated folder in output" OFF)
 
@@ -79,6 +79,4 @@ if(ENABLE_AVX512F)
     endif()
 endif()
 
-if (VERBOSE_BUILD)
-    set(CMAKE_VERBOSE_MAKEFILE ON CACHE BOOL "" FORCE)
-endif()
+set(CMAKE_VERBOSE_MAKEFILE ${VERBOSE_BUILD} CACHE BOOL "" FORCE)

cmake/developer_package/frontends/frontends.cmake

@@ -82,10 +82,11 @@ unset(protobuf_installed CACHE)
 
 #
 # ov_add_frontend(NAME <IR|ONNX|...>
-#                 FILEDESCRIPTION <description>
-#                 [LINKABLE_FRONTEND]
-#                 [SKIP_INSTALL]
-#                 [PROTOBUF_LITE]
+#                 FILEDESCRIPTION <description> # used on Windows to describe DLL file
+#                 [LINKABLE_FRONTEND] # whether we can use FE API directly or via FEM only
+#                 [SKIP_INSTALL] # private frontend, not for end users
+#                 [PROTOBUF_LITE] # requires only libprotobuf-lite
+#                 [SKIP_NCC_STYLE] # use custom NCC rules
 #                 [LINK_LIBRARIES <lib1 lib2 ...>])
 #
 macro(ov_add_frontend)
@@ -106,6 +107,17 @@ macro(ov_add_frontend)
     set(FRONTEND_NAMES "${FRONTEND_NAMES}" CACHE INTERNAL "" FORCE)
 
     file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
+    if (WIN32)
+        # Remove linux specific files
+        file(GLOB_RECURSE LIN_FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/os/lin/*.cpp
+                ${CMAKE_CURRENT_SOURCE_DIR}/src/os/lin/*.hpp)
+        list(REMOVE_ITEM LIBRARY_SRC "${LIN_FILES}")
+    else()
+        # Remove windows specific files
+        file(GLOB_RECURSE WIN_FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/os/win/*.cpp
+                ${CMAKE_CURRENT_SOURCE_DIR}/src/os/win/*.hpp)
+        list(REMOVE_ITEM LIBRARY_SRC "${WIN_FILES}")
+    endif()
     file(GLOB_RECURSE LIBRARY_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/src/*.hpp)
     file(GLOB_RECURSE LIBRARY_PUBLIC_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp)
 
@@ -231,7 +243,7 @@ macro(ov_add_frontend)
         endif()
 
         if(OV_FRONTEND_LINKABLE_FRONTEND)
-            # install -dev part
+            # install library development files
             install(DIRECTORY ${${TARGET_NAME}_INCLUDE_DIR}/openvino
                     DESTINATION ${FRONTEND_INSTALL_INCLUDE}/
                     COMPONENT core_dev

cmake/developer_package/linux_name.cmake

@@ -31,4 +31,8 @@ if (LINUX)
             set(${res_var} NOTFOUND PARENT_SCOPE)
         endif ()
     endfunction()
+else()
+    function(get_linux_name res_var)
+        set(${res_var} NOTFOUND PARENT_SCOPE)
+    endfunction()
 endif ()

cmake/developer_package/ncc_naming_style/ncc_naming_style.cmake

@@ -23,7 +23,7 @@ execute_process(
     ERROR_VARIABLE error_var)
 
 if(NOT clang_find_result EQUAL "0")
-    message(WARNING "Please, install libclang-[N]-dev package (required for ncc naming style check)")
+    message(WARNING "Please, install clang-[N] libclang-[N]-dev package (required for ncc naming style check)")
     message(WARNING "find_package(Clang) output: ${output_var}")
     message(WARNING "find_package(Clang) error: ${error_var}")
     set(ENABLE_NCC_STYLE OFF)
@@ -106,9 +106,11 @@ function(ov_ncc_naming_style)
          "${NCC_STYLE_SOURCE_DIRECTORY}/*.cpp")
 
     list(APPEND NCC_STYLE_ADDITIONAL_INCLUDE_DIRECTORIES "${NCC_STYLE_SOURCE_DIRECTORY}")
+    # without it sources with same name from different directories will map to same .ncc_style target
+    file(RELATIVE_PATH source_dir_rel ${CMAKE_SOURCE_DIR} ${NCC_STYLE_SOURCE_DIRECTORY})
 
     foreach(source IN LISTS sources)
-        set(output_file "${ncc_style_bin_dir}/${source}.ncc_style")
+        set(output_file "${ncc_style_bin_dir}/${source_dir_rel}/${source}.ncc_style")
         set(full_source_path "${NCC_STYLE_SOURCE_DIRECTORY}/${source}")
 
         add_custom_command(

cmake/developer_package/options.cmake

@@ -11,6 +11,11 @@ macro (ie_option variable description value)
     list(APPEND IE_OPTIONS ${variable})
 endmacro()
 
+# Usage: ov_option(<option_variable> "description" <initial value or boolean expression> [IF <condition>])
+macro (ov_option variable description value)
+    ie_option(${variable} "${description}" ${value})
+endmacro()
+
 macro (ie_dependent_option variable description def_value condition fallback_value)
     cmake_dependent_option(${variable} "${description}" ${def_value} "${condition}" ${fallback_value})
     list(APPEND IE_OPTIONS ${variable})

cmake/developer_package/packaging.cmake

@@ -69,8 +69,8 @@ macro(ie_cpack)
     endif()
 
     foreach(ver IN LISTS MAJOR MINOR PATCH)
-        if(DEFINED IE_VERSION_${ver})
-            set(CPACK_PACKAGE_VERSION_${ver} ${IE_VERSION_${ver}})
+        if(DEFINED OpenVINO_VERSION_${ver})
+            set(CPACK_PACKAGE_VERSION_${ver} ${OpenVINO_VERSION_${ver}})
         endif()
     endforeach()
 

cmake/developer_package/plugins/plugins.cmake

@@ -13,8 +13,8 @@ function(ie_plugin_get_file_name target_name library_name)
     set("${library_name}" "${LIB_PREFIX}${target_name}${LIB_SUFFIX}" PARENT_SCOPE)
 endfunction()
 
-if(NOT TARGET ie_plugins)
-    add_custom_target(ie_plugins)
+if(NOT TARGET ov_plugins)
+    add_custom_target(ov_plugins)
 endif()
 
 #
@@ -27,11 +27,12 @@ endif()
 #               [OBJECT_LIBRARIES <object_libs>]
 #               [VERSION_DEFINES_FOR <source>]
 #               [SKIP_INSTALL]
+#               [SKIP_REGISTRATION] Skip creation of <device>.xml
 #               [ADD_CLANG_FORMAT]
 #               )
 #
 function(ie_add_plugin)
-    set(options SKIP_INSTALL ADD_CLANG_FORMAT AS_EXTENSION)
+    set(options SKIP_INSTALL ADD_CLANG_FORMAT AS_EXTENSION SKIP_REGISTRATION)
     set(oneValueArgs NAME DEVICE_NAME VERSION_DEFINES_FOR PSEUDO_PLUGIN_FOR)
     set(multiValueArgs DEFAULT_CONFIG SOURCES OBJECT_LIBRARIES CPPLINT_FILTERS)
     cmake_parse_arguments(IE_PLUGIN "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
@@ -101,7 +102,7 @@ function(ie_add_plugin)
             add_cpplint_target(${IE_PLUGIN_NAME}_cpplint FOR_TARGETS ${IE_PLUGIN_NAME} CUSTOM_FILTERS ${custom_filter})
         endif()
 
-        add_dependencies(ie_plugins ${IE_PLUGIN_NAME})
+        add_dependencies(ov_plugins ${IE_PLUGIN_NAME})
         if(TARGET openvino_gapi_preproc)
             if(BUILD_SHARED_LIBS)
                 add_dependencies(${IE_PLUGIN_NAME} openvino_gapi_preproc)
@@ -146,25 +147,27 @@ function(ie_add_plugin)
         endif()
     endif()
 
-    # check that plugin with such name is not registered
+    # Enable for static build to generate correct plugins.hpp
+    if(NOT IE_PLUGIN_SKIP_REGISTRATION OR NOT BUILD_SHARED_LIBS)
+        # check that plugin with such name is not registered
+        foreach(plugin_entry IN LISTS PLUGIN_FILES)
+            string(REPLACE ":" ";" plugin_entry "${plugin_entry}")
+            list(GET plugin_entry -1 library_name)
+            list(GET plugin_entry 0 plugin_name)
+            if(plugin_name STREQUAL "${IE_PLUGIN_DEVICE_NAME}" AND
+                    NOT library_name STREQUAL ${IE_PLUGIN_NAME})
+                message(FATAL_ERROR "${IE_PLUGIN_NAME} and ${library_name} are both registered as ${plugin_name}")
+            endif()
+        endforeach()
 
-    foreach(plugin_entry IN LISTS PLUGIN_FILES)
-        string(REPLACE ":" ";" plugin_entry "${plugin_entry}")
-        list(GET plugin_entry -1 library_name)
-        list(GET plugin_entry 0 plugin_name)
-        if(plugin_name STREQUAL "${IE_PLUGIN_DEVICE_NAME}" AND
-           NOT library_name STREQUAL ${IE_PLUGIN_NAME})
-            message(FATAL_ERROR "${IE_PLUGIN_NAME} and ${library_name} are both registered as ${plugin_name}")
-        endif()
-    endforeach()
+        # append plugin to the list to register
 
-    # append plugin to the list to register
-
-    list(APPEND PLUGIN_FILES "${IE_PLUGIN_DEVICE_NAME}:${IE_PLUGIN_NAME}")
-    set(PLUGIN_FILES "${PLUGIN_FILES}" CACHE INTERNAL "" FORCE)
-    set(${IE_PLUGIN_DEVICE_NAME}_CONFIG "${IE_PLUGIN_DEFAULT_CONFIG}" CACHE INTERNAL "" FORCE)
-    set(${IE_PLUGIN_DEVICE_NAME}_PSEUDO_PLUGIN_FOR "${IE_PLUGIN_PSEUDO_PLUGIN_FOR}" CACHE INTERNAL "" FORCE)
-    set(${IE_PLUGIN_DEVICE_NAME}_AS_EXTENSION "${IE_PLUGIN_AS_EXTENSION}" CACHE INTERNAL "" FORCE)
+        list(APPEND PLUGIN_FILES "${IE_PLUGIN_DEVICE_NAME}:${IE_PLUGIN_NAME}")
+        set(PLUGIN_FILES "${PLUGIN_FILES}" CACHE INTERNAL "" FORCE)
+        set(${IE_PLUGIN_DEVICE_NAME}_CONFIG "${IE_PLUGIN_DEFAULT_CONFIG}" CACHE INTERNAL "" FORCE)
+        set(${IE_PLUGIN_DEVICE_NAME}_PSEUDO_PLUGIN_FOR "${IE_PLUGIN_PSEUDO_PLUGIN_FOR}" CACHE INTERNAL "" FORCE)
+        set(${IE_PLUGIN_DEVICE_NAME}_AS_EXTENSION "${IE_PLUGIN_AS_EXTENSION}" CACHE INTERNAL "" FORCE)
+    endif()
 endfunction()
 
 function(ov_add_plugin)
@@ -172,13 +175,12 @@ function(ov_add_plugin)
 endfunction()
 
 #
-# ie_register_plugins_dynamic(MAIN_TARGET <main target name>
-#                             POSSIBLE_PLUGINS <list of plugins which can be build by this repo>)
+# ie_register_plugins_dynamic(MAIN_TARGET <main target name>)
 #
 macro(ie_register_plugins_dynamic)
     set(options)
     set(oneValueArgs MAIN_TARGET)
-    set(multiValueArgs POSSIBLE_PLUGINS)
+    set(multiValueArgs)
     cmake_parse_arguments(IE_REGISTER "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
     if(NOT IE_REGISTER_MAIN_TARGET)
@@ -261,6 +263,15 @@ macro(ie_register_plugins)
     endif()
 endmacro()
 
+#
+# ov_register_plugins()
+#
+macro(ov_register_plugins)
+    if(BUILD_SHARED_LIBS)
+        ie_register_plugins_dynamic(${ARGN})
+    endif()
+endmacro()
+
 #
 # ie_target_link_plugins(<TARGET_NAME>)
 #

cmake/developer_package/version.cmake

@@ -26,20 +26,22 @@ function (commitHash VAR)
     set (${VAR} ${GIT_COMMIT_HASH} PARENT_SCOPE)
 endfunction()
 
-macro(ie_parse_ci_build_number)
-    set(IE_VERSION_BUILD 000)
+macro(ov_parse_ci_build_number)
+    set(OpenVINO_VERSION_BUILD 000)
+    set(IE_VERSION_BUILD ${OpenVINO_VERSION_BUILD})
+
     if(CI_BUILD_NUMBER MATCHES "^([0-9]+)\.([0-9]+)\.([0-9]+)\-([0-9]+)\-.*")
-        set(IE_VERSION_MAJOR ${CMAKE_MATCH_1})
-        set(IE_VERSION_MINOR ${CMAKE_MATCH_2})
-        set(IE_VERSION_PATCH ${CMAKE_MATCH_3})
-        set(IE_VERSION_BUILD ${CMAKE_MATCH_4})
+        set(OpenVINO_VERSION_MAJOR ${CMAKE_MATCH_1})
+        set(OpenVINO_VERSION_MINOR ${CMAKE_MATCH_2})
+        set(OpenVINO_VERSION_PATCH ${CMAKE_MATCH_3})
+        set(OpenVINO_VERSION_BUILD ${CMAKE_MATCH_4})
     endif()
 
     if(NOT DEFINED repo_root)
         message(FATAL_ERROR "repo_root is not defined")
     endif()
 
-    macro(ie_get_hpp_version)
+    macro(ov_get_hpp_version)
         if(NOT DEFINED OpenVINO_SOURCE_DIR)
             return()
         endif()
@@ -59,11 +61,12 @@ macro(ie_parse_ci_build_number)
 
         foreach(suffix MAJOR MINOR PATCH)
             set(ie_version_name "IE_VERSION_${suffix}")
-            set(ov_version_name "OPENVINO_VERSION_${suffix}")
+            set(ov_version_name "OpenVINO_VERSION_${suffix}")
+            set(ov_version_name_hpp "OPENVINO_VERSION_${suffix}")
 
             string(REGEX REPLACE ".+${ie_version_name}[ ]+([0-9]+).*" "\\1"
                     ${ie_version_name}_HPP "${IE_VERSION_PARTS}")
-            string(REGEX REPLACE ".+${ov_version_name}[ ]+([0-9]+).*" "\\1"
+            string(REGEX REPLACE ".+${ov_version_name_hpp}[ ]+([0-9]+).*" "\\1"
                     ${ov_version_name}_HPP "${OV_VERSION_PARTS}")
 
             if(NOT ${ie_version_name}_HPP EQUAL ${ov_version_name}_HPP)
@@ -72,26 +75,26 @@ macro(ie_parse_ci_build_number)
             endif()
         endforeach()
 
-        set(ie_hpp_version_is_found ON)
+        set(ov_hpp_version_is_found ON)
     endmacro()
 
-    # detect OpenVINO version via ie_version.hpp
-    ie_get_hpp_version()
+    # detect OpenVINO version via openvino/core/version.hpp and ie_version.hpp
+    ov_get_hpp_version()
 
-    if(ie_hpp_version_is_found)
-        foreach(var IE_VERSION_MAJOR IE_VERSION_MINOR IE_VERSION_PATCH)
+    if(ov_hpp_version_is_found)
+        foreach(var OpenVINO_VERSION_MAJOR OpenVINO_VERSION_MINOR OpenVINO_VERSION_PATCH)
             if(DEFINED ${var} AND NOT ${var} EQUAL ${var}_HPP)
                 message(FATAL_ERROR "${var} parsed from CI_BUILD_NUMBER (${${var}}) \
-                    and from ie_version.hpp (${${var}_HPP}) are different")
+                    and from openvino/core/version.hpp (${${var}_HPP}) are different")
             else()
-                # CI_BUILD_NUMBER is not defined well, take info from ie_verison.hpp as a baseline
+                # CI_BUILD_NUMBER is not defined well, take info from openvino/core/version.hpp as a baseline
                 set(${var} ${${var}_HPP})
             endif()
         endforeach()
     endif()
 
-    set(IE_VERSION "${IE_VERSION_MAJOR}.${IE_VERSION_MINOR}.${IE_VERSION_PATCH}")
-    message(STATUS "OpenVINO version is ${IE_VERSION}")
+    set(OpenVINO_VERSION "${OpenVINO_VERSION_MAJOR}.${OpenVINO_VERSION_MINOR}.${OpenVINO_VERSION_PATCH}")
+    message(STATUS "OpenVINO version is ${OpenVINO_VERSION} (Build ${OpenVINO_VERSION_BUILD})")
 endmacro()
 
 if (DEFINED ENV{CI_BUILD_NUMBER})
@@ -104,10 +107,10 @@ else()
     set(CI_BUILD_NUMBER "${custom_build}")
 endif()
 
-# provides Inference Engine version
+# provides OpenVINO version
 # 1. If CI_BUILD_NUMBER is defined, parses this information
-# 2. Otherwise, parses ie_version.hpp
-ie_parse_ci_build_number()
+# 2. Otherwise, parses openvino/core/version.hpp
+ov_parse_ci_build_number()
 
 macro (addVersionDefines FILE)
     set(__version_file ${FILE})

cmake/developer_package/vs_version/vs_version.cmake

@@ -2,9 +2,9 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-set(IE_VS_VER_FILEVERSION_QUAD "${IE_VERSION_MAJOR},${IE_VERSION_MINOR},${IE_VERSION_PATCH},0")
-set(IE_VS_VER_PRODUCTVERSION_QUAD "${IE_VERSION_MAJOR},${IE_VERSION_MINOR},${IE_VERSION_PATCH},0")
-set(IE_VS_VER_FILEVERSION_STR "${IE_VERSION_MAJOR}.${IE_VERSION_MINOR}.${IE_VERSION_PATCH}.0")
+set(IE_VS_VER_FILEVERSION_QUAD "${OpenVINO_VERSION_MAJOR},${OpenVINO_VERSION_MINOR},${OpenVINO_VERSION_PATCH},${OpenVINO_VERSION_BUILD}")
+set(IE_VS_VER_PRODUCTVERSION_QUAD "${OpenVINO_VERSION_MAJOR},${OpenVINO_VERSION_MINOR},${OpenVINO_VERSION_PATCH},${OpenVINO_VERSION_BUILD}")
+set(IE_VS_VER_FILEVERSION_STR "${OpenVINO_VERSION_MAJOR}.${OpenVINO_VERSION_MINOR}.${OpenVINO_VERSION_PATCH}.${OpenVINO_VERSION_BUILD}")
 
 set(IE_VS_VER_COMPANY_NAME_STR "Intel Corporation")
 set(IE_VS_VER_PRODUCTVERSION_STR "${CI_BUILD_NUMBER}")

cmake/extra_modules.cmake

@@ -6,15 +6,19 @@ function(ie_generate_dev_package_config)
     # dummy check that OpenCV is here
     find_package(OpenCV QUIET)
 
-    set(all_dev_targets gflags ov_runtime_libraries)
     foreach(component IN LISTS openvino_export_components)
         # export all targets with prefix and use them during extra modules build
         export(TARGETS ${${component}} NAMESPACE IE::
-            APPEND FILE "${CMAKE_BINARY_DIR}/${component}_dev_targets.cmake")
+               APPEND FILE "${CMAKE_BINARY_DIR}/${component}_dev_targets.cmake")
         list(APPEND all_dev_targets ${${component}})
     endforeach()
     add_custom_target(ie_dev_targets DEPENDS ${all_dev_targets})
 
+    # if we've found system gflags
+    if(gflags_DIR)
+        set(gflags_BINARY_DIR "${gflags_DIR}")
+    endif()
+
     configure_package_config_file("${OpenVINO_SOURCE_DIR}/cmake/templates/InferenceEngineDeveloperPackageConfig.cmake.in"
                                   "${CMAKE_BINARY_DIR}/InferenceEngineDeveloperPackageConfig.cmake"
                                   INSTALL_DESTINATION share # not used
@@ -30,18 +34,22 @@ function(ov_generate_dev_package_config)
     # dummy check that OpenCV is here
     find_package(OpenCV QUIET)
 
-    set(all_dev_targets gflags ov_runtime_libraries)
     foreach(component IN LISTS openvino_export_components)
         string(FIND "${component}" "_legacy" index)
-        if (index EQUAL -1)
+        if(index EQUAL -1)
             # export all targets with prefix and use them during extra modules build
             export(TARGETS ${${component}} NAMESPACE openvino::
-                APPEND FILE "${CMAKE_BINARY_DIR}/ov_${component}_dev_targets.cmake")
+                   APPEND FILE "${CMAKE_BINARY_DIR}/ov_${component}_dev_targets.cmake")
             list(APPEND all_dev_targets ${${component}})
         endif()
     endforeach()
     add_custom_target(ov_dev_targets DEPENDS ${all_dev_targets})
 
+    # if we've found system gflags
+    if(gflags_DIR)
+        set(gflags_BINARY_DIR "${gflags_DIR}")
+    endif()
+
     configure_package_config_file("${OpenVINO_SOURCE_DIR}/cmake/templates/OpenVINODeveloperPackageConfig.cmake.in"
                                   "${CMAKE_BINARY_DIR}/OpenVINODeveloperPackageConfig.cmake"
                                   INSTALL_DESTINATION share # not used
@@ -59,14 +67,14 @@ endfunction()
 
 function(register_extra_modules)
     # post export
-    openvino_developer_export_targets(COMPONENT core TARGETS inference_engine)
-    openvino_developer_export_targets(COMPONENT core TARGETS ngraph)
+    openvino_developer_export_targets(COMPONENT core_legacy TARGETS inference_engine)
+    openvino_developer_export_targets(COMPONENT core_legacy TARGETS ngraph)
 
     set(InferenceEngineDeveloperPackage_DIR "${CMAKE_CURRENT_BINARY_DIR}/runtime")
     set(OpenVINODeveloperPackage_DIR "${CMAKE_BINARY_DIR}/runtime")
 
     function(generate_fake_dev_package NS)
-        if (NS STREQUAL "openvino")
+        if(NS STREQUAL "openvino")
             set(devconfig_file "${OpenVINODeveloperPackage_DIR}/OpenVINODeveloperPackageConfig.cmake")
         else()
             set(devconfig_file "${InferenceEngineDeveloperPackage_DIR}/InferenceEngineDeveloperPackageConfig.cmake")
@@ -81,10 +89,6 @@ function(register_extra_modules)
                 file(APPEND "${devconfig_file}" "add_library(${NS}::${target} ALIAS ${target})\n")
             endif()
         endforeach()
-        if ("${NS}" STREQUAL "openvino")
-            file(APPEND "${devconfig_file}" "add_library(${NS}::runtime ALIAS openvino)\n")
-            file(APPEND "${devconfig_file}" "add_library(${NS}::runtime::dev ALIAS openvino_dev)\n")
-        endif()
     endfunction()
 
     generate_fake_dev_package("openvino")
@@ -137,7 +141,7 @@ ie_generate_dev_package_config()
 ov_generate_dev_package_config()
 
 # extra modules must be registered after inference_engine library
-# and all other IE common libraries (ov_runtime_libraries) are creared
+# and all other OpenVINO Core libraries are creared
 # because 'register_extra_modules' creates fake InferenceEngineDeveloperPackageConfig.cmake
 # with all imported developer targets
 register_extra_modules()

cmake/features.cmake

@@ -59,7 +59,7 @@ cmake_dependent_option (ENABLE_WHEEL "Build wheel packages for PyPi" OFF
 # Inference Engine specific options
 #
 
-# "MKL-DNN library based on OMP or TBB or Sequential implementation: TBB|OMP|SEQ"
+# "OneDNN library based on OMP or TBB or Sequential implementation: TBB|OMP|SEQ"
 if(X86 OR ARM OR (MSVC AND (ARM OR AARCH64)) )
     set(THREADING_DEFAULT "SEQ")
 else()
@@ -82,7 +82,7 @@ else()
     set(ENABLE_TBBBIND_2_5_DEFAULT OFF)
 endif()
 
-ie_dependent_option (ENABLE_TBBBIND_2_5 "Enable TBBBind_2_5 static usage in OpenVINO runtime" ON "ENABLE_TBBBIND_2_5_DEFAULT" OFF)
+ie_dependent_option (ENABLE_TBBBIND_2_5 "Enable TBBBind_2_5 static usage in OpenVINO runtime" ${ENABLE_TBBBIND_2_5_DEFAULT} "THREADING MATCHES TBB" OFF)
 
 ie_dependent_option (ENABLE_INTEL_GNA "GNA support for inference engine" ON
     "NOT APPLE;NOT ANDROID;X86_64;CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 5.4" OFF)
@@ -136,6 +136,17 @@ ie_dependent_option(ENABLE_TBB_RELEASE_ONLY "Only Release TBB libraries are link
 
 ie_dependent_option (ENABLE_SYSTEM_PUGIXML "use the system copy of pugixml" OFF "BUILD_SHARED_LIBS" OFF)
 
+get_linux_name(LINUX_OS_NAME)
+if(LINUX_OS_NAME MATCHES "^Ubuntu [0-9]+\.[0-9]+$" AND NOT DEFINED ENV{TBBROOT})
+    # Debian packages are enabled on Ubuntu systems
+    # so, system TBB can be tried for usage
+    set(ENABLE_SYSTEM_TBB_DEFAULT ON)
+else()
+    set(ENABLE_SYSTEM_TBB_DEFAULT OFF)
+endif()
+
+ie_dependent_option (ENABLE_SYSTEM_TBB  "use the system version of TBB" ${ENABLE_SYSTEM_TBB_DEFAULT} "THREADING MATCHES TBB;LINUX" OFF)
+
 ie_option (ENABLE_DEBUG_CAPS "enable OpenVINO debug capabilities at runtime" OFF)
 
 ie_dependent_option (ENABLE_GPU_DEBUG_CAPS "enable GPU debug capabilities at runtime" ON "ENABLE_DEBUG_CAPS" OFF)

cmake/templates/InferenceEngineConfig-version.cmake.in

@@ -2,9 +2,9 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-set(PACKAGE_VERSION_MAJOR @IE_VERSION_MAJOR@)
-set(PACKAGE_VERSION_MINOR @IE_VERSION_MINOR@)
-set(PACKAGE_VERSION_PATCH @IE_VERSION_PATCH@)
+set(PACKAGE_VERSION_MAJOR @OpenVINO_VERSION_MAJOR@)
+set(PACKAGE_VERSION_MINOR @OpenVINO_VERSION_MINOR@)
+set(PACKAGE_VERSION_PATCH @OpenVINO_VERSION_PATCH@)
 set(PACKAGE_VERSION "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}.${PACKAGE_VERSION_PATCH}")
 
 set(PACKAGE_VERSION_EXACT False)

cmake/templates/InferenceEngineDeveloperPackageConfig.cmake.in

@@ -12,19 +12,20 @@ set_and_check(OpenVINO_MAIN_SOURCE_DIR "@OpenVINO_SOURCE_DIR@") # KMB
 
 # Variables to export in plugin's projects
 
-set(ie_options "@IE_OPTIONS@;CMAKE_BUILD_TYPE;CMAKE_SKIP_RPATH")
-list(APPEND ie_options CMAKE_CXX_COMPILER_LAUNCHER CMAKE_C_COMPILER_LAUNCHER)
+set(ie_options "@IE_OPTIONS@")
+list(APPEND ie_options CMAKE_CXX_COMPILER_LAUNCHER CMAKE_C_COMPILER_LAUNCHER
+                       CMAKE_BUILD_TYPE CMAKE_SKIP_RPATH CMAKE_INSTALL_PREFIX)
 file(TO_CMAKE_PATH "${CMAKE_CURRENT_LIST_DIR}" cache_path)
 
 message(STATUS "The following CMake options are exported from Inference Engine Developer package")
-message("")
+message(" ")
 foreach(option IN LISTS ie_options)
     if(NOT DEFINED "${option}")
         load_cache("${cache_path}" READ_WITH_PREFIX "" ${option})
     endif()
     message("    ${option}: ${${option}}")
 endforeach()
-message("")
+message(" ")
 
 # for samples in 3rd party projects
 set_and_check(gflags_DIR "@gflags_BINARY_DIR@")
@@ -48,11 +49,6 @@ find_dependency(ngraph
                 NO_CMAKE_FIND_ROOT_PATH
                 NO_DEFAULT_PATH)
 
-find_dependency(OpenVINODeveloperPackage
-                PATHS "${CMAKE_CURRENT_LIST_DIR}"
-                NO_CMAKE_FIND_ROOT_PATH
-                NO_DEFAULT_PATH)
-
 if(TARGET openvino::runtime AND NOT TARGET IE::runtime)
     add_library(IE::runtime INTERFACE IMPORTED)
     set_target_properties(IE::runtime PROPERTIES
@@ -70,6 +66,18 @@ foreach(component @openvino_export_components@)
     include("${CMAKE_CURRENT_LIST_DIR}/${component}_dev_targets.cmake")
 endforeach()
 
+if(TARGET IE::ov_core_dev AND NOT TARGET openvino::core::dev)
+    add_library(openvino::core::dev INTERFACE IMPORTED)
+    set_target_properties(openvino::core::dev PROPERTIES
+        INTERFACE_LINK_LIBRARIES IE::ov_core_dev)
+endif()
+
+if(TARGET IE::runtime::dev AND NOT TARGET openvino::runtime::dev)
+    add_library(openvino::runtime::dev INTERFACE IMPORTED)
+    set_target_properties(openvino::runtime::dev PROPERTIES
+        INTERFACE_LINK_LIBRARIES IE::runtime::dev)
+endif()
+
 if(ENABLE_SYSTEM_PUGIXML)
     find_dependency(PugiXML)
     set_property(TARGET pugixml PROPERTY IMPORTED_GLOBAL TRUE)
@@ -86,13 +94,11 @@ endif()
 # Extra Compile Flags
 #
 
-if(NOT MSVC)
+if(CMAKE_COMPILER_IS_GNUCXX)
     ie_add_compiler_flags(-Wno-error=unused-variable)
-    if(CMAKE_COMPILER_IS_GNUCXX)
-        ie_add_compiler_flags(-Wno-error=unused-but-set-variable)
-        if(SUGGEST_OVERRIDE_SUPPORTED)
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-suggest-override")
-        endif()
+    ie_add_compiler_flags(-Wno-error=unused-but-set-variable)
+    if(SUGGEST_OVERRIDE_SUPPORTED)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-suggest-override")
     endif()
 endif()
 

cmake/templates/OpenVINOConfig-version.cmake.in

@@ -2,9 +2,9 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-set(PACKAGE_VERSION_MAJOR @IE_VERSION_MAJOR@)
-set(PACKAGE_VERSION_MINOR @IE_VERSION_MINOR@)
-set(PACKAGE_VERSION_PATCH @IE_VERSION_PATCH@)
+set(PACKAGE_VERSION_MAJOR @OpenVINO_VERSION_MAJOR@)
+set(PACKAGE_VERSION_MINOR @OpenVINO_VERSION_MINOR@)
+set(PACKAGE_VERSION_PATCH @OpenVINO_VERSION_PATCH@)
 set(PACKAGE_VERSION "${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}.${PACKAGE_VERSION_PATCH}")
 
 set(PACKAGE_VERSION_EXACT False)

cmake/templates/OpenVINOConfig.cmake.in

@@ -12,6 +12,7 @@
 #  * `Runtime`: OpenVINO C++ and C Core & Inference Runtime, frontend common
 #  * `ONNX`: OpenVINO ONNX frontend
 #  * `Paddle`: OpenVINO Paddle frontend
+#  * `TensorFlow`: OpenVINO TensorFlow frontend
 #
 # If no components are specified, `Runtime` component is provided:
 #
@@ -146,14 +147,29 @@ set(_ov_package_prefix_dir "${PACKAGE_PREFIX_DIR}")
 
 set(THREADING "@THREADING@")
 if((THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO") AND NOT TBB_FOUND)
-    set_and_check(_tbb_dir "@PACKAGE_IE_TBB_DIR@")
+    set(enable_system_tbb "@ENABLE_SYSTEM_TBB@")
+    if(NOT enable_system_tbb)
+        set_and_check(_tbb_dir "@PACKAGE_IE_TBB_DIR@")
+        set(find_package_tbb_extra_args
+            CONFIG
+            PATHS
+                # oneTBB case exposed via export TBBROOT=<custom TBB root>
+                "$ENV{TBBROOT}/lib64/cmake/TBB"
+                "$ENV{TBBROOT}/lib/cmake/TBB"
+                # "$ENV{TBB_DIR}"
+                # for custom TBB exposed via cmake -DTBBROOT=<custom TBB root>
+                "${TBBROOT}/cmake"
+                # _tbb_dir points to TBB_DIR (custom | temp | system) used to build OpenVINO
+                ${_tbb_dir}
+            NO_CMAKE_FIND_ROOT_PATH
+            NO_DEFAULT_PATH)
+        unset(_tbb_dir)
+    endif()
+    unset(enable_system_tbb)
+
     _ov_find_dependency(TBB
                         COMPONENTS tbb tbbmalloc
-                        CONFIG
-                        PATHS ${TBBROOT}/cmake
-                              ${_tbb_dir}
-                        NO_CMAKE_FIND_ROOT_PATH
-                        NO_DEFAULT_PATH)
+                        ${find_package_tbb_extra_args})
 
     set(install_tbbbind "@install_tbbbind@")
     if(install_tbbbind)
@@ -164,6 +180,7 @@ if((THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO") AND NOT TBB_FOUND
                             NO_DEFAULT_PATH)
         set_target_properties(${TBBBIND_2_5_IMPORTED_TARGETS} PROPERTIES IMPORTED_GLOBAL ON)
     endif()
+    unset(install_tbbbind)
 endif()
 
 _ov_find_dependency(Threads)
@@ -175,7 +192,7 @@ if(ENABLE_INTEL_GNA AND NOT ENABLE_INTEL_GNA_SHARED AND NOT libGNA_FOUND)
     _ov_find_dependency(libGNA
                         COMPONENTS KERNEL
                         CONFIG
-                        PATHS ${CMAKE_CURRENT_LIST_DIR}
+                        PATHS "${CMAKE_CURRENT_LIST_DIR}"
                         NO_CMAKE_FIND_ROOT_PATH
                         NO_DEFAULT_PATH)
 endif()
@@ -184,7 +201,8 @@ if(NOT TARGET openvino)
     set(_ov_as_external_package ON)
     include("${CMAKE_CURRENT_LIST_DIR}/OpenVINOTargets.cmake")
 
-    # TODO: WA for cmake version < 3.16
+    # WA for cmake version < 3.16 which does not export
+    # IMPORTED_LINK_DEPENDENT_LIBRARIES_** properties if no PUBLIC dependencies for the library
     if((THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO") AND TBB_FOUND)
         foreach (type RELEASE DEBUG RELWITHDEBINFO MINSIZEREL)
             set_property(TARGET openvino::runtime APPEND PROPERTY IMPORTED_LINK_DEPENDENT_LIBRARIES_${type} "TBB::tbb;TBB::tbbmalloc")

cmake/templates/OpenVINODeveloperPackageConfig.cmake.in

@@ -10,19 +10,20 @@ set_and_check(OpenVINO_SOURCE_DIR "@OpenVINO_SOURCE_DIR@")
 
 # Variables to export in plugin's projects
 
-set(ie_options "@IE_OPTIONS@;CMAKE_BUILD_TYPE;CMAKE_SKIP_RPATH")
-list(APPEND ie_options CMAKE_CXX_COMPILER_LAUNCHER CMAKE_C_COMPILER_LAUNCHER)
+set(ov_options "@IE_OPTIONS@")
+list(APPEND ov_options CMAKE_CXX_COMPILER_LAUNCHER CMAKE_C_COMPILER_LAUNCHER
+                       CMAKE_BUILD_TYPE CMAKE_SKIP_RPATH CMAKE_INSTALL_PREFIX)
 file(TO_CMAKE_PATH "${CMAKE_CURRENT_LIST_DIR}" cache_path)
 
 message(STATUS "The following CMake options are exported from OpenVINO Developer package")
-message("")
-foreach(option IN LISTS ie_options)
+message(" ")
+foreach(option IN LISTS ov_options)
     if(NOT DEFINED "${option}")
         load_cache("${cache_path}" READ_WITH_PREFIX "" ${option})
     endif()
     message("    ${option}: ${${option}}")
 endforeach()
-message("")
+message(" ")
 
 # for samples in 3rd party projects
 set_and_check(gflags_DIR "@gflags_BINARY_DIR@")
@@ -51,10 +52,10 @@ endforeach()
 if(ENABLE_SYSTEM_PUGIXML)
     find_dependency(PugiXML)
     set_property(TARGET pugixml PROPERTY IMPORTED_GLOBAL TRUE)
-    add_library(IE::pugixml ALIAS pugixml)
+    add_library(openvino::pugixml ALIAS pugixml)
 endif()
 
-# inherit OpenCV from main IE project if enabled
+# inherit OpenCV from main OpenVINO project if enabled
 if ("@OpenCV_FOUND@")
     load_cache("${cache_path}" READ_WITH_PREFIX "" OpenCV_DIR)
     find_dependency(OpenCV)
@@ -64,13 +65,11 @@ endif()
 # Extra Compile Flags
 #
 
-if(NOT MSVC)
+if(CMAKE_COMPILER_IS_GNUCXX)
     ie_add_compiler_flags(-Wno-error=unused-variable)
-    if(CMAKE_COMPILER_IS_GNUCXX)
-        ie_add_compiler_flags(-Wno-error=unused-but-set-variable)
-        if(SUGGEST_OVERRIDE_SUPPORTED)
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-suggest-override")
-        endif()
+    ie_add_compiler_flags(-Wno-error=unused-but-set-variable)
+    if(SUGGEST_OVERRIDE_SUPPORTED)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-suggest-override")
     endif()
 endif()
 

docs/CMakeLists.txt

@@ -46,6 +46,7 @@ endif()
 set(LINKCHECKER_PY "" CACHE FILEPATH "Path to linkchecker.py for documentation check dir.")
 set(ENABLE_OPENVINO_NOTEBOOKS OFF CACHE BOOL "Build with openvino notebooks")
 set(OMZ_DOCS_DIR "" CACHE PATH "Path to open_model_zoo documentation dir.")
+set(OTE_DOCS_DIR "" CACHE PATH "Path to training_extensions documentation dir.")
 set(WORKBENCH_DOCS_DIR "" CACHE PATH "Path to workbench documentation dir.")
 set(OVMS_DOCS_DIR "" CACHE PATH "Path to model server documentation dir.")
 set(GRAPH_CSV_DIR "" CACHE PATH "Path to the folder containing csv data for rendering graphs.")
@@ -159,6 +160,15 @@ function(build_docs)
             --output_dir=${DOCS_BUILD_DIR}/workbench)
     endif()
 
+    # ote doc files
+    if(EXISTS "${OTE_DOCS_DIR}")
+        get_filename_component(WORKBENCH_DOCS_DIR "${OTE_DOCS_DIR}" ABSOLUTE)
+
+        list(APPEND commands COMMAND ${PYTHON_EXECUTABLE} ${DOXY_MD_FILTER}
+            --input_dir=${OTE_DOCS_DIR}
+            --output_dir=${DOCS_BUILD_DIR}/ote)
+    endif()
+
     # ovms doc files
     if(EXISTS "${OVMS_DOCS_DIR}")
         get_filename_component(OVMS_DOCS_DIR "${OVMS_DOCS_DIR}" ABSOLUTE)

docs/Doxyfile.config

@@ -264,6 +264,10 @@ TAB_SIZE               = 4
 ALIASES                = "ref_ie{1}=@ref InferenceEngine::\1 \"\1\""
 ALIASES                += sphinxdirective="\n\xmlonly<sphinxdirective>"
 ALIASES                += endsphinxdirective="</sphinxdirective>\endxmlonly"
+ALIASES                += sphinxtabset="\n\xmlonly<sphinxtabset></sphinxtabset>\endxmlonly\n"
+ALIASES                += endsphinxtabset="\n\xmlonly<endsphinxtabset></endsphinxtabset>\endxmlonly\n"
+ALIASES                += sphinxtab{1}="\n\xmlonly<sphinxtab>\1</sphinxtab>\endxmlonly\n"
+ALIASES                += endsphinxtab="\n\xmlonly<endsphinxtab></endsphinxtab>\endxmlonly\n"
 
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
 # only. Doxygen will then generate output that is more tailored for C. For

docs/Extensibility_UG/GPU_Extensibility.md

@@ -0,0 +1,239 @@
+# How to Implement Custom GPU Operations {#openvino_docs_Extensibility_UG_GPU}
+
+To enable operations not supported by OpenVINO out of the box, you may need an extension for an OpenVINO operation set, and a custom kernel for the device you will target. This page describes custom kernel support for the GPU device.
+
+The GPU codepath abstracts many details about OpenCL. You need to provide the kernel code in OpenCL C and an XML configuration file that connects the kernel and its parameters to the parameters of the operation.
+
+There are two options for using the custom operation configuration file:
+
+* Include a section with your kernels into the automatically-loaded `<lib_path>/cldnn_global_custom_kernels/cldnn_global_custom_kernels.xml` file.
+* Call the `ov::Core::set_property()` method from your application with the `"CONFIG_FILE"` key and the configuration file name as a value before loading the network that uses custom operations to the plugin:
+
+@sphinxtabset
+
+@sphinxtab{C++}
+@snippet docs/snippets/gpu/custom_kernels_api.cpp part0
+@endsphinxtab
+
+@sphinxtab{Python}
+@snippet docs/snippets/gpu/custom_kernels_api.py part0
+@endsphinxtab
+
+@endsphinxtabset
+
+All OpenVINO samples, except the trivial `hello_classification`, and most Open Model Zoo demos
+feature a dedicated command-line option `-c` to load custom kernels. For example, to load custom operations for the classification sample, run the command below:
+```sh
+$ ./classification_sample -m <path_to_model>/bvlc_alexnet_fp16.xml -i ./validation_set/daily/227x227/apron.bmp -d GPU
+ -c <absolute_path_to_config>/custom_layer_example.xml
+```
+
+## Configuration File Format <a name="config-file-format"></a>
+
+The configuration file is expected to follow the `.xml` file structure
+with a node of the `CustomLayer` type for every custom operation you provide.
+
+The definitions described in the sections below use the following notations:
+
+Notation | Description
+---|---
+(0/1) | Can have zero or one instance of this node or attribute
+(1) | Must have only one instance of this node or attribute
+(0+) | Can have any number of instances of this node or attribute
+(1+) | Can have one or more instances of this node or attribute
+
+### CustomLayer Node and Sub-Node Structure
+
+`CustomLayer` node contains the entire configuration for a single custom operation.
+
+| Attribute Name   |\#    |  Description |
+|-----|-----|-----|
+| `name`           | (1)  | The name of the operation type to be used. This name should be identical to the type used in the IR.|
+| `type`           | (1)  | Must be `SimpleGPU`.                                                                                |
+| `version`        | (1)  | Must be `1`.                                                                                        |
+
+**Sub-nodes**: `Kernel` (1), `Buffers` (1), `CompilerOptions` (0+),
+`WorkSizes` (0/1)
+
+### Kernel Node and Sub-Node Structure
+
+`Kernel` node contains all kernel source code configuration.
+
+**Sub-nodes**: `Source` (1+), `Define` (0+)
+
+### Source Node and Sub-Node Structure
+
+`Source` node points to a single OpenCL source file.
+
+| Attribute Name | \#  |Description|
+|-----|-----|-----|
+| `filename`     | (1) | Name of the file containing OpenCL source code. Note that the path is relative to your executable. Multiple source nodes will have their sources concatenated in order. |
+
+**Sub-nodes**: None
+
+### Define Node and Sub-Node Structure
+
+`Define` node configures a single `#&zwj;define` instruction to be added to
+the sources during compilation (JIT).
+
+| Attribute Name | \#    | Description |
+|------|-------|------|
+| `name`         | (1)   | The name of the defined JIT. For static constants, this can include the value as well, which is taken as a string. |
+| `param`        | (0/1) | This parameter value is used as the value of this JIT definition.                                          |
+| `type`         | (0/1) | The parameter type. Accepted values: `int`, `float`, and `int[]`, `float[]` for arrays.                    |
+| `default`      | (0/1) | The default value to be used if the specified parameters are missing from the operation in the IR.          |
+
+**Sub-nodes:** None
+
+The resulting JIT has the following form:
+`#&zwj;define [name] [type] [value/default]`.
+
+### Buffers Node and Sub-Node Structure
+
+`Buffers` node configures all input/output buffers for the OpenCL entry
+function. No buffers node structure exists.
+
+**Sub-nodes:** `Data` (0+), `Tensor` (1+)
+
+### Data Node and Sub-Node Structure
+
+`Data` node configures a single input with static data, for example,
+weights or biases.
+
+| Attribute Name | \#  | Description |
+|----|-----|------|
+| `name`         | (1) | Name of a blob attached to an operation in the IR             |
+| `arg-index`    | (1) | 0-based index in the entry function arguments to be bound to |
+
+**Sub-nodes**: None
+
+### Tensor Node and Sub-Node Structure
+
+`Tensor` node configures a single input or output tensor.
+
+| Attribute Name | \#    | Description  |
+|------|-------|-------|
+| `arg-index`    | (1)   | 0-based index in the entry function arguments to be bound to.                                                                          |
+| `type`         | (1)   | `input` or `output`                                                                                                                    |
+| `port-index`   | (1)   | 0-based index in the operation input/output ports in the IR                                                                            |
+| `format`       | (0/1) | Data layout declaration for the tensor. Accepted values: `BFYX`, `BYXF`, `YXFB`, `FYXB`, and same values in all lowercase. Default value: `BFYX` |
+
+### CompilerOptions Node and Sub-Node Structure
+
+`CompilerOptions` node configures the compilation flags for the OpenCL
+sources.
+
+| Attribute Name | \#  | Description                                        |
+|--------|-----|------|
+| `options`      | (1) | Options string to be passed to the OpenCL compiler |
+
+**Sub-nodes**: None
+
+### WorkSizes Node and Sub-Node Structure
+
+`WorkSizes` node configures the global/local work sizes to be used when
+queuing an OpenCL program for execution.
+
+| Attribute Name      | \#             | Description                                                                 |
+|-----|------|-----|
+| `global`<br>`local` | (0/1)<br>(0/1) | An array of up to three integers or formulas for defining OpenCL work-sizes to be used during execution.<br> The formulas can use the values of the B,F,Y,X dimensions and contain the operators: +,-,/,\*,%. All operators are evaluated in integer arithmetic. <br>Default value: `global=”B*F*Y*X” local=””` |
+| `dim`               | (0/1)          | A tensor to take the work-size from. Accepted values: `input N`, `output`, where `N` is an index of input tensor starting with 0. Default value: `output` |
+
+**Sub-nodes**: None
+
+## Example Configuration File
+
+The following code sample provides an example configuration file in XML
+format. For information on the configuration file structure, see
+[Configuration File Format](#config-file-format).
+```xml
+<CustomLayer name="ReLU" type="SimpleGPU" version="1">
+  <Kernel entry="example_relu_kernel">
+    <Source filename="custom_layer_kernel.cl"/>
+    <Define name="neg_slope" type="float" param="negative_slope" default="0.0"/>
+  </Kernel>
+  <Buffers>
+    <Tensor arg-index="0" type="input" port-index="0" format="BFYX"/>
+    <Tensor arg-index="1" type="output" port-index="0" format="BFYX"/>
+  </Buffers>
+  <CompilerOptions options="-cl-mad-enable"/>
+  <WorkSizes global="X,Y,B*F"/>
+</CustomLayer>
+```
+
+## Built-In Definitions for Custom Layers
+
+The following table includes definitions that are attached before
+user sources.
+
+For an example, see [Example Kernel](#example-kernel).
+
+| Name | Value  |
+|---|---|
+| `NUM_INPUTS` | Number of the input tensors bound to this kernel |
+| `GLOBAL_WORKSIZE`  | An array of global work sizes used to execute this kernel |
+| `GLOBAL_WORKSIZE_SIZE` | The size of the `GLOBAL_WORKSIZE` array |
+| `LOCAL_WORKSIZE`  | An array of local work sizes used to execute this kernel  |
+| `LOCAL_WORKSIZE_SIZE`   | The size of the `LOCAL_WORKSIZE` array |
+| `<TENSOR>_DIMS`| An array of the tensor dimension sizes. Always ordered as `BFYX` |
+| `<TENSOR>_DIMS_SIZE`| The size of the `<TENSOR>_DIMS` array.|
+| `<TENSOR>_TYPE`| The datatype of the tensor: `float`, `half`, or `char`|
+| `<TENSOR>_FORMAT_<TENSOR_FORMAT>` | The format of the tensor, BFYX, BYXF, YXFB , FYXB, or ANY. The format is concatenated to the defined name. You can use the tensor format to define codepaths in your code with `#&zwj;ifdef/#&zwj;endif`. |
+| `<TENSOR>_LOWER_PADDING` | An array of padding elements used for the tensor dimensions before they start. Always ordered as BFYX.|
+| `<TENSOR>_LOWER_PADDING_SIZE` | The size of the `<TENSOR>_LOWER_PADDING` array  |
+| `<TENSOR>_UPPER_PADDING`   | An array of padding elements used for the tensor dimensions after they end. Always ordered as BFYX. |
+| `<TENSOR>_UPPER_PADDING_SIZE`  | The size of the `<TENSOR>_UPPER_PADDING` array |
+| `<TENSOR>_PITCHES` | The offset (in elements) between adjacent elements in each dimension. Always ordered as BFYX.|
+| `<TENSOR>_PITCHES_SIZE`| The size of the `<TENSOR>_PITCHES` array   |
+| `<TENSOR>_OFFSET`| The number of elements from the start of the tensor to the first valid element, bypassing the lower padding.  |
+
+All `<TENSOR>` values are automatically defined for every tensor
+bound to this operation, such as `INPUT0`, `INPUT1`, and `OUTPUT0`, as shown
+in the following example:
+
+```c
+#define INPUT0_DIMS_SIZE 4
+#define INPUT0_DIMS (int []){ 1,96,55,55, }
+```
+
+## Example Kernel<a name="example-kernel"></a>
+
+```c
+#pragma OPENCL EXTENSION cl_khr_fp16 : enable
+__kernel void example_relu_kernel(
+    const __global INPUT0_TYPE*  input0,
+          __global OUTPUT0_TYPE* output)
+{
+    const uint idx  = get_global_id(0);
+    const uint idy  = get_global_id(1);
+    const uint idbf = get_global_id(2); // batches*features, as OpenCL supports 3D nd-ranges only
+    const uint feature = idbf % OUTPUT0_DIMS[1];
+    const uint batch   = idbf / OUTPUT0_DIMS[1];
+    //notice that pitches are in elements, not in bytes!
+    const uint in_id  = batch*INPUT0_PITCHES[0] + feature*INPUT0_PITCHES[1]   + idy*INPUT0_PITCHES[2]  + idx*INPUT0_PITCHES[3]  + INPUT0_OFFSET;
+    const uint out_id = batch*OUTPUT0_PITCHES[0] + feature*OUTPUT0_PITCHES[1]  + idy*OUTPUT0_PITCHES[2]  + idx*OUTPUT0_PITCHES[3]  + OUTPUT0_OFFSET;
+
+    INPUT0_TYPE value = input0[in_id];
+    // neg_slope (which is non-zero for leaky ReLU) is put automatically as #define, refer to the config xml
+    output[out_id] = value < 0 ? value * neg_slope : value;
+}
+```
+
+
+> **NOTE**: As described in the previous section, all items like
+> `INPUT0_TYPE` are actually defined as OpenCL (pre-)compiler inputs by
+> OpenVINO for efficiency reasons. See [Debugging
+> Tips](#debugging-tips) for information on debugging the results.
+
+## Debugging Tips<a name="debugging-tips"></a>
+
+* **Using `printf` in the OpenCL™ Kernels**.
+To debug the specific values, you can use `printf` in your kernels.
+However, be careful not to output excessively, which
+could generate too much data. The `printf` output is typical, so
+your output can be truncated to fit the buffer. Also, because of
+buffering, you actually get an entire buffer of output when the
+execution ends.<br>
+
+For more information, refer to the [printf
+Function](https://www.khronos.org/registry/OpenCL/sdk/1.2/docs/man/xhtml/printfFunction.html).

docs/Extensibility_UG/Intro.md

@@ -1,4 +1,4 @@
-# OpenVINO Extensibility Mechanism {#openvino_docs_Extensibility_UG_Intro}
+# OpenVINO Extensibility Mechanism {#openvino_docs_Extensibility_UG_Intro}
 
 @sphinxdirective
 
@@ -7,36 +7,68 @@
    :hidden:
 
    openvino_docs_Extensibility_UG_add_openvino_ops
+   openvino_docs_Extensibility_UG_Frontend_Extensions
+   openvino_docs_Extensibility_UG_GPU
+   openvino_docs_IE_DG_Extensibility_DG_VPU_Kernel
+   openvino_docs_MO_DG_prepare_model_customize_model_optimizer_Customize_Model_Optimizer
 
 @endsphinxdirective
 
-The Intel® Distribution of OpenVINO™ toolkit supports neural network models trained with multiple frameworks including
-TensorFlow, Caffe, MXNet, Kaldi, PaddlePaddle, and ONNX. The list of supported operations (layers) is different for
+The Intel® Distribution of OpenVINO™ toolkit supports neural network models trained with various frameworks, including
+TensorFlow, PyTorch, ONNX, PaddlePaddle, MXNet, Caffe, and Kaldi. The list of supported operations is different for
 each of the supported frameworks. To see the operations supported by your framework, refer to
 [Supported Framework Operations](../MO_DG/prepare_model/Supported_Frameworks_Layers.md).
 
-Custom operations, that is those not included in the list, are not recognized by OpenVINO™ out-of-the-box. Therefore, creating Intermediate Representation (IR) for a model using them requires additional steps. This guide illustrates the workflow for running inference on topologies featuring custom operations, allowing you to plug in your own implementation for existing or completely new operations.
+Custom operations, that is those not included in the list, are not recognized by OpenVINO™ out-of-the-box. The need for a custom operation may appear in two main cases:
 
-If your model contains operations not normally supported by OpenVINO™, the OpenVINO™ Extensibility API lets you add support for those custom operations and use one implementation for Model Optimizer and OpenVINO™ Runtime.
+1. A regular framework operation that is new or rarely used, which is why it hasn’t been implemented in OpenVINO yet.
 
-There are two steps to support inference of a model with custom operation(s):
-1. Add support for a [custom operation in the Model Optimizer](../MO_DG/prepare_model/customize_model_optimizer/Customize_Model_Optimizer.md) so
-the Model Optimizer can generate the IR with the operation.
-2. Create a custom operation in it as described in the [Custom Operation](add_openvino_ops.md).
+2. A new user operation that was created for some specific model topology by a model author using framework extension capabilities.
 
-## OpenVINO™ Extensions
+Importing models with such operations requires additional steps. This guide illustrates the workflow for running inference on models featuring custom operations, allowing you to plug in your own implementation for them. OpenVINO™ Extensibility API lets you add support for those custom operations and use one implementation for Model Optimizer and OpenVINO™ Runtime.
 
-An OpenVINO™ provides extensions for:
+Defining a new custom operation basically consist of two parts:
 
- * [Custom OpenVINO™ Operation](add_openvino_ops.md):
-    - Enables the creation of unsupported operations
-    - Enables the use of `ov::Core::read_model` to read models with unsupported operations
-    - Provides a shape inference mechanism for custom operations
-    - Provides an evaluate method which allow to support the operation on CPU or perform constant folding
+1. Definition of operation semantics in OpenVINO, the code that describes how this operation should be inferred consuming input tensor(s) and producing output tensor(s). How to implement execution kernels for [GPU](./GPU_Extensibility.md) and [VPU](./VPU_Extensibility.md) is described in separate guides.
 
-> **NOTE**: This documentation is written based on the [Template extension](https://github.com/openvinotoolkit/openvino/tree/master/docs/template_extension/new), which demonstrates extension development details. You can review the complete code, which is fully compilable and up-to-date, to see how it works.
+2. Mapping rule that facilitates conversion of framework operation representation to OpenVINO defined operation semantics.
 
-## Load extensions to OpenVINO™ Runtime
+The first part is required for inference, the second part is required for successful import of a model containing such operations from the original framework model format. There are several options to implement each part, the next sections will describe them in detail.
+
+## Definition of Operation Semantics
+
+
+If the custom operation can be mathematically represented as a combination of exiting OpenVINO operations and such decomposition gives desired performance, then low-level operation implementation is not required. When deciding feasibility of such decomposition refer to the latest OpenVINO operation set. You can use any valid combination of exiting operations. How to map a custom operation is described in the next section of this document.
+
+If such decomposition is not possible or appears too bulky with lots of consisting operations that are not performing well, then a new class for the custom operation should be implemented as described in the [Custom Operation Guide](add_openvino_ops.md). 
+
+Prefer implementing a custom operation class if you already have a generic C++ implementation of operation kernel. Otherwise try to decompose the operation first as described above and then after verifying correctness of inference and resulting performance, optionally invest to implementing bare metal C++ implementation.
+
+## Mapping from Framework Operation
+
+Depending on model format used for import, mapping of custom operation is implemented differently, choose one of:
+
+1. If model is represented in ONNX (including models exported from Pytorch in ONNX) or PaddlePaddle formats, then one of the classes from [Frontend Extension API](frontend_extensions.md) should be used. It consists of several classes available in C++ which can be used with Model Optimizer `--extensions` option or when model is imported directly to OpenVINO run-time using read_model method. Python API is also available for run-time model importing.
+
+2. If model is represented in TensorFlow, Caffe, Kaldi or MXNet formats, then [Model Optimizer Extensions](../MO_DG/prepare_model/customize_model_optimizer/Customize_Model_Optimizer.md) should be used. This approach is available for model conversion in Model Optimizer only.
+
+Existing of two approaches simultaneously is explained by two different types of frontends used for model conversion in OpenVINO: new frontends (ONNX, PaddlePaddle) and legacy frontends (TensorFlow, Caffe, Kaldi and MXNet). Model Optimizer can use both front-ends in contrast to the direct import of model with `read_model` method which can use new frontends only. Follow one of the appropriate guides referenced above to implement mappings depending on framework frontend.
+
+If you are implementing extensions for ONNX or PaddlePaddle new frontends and plan to use Model Optimizer `--extension` option for model conversion, then the extensions should be
+
+1. Implemented in C++ only
+
+2. Compiled as a separate shared library (see details how to do that later in this guide).
+
+You cannot write new frontend extensions using Python API if you plan to use them with Model Optimizer.
+
+Remaining part of this guide uses Frontend Extension API applicable for new frontends.
+
+## Registering Extensions
+
+A custom operation class and a new mapping frontend extension class object should be registered to be usable in OpenVINO runtime.
+
+> **NOTE**: This documentation is written based on the [Template extension](https://github.com/openvinotoolkit/openvino/tree/master/docs/template_extension/new), which demonstrates extension development details based on minimalistic `Identity` operation that is a placeholder for your real custom operation. You can review the complete code, which is fully compliable, to see how it works.
 
 To load the extensions to the `ov::Core` object, use the `ov::Core::add_extension` method, this method allows to load library with extensions or extensions from the code.
 
@@ -44,27 +76,50 @@ To load the extensions to the `ov::Core` object, use the `ov::Core::add_extensio
 
 Extensions can be loaded from code with `ov::Core::add_extension` method:
 
+@sphinxtabset
+
+@sphinxtab{C++}
+
+@snippet docs/snippets/ov_extensions.cpp add_extension
+
+@endsphinxtab
+
+@sphinxtab{Python}
+
+@snippet docs/snippets/ov_extensions.py add_extension
+
+@endsphinxtab
+
+@endsphinxtabset
+
+`Identity` is custom operation class defined in [Custom Operation Guide](add_openvino_ops.md). This is enough to enable reading IR which uses `Identity` extension operation emitted by Model Optimizer. To be able to load original model directly to the runtime, you need to add also a mapping extension:
+
 @sphinxdirective
 
 .. tab:: C++
 
     .. doxygensnippet:: docs/snippets/ov_extensions.cpp
        :language: cpp
-       :fragment: add_extension
+       :fragment: add_frontend_extension
 
 .. tab:: Python
 
     .. doxygensnippet:: docs/snippets/ov_extensions.py
        :language: python
-       :fragment: add_extension
+       :fragment: add_frontend_extension
 
 @endsphinxdirective
+ 
+When Python API is used there is no way to implement a custom OpenVINO operation. Also, even if custom OpenVINO operation is implemented in C++ and loaded to the runtime through a shared library, there is still no way to add a frontend mapping extension that refers to this custom operation. Use C++ shared library approach to implement both operations semantics and framework mapping in this case.
+
+You still can use Python for operation mapping and decomposition in case if operations from the standard OpenVINO operation set is used only.
 
 ### Create library with extensions
 
-You need to create extension library in following cases:
- - Load extensions to Model Optimizer
- - Load extensions to Python application
+You need to create extension library in the following cases:
+ - Convert model with custom operations in Model Optimizer
+ - Load model with custom operations in Python application. It is applicable for both framework model and IR.
+ - Loading models with custom operations in tools that support loading extensions from a library, for example `benchmark_app`.
 
 If you want to create an extension library, for example in order to load these extensions to the Model Optimizer, you need to do next steps:
 Create an entry point for extension library. OpenVINO™ provides an `OPENVINO_CREATE_EXTENSIONS()` macro, which allows to define an entry point to a library with OpenVINO™ Extensions.
@@ -92,24 +147,25 @@ $ cmake --build .
 
 After the build you can use path to your extension library to load your extensions to OpenVINO™ Runtime:
 
-@sphinxdirective
+@sphinxtabset
 
-.. tab:: C++
+@sphinxtab{C++}
 
-    .. doxygensnippet:: docs/snippets/ov_extensions.cpp
-       :language: cpp
-       :fragment: add_extension_lib
+@snippet docs/snippets/ov_extensions.cpp add_extension_lib
 
-.. tab:: Python
+@endsphinxtab
 
-    .. doxygensnippet:: docs/snippets/ov_extensions.py
-       :language: python
-       :fragment: add_extension_lib
+@sphinxtab{Python}
 
-@endsphinxdirective
+@snippet docs/snippets/ov_extensions.py add_extension_lib
+
+@endsphinxtab
+
+@endsphinxtabset
 
 ## See Also
 
 * [OpenVINO Transformations](./ov_transformations.md)
-* [Using Inference Engine Samples](../OV_Runtime_UG/Samples_Overview.md)
+* [Using OpenVINO Runtime Samples](../OV_Runtime_UG/Samples_Overview.md)
 * [Hello Shape Infer SSD sample](../../samples/cpp/hello_reshape_ssd/README.md)
+

docs/Extensibility_UG/VPU_Extensibility.md

@@ -0,0 +1,619 @@
+# How to Implement Custom Layers for VPU (Intel® Neural Compute Stick 2) {#openvino_docs_IE_DG_Extensibility_DG_VPU_Kernel}
+
+To enable operations not supported by OpenVINO™ out of the box, you need a custom extension for Model Optimizer, a custom nGraph operation set, and a custom kernel for the device you will target. This page describes custom kernel support for one the VPU, the Intel® Neural Compute Stick 2 device, which uses the MYRIAD device plugin.
+
+> **NOTES:** 
+> * OpenCL\* custom layer support is available in the preview mode.
+> * This section assumes you are familiar with developing kernels using OpenCL.
+To customize your topology with an OpenCL layer, carry out the tasks described on this page:
+
+1. Write and compile your OpenCL code with the standalone offline OpenCL compiler (`clc`).
+2. Write a configuration file to bind the OpenCL kernel to the topology file (`.xml`) of the model IR.
+3. Pass the configuration file to the OpenVINO™ Runtime with the model IR.
+
+## Compile OpenCL code for VPU (Intel® Neural Compute Stick 2)
+
+> **NOTE**: OpenCL compiler, targeting Intel® Neural Compute Stick 2 for the SHAVE* processor only, is redistributed with OpenVINO.
+OpenCL support is provided by ComputeAorta* and is distributed under a license agreement between Intel® and Codeplay* Software Ltd.
+The OpenCL toolchain for the Intel® Neural Compute Stick 2 supports offline compilation only, so first compile OpenCL C code using the standalone `clc` compiler. You can find the compiler binary at `<INSTALL_DIR>/tools/cl_compiler`.
+
+> **NOTE**: By design, custom OpenCL layers support any OpenCL kernels written assuming OpenCL version 1.2. It also supports half float extension and is optimized for this type, because it is a native type for Intel® Movidius™ VPUs.
+1. Prior to running a compilation, make sure that the following variables are set:
+   * `SHAVE_MA2X8XLIBS_DIR=<INSTALL_DIR>/tools/cl_compiler/lib/`
+   * `SHAVE_LDSCRIPT_DIR=<INSTALL_DIR>/tools/cl_compiler/ldscripts/`
+   * `SHAVE_MYRIAD_LD_DIR=<INSTALL_DIR>/tools/cl_compiler/bin/`
+   * `SHAVE_MOVIASM_DIR=<INSTALL_DIR>/tools/cl_compiler/bin/`
+2. Run the compilation with the command below. You should use `--strip-binary-header` to make an OpenCL runtime-agnostic binary runnable with the OpenVINO™ Runtime.
+   ```bash
+   cd <INSTALL_DIR>/tools/cl_compiler/bin
+   ./clc --strip-binary-header custom_layer.cl -o custom_layer.bin
+   ```
+
+## Write a Configuration File
+
+To tie the topology IR for a layer you customize, prepare a configuration file, so that the OpenVINO™ Runtime can find parameters for your kernel and the execution work grid is described.
+For example, consider the following OpenCL kernel signature:
+```cpp
+__kernel void reorg_nhwc(__global const half *src, __global half *out, int w, int h, int c, int stride);
+```
+A configuration file for this kernel might be the following:
+```xml
+<CustomLayer name="ReorgYolo" type="MVCL" version="1">
+   <Kernel entry="reorg_nhwc">
+       <Source filename="reorg.bin"/>
+   </Kernel>
+   <Parameters>
+       <Tensor arg-name="src"    type="input"  port-index="0"                format="BYXF"/>
+       <Tensor arg-name="out"    type="output" port-index="0"                format="BYXF"/>
+       <Scalar arg-name="w"      type="int"    port-index="0" source="I.X"                />
+       <Scalar arg-name="h"      type="int"    port-index="0" source="I.Y"                />
+       <Scalar arg-name="c"      type="int"    port-index="0" source="I.F"                />
+       <Scalar arg-name="stride" type="int"                   source="stride"             />
+   </Parameters>
+   <WorkSizes dim="input,0" global="(Y+7)/8*8,1,1" local="8,1,1"/>
+</CustomLayer>
+```
+Each custom layer is described with the `CustomLayer` node. It has the following nodes and attributes:
+  - Root node `CustomLayer` contains the following attributes:
+    - `name` – (Required) The name of the OpenVINO™ Runtime layer to bind the kernel with.
+    - `type` and `version` – (Required) Reserved for future use. Set them to `MVCL` and `1` respectively.
+    - `max-shaves` – (Optional) The maximum number of SHAVE cores that should be dedicated for the layer. It is useful for debugging concurrency issues or for resource saving that memory bound kernel does not scale well with the number of cores, so more resources can be left for the rest of a topology.
+  - Sub-node `Kernel` must contain the following attributes:
+    - `entry` – The name of your kernel function as you defined it in a source file. In the example above, it is `reorg_nhwc`.
+    - Node `Source` must contain the following attributes:
+      - `filename` – The path to a compiled binary relative to the XML configuration file.
+  - Sub-node `Parameters` – Describes parameters bindings. For more information, see the description below.
+  - Sub-node `WorkSizes` – Describes local and global work group sizes and the source for dimension deduction as a pair `direction,port`. In the example above, the work group is described relatively to the dimension of the input tensor that comes through port 0 in the IR. `global` and `local` work group configurations support any simple math expressions with +,-,\*,/, and () from `B`(batch), `Y`(height), `X`(width) and `F`(channels).
+  - Sub-node `Where` – Allows to customize bindings with the `key="value"` attribute. For example, to substitute only 3x3 convolutions, write `<Where kernel="3,3"/>` in the binding xml.
+
+  Parameter description supports `Tensor` of one of tensor types such as `input`, `output`, `input_buffer`, `output_buffer` or `data`, `Scalar`, or `Data` nodes and has the following format:
+  - Each `Tensor` node of `input` or `output` type must contain the following attributes:
+    - `arg-name` – The name of a kernel parameter in the kernel signature.
+    - `type` – Node type: `input` or `output` as specified in the IR.
+    - `port-index` – A number of input/output ports as specified in the IR.
+    - `format` – The channel order in the tensor. Optional conversion layers are generated if the custom layer format is not compatible with formats of neighboring layers. `BFXY`, `BYXF`, and `ANY` formats are supported currently.
+  - Each `Tensor` node of `input_buffer` or `output_buffer` type must contain the following attributes:
+    - `arg-name` – The name of a kernel parameter in the kernel signature.
+    - `type` – Node type: `input_buffer` or `output_buffer`. Use the appropriate type to bind multiple kernels that correspond to different stages of the same layer.
+    - `port-index` – The unique identifier to bind by.
+    - `dim` – The dim source with the same `direction,port` format used for `WorkSizes` bindings.
+    - `size` – Amount of bytes needed. Current expression syntax supports only expression over dimensions of over selected input/output tensor or constants and might be expended in the future.
+
+    Here is an example of multi-stage MVN layer binding:
+  ```xml
+  <CustomLayer name="MVN" stage="0" type="MVCL" version="1">
+      <Kernel entry="reduction_mean">
+          <Source filename="mvn.bin"/>
+      </Kernel>
+      <Parameters>
+          <Tensor arg-name="src"                type="input"         port-index="0"               format="BFYX"/>
+          <Tensor arg-name="mean"               type="output_buffer" port-index="0" dim="output,0" size="Y*F*4"/>
+          <Tensor arg-name="variance"           type="output_buffer" port-index="1" dim="output,0" size="Y*F*4"/>
+          <!--other parameters  -->
+      </Parameters>
+      <WorkSizes dim="output,0" global="((Y+7)/8)*8,F,1" local="8,1,1"/>
+  </CustomLayer>
+  <CustomLayer name="MVN" stage="1" type="MVCL" version="1">
+      <Kernel entry="mvn_scale">
+          <Source filename="mvn_scale_changed_orded.bin"/>
+      </Kernel>
+      <Parameters>
+          <Tensor arg-name="src_data"           type="input"        port-index="0"               format="BFYX"/>
+          <Tensor arg-name="dst_data"           type="output"       port-index="0"               format="BFYX"/>
+          <Tensor arg-name="mean_part"          type="input_buffer" port-index="0" dim="output,0" size="Y*F*4"/>
+          <Tensor arg-name="power_mean"         type="input_buffer" port-index="1" dim="output,0" size="Y*F*4"/>
+          <!--other parameters  -->
+      </Parameters>
+      <WorkSizes dim="output,0" global="((Y+7)/8)*8,F,1" local="8,1,1"/>
+  </CustomLayer>
+  ```
+  - Each `Tensor` node that has the type `data` must contain the following attributes:
+   - `source` – A name of the blob as it is in the IR. Typical example is `weights` for convolution.
+   - `format` – Specifies the channel order in the tensor. Optional conversion layers are generated if the custom layer format is not.
+  ```xml
+  <CustomLayer name="BinaryConvolution" type="MVCL" version="1">
+    <Kernel entry="binary_convolution">
+        <Source filename="binary_layers.bin"/>
+    </Kernel>
+    <Parameters>
+        <Tensor arg-name="src_data"      type="input"   port-index="0"                      format="BFYX"/>
+        <Data   arg-name="weights_data"  type="data"                     source="weights"   format="ANY"/>
+        <Tensor arg-name="dst_data"      type="output"  port-index="0"                      format="BFYX"/>
+        <!--other parameters  -->
+    </Parameters>
+    <WorkSizes dim="output,0" global="X,Y,F" local="1,1,1"/>
+  </CustomLayer>
+  ```
+  - Each `Scalar` node must contain the following attributes:
+   - `arg-name` – The name of a kernel parameter in the kernel signature.
+   - `type` – `int` or `float` value. It is used for correct argument extraction from IR parameters.
+   - `source` – Contains the name of the parameter in the IR file or input/output (`I`/`O`, `In`/`On`, where `n` is a port number)
+   followed by dimension `B`(batch), `Y`(height), `X`(width), or `F`(channels).
+
+  - Each `Data` node must contain the following attributes:
+    - `arg-name` – The name of a kernel parameter in the kernel signature.
+    - `type` – Node type. Currently, `local_data` is the only supported value, which defines buffer allocated in fast local on-chip memory. It is limited to 100KB for all `__local` and
+    `__private` arrays defined inside the kernel as well as all `__local` parameters passed to the kernel. Note that a manual-DMA extension requires double buffering.
+    If the custom layer is detected to run out of local memory, the inference fails.
+    - `dim` – The dim source with the same `direction,port` format used for `WorkSizes` bindings.
+    - `size` – Amount of bytes needed. The current expression syntax supports only expression over dimensions of over selected input/output tensor or constants and may be extended in the future.
+  The example binding below illustrates a kernel with two local buffers passed to the kernel.
+  ```xml
+  <CustomLayer name="GRN" type="MVCL" version="1">
+      <Kernel entry="grn_NCHW">
+          <Source filename="grn.bin"/>
+      </Kernel>
+      <Parameters>
+          <Tensor arg-name="src_data" type="input"         port-index="0"                  format="BFYX"/>
+          <Tensor arg-name="dst_data" type="output"        port-index="0"                  format="BFYX"/>
+          <Data   arg-name="src"      type="local_data"                      dim="input,0" size="X*F*2" />
+          <Data   arg-name="dst"      type="local_data"                      dim="input,0" size="X*F*2" />
+          <Scalar arg-name="C"        type="int"           port-index="0"    source="I.F"               />
+          <Scalar arg-name="bias"     type="float"                           source="bias"              />
+      </Parameters>
+      <WorkSizes dim="input,0" global="X,Y,1" local="X,1,1"/>
+  </CustomLayer>
+```
+
+## Pass Configuration File to OpenVINO™ Runtime
+
+> **NOTE**: If both native and custom layer implementations are present, the custom kernel has a priority over the native one.
+Before loading the network that features the custom layers, provide a separate configuration file and load it using the ov::Core::set_property() method with the "CONFIG_KEY" key and the configuration file name as a value before loading the network that uses custom operations to the plugin:
+
+@snippet docs/snippets/vpu/custom_op.cpp part0
+
+## Optimizing Kernels with OpenCL for VPU (Intel® Neural Compute Stick 2)
+
+This section provides optimization guidelines on writing custom layers with OpenCL for VPU devices. Knowledge about general OpenCL
+programming model and OpenCL kernel language is assumed and not a subject of this section. The OpenCL model mapping to VPU is described in the table below.
+
+| OpenCL Model  | VPU Mapping|
+|-----|----|
+| Device code | Executed on SHAVE cores    |
+| Private memory | Mapped to CMX internal memory, limited to 100KB per work group, valid only while the work group is executed |
+| Local memory   | Mapped to CMX internal memory, limited to 100KB per work group, valid only while the work group is executed |
+| Global memory  | Mapped to DDR, used to pass execution preserved parameters for inputs, outputs, and blobs                |
+| Work group     | Executed on a single SHAVE core iterating over multiple work items      |
+
+Note that by the OpenCL specification, the work group execution order is not specified. This means that it is your
+responsibility to ensure that race conditions among work groups are not introduced. Custom layer runtime spits evenly
+work grid among available compute resources and executes them in an arbitrary order. This static scheduling approach works best if the load is evenly spread out across work groups, which is a typical case for Deep Learning kernels. The following guidelines are recommended to use for work group partitioning:
+
+1. Split work evenly across work groups.
+2. Adjust work group granularity to maintain equal workload for all compute codes.
+3. Set the maximum number of cores using the `max-shaves` attribute for the `CustomLayer` node. This keeps more resources for the rest of topology. It is also useful if the kernel scalability reached its limits, which may happen while optimizing memory bound kernels or kernels with poor parallelization.
+4. Try an alternate data layout (`BFXY`/`BYXF`) for the kernel if it improves work group partitioning or data access patterns.
+Consider not just specific layer boost, but full topology performance because data conversion layers would be automatically inserted
+as appropriate.
+
+Offline OpenCL compiler (`clc`) features automatic vectorization over `get_global_id(0)` usage, if uniform access is detected.
+For example, the kernel below could be automatically vectorized:
+```cpp
+__kernel void cvtf32f16(__global float* restrict inImage, __global half*  restrict outImage,
+                        float   scale, float   bais)
+{
+    int idx = get_global_id(0) + get_global_id(1) * get_global_size(0) + get_global_id(2) * get_global_size(0) * get_global_size(1);
+    outImage[idx] = convert_half(inImage[idx]*scale+bais);
+}
+```
+However, this work-group based vectorizer (WGV) conflicts with the default LLVM vectorizer based on superword level parallelism
+(SLP) for the current compiler version. Manual vectorization is recommended to provide the best performance for non-uniform code
+patterns. WGV works if and only if vector types are not used in the code.
+
+Here is a short list of optimization tips:
+
+1. Help auto-vectorizer ensure non-aliasing pointers for kernel parameters by putting `restrict` where possible.
+  - This can give a performance boost, especially for kernels with unrolling, like `ocl_grn` from the example below.
+  - Place `restrict` markers for kernels with manually vectorized codes. In the `ocl_grn` kernel below, the unrolled version without `restrict` is up to 20% slower than the most optimal one, which combines unrolling and `restrict`.
+2. Put `#&zwj;pragma unroll N` to your loop header. The compiler does not trigger unrolling by default, so it is your responsibility to
+annotate the code with pragmas as appropriate. The `ocl_grn` version with `#&zwj;pragma unroll 4` is up to 50% faster, most of which comes from unrolling the first loop, because LLVM, in general, is better in scheduling 3-stage loops (load-compute-store), while the fist loop
+ `variance += (float)(src_data[c*H*W + y*W + x] * src_data[c*H*W + y*W + x]);` is only 2-stage (load-compute). Pay
+attention to unrolling such cases first. Unrolling factor is loop-dependent. Choose the smallest number that
+still improves performance as an optimum between the kernel size and execution speed. For this specific kernel, changing the unroll factor from `4` to `6` results in the same performance, so unrolling factor equal to 4 is an optimum. For Intel® Neural Compute Stick 2, unrolling is conjugated with the automatic software pipelining for load, store, and compute stages:
+```cpp
+__kernel void ocl_grn(__global const half* restrict src_data, __global half* restrict dst_data, int C, float bias)
+{
+    int x = get_global_id(0);
+    int W = get_global_size(0);
+    int y = get_global_id(1);
+    int H = get_global_size(1);
+    float variance = bias + 1e-9f;
+    #pragma unroll 4
+    for (int c = 0; c < C; c++)
+        variance += (float)(src_data[c*H*W + y*W + x] * src_data[c*H*W + y*W + x]);
+    variance = 1.f / native_sqrt(variance);
+    #pragma unroll 4
+    for (int c = 0; c < C; c++)
+        dst_data[c*H*W + y*W + x] = (half)((float)src_data[c*H*W + y*W + x] * variance);
+}
+```
+To check the efficiency of WGV, you can compare performance of the kernel above with the kernel below, which is manually vectorized over width:
+```cpp
+__kernel void ocl_grn_line(__global const half* restrict src_data,  __global half* restrict dst_data, int C, int W, float bias)
+{
+    int y   = get_global_id(1);
+    int H   = get_global_size(1);
+    for (int x = 0; x < W/8; x++)
+    {
+        float8 variance = (float8)(bias+1e-9f);
+        #pragma unroll 4
+        for (int c = 0; c < C; c++)
+        {
+            __global const half8* restrict src_line = ((__global const half8 * restrict)(src_data + c*H*W + y*W));
+            half8 sh = src_line[x];
+            variance += convert_float8(sh*sh);
+        }
+        variance = 1.f/native_sqrt(variance);
+        #pragma unroll 4
+        for (int c = 0; c < C; c++)
+        {
+            __global const half8* restrict src_line = ((__global const half8 * restrict)(src_data + c*H*W + y*W));
+            __global       half8* restrict dst_line = ((__global       half8 * restrict)(dst_data + c*H*W + y*W));
+            dst_line[x] = convert_half8(convert_float8(src_line[x])*variance);
+        }
+    }
+    for (int x = W/8*8; x < W; x++)
+    {
+        float variance = bias+1e-9f;
+        #pragma unroll 4
+        for (int c = 0; c < C; c++)
+            variance += (float)(src_data[c*H*W + y*W + x]*src_data[c*H*W + y*W + x]);
+        variance = 1.f/native_sqrt(variance);
+        #pragma unroll 4
+        for (int c = 0; c < C; c++)
+            dst_data[c*H*W + y*W + x] = (float)src_data[c*H*W + y*W + x]*variance;
+    }
+}
+```
+Both versions perform the same, but the second one has more complex code.
+
+3. If it is easy to predict the work group size, you can also use the `reqd_work_group_size` kernel attribute to ask the compiler
+to unroll the code up to the local size of the work group. Note that if the kernel is actually executed with the
+different work group configuration, the result is undefined.
+
+4. Prefer to use the `half` compute if it keeps reasonable accuracy. 16-bit float is a native type for Intel® Neural Compute Stick 2, most of the functions `half_*` are mapped to a single hardware instruction.
+Use the standard `native_*` function for the rest of types.
+
+5. Prefer to use the `convert_half` function over `vstore_half` if conversion to 32-bit float is required. `convert_half` is mapped to a single hardware instruction. For the `cvtf32f16` kernel above, the line `outImage[idx] = convert_half(inImage[idx]*scale+bais);` is eight times slower than the code with `vstore_half`.
+
+6. Mind early exits. Early exit can be extremely costly for the current version of the `clc` compiler due to conflicts with the
+auto-vectorizer. The generic advice would be to setup local size by `x` dimension equal to inputs or/and outputs width.
+If it is impossible to define the work grid that exactly matches inputs or/and outputs to eliminate checks, for example,
+`if (get_global_id(0) >= width) return`, use line-wise kernel variant with manual vectorization. 
+The kernel example below demonstrates the impact of early exits on kernel performance.
+   ```cpp
+   // Initial version
+   __kernel void reorg(const __global half* restrict src, __global half* restrict out, int stride)
+   {
+     int w = get_global_id(0);
+     int W = get_global_size(0);
+     int h = get_global_id(1);
+     int H = get_global_size(1);
+     int c = get_global_id(2);
+     int C = get_global_size(2);
+     int C2 = C/(stride*stride);
+     int offset = c / C2;
+     int c2 = c - C2 * offset;
+     int H2 = H*stride;
+     int W2 = W*stride;
+     int h2 = h*stride + offset / stride;
+     int w2 = w*stride + offset - stride * (offset / stride);
+     out[W*H*c + W*h + w] = src[W2*H2*c2 + W2*h2 + w2];
+   }
+   ```
+This `reorg` kernel is auto-vectorizable, but an input for YOLO v2 topology is `NCHW=<1,64,26,26>` and it is not multiple of vector width, which is `8` for `half` data type. As a result, the Inference Engine does not select the auto-vectorized kernel.
+To compare performance of auto-vectorized and scalar version of the kernel, change the input size to`NCHW=<1,64,26,32>`. This enables the auto-vectorized version to be selected by the Inference Engine and can give you about 30% uplift.
+Since the auto-vectorized version is faster, it makes sense to enable it for the YOLO v2 topology input size by setting the local size multiple of vector, for example, 32, and adjust global sizes accordingly. As a result, the execution work grid exceeds actual input dimension, so out-of-bound checks should be inserted. See the updated kernel version below:
+   ```cpp
+   // Version with out-of-bound checks added
+   __kernel void reorg(const __global half* restrict src, __global half* restrict out, int W, int stride)
+   {
+     int w = get_global_id(0);
+     w = min(w, W-1);
+     int h = get_global_id(1);
+     int H = get_global_size(1);
+     int c = get_global_id(2);
+     int C = get_global_size(2);
+     int C2 = C/(stride*stride);
+     int offset = c / C2;
+     int c2 = c - C2 * offset;
+     int H2 = H*stride;
+     int W2 = W*stride;
+     int h2 = h*stride + offset / stride;
+     int w2 = w*stride + offset - stride * (offset / stride);
+     out[W*H*c + W*h + w] = src[W2*H2*c2 + W2*h2 + w2];
+   }
+   ```
+This code performs the same as the initial kernel above (scalar) due to branching overhead. If you replace min/max expression `w = min(w, W-1);` with `if (w >= W) return;`, runtime increases up to 2x against to code without branching (initial version).<br>
+If branching is inevitable for your element-based kernel, it is recommended to change the scheme to line-based. See the kernel variant below:
+```cpp
+// Line-wise version
+__kernel void reorg(const __global half* restrict src, __global half* restrict out, int H, int W, int stride)
+{
+    int h = min((int)get_global_id(0), H-1);
+    int c = get_global_id(1);
+    int C = get_global_size(1);
+    int C2 = C/(stride*stride);
+    int offset = c / C2;
+    int c2 = c - C2 * offset;
+    int H2 = H*stride;
+    int W2 = W*stride;
+    for (int w = 0; w < W; ++w)
+    {
+        int h2 = h*stride + offset / stride;
+        int w2 = w*stride + offset - stride * (offset / stride);
+        out[W*H*c + W*h + w] = src[W2*H2*c2 + W2*h2 + w2];
+    }
+}
+```
+This decreases the execution time up to 40% against the best performing vectorized kernel without early exits (initial version).
+7. Reuse computations among work items by using line-based kernels or sharing values though `__local` memory.
+8. Improve data access locality. Most of custom kernels are memory bound while convolution and fully connected layers are hardware-implemented. The code below demonstrates a further optimized version of the `reorg` kernel unrolled by `stride`:
+   ```cpp
+   // Unrolled line-wise version
+   __kernel void reorg_unrolled_by_stride(const __global half* restrict src, __global half* restrict dst,
+                                          int H, int W, int stride)
+   {
+     int h = min((int)get_global_id(0), H-1);
+     int c2 = get_global_id(1);
+     int C2 = get_global_size(1);
+     int C = C2*stride*stride;
+     int H2 = H*stride;
+     int W2 = W*stride;
+     for (int stride_y = 0; stride_y < stride; stride_y++)
+       for (int stride_x = 0; stride_x < stride; stride_x++)
+         for (int w2 = 0, w = 0; w < W; w2 += stride, w++)
+           dst[W*H*C2*(stride_y*stride+stride_x) + W*H*c2 + W*h + w] = src[W2*H2*c2 + W2*h*stride + W2*stride_y + w2 + stride_x];
+   }
+   ```
+`scr` data in this case loaded only once. As the result, the cycle count drops up to 45% against the line-wise version.
+
+9. Copy data from `__dlobal` to `__local` or `__private` memory if the data is accessed more than once. Access to
+`__dlobal` memory is orders of magnitude slower than access to `__local`/`__private` due to statically scheduled pipeline, which
+stalls completely on memory access without any prefetch. The same recommendation is applicable for scalar load/store
+from/to a `__blobal` pointer since work-group copying could be done in a vector fashion.
+
+10. Use a manual DMA extension. Local (on-chip) memory throughput is up to 24x higher than DDR throughput. Starting from OpenVINO™ 2020.1, VPU OpenCL features manual-DMA kernel extension to copy sub-tensor used by work group into local memory and performing compute without DDR evolved. Here is the simple GRN kernel implementation that runs over DDR. Local size is in the form (width of the input tensor, 1, 1) to define a large enough work group to get code automatically vectorized and unrolled, while global size is (width of the input tensor, height of the input tensor, 1):
+   ```cpp
+   __kernel void grn_NCHW(
+     __global const half* restrict src_data,
+     __global       half* restrict dst_data,
+     int C,
+     float bias)
+   {
+     float variance = bias + 1e-9f;
+     #pragma unroll 4
+     for (int c = 0; c < C; c++)
+     {
+       float val = (float) src_data[c*get_global_size(1)*get_global_size(0) + get_global_id(1)*get_global_size(0) + get_global_id(0)];
+       variance += val*val;
+     }
+     half hvariance = (half)(native_rsqrt((half)(variance/16.f))*0.25f);
+     #pragma unroll 4
+     for (int c = 0; c < C; c++)
+     {
+       dst_data[c*get_global_size(1)*get_global_size(0) + get_global_id(1)*get_global_size(0) + get_global_id(0)]
+       = src_data[c*get_global_size(1)*get_global_size(0) + get_global_id(1)*get_global_size(0) + get_global_id(0)] * hvariance;
+     }
+   }
+   ```
+
+This kernel can be rewritten to introduce special data binding `__dma_preload` and `__dma_postwrite intrinsics`. This means that instead of one kernel, a group of three kernels should be implemented: `kernelName`, `__dma_preload_kernelName`, and `__dma_postwrite_kernelName`.  `__dma_preload_kernelName` for a particular work group `n` is guaranteed to be executed before the `n`-th work group itself, while `__dma_postwrite_kernelName` is guaranteed to be executed after a corresponding work group. You can define one of those functions that are intended to be used to copy data from-to `__global` and `__local` memory. The syntactics requires exact functional signature match. The example below illustrates how to prepare your kernel for manual-DMA.
+
+   ```cpp
+   __kernel void __dma_preload_grn_NCHW(
+     __global const half* restrict src,
+     __global       half* restrict dst,
+     __local        half* restrict local_src,
+     __local        half* restrict local_dst,
+     int C,
+     float bias)
+     {
+     // ToDO: copy required piece of src tensor into local_src
+   }
+   
+   __kernel void __dma_postwrite_grn_NCHW(
+     __global const half* restrict src,
+     __global       half* restrict dst,
+     __local  const half* restrict local_src,
+     __local        half* restrict local_dst,
+     int C,
+     float bias)
+   {
+     // ToDO: copy back computed piece of local_dst into dst
+   }
+   
+   __kernel void grn_NCHW(
+     __global const half* restrict src_data,
+     __global       half* restrict dst_data,
+     __local        half* restrict src,
+     __local        half* restrict dst,
+     int C,
+     float bias)
+   {
+     // same as the example above
+   }
+   ``` 
+The GRN kernel operates on channel-major tensors to compute average over full channel range and then normalizes input elements to produce the output.
+As a part of the manual DMA extension, a group of work group copy functions are introduced in addition to `async_work_group_copy`, which is also mapped to a DMA call.
+
+Here is the list of supported functions:
+```cpp
+// 2D sub-tensor copy
+event_t WorkGroupDmaCreateStrideTransaction(
+                const local T *src,
+                global T *dst,
+                size_t  src_width, // width of the line of source in bytes
+                size_t  dst_width, // width of the line of destination in bytes
+                size_t  src_stride, // stride between corresponding 2 consecutive lines of source in bytes
+                size_t  dst_stride, // stride between corresponding 2 consecutive lines of destination in bytes
+                size_t size, // total number of bytes loaded for all lines from source to destination
+                event_t  event) __OVERLOAD;
+event_t WorkGroupDmaCreateStrideTransaction(
+                const global T *src,
+                local T *dst,
+                size_t  src_width, // width of the line of source in bytes
+                size_t  dst_width, // width of the line of destination in bytes
+                size_t  src_stride, // stride between corresponding 2 consecutive lines of source in bytes
+                size_t  dst_stride, // stride between corresponding 2 consecutive lines of destination in bytes
+                size_t size, // total number of bytes loaded for all lines from source to destination
+                event_t  event) __OVERLOAD;
+// 3D sub-tensor copy
+event_t WorkGroupDmaCreate3DTransaction(
+                 const local T *src,
+                 global T *dst,
+                 size_t  src_width, // width of the line of source in bytes
+                 size_t  dst_width, // width of the line of destination in bytes
+                 size_t  src_stride, // stride between corresponding 2 consecutive lines of source in bytes
+                 size_t  dst_stride, // stride between corresponding 2 consecutive lines of destination in bytes
+                 size_t  num_planes, // number of planes to be copied
+                 size_t  src_plane_stride, // stride between corresponding 2 consecutive planes of source in bytes
+                 size_t  dst_plane_stride, // stride between corresponding 2 consecutive planes of destination in bytes
+                 size_t  size, // size of the loaded plane in bytes, analogues to the size in 2D case
+                 event_t  event) __OVERLOAD;
+event_t WorkGroupDmaCreate3DTransaction(
+                 const global T *src,
+                 local T *dst,
+                 size_t  src_width, // width of the line of source in bytes
+                 size_t  dst_width, // width of the line of destination in bytes
+                 size_t  src_stride, // stride between corresponding 2 consecutive lines of source in bytes
+                 size_t  dst_stride, // stride between corresponding 2 consecutive lines of destination in bytes
+                 size_t  num_planes, // number of planes to be copied
+                 size_t  src_plane_stride, // stride between corresponding 2 consecutive planes of source in bytes
+                 size_t  dst_plane_stride, // stride between corresponding 2 consecutive planes of destination in bytes
+                 size_t  size, // size of the loaded plane in bytes, analogues to the size in 2D case
+                 event_t  event) __OVERLOAD;
+```
+where `T` can be `uchar`, `char`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `half` or `float`.
+
+Modified version of the GRN kernel could be the following:
+```cpp
+__kernel void __dma_preload_grn_NCHW(
+    __global const half* restrict src,
+    __global       half* restrict dst,
+    __local        half* restrict local_src,
+    __local        half* restrict local_dst,
+    int C,
+    float bias)
+{
+    WorkGroupDmaCreate3DTransaction(
+        src + get_group_id(0)*get_local_size(0)
+            + get_group_id(1)*get_local_size(1)*get_global_size(0), // src
+        local_src, // dst
+        get_local_size(0) * sizeof(half), // src width
+        get_local_size(0) * sizeof(half), // dst width
+        get_global_size(0) * sizeof(half), // src stride
+        get_local_size(0) * sizeof(half), // dst stride
+        C, // num planes
+        get_global_size(0) * get_global_size(1) * sizeof(half), // src plane stride
+        get_local_size(0) * get_local_size(1) * sizeof(half), // dst plane stride
+        get_local_size(0) * get_local_size(1) * sizeof(half), // plane size
+        0);
+}
+__kernel void __dma_postwrite_grn_NCHW(
+    __global const half* restrict src,
+    __global       half* restrict dst,
+    __local  const half* restrict local_src,
+    __local        half* restrict local_dst,
+    int C,
+    float bias)
+{
+    WorkGroupDmaCreate3DTransaction(
+        local_dst, // src
+        dst + get_group_id(0)*get_local_size(0)
+            + get_group_id(1)*get_local_size(1)*get_global_size(0), // dst
+        get_local_size(0) * sizeof(half), // src width
+        get_local_size(0) * sizeof(half), // dst width
+        get_local_size(0) * sizeof(half), // src stride
+        get_global_size(0) * sizeof(half), // dst stride
+        C, // num planes
+        get_local_size(0) * get_local_size(1) * sizeof(half), // src plane stride
+        get_global_size(0) * get_global_size(1) * sizeof(half), // dst plane stride
+        get_local_size(0) * get_local_size(1) * sizeof(half), // plane size
+        0);
+}
+__kernel void grn_NCHW(
+    __global const half* restrict src_data,
+    __global       half* restrict dst_data,
+    __local        half* restrict src,
+    __local        half* restrict dst,
+    int C,
+    float bias)
+{
+    float variance = bias + 1e-9f;
+    #pragma unroll 8
+    for (int c = 0; c < C; c++)
+    {
+        float val = (float) src[c*get_local_size(1)*get_local_size(0) + get_local_id(1)*get_local_size(0) + get_local_id(0)];
+        variance += val*val;
+    }
+    half hvariance = (half)(native_rsqrt((half)(variance/16.f))*0.25f);
+    #pragma unroll 8
+    for (int c = 0; c < C; c++)
+    {
+        dst[c*get_local_size(1)*get_local_size(0) + get_local_id(1)*get_local_size(0) + get_local_id(0)]
+        = src[c*get_local_size(1)*get_local_size(0) + get_local_id(1)*get_local_size(0) + get_local_id(0)] * hvariance;
+    }
+}
+```
+
+Note the `get_local_size` and `get_local_id` usage inside the kernel. 21x speedup is expected for a kernel on enet-curbs setup because it was completely limited by memory usage.
+
+An alternative method to using DMA is to use work item copy extension. Those functions are executed inside a kernel and requires work groups equal to single work item.
+
+Here is the list of supported work item functions:
+```cpp
+item_dma_event_t WorkItemDmaCreateTransaction(
+            const global T *src,
+            private T *dst,
+            size_t  size,
+            item_dma_event_t  event) __OVERLOAD;
+item_dma_event_t WorkItemDmaCreateTransaction(
+            const private T *src,
+            global T *dst,
+            size_t  size,
+            item_dma_event_t  event) __OVERLOAD;
+item_dma_event_t WorkItemDmaCreateStrideTransaction(
+                const global T *src,
+                private T *dst,
+                size_t  src_width,
+                size_t  dst_width,
+                size_t  src_stride,
+                size_t  dst_stride,
+                size_t size,
+                item_dma_event_t  event) __OVERLOAD;
+item_dma_event_t WorkItemDmaCreateStrideTransaction(
+                const private T *src,
+                global T *dst,
+                size_t  src_width,
+                size_t  dst_width,
+                size_t  src_stride,
+                size_t  dst_stride,
+                size_t size,
+                item_dma_event_t  event) __OVERLOAD;
+item_dma_event_t WorkItemDmaCreate3DTransaction(
+                const global T *src,
+                private T *dst,
+                size_t  src_width,
+                size_t  dst_width,
+                size_t  src_stride,
+                size_t  dst_stride,
+                size_t  num_planes,
+                size_t  src_plane_stride,
+                size_t  dst_plane_stride,
+                size_t  size,
+                item_dma_event_t  event) __OVERLOAD;
+item_dma_event_t WorkItemDmaCreate3DTransaction(
+                const private T *src,
+                global T *dst,
+                size_t  src_width,
+                size_t  dst_width,
+                size_t  src_stride,
+                size_t  dst_stride,
+                size_t  num_planes,
+                size_t  src_plane_stride,
+                size_t  dst_plane_stride,
+                size_t  size,
+                item_dma_event_t  event) __OVERLOAD;
+```
+where `T` can be `uchar`, `char`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `half` or `float`.

docs/Extensibility_UG/add_openvino_ops.md

@@ -1,4 +1,4 @@
-# Custom OpenVINO™ Operations {#openvino_docs_Extensibility_UG_add_openvino_ops}
+# Custom OpenVINO™ Operations {#openvino_docs_Extensibility_UG_add_openvino_ops}
 
 OpenVINO™ Extension API allows you to register custom operations to support models with operations which OpenVINO™ does not support out-of-the-box.
 
@@ -20,14 +20,10 @@ Follow the steps below to add a custom operation:
 
 5. Override the `visit_attributes` method, which enables serialization and deserialization of operation attributes. An `AttributeVisitor` is passed to the method, and the implementation is expected to walk over all the attributes in the op using the type-aware `on_attribute` helper. Helpers are already implemented for standard C++ types like `int64_t`, `float`, `bool`, `vector`, and for existing OpenVINO defined types.
 
-6. Override `evaluate`, which is an optional method that enables fallback of some devices to this implementation and the application of constant folding if there is a custom operation on the constant branch. If your operation contains `evaluate` method you also need to override the `has_evaluate` method, this method allow to get information about availability of `evaluate` method for the operation.
-
-7. Add the `OPENVINO_FRAMEWORK_MAP` macro if you want to map custom operation to framework operation with the same name. It is an optional macro which can be used for one to one mapping. In order to use this macro please include frontend specific headers:
-   @snippet template_extension/new/identity.hpp op:frontend_include
+6. Override `evaluate`, which is an optional method that enables fallback of some devices to this implementation and the application of constant folding if there is a custom operation on the constant branch. If your operation contains `evaluate` method you also need to override the `has_evaluate` method, this method allows to get information about availability of `evaluate` method for the operation.
 
 Based on that, declaration of an operation class can look as follows:
 
-@snippet template_extension/new/identity.hpp op:header
 
 ### Operation Constructors
 
@@ -55,8 +51,9 @@ OpenVINO™ operation contains two constructors:
 
 @snippet template_extension/new/identity.cpp op:visit_attributes
 
-### `evaluate()` and `has_evaluate()`
+### evaluate() and has_evaluate()
 
 `ov::Node::evaluate` method enables you to apply constant folding to an operation.
 
 @snippet template_extension/new/identity.cpp op:evaluate
+

docs/Extensibility_UG/frontend_extensions.md

@@ -0,0 +1,105 @@
+# Frontend Extensions {#openvino_docs_Extensibility_UG_Frontend_Extensions}
+
+The goal of this chapter is to explain how to use Frontend extension classes to facilitate mapping of custom operations from framework model representation to OpenVINO representation. Refer to [Introduction to OpenVINO Extension](Intro.md) to understand entire flow.
+
+This API is applicable for new frontends only, which exist for ONNX and PaddlePaddle. If a different model format is used, follow legacy [Model Optimizer Extensions](../MO_DG/prepare_model/customize_model_optimizer/Customize_Model_Optimizer.md) guide.
+
+> **NOTE**: This documentation is written based on the [Template extension](https://github.com/openvinotoolkit/openvino/tree/master/docs/template_extension/new), which demonstrates extension development details based on minimalistic `Identity` operation that is a placeholder for your real custom operation. You can review the complete code, which is fully compliable, to see how it works.
+
+## Single Operation Mapping with OpExtension
+
+This section covers the case when a single operation in framework representation is mapped to a single operation in OpenVINO representation. This is called *one-to-one mapping*. There is `OpExtension` class that works well if all the following conditions are satisfied:
+
+1. Number of inputs to operation in the Framework representation is the same as in the OpenVINO representation.
+
+2. Number of outputs is also the same in both representations.
+
+3. Inputs can be indexed and are mapped in order correspondingly, e.g. input with index 0 in framework representation maps to input with index 0 in OpenVINO representation and so on.
+
+4. The same for outputs.
+
+5. Each attribute in OpenVINO operation can be initialized from one of the attributes of original operation or by some predefined constant value. Value of copied attributes cannot contain expressions, value is accepted as-is, so type of a value should be compatible.
+
+> **NOTE**: `OpExtension` class is currently available for ONNX frontend only. PaddlePaddle frontend has named inputs and outputs for operation (not indexed) therefore OpExtension mapping is not applicable for this case.
+
+The next example maps ONNX operation with type [“Identity”]( https://github.com/onnx/onnx/blob/main/docs/Operators.md#Identity) to OpenVINO template extension `Identity` class.
+
+@snippet ov_extensions.cpp frontend_extension_Identity_header
+@snippet ov_extensions.cpp frontend_extension_Identity
+
+The mapping doesn’t involve any attributes, as operation Identity doesn’t have them.
+
+Extension objects, like just constructed `extension` can be used to add to the OpenVINO runtime just before the loading a model that contains custom operations:
+
+@snippet ov_extensions.cpp frontend_extension_read_model
+
+Or extensions can be constructed in a separately compiled shared library. Separately compiled library can be used in Model Optimizer or `benchmark_app`. Read about how to build and load such library in chapter “Create library with extensions” in [Introduction to OpenVINO Extension](Intro.md).
+
+If operation have multiple inputs and/or outputs they will be mapped in order. The type of elements in input/output tensors should match expected types in the surrounding operations. For example, if custom operation produces `f32` data type then operation that consumes this output should also support `f32`. Otherwise, model conversion fails with an error, there are no automatic type conversion happens.
+
+### Converting to Standard OpenVINO Operation
+
+`OpExtension` class can be used when mapping to one of the operations from standard OpenVINO operation set is what you need and there is no class like `TemplateExtension::Identity` implemented.
+
+Here is an example for a custom framework operation “MyRelu”. Suppose it is mathematically equivalent to standard `Relu` that exists in OpenVINO operation set, but for some reason has type name “MyRelu”. In this case you can directly say that “MyRelu” -> `Relu` mapping should be used:
+
+@snippet ov_extensions.cpp frontend_extension_MyRelu
+
+In the resulting converted OpenVINO model, “MyRelu” operation will be replaced by the standard operation `Relu` from the latest available OpenVINO operation set. Notice that when standard operation is used, it can be specified using just a type string (“Relu”) instead of using a `ov::opset8::Relu` class name as a template parameter for `OpExtension`. This method is available for operations from the standard operation set only. For a user custom OpenVINO operation the corresponding class should be always specified as a template parameter as it was demonstrated with `TemplateExtension::Identity`.
+
+### Attributes Mapping
+
+As described above, `OpExtension` is useful when attributes can be mapped one by one or initialized by a constant. If the set of attributes in framework representation and OpenVINO representation completely match by their names and types, nothing should be specified in OpExtension constructor parameters. The attributes are discovered and mapped automatically based on `visit_attributes` method that should be defined for any OpenVINO operation.
+
+Imagine you have CustomOperation class implementation that has two attributes with names `attr1` and `attr2`:
+
+@snippet ov_extensions.cpp frontend_extension_CustomOperation
+
+And original model in framework representation also has operation with name “CustomOperatoin” with the same `attr1` and `attr2` attributes. Then with the following code:
+
+@snippet ov_extensions.cpp frontend_extension_CustomOperation_as_is
+
+both `attr1` and `attr2` are copied from framework representation to OpenVINO representation automatically. If for some reason names of attributes are different but values still can be copied “as-is” you can pass attribute names mapping in `OpExtension` constructor:
+
+@snippet ov_extensions.cpp frontend_extension_CustomOperation_rename
+
+Where `fw_attr1` and `fw_attr2` are names for corresponding attributes in framework operation representation.
+
+If copying of an attribute is not what you need, `OpExtension` also can set attribute to predefined constant value. For the same `CustomOperation`, imagine you want to set `attr2` to value 5 instead of copying from `fw_attr2`, to achieve that do the following:
+
+@snippet ov_extensions.cpp frontend_extension_CustomOperation_rename_set
+
+So the conclusion is that each attribute of target OpenVINO operation should be initialized either by
+
+1. Setting automatically due to name matching
+
+2. Mapped by attribute name
+
+3. Set to a constant value
+
+This is achieved by specifying maps as arguments for `OpExtension` constructor.
+
+
+## Mapping to Multiple Operations with ConversionExtension
+
+Previous sections cover the case when a single operation is mapped to a single operation with optional adjustment in names and attribute values. That is likely enough for your own custom operation with existing C++ kernel implementation. In this case your framework representation and OpenVINO representation for the operation are under your control and inputs/outpus/attributes can be aligned to make `OpExtension` usable.
+
+In case if one-to-one mapping is not possible, *decomposition to multiple operations* should be considered. It is achieved by using more verbose and less automated `ConversionExtension` class. It enables writing arbitrary code to replace a single framework operation by multiple connected OpenVINO operations constructing dependency graph of any complexity.
+
+`ConversionExtension` maps a single operation to a function which builds a graph using OpenVINO operation classes. Follow chapter [Build a Model in OpenVINO Runtime](@ref ov_ug_build_model) to learn how to use OpenVINO operation classes to build a fragment of model for replacement.
+
+The next example illustrates using `ConversionExtension` for conversion of “ThresholdedRelu” from ONNX according to the formula: `ThresholdedRelu(x, alpha) -> Multiply(x, Convert(Greater(x, alpha), type=float))`.
+
+> **NOTE**: `ThresholdedRelu` is one of the standard ONNX operators which is supported by ONNX frontend natively out-of-the-box. Here we are re-implementing it to illustrate how you can add a similar support for your custom operation instead of `ThresholdedRelu`.
+
+@snippet ov_extensions.cpp frontend_extension_ThresholdedReLU_header
+@snippet ov_extensions.cpp frontend_extension_ThresholdedReLU
+
+To access original framework operation attribute value and connect to inputs, `node` object of type `NodeContext` is used. It has two main methods:
+
+* `NodeContext::get_input` to get input with a given index,
+
+* `NodeContext::get_attribute` to get attribute value with a given name.
+
+The conversion function should return a vector of node outputs that are mapped to corresponding outputs of the original framework operation in the same order.
+

docs/Extensibility_UG/ov_transformations.md

@@ -12,6 +12,7 @@
 
 @endsphinxdirective
 
+OpenVINO Transformation mechanism allows to develop transformation passes to modify `ov::Model`. You can use this mechanism to apply additional optimizations to the original Model or transform unsupported subgraphs and operations to new operations which are supported by the plugin.
 This guide contains all necessary information that you need to start implementing OpenVINO™ transformations.
 
 ## Working with Model

docs/IE_PLUGIN_DG/ExecutableNetwork.md

@@ -37,8 +37,8 @@ The implementation `CompileNetwork` is fully device-specific.
 
 The function accepts a const shared pointer to `ngraph::Function` object and performs the following steps:
 
-1. Applies ngraph passes using `TransformNetwork` function, which defines plugin-specific conversion pipeline. To support low precision inference, the pipeline can include Low Precision Transformations. These transformations are usually hardware specific. You can find how to use and configure Low Precisions Transformations in [Low Precision Transformations](@ref openvino_docs_IE_DG_lpt) guide.
-2. Maps the transformed graph to a backend specific graph representation (for example, to MKLDNN graph for Intel CPU).
+1. Applies nGraph passes using `TransformNetwork` function, which defines plugin-specific conversion pipeline. To support low precision inference, the pipeline can include Low Precision Transformations. These transformations are usually hardware specific. You can find how to use and configure Low Precisions Transformations in [Low Precision Transformations](@ref openvino_docs_OV_UG_lpt) guide.
+2. Maps the transformed graph to a backend specific graph representation (for example, to CPU plugin internal graph representation).
 3. Allocates and fills memory for graph weights, backend specific memory handles and so on.
 
 @snippet src/template_executable_network.cpp executable_network:map_graph

docs/IE_PLUGIN_DG/Intro.md

@@ -9,11 +9,12 @@
 
    Implement Plugin Functionality <openvino_docs_ie_plugin_dg_plugin>
    Implement Executable Network Functionality <openvino_docs_ie_plugin_dg_executable_network>
-   openvino_docs_ie_plugin_dg_quantized_networks
    Implement Synchronous Inference Request <openvino_docs_ie_plugin_dg_infer_request>
    Implement Asynchronous Inference Request <openvino_docs_ie_plugin_dg_async_infer_request>
    openvino_docs_ie_plugin_dg_plugin_build
    openvino_docs_ie_plugin_dg_plugin_testing
+   openvino_docs_ie_plugin_detailed_guides
+   openvino_docs_ie_plugin_api_references
 
 @endsphinxdirective
 
@@ -55,11 +56,11 @@ Detailed guides
 * [Build](@ref openvino_docs_ie_plugin_dg_plugin_build) a plugin library using CMake\*
 * Plugin and its components [testing](@ref openvino_docs_ie_plugin_dg_plugin_testing)
 * [Quantized networks](@ref openvino_docs_ie_plugin_dg_quantized_networks)
-* [Low precision transformations](@ref openvino_docs_IE_DG_lpt) guide
+* [Low precision transformations](@ref openvino_docs_OV_UG_lpt) guide
 * [Writing OpenVINO™ transformations](@ref openvino_docs_transformations) guide
 
 API References
 -----------------------
 
-* [Inference Engine Plugin API](groupie_dev_api.html)
-* [Inference Engine Transformation API](groupie_transformation_api.html)
+* [Inference Engine Plugin API](@ref ie_dev_api)
+* [Inference Engine Transformation API](@ref ie_transformation_api)

docs/IE_PLUGIN_DG/Plugin.md

@@ -2,7 +2,7 @@
 
 Inference Engine Plugin usually represents a wrapper around a backend. Backends can be:
 - OpenCL-like backend (e.g. clDNN library) for GPU devices.
-- MKLDNN backend for Intel CPU devices.
+- oneDNN backend for Intel CPU devices.
 - NVIDIA cuDNN for NVIDIA GPUs.
 
 The responsibility of Inference Engine Plugin:

docs/IE_PLUGIN_DG/QuantizedNetworks.md

@@ -9,7 +9,7 @@ For more details about low-precision model representation please refer to this [
 During the model load each plugin can interpret quantization rules expressed in *FakeQuantize* operations:
 - Independently based on the definition of *FakeQuantize* operation.
 - Using a special library of low-precision transformations (LPT) which applies common rules for generic operations,
-such as Convolution, Fully-Connected, Eltwise, etc., and translates "fake-quantized" models into the models with low-precision operations. For more information about low-precision flow please refer to the following [document](@ref openvino_docs_IE_DG_Int8Inference). 
+such as Convolution, Fully-Connected, Eltwise, etc., and translates "fake-quantized" models into models with low-precision operations.
 
 Here we provide only a high-level overview of the interpretation rules of FakeQuantize. 
 At runtime each FakeQuantize can be split into two independent operations: **Quantize** and **Dequantize**. 

docs/IE_PLUGIN_DG/detailed_guides.md

@@ -0,0 +1,18 @@
+# Advanced Topics {#openvino_docs_ie_plugin_detailed_guides}
+
+@sphinxdirective
+
+.. toctree::
+   :maxdepth: 1
+   :hidden:
+
+   openvino_docs_ie_plugin_dg_quantized_networks
+   openvino_docs_OV_UG_lpt
+
+@endsphinxdirective
+
+The guides below provides extra information about specific features of OpenVINO needed for understanding during OpenVINO plugin development:
+
+* [Quantized networks](@ref openvino_docs_ie_plugin_dg_quantized_networks)
+* [Low precision transformations](@ref openvino_docs_OV_UG_lpt) guide
+* [Writing OpenVINO™ transformations](@ref openvino_docs_transformations) guide

docs/IE_PLUGIN_DG/dev_api_references.md

@@ -0,0 +1,17 @@
+# Plugin API Reference {#openvino_docs_ie_plugin_api_references}
+
+@sphinxdirective
+
+.. toctree::
+   :maxdepth: 1
+   :hidden:
+
+   ../groupie_dev_api
+   ../groupie_transformation_api
+
+@endsphinxdirective
+
+The guides below provides extra API references needed for OpenVINO plugin development:
+
+* [OpenVINO Plugin API](@ref ie_dev_api)
+* [OpenVINO Transformation API](@ref ie_transformation_api)

docs/IE_PLUGIN_DG/layout.xml

@@ -5,74 +5,74 @@
             <tab type="usergroup" url="index.html" title="Developer Guide for Inference Engine Plugin Library">
                 <tab type="user" url="@ref plugin" visibile="yes" title="Implement Plugin Functionality"/>
                 <tab type="user" url="@ref executable_network" visibile="yes" title="Implement Executable Network Functionality">
-                    <tab type="usergroup" title="Low Precision Transformations" url="@ref openvino_docs_IE_DG_lpt">
-                        <tab type="user" title="Attributes" url="@ref openvino_docs_IE_DG_lpt_attributes">
-                            <tab type="user" title="AvgPoolPrecisionPreserved" url="@ref openvino_docs_IE_DG_lpt_AvgPoolPrecisionPreserved"/>
-                            <tab type="user" title="IntervalsAlignment" url="@ref openvino_docs_IE_DG_lpt_IntervalsAlignment"/>
-                            <tab type="user" title="PerTensorQuantization" url="@ref openvino_docs_IE_DG_lpt_PerTensorQuantization"/>
-                            <tab type="user" title="PrecisionPreserved" url="@ref openvino_docs_IE_DG_lpt_PrecisionPreserved"/>
-                            <tab type="user" title="Precisions" url="@ref openvino_docs_IE_DG_lpt_Precisions"/>
-                            <tab type="user" title="QuantizationAlignment" url="@ref openvino_docs_IE_DG_lpt_QuantizationAlignment"/>
+                    <tab type="usergroup" title="Low Precision Transformations" url="@ref openvino_docs_OV_UG_lpt">
+                        <tab type="user" title="Attributes" url="@ref openvino_docs_OV_UG_lpt_attributes">
+                            <tab type="user" title="AvgPoolPrecisionPreserved" url="@ref openvino_docs_OV_UG_lpt_AvgPoolPrecisionPreserved"/>
+                            <tab type="user" title="IntervalsAlignment" url="@ref openvino_docs_OV_UG_lpt_IntervalsAlignment"/>
+                            <tab type="user" title="PrecisionPreserved" url="@ref openvino_docs_OV_UG_lpt_PrecisionPreserved"/>
+                            <tab type="user" title="Precisions" url="@ref openvino_docs_OV_UG_lpt_Precisions"/>
+                            <tab type="user" title="QuantizationAlignment" url="@ref openvino_docs_OV_UG_lpt_QuantizationAlignment"/>
+                            <tab type="user" title="QuantizationGranularity" url="@ref openvino_docs_OV_UG_lpt_QuantizationGranularity"/>
                         </tab>
-                        <tab type="user" title="Step 1. Prerequisites transformations" url="@ref openvino_docs_IE_DG_lpt_step1_prerequisites">
-                            <tab type="user" title="LinOpSequenceFusion" url="@ref openvino_docs_IE_DG_lpt_LinOpSequenceFusion"/>
-                            <tab type="user" title="PullReshapeThroughDequantization" url="@ref openvino_docs_IE_DG_lpt_PullReshapeThroughDequantization"/>
-                            <tab type="user" title="PullTransposeThroughDequantization" url="@ref openvino_docs_IE_DG_lpt_PullTransposeThroughDequantization"/>
+                        <tab type="user" title="Step 1. Prerequisites transformations" url="@ref openvino_docs_OV_UG_lpt_step1_prerequisites">
+                            <tab type="user" title="LinOpSequenceFusion" url="@ref openvino_docs_OV_UG_lpt_LinOpSequenceFusion"/>
+                            <tab type="user" title="PullReshapeThroughDequantization" url="@ref openvino_docs_OV_UG_lpt_PullReshapeThroughDequantization"/>
+                            <tab type="user" title="PullTransposeThroughDequantization" url="@ref openvino_docs_OV_UG_lpt_PullTransposeThroughDequantization"/>
                         </tab>
-                        <tab type="user" title="Step 2. Markup transformations" url="@ref openvino_docs_IE_DG_lpt_step2_markup">
-                            <tab type="user" title="AlignQuantizationIntervals" url="@ref openvino_docs_IE_DG_lpt_AlignQuantizationIntervals"/>
-                            <tab type="user" title="AlignQuantizationParameters" url="@ref openvino_docs_IE_DG_lpt_AlignQuantizationParameters"/>
-                            <tab type="user" title="CreateAttribute" url="@ref openvino_docs_IE_DG_lpt_CreateAttribute"/>
-                            <tab type="user" title="CreatePrecisionsDependentAttribute" url="@ref openvino_docs_IE_DG_lpt_CreatePrecisionsDependentAttribute"/>
-                            <tab type="user" title="MarkupAvgPoolPrecisionPreserved" url="@ref openvino_docs_IE_DG_lpt_MarkupAvgPoolPrecisionPreserved"/>
-                            <tab type="user" title="MarkupCanBeQuantized" url="@ref openvino_docs_IE_DG_lpt_MarkupCanBeQuantized"/>
-                            <tab type="user" title="MarkupPerTensorQuantization" url="@ref openvino_docs_IE_DG_lpt_MarkupPerTensorQuantization"/>
-                            <tab type="user" title="MarkupPrecisions" url="@ref openvino_docs_IE_DG_lpt_MarkupPrecisions"/>
-                            <tab type="user" title="PropagatePrecisions" url="@ref openvino_docs_IE_DG_lpt_PropagatePrecisions"/>
-                            <tab type="user" title="PropagateThroughPrecisionPreserved" url="@ref openvino_docs_IE_DG_lpt_PropagateThroughPrecisionPreserved"/>
-                            <tab type="user" title="PropagateToInput" url="@ref openvino_docs_IE_DG_lpt_PropagateToInput"/>
-                            <tab type="user" title="UpdateSharedPrecisionPreserved" url="@ref openvino_docs_IE_DG_lpt_UpdateSharedPrecisionPreserved"/>
+                        <tab type="user" title="Step 2. Markup transformations" url="@ref openvino_docs_OV_UG_lpt_step2_markup">
+                            <tab type="user" title="AlignQuantizationIntervals" url="@ref openvino_docs_OV_UG_lpt_AlignQuantizationIntervals"/>
+                            <tab type="user" title="AlignQuantizationParameters" url="@ref openvino_docs_OV_UG_lpt_AlignQuantizationParameters"/>
+                            <tab type="user" title="CreateAttribute" url="@ref openvino_docs_OV_UG_lpt_CreateAttribute"/>
+                            <tab type="user" title="CreatePrecisionsDependentAttribute" url="@ref openvino_docs_OV_UG_lpt_CreatePrecisionsDependentAttribute"/>
+                            <tab type="user" title="MarkupAvgPoolPrecisionPreserved" url="@ref openvino_docs_OV_UG_lpt_MarkupAvgPoolPrecisionPreserved"/>
+                            <tab type="user" title="MarkupCanBeQuantized" url="@ref openvino_docs_OV_UG_lpt_MarkupCanBeQuantized"/>
+                            <tab type="user" title="MarkupPerTensorQuantization" url="@ref openvino_docs_OV_UG_lpt_MarkupPerTensorQuantization"/>
+                            <tab type="user" title="MarkupPrecisions" url="@ref openvino_docs_OV_UG_lpt_MarkupPrecisions"/>
+                            <tab type="user" title="PropagatePrecisions" url="@ref openvino_docs_OV_UG_lpt_PropagatePrecisions"/>
+                            <tab type="user" title="PropagateThroughPrecisionPreserved" url="@ref openvino_docs_OV_UG_lpt_PropagateThroughPrecisionPreserved"/>
+                            <tab type="user" title="PropagateToInput" url="@ref openvino_docs_OV_UG_lpt_PropagateToInput"/>
+                            <tab type="user" title="UpdateSharedPrecisionPreserved" url="@ref openvino_docs_OV_UG_lpt_UpdateSharedPrecisionPreserved"/>
                         </tab>
-                        <tab type="user" title="Step 3. Main transformations" url="@ref openvino_docs_IE_DG_lpt_step3_main">
-                            <tab type="user" title="AddTransformation" url="@ref openvino_docs_IE_DG_lpt_AddTransformation"/>
-                            <tab type="user" title="AvgPoolTransformation" url="@ref openvino_docs_IE_DG_lpt_AvgPoolTransformation"/>
-                            <tab type="user" title="ClampTransformation" url="@ref openvino_docs_IE_DG_lpt_ClampTransformation"/>
-                            <tab type="user" title="ConcatTransformation" url="@ref openvino_docs_IE_DG_lpt_ConcatTransformation"/>
-                            <tab type="user" title="ConvolutionTransformation" url="@ref openvino_docs_IE_DG_lpt_ConvolutionTransformation"/>
-                            <tab type="user" title="ConvolutionBackpropDataTransformation" url="@ref openvino_docs_IE_DG_lpt_ConvolutionBackpropDataTransformation"/>
-                            <tab type="user" title="DepthToSpaceTransformation" url="@ref openvino_docs_IE_DG_lpt_DepthToSpaceTransformation"/>
-                            <tab type="user" title="FakeQuantizeDecompositionTransformation" url="@ref openvino_docs_IE_DG_lpt_FakeQuantizeDecompositionTransformation"/>
-                            <tab type="user" title="FakeQuantizeTransformation" url="@ref openvino_docs_IE_DG_lpt_FakeQuantizeTransformation"/>
-                            <tab type="user" title="InterpolateTransformation" url="@ref openvino_docs_IE_DG_lpt_InterpolateTransformation"/>
-                            <tab type="user" title="GroupConvolutionTransformation" url="@ref openvino_docs_IE_DG_lpt_GroupConvolutionTransformation"/>
-                            <tab type="user" title="MatMulTransformation" url="@ref openvino_docs_IE_DG_lpt_MatMulTransformation"/>
-                            <tab type="user" title="MaxPoolTransformation" url="@ref openvino_docs_IE_DG_lpt_MaxPoolTransformation"/>
-                            <tab type="user" title="MultiplyTransformation" url="@ref openvino_docs_IE_DG_lpt_MultiplyTransformation"/>
-                            <tab type="user" title="MVNTransformation" url="@ref openvino_docs_IE_DG_lpt_MVNTransformation"/>
-                            <tab type="user" title="NormalizeL2Transformation" url="@ref openvino_docs_IE_DG_lpt_NormalizeL2Transformation"/>
-                            <tab type="user" title="PadTransformation" url="@ref openvino_docs_IE_DG_lpt_PadTransformation"/>
-                            <tab type="user" title="PReluTransformation" url="@ref openvino_docs_IE_DG_lpt_PReluTransformation"/>
-                            <tab type="user" title="ReduceMaxTransformation" url="@ref openvino_docs_IE_DG_lpt_ReduceMaxTransformation"/>
-                            <tab type="user" title="ReduceMeanTransformation" url="@ref openvino_docs_IE_DG_lpt_ReduceMeanTransformation"/>
-                            <tab type="user" title="ReduceMinTransformation" url="@ref openvino_docs_IE_DG_lpt_ReduceMinTransformation"/>
-                            <tab type="user" title="ReduceSumTransformation" url="@ref openvino_docs_IE_DG_lpt_ReduceSumTransformation"/>
-                            <tab type="user" title="ReluTransformation" url="@ref openvino_docs_IE_DG_lpt_ReluTransformation"/>
-                            <tab type="user" title="ReshapeTransformation" url="@ref openvino_docs_IE_DG_lpt_ReshapeTransformation"/>
-                            <tab type="user" title="SqueezeTransformation" url="@ref openvino_docs_IE_DG_lpt_SqueezeTransformation"/>
-                            <tab type="user" title="ShuffleChannelsTransformation" url="@ref openvino_docs_IE_DG_lpt_ShuffleChannelsTransformation"/>
-                            <tab type="user" title="SplitTransformation" url="@ref openvino_docs_IE_DG_lpt_SplitTransformation"/>
-                            <tab type="user" title="StridedSliceTransformation" url="@ref openvino_docs_IE_DG_lpt_StridedSliceTransformation"/>
-                            <tab type="user" title="TransposeTransformation" url="@ref openvino_docs_IE_DG_lpt_TransposeTransformation"/>
-                            <tab type="user" title="UnsqueezeTransformation" url="@ref openvino_docs_IE_DG_lpt_UnsqueezeTransformation"/>
-                            <tab type="user" title="VariadicSplitTransformation" url="@ref openvino_docs_IE_DG_lpt_VariadicSplitTransformation"/>
+                        <tab type="user" title="Step 3. Main transformations" url="@ref openvino_docs_OV_UG_lpt_step3_main">
+                            <tab type="user" title="AddTransformation" url="@ref openvino_docs_OV_UG_lpt_AddTransformation"/>
+                            <tab type="user" title="AvgPoolTransformation" url="@ref openvino_docs_OV_UG_lpt_AvgPoolTransformation"/>
+                            <tab type="user" title="ClampTransformation" url="@ref openvino_docs_OV_UG_lpt_ClampTransformation"/>
+                            <tab type="user" title="ConcatTransformation" url="@ref openvino_docs_OV_UG_lpt_ConcatTransformation"/>
+                            <tab type="user" title="ConvolutionTransformation" url="@ref openvino_docs_OV_UG_lpt_ConvolutionTransformation"/>
+                            <tab type="user" title="ConvolutionBackpropDataTransformation" url="@ref openvino_docs_OV_UG_lpt_ConvolutionBackpropDataTransformation"/>
+                            <tab type="user" title="DepthToSpaceTransformation" url="@ref openvino_docs_OV_UG_lpt_DepthToSpaceTransformation"/>
+                            <tab type="user" title="FakeQuantizeDecompositionTransformation" url="@ref openvino_docs_OV_UG_lpt_FakeQuantizeDecompositionTransformation"/>
+                            <tab type="user" title="FakeQuantizeTransformation" url="@ref openvino_docs_OV_UG_lpt_FakeQuantizeTransformation"/>
+                            <tab type="user" title="InterpolateTransformation" url="@ref openvino_docs_OV_UG_lpt_InterpolateTransformation"/>
+                            <tab type="user" title="GroupConvolutionTransformation" url="@ref openvino_docs_OV_UG_lpt_GroupConvolutionTransformation"/>
+                            <tab type="user" title="MatMulTransformation" url="@ref openvino_docs_OV_UG_lpt_MatMulTransformation"/>
+                            <tab type="user" title="MaxPoolTransformation" url="@ref openvino_docs_OV_UG_lpt_MaxPoolTransformation"/>
+                            <tab type="user" title="MultiplyTransformation" url="@ref openvino_docs_OV_UG_lpt_MultiplyTransformation"/>
+                            <tab type="user" title="MVNTransformation" url="@ref openvino_docs_OV_UG_lpt_MVNTransformation"/>
+                            <tab type="user" title="NormalizeL2Transformation" url="@ref openvino_docs_OV_UG_lpt_NormalizeL2Transformation"/>
+                            <tab type="user" title="PadTransformation" url="@ref openvino_docs_OV_UG_lpt_PadTransformation"/>
+                            <tab type="user" title="PReluTransformation" url="@ref openvino_docs_OV_UG_lpt_PReluTransformation"/>
+                            <tab type="user" title="ReduceMaxTransformation" url="@ref openvino_docs_OV_UG_lpt_ReduceMaxTransformation"/>
+                            <tab type="user" title="ReduceMeanTransformation" url="@ref openvino_docs_OV_UG_lpt_ReduceMeanTransformation"/>
+                            <tab type="user" title="ReduceMinTransformation" url="@ref openvino_docs_OV_UG_lpt_ReduceMinTransformation"/>
+                            <tab type="user" title="ReduceSumTransformation" url="@ref openvino_docs_OV_UG_lpt_ReduceSumTransformation"/>
+                            <tab type="user" title="ReluTransformation" url="@ref openvino_docs_OV_UG_lpt_ReluTransformation"/>
+                            <tab type="user" title="ReshapeTransformation" url="@ref openvino_docs_OV_UG_lpt_ReshapeTransformation"/>
+                            <tab type="user" title="SqueezeTransformation" url="@ref openvino_docs_OV_UG_lpt_SqueezeTransformation"/>
+                            <tab type="user" title="ShuffleChannelsTransformation" url="@ref openvino_docs_OV_UG_lpt_ShuffleChannelsTransformation"/>
+                            <tab type="user" title="SplitTransformation" url="@ref openvino_docs_OV_UG_lpt_SplitTransformation"/>
+                            <tab type="user" title="StridedSliceTransformation" url="@ref openvino_docs_OV_UG_lpt_StridedSliceTransformation"/>
+                            <tab type="user" title="TransposeTransformation" url="@ref openvino_docs_OV_UG_lpt_TransposeTransformation"/>
+                            <tab type="user" title="UnsqueezeTransformation" url="@ref openvino_docs_OV_UG_lpt_UnsqueezeTransformation"/>
+                            <tab type="user" title="VariadicSplitTransformation" url="@ref openvino_docs_OV_UG_lpt_VariadicSplitTransformation"/>
                         </tab>
-                        <tab type="user" title="Step 4. Cleanup transformations" url="@ref openvino_docs_IE_DG_lpt_step4_cleanup">
-                            <tab type="user" title="FoldConvertTransformation" url="@ref openvino_docs_IE_DG_lpt_FoldConvertTransformation"/>
-                            <tab type="user" title="FoldFakeQuantizeTransformation" url="@ref openvino_docs_IE_DG_lpt_FoldFakeQuantizeTransformation"/>
-                            <tab type="user" title="FuseConvertTransformation" url="@ref openvino_docs_IE_DG_lpt_FuseConvertTransformation"/>
-                            <tab type="user" title="FuseMultiplyToFakeQuantizeTransformation" url="@ref openvino_docs_IE_DG_lpt_FuseMultiplyToFakeQuantizeTransformation"/>
-                            <tab type="user" title="FuseSubtractToFakeQuantizeTransformation" url="@ref openvino_docs_IE_DG_lpt_FuseSubtractToFakeQuantizeTransformation"/>
-                            <tab type="user" title="MultiplyToGroupConvolutionTransformation" url="@ref openvino_docs_IE_DG_lpt_MultiplyToGroupConvolutionTransformation"/>
+                        <tab type="user" title="Step 4. Cleanup transformations" url="@ref openvino_docs_OV_UG_lpt_step4_cleanup">
+                            <tab type="user" title="FoldConvertTransformation" url="@ref openvino_docs_OV_UG_lpt_FoldConvertTransformation"/>
+                            <tab type="user" title="FoldFakeQuantizeTransformation" url="@ref openvino_docs_OV_UG_lpt_FoldFakeQuantizeTransformation"/>
+                            <tab type="user" title="FuseConvertTransformation" url="@ref openvino_docs_OV_UG_lpt_FuseConvertTransformation"/>
+                            <tab type="user" title="FuseMultiplyToFakeQuantizeTransformation" url="@ref openvino_docs_OV_UG_lpt_FuseMultiplyToFakeQuantizeTransformation"/>
+                            <tab type="user" title="FuseSubtractToFakeQuantizeTransformation" url="@ref openvino_docs_OV_UG_lpt_FuseSubtractToFakeQuantizeTransformation"/>
+                            <tab type="user" title="MultiplyToGroupConvolutionTransformation" url="@ref openvino_docs_OV_UG_lpt_MultiplyToGroupConvolutionTransformation"/>
                         </tab>
                     </tab>
                 </tab>

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/PluginTransformationPipeline.md

@@ -1,17 +0,0 @@
-# Plugin Transformation Pipeline {#openvino_docs_IE_DG_plugin_transformation_pipeline}
-
-@sphinxdirective
-
-.. toctree::
-   :maxdepth: 1
-   :caption: Executable Network
-   :hidden:
-
-   Low Precision Transformations <openvino_docs_IE_DG_lpt>
-
-@endsphinxdirective
-
-Typical plugin transformation pipeline includes steps:
-  1. Common transformations
-  2. [Low precision transformations](@ref openvino_docs_IE_DG_lpt)
-  3. Plugin specific transformations

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/attributes/avg_pool_precision_preserved.md

@@ -1,4 +1,4 @@
-# AvgPoolPrecisionPreserved attribute {#openvino_docs_IE_DG_lpt_AvgPoolPrecisionPreserved}
+# AvgPoolPrecisionPreserved attribute {#openvino_docs_OV_UG_lpt_AvgPoolPrecisionPreserved}
 
 ngraph::AvgPoolPrecisionPreservedAttribute class represents the `AvgPoolPrecisionPreserved` attribute.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/attributes/intervals_alignment.md

@@ -1,4 +1,4 @@
-# IntervalsAlignment attribute {#openvino_docs_IE_DG_lpt_IntervalsAlignment}
+# IntervalsAlignment attribute {#openvino_docs_OV_UG_lpt_IntervalsAlignment}
 
 ngraph::IntervalsAlignmentAttribute class represents the `IntervalsAlignment` attribute.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/attributes/per_tensor_quantization.md

@@ -1,11 +0,0 @@
-# PerTensorQuantization attribute {#openvino_docs_IE_DG_lpt_PerTensorQuantization}
-
-ngraph::PerTensorQuantizationAttribute class represents the `PerTensorQuantization` attribute.
-
-The attribute defines if the operation input port requires per-tensor quantization.
-
-| Property name | Values                                       |
-|---------------|----------------------------------------------|
-| Required      | Yes                                          |
-| Defined       | Operation, input ports                        |
-| Properties    |                                              |

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/attributes/precision_preserved.md

@@ -1,4 +1,4 @@
-# PrecisionPreserved attribute {#openvino_docs_IE_DG_lpt_PrecisionPreserved}
+# PrecisionPreserved attribute {#openvino_docs_OV_UG_lpt_PrecisionPreserved}
 
 ngraph::PrecisionPreservedAttribute class represents the `PrecisionPreserved` attribute.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/attributes/precisions.md

@@ -1,4 +1,4 @@
-# Precisions attribute {#openvino_docs_IE_DG_lpt_Precisions}
+# Precisions attribute {#openvino_docs_OV_UG_lpt_Precisions}
 
 ngraph::PrecisionsAttribute class represents the `Precisions` attribute.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/attributes/quantization_alignment.md

@@ -1,4 +1,4 @@
-# QuantizationAlignment attribute {#openvino_docs_IE_DG_lpt_QuantizationAlignment}
+# QuantizationAlignment attribute {#openvino_docs_OV_UG_lpt_QuantizationAlignment}
 
 ngraph::QuantizationAlignmentAttribute class represents the `QuantizationAlignment` attribute.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/attributes/quantization_granularity.md

@@ -0,0 +1,11 @@
+# QuantizationGranularity attribute {#openvino_docs_OV_UG_lpt_QuantizationGranularity}
+
+ngraph::QuantizationAttribute class represents the `QuantizationGranularity` attribute.
+
+The attribute defines quantization granularity of operation inputs.
+
+| Property name | Values                                       |
+|---------------|----------------------------------------------|
+| Required      | No                                           |
+| Defined       | Input ports                                  |
+| Properties    | Quantization granularity                     |

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/lpt.md

@@ -1,4 +1,4 @@
-# OpenVINO™ Low Precision Transformations {#openvino_docs_IE_DG_lpt}
+# OpenVINO™ Low Precision Transformations {#openvino_docs_OV_UG_lpt}
 
 @sphinxdirective
 
@@ -7,13 +7,13 @@
    :caption: Low Precision Transformations
    :hidden:
 
-   Low Precision Transformations <openvino_docs_IE_DG_lpt>
+   Low Precision Transformations <openvino_docs_OV_UG_lpt>
 
-   Attributes <openvino_docs_IE_DG_lpt_attributes>
-   Step 1. Prerequisites transformations <openvino_docs_IE_DG_lpt_step1_prerequisites>
-   Step 2. Markup transformations <openvino_docs_IE_DG_lpt_step2_markup>
-   Step 3. Main transformations <openvino_docs_IE_DG_lpt_step3_main>
-   Step 4. Cleanup transformations <openvino_docs_IE_DG_lpt_step4_cleanup>
+   Attributes <openvino_docs_OV_UG_lpt_attributes>
+   Step 1. Prerequisites transformations <openvino_docs_OV_UG_lpt_step1_prerequisites>
+   Step 2. Markup transformations <openvino_docs_OV_UG_lpt_step2_markup>
+   Step 3. Main transformations <openvino_docs_OV_UG_lpt_step3_main>
+   Step 4. Cleanup transformations <openvino_docs_OV_UG_lpt_step4_cleanup>
 
 @endsphinxdirective
 
@@ -72,11 +72,7 @@ For example, if you would like to infer a model with `Convolution` operation in
 > There are several supported quantization approaches on activations and on weights. All supported approaches are described in [Quantization approaches](#quantization-approaches) section below. In demonstrated model [FakeQuantize operation quantization](#fakequantize-operation) approach is used.
 
 ### Low precision tools
-There are two tools to quantize a model:
-1. [Post-Training Optimization Toolkit](@ref pot_docs_LowPrecisionOptimizationGuide) (POT)
-2. [Neural Network Compression Framework](https://github.com/openvinotoolkit/nncf) (NNCF)
-
-Additionally, low precision transformations can handle ONNX quantized models.
+For more details on how to get a quantized model, refer to [Model Optimization](@ref openvino_docs_model_optimization_guide) document.
 
 ## Quantization approaches
 LPT transformations support two quantization approaches:
@@ -115,63 +111,63 @@ Inside each step LPT transformations handle input model operation by operation,
 As result, usually all operations are inferred by plugin in low precision. If plugin doesn't support an operation inference in low precision, then corresponding LPT transformation can be disabled, and input tensor precisions for the operation will not be changed. In this case the operation is inferred in the original precision. 
 
 Low precision transformations pipeline includes four steps:
-* [Step #1: Prerequisites](@ref openvino_docs_IE_DG_lpt_step1_prerequisites)
-* [Step #2: Markup transformations](@ref openvino_docs_IE_DG_lpt_step2_markup)
-* [Step #3: Main transformations](@ref openvino_docs_IE_DG_lpt_step3_main)
-* [Step #4: Cleanup transformations](@ref openvino_docs_IE_DG_lpt_step4_cleanup)
+* [Step #1: Prerequisites](@ref openvino_docs_OV_UG_lpt_step1_prerequisites)
+* [Step #2: Markup transformations](@ref openvino_docs_OV_UG_lpt_step2_markup)
+* [Step #3: Main transformations](@ref openvino_docs_OV_UG_lpt_step3_main)
+* [Step #4: Cleanup transformations](@ref openvino_docs_OV_UG_lpt_step4_cleanup)
 
 ### Step 1. Prerequisites
 This step fuses and propagates some operations in the model to prepare for the next step. It is required for OpenVINO plugins. Transformations:
-* [PullReshapeThroughDequantization](@ref openvino_docs_IE_DG_lpt_PullReshapeThroughDequantization)
-* [PullTransposeThroughDequantization](@ref openvino_docs_IE_DG_lpt_PullTransposeThroughDequantization)
-* [LinOpSequenceFusion](@ref openvino_docs_IE_DG_lpt_LinOpSequenceFusion)
+* [PullReshapeThroughDequantization](@ref openvino_docs_OV_UG_lpt_PullReshapeThroughDequantization)
+* [PullTransposeThroughDequantization](@ref openvino_docs_OV_UG_lpt_PullTransposeThroughDequantization)
+* [LinOpSequenceFusion](@ref openvino_docs_OV_UG_lpt_LinOpSequenceFusion)
 
-The model on this step is changed. There are more details in developer guide [Prerequisites transformations](@ref openvino_docs_IE_DG_lpt_step1_prerequisites).
+The model on this step is changed. There are more details in developer guide [Prerequisites transformations](@ref openvino_docs_OV_UG_lpt_step1_prerequisites).
 
 ### Step 2. Markup
 This step creates runtime attributes for operations. These attributes will be used in next step. Transformations:
-* [MarkupCanBeQuantized](@ref openvino_docs_IE_DG_lpt_MarkupCanBeQuantized)
-* [MarkupPrecisions](@ref openvino_docs_IE_DG_lpt_MarkupPrecisions)
-* [MarkupPerTensorQuantization](@ref openvino_docs_IE_DG_lpt_MarkupPerTensorQuantization)
-* [MarkupAvgPoolPrecisionPreserved](@ref openvino_docs_IE_DG_lpt_MarkupAvgPoolPrecisionPreserved)
-* [PropagatePrecisions](@ref openvino_docs_IE_DG_lpt_PropagatePrecisions)
-* [AlignQuantizationIntervals](@ref openvino_docs_IE_DG_lpt_AlignQuantizationIntervals)
-* [AlignQuantizationParameters](@ref openvino_docs_IE_DG_lpt_AlignQuantizationParameters)
+* [MarkupCanBeQuantized](@ref openvino_docs_OV_UG_lpt_MarkupCanBeQuantized)
+* [MarkupPrecisions](@ref openvino_docs_OV_UG_lpt_MarkupPrecisions)
+* [MarkupPerTensorQuantization](@ref openvino_docs_OV_UG_lpt_MarkupPerTensorQuantization)
+* [MarkupAvgPoolPrecisionPreserved](@ref openvino_docs_OV_UG_lpt_MarkupAvgPoolPrecisionPreserved)
+* [PropagatePrecisions](@ref openvino_docs_OV_UG_lpt_PropagatePrecisions)
+* [AlignQuantizationIntervals](@ref openvino_docs_OV_UG_lpt_AlignQuantizationIntervals)
+* [AlignQuantizationParameters](@ref openvino_docs_OV_UG_lpt_AlignQuantizationParameters)
 
-The model on this step is changed: only new attributes are added to some operations. There are more details in developer guide [Markup transformations](@ref openvino_docs_IE_DG_lpt_step2_markup).
+The model on this step is changed: only new attributes are added to some operations. There are more details in developer guide [Markup transformations](@ref openvino_docs_OV_UG_lpt_step2_markup).
 
 ### Step 3. Main transformations, FakeQuantize decomposition and dequantization operations handling
-This step has the most transformations. These transformations can be separated in two groups: decomposition transformation and dequantization operations handling. There are more details in developer guide [Main transformations](@ref openvino_docs_IE_DG_lpt_step3_main). Transformations:
-* [AddTransformation](@ref openvino_docs_IE_DG_lpt_AddTransformation)
-* [AvgPoolTransformation](@ref openvino_docs_IE_DG_lpt_AvgPoolTransformation)
-* [ClampTransformation](@ref openvino_docs_IE_DG_lpt_AvgPoolTransformation)
-* [ConcatTransformation](@ref openvino_docs_IE_DG_lpt_ConcatTransformation)
-* [ConvolutionTransformation](@ref openvino_docs_IE_DG_lpt_ConvolutionTransformation)
-* [ConvolutionBackpropDataTransformation](@ref openvino_docs_IE_DG_lpt_ConvolutionBackpropDataTransformation)
-* [DepthToSpaceTransformation](@ref openvino_docs_IE_DG_lpt_DepthToSpaceTransformation)
-* [FakeQuantizeDecompositionTransformation](@ref openvino_docs_IE_DG_lpt_FakeQuantizeDecompositionTransformation)
-* [FakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FakeQuantizeTransformation)
-* [InterpolateTransformation](@ref openvino_docs_IE_DG_lpt_InterpolateTransformation)
-* [GroupConvolutionTransformation](@ref openvino_docs_IE_DG_lpt_GroupConvolutionTransformation)
-* [MatMulTransformation](@ref openvino_docs_IE_DG_lpt_MatMulTransformation)
-* [MaxPoolTransformation](@ref openvino_docs_IE_DG_lpt_MaxPoolTransformation)
-* [MultiplyTransformation](@ref openvino_docs_IE_DG_lpt_MultiplyTransformation)
-* [MVNTransformation](@ref openvino_docs_IE_DG_lpt_MVNTransformation)
-* [NormalizeL2Transformation](@ref openvino_docs_IE_DG_lpt_NormalizeL2Transformation)
-* [PReluTransformation](@ref openvino_docs_IE_DG_lpt_PReluTransformation)
-* [ReduceMaxTransformation](@ref openvino_docs_IE_DG_lpt_ReduceMaxTransformation)
-* [ReduceMeanTransformation](@ref openvino_docs_IE_DG_lpt_ReduceMeanTransformation)
-* [ReduceMinTransformation](@ref openvino_docs_IE_DG_lpt_ReduceMinTransformation)
-* [ReduceSumTransformation](@ref openvino_docs_IE_DG_lpt_ReduceSumTransformation)
-* [ReluTransformation](@ref openvino_docs_IE_DG_lpt_ReluTransformation)
-* [ReshapeTransformation](@ref openvino_docs_IE_DG_lpt_ReshapeTransformation)
-* [SqueezeTransformation](@ref openvino_docs_IE_DG_lpt_SqueezeTransformation)
-* [ShuffleChannelsTransformation](@ref openvino_docs_IE_DG_lpt_ShuffleChannelsTransformation)
-* [SplitTransformation](@ref openvino_docs_IE_DG_lpt_SplitTransformation)
-* [StridedSliceTransformation](@ref openvino_docs_IE_DG_lpt_StridedSliceTransformation)
-* [TransposeTransformation](@ref openvino_docs_IE_DG_lpt_TransposeTransformation)
-* [UnsqueezeTransformation](@ref openvino_docs_IE_DG_lpt_UnsqueezeTransformation)
-* [VariadicSplitTransformation](@ref openvino_docs_IE_DG_lpt_VariadicSplitTransformation)
+This step has the most transformations. These transformations can be separated in two groups: decomposition transformation and dequantization operations handling. There are more details in developer guide [Main transformations](@ref openvino_docs_OV_UG_lpt_step3_main). Transformations:
+* [AddTransformation](@ref openvino_docs_OV_UG_lpt_AddTransformation)
+* [AvgPoolTransformation](@ref openvino_docs_OV_UG_lpt_AvgPoolTransformation)
+* [ClampTransformation](@ref openvino_docs_OV_UG_lpt_AvgPoolTransformation)
+* [ConcatTransformation](@ref openvino_docs_OV_UG_lpt_ConcatTransformation)
+* [ConvolutionTransformation](@ref openvino_docs_OV_UG_lpt_ConvolutionTransformation)
+* [ConvolutionBackpropDataTransformation](@ref openvino_docs_OV_UG_lpt_ConvolutionBackpropDataTransformation)
+* [DepthToSpaceTransformation](@ref openvino_docs_OV_UG_lpt_DepthToSpaceTransformation)
+* [FakeQuantizeDecompositionTransformation](@ref openvino_docs_OV_UG_lpt_FakeQuantizeDecompositionTransformation)
+* [FakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FakeQuantizeTransformation)
+* [InterpolateTransformation](@ref openvino_docs_OV_UG_lpt_InterpolateTransformation)
+* [GroupConvolutionTransformation](@ref openvino_docs_OV_UG_lpt_GroupConvolutionTransformation)
+* [MatMulTransformation](@ref openvino_docs_OV_UG_lpt_MatMulTransformation)
+* [MaxPoolTransformation](@ref openvino_docs_OV_UG_lpt_MaxPoolTransformation)
+* [MultiplyTransformation](@ref openvino_docs_OV_UG_lpt_MultiplyTransformation)
+* [MVNTransformation](@ref openvino_docs_OV_UG_lpt_MVNTransformation)
+* [NormalizeL2Transformation](@ref openvino_docs_OV_UG_lpt_NormalizeL2Transformation)
+* [PReluTransformation](@ref openvino_docs_OV_UG_lpt_PReluTransformation)
+* [ReduceMaxTransformation](@ref openvino_docs_OV_UG_lpt_ReduceMaxTransformation)
+* [ReduceMeanTransformation](@ref openvino_docs_OV_UG_lpt_ReduceMeanTransformation)
+* [ReduceMinTransformation](@ref openvino_docs_OV_UG_lpt_ReduceMinTransformation)
+* [ReduceSumTransformation](@ref openvino_docs_OV_UG_lpt_ReduceSumTransformation)
+* [ReluTransformation](@ref openvino_docs_OV_UG_lpt_ReluTransformation)
+* [ReshapeTransformation](@ref openvino_docs_OV_UG_lpt_ReshapeTransformation)
+* [SqueezeTransformation](@ref openvino_docs_OV_UG_lpt_SqueezeTransformation)
+* [ShuffleChannelsTransformation](@ref openvino_docs_OV_UG_lpt_ShuffleChannelsTransformation)
+* [SplitTransformation](@ref openvino_docs_OV_UG_lpt_SplitTransformation)
+* [StridedSliceTransformation](@ref openvino_docs_OV_UG_lpt_StridedSliceTransformation)
+* [TransposeTransformation](@ref openvino_docs_OV_UG_lpt_TransposeTransformation)
+* [UnsqueezeTransformation](@ref openvino_docs_OV_UG_lpt_UnsqueezeTransformation)
+* [VariadicSplitTransformation](@ref openvino_docs_OV_UG_lpt_VariadicSplitTransformation)
 
 #### Decomposition transformations
 Decomposition transformations decompose the `FakeQuantize` operation to: quantize (`FakeQuantize` with low precision output) and dequantization operations (opposite to quantize, with low precision input and the original precision output). For dequantization operations LPT uses three operations: `Convert`, `Subtract` and `Multiply`. Element-wise operations `Subtract` and `Multiply` have constants on the second branches. If dequantization operations are not handled at the end of LPT pipeline, then they will be fused back to the `FakeQuantize`.
@@ -197,14 +193,14 @@ Original `Convolution` operation in FP32 with dequantization operations before:
 
 ### Step 4: Cleanup of the result model
 LPT cleanup transformations is final stage in LPT pipeline. In this step LPT transformations clean up the result model to avoid not handled dequantization operations: fuse dequantization operations if possible (fuse at least `Convert` operations if not) to other model operations to cleanup result model. Transformations:
-* [FoldConvertTransformation](@ref openvino_docs_IE_DG_lpt_FoldConvertTransformation)
-* [FoldFakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FoldFakeQuantizeTransformation)
-* [FuseConvertTransformation](@ref openvino_docs_IE_DG_lpt_FuseConvertTransformation)
-* [FuseMultiplyToFakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FuseMultiplyToFakeQuantizeTransformation)
-* [FuseSubtractToFakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FuseSubtractToFakeQuantizeTransformation)
-* [MultiplyToGroupConvolutionTransformation](@ref openvino_docs_IE_DG_lpt_MultiplyToGroupConvolutionTransformation)
+* [FoldConvertTransformation](@ref openvino_docs_OV_UG_lpt_FoldConvertTransformation)
+* [FoldFakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FoldFakeQuantizeTransformation)
+* [FuseConvertTransformation](@ref openvino_docs_OV_UG_lpt_FuseConvertTransformation)
+* [FuseMultiplyToFakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FuseMultiplyToFakeQuantizeTransformation)
+* [FuseSubtractToFakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FuseSubtractToFakeQuantizeTransformation)
+* [MultiplyToGroupConvolutionTransformation](@ref openvino_docs_OV_UG_lpt_MultiplyToGroupConvolutionTransformation)
 
-There are more details in developer guide [Cleanup transformations](@ref openvino_docs_IE_DG_lpt_step4_cleanup).
+There are more details in developer guide [Cleanup transformations](@ref openvino_docs_OV_UG_lpt_step4_cleanup).
 
 `FakeQuantize` operation with not handled dequantization operations:  
 ![TODO: FakeQuantize operation with dequantization operations before LPT](quantization/img/fq.transformed.png)
@@ -236,11 +232,11 @@ This step is optional. It modifies the nGraph function to a device-specific oper
 
 Let's explore quantized [TensorFlow* implementation of ResNet-50](https://github.com/openvinotoolkit/open_model_zoo/tree/master/models/public/resnet-50-tf) model. Use [Model Downloader](@ref omz_tools_downloader) tool to download the `fp16` model from [OpenVINO™ Toolkit - Open Model Zoo repository](https://github.com/openvinotoolkit/open_model_zoo):
 ```sh
-./downloader.py --name resnet-50-tf --precisions FP16-INT8
+omz_downloader --name resnet-50-tf --precisions FP16-INT8
 ```
 After that you should quantize model by the [Model Quantizer](@ref omz_tools_downloader) tool.
 ```sh
-./quantizer.py --model_dir public/resnet-50-tf --dataset_dir <DATASET_DIR> --precisions=FP16-INT8
+omz_quantizer --model_dir public/resnet-50-tf --dataset_dir <DATASET_DIR> --precisions=FP16-INT8
 ```
 
 ### Inference
@@ -259,7 +255,7 @@ Result model depends on different factors:
 
 
 Information about layer precision is stored in the performance counters that are
-available from the Inference Engine API. For example, the part of performance counters table for quantized [TensorFlow* implementation of ResNet-50](https://github.com/openvinotoolkit/open_model_zoo/tree/master/models/public/resnet-50-tf) model inference on CPU Plugin looks as follows:
+available from the OpenVINO Runtime API. For example, the part of performance counters table for quantized [TensorFlow* implementation of ResNet-50](https://github.com/openvinotoolkit/open_model_zoo/tree/master/models/public/resnet-50-tf) model inference on CPU Plugin looks as follows:
 
 
 | layerName                                                 | execStatus | layerType    | execType             | realTime (ms) | cpuTime (ms) |

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/lpt_attributes.md

@@ -1,4 +1,4 @@
-# Attributes {#openvino_docs_IE_DG_lpt_attributes}
+# Attributes {#openvino_docs_OV_UG_lpt_attributes}
 
 @sphinxdirective
 
@@ -7,30 +7,31 @@
    :caption: Attributes
    :hidden:
 
-   AvgPoolPrecisionPreserved <openvino_docs_IE_DG_lpt_AvgPoolPrecisionPreserved>
-   IntervalsAlignment <openvino_docs_IE_DG_lpt_IntervalsAlignment>
-   PerTensorQuantization <openvino_docs_IE_DG_lpt_PerTensorQuantization>
-   PrecisionPreserved <openvino_docs_IE_DG_lpt_PrecisionPreserved>
-   Precisions <openvino_docs_IE_DG_lpt_Precisions>
-   QuantizationAlignment <openvino_docs_IE_DG_lpt_QuantizationAlignment>
+   AvgPoolPrecisionPreserved <openvino_docs_OV_UG_lpt_AvgPoolPrecisionPreserved>
+   IntervalsAlignment <openvino_docs_OV_UG_lpt_IntervalsAlignment>   
+   PrecisionPreserved <openvino_docs_OV_UG_lpt_PrecisionPreserved>
+   Precisions <openvino_docs_OV_UG_lpt_Precisions>
+   QuantizationAlignment <openvino_docs_OV_UG_lpt_QuantizationAlignment>
+   QuantizationGranularity <openvino_docs_OV_UG_lpt_QuantizationGranularity>
 
 @endsphinxdirective
 
 ## Introduction
 
-| Name                                                                                | Target                 | Required | Mutable |
-|-------------------------------------------------------------------------------------|------------------------|----------|---------|
-| [AvgPoolPrecisionPreserved](@ref openvino_docs_IE_DG_lpt_AvgPoolPrecisionPreserved) | Precision              | No       | Yes     |
-| [IntervalsAlignment](@ref openvino_docs_IE_DG_lpt_IntervalsAlignment)               | Quantization interval  | Yes      | Yes     |
-| [PerTensorQuantization](@ref openvino_docs_IE_DG_lpt_PerTensorQuantization)         | Precision              | Yes      | No      |
-| [PrecisionPreserved](@ref openvino_docs_IE_DG_lpt_PrecisionPreserved)               | Precision              | Yes      | Yes     |
-| [Precisions](@ref openvino_docs_IE_DG_lpt_Precisions)                               | Precision              | Yes      | Yes     |
-| [QuantizationAlignment](@ref openvino_docs_IE_DG_lpt_QuantizationAlignment)         | Quantization alignment | Yes      | Yes     |
+| Name                                                                                | Target                   | Required | Mutable |
+|-------------------------------------------------------------------------------------|--------------------------|----------|---------|
+| [AvgPoolPrecisionPreserved](@ref openvino_docs_OV_UG_lpt_AvgPoolPrecisionPreserved) | Precision                | No       | Yes     |
+| [IntervalsAlignment](@ref openvino_docs_OV_UG_lpt_IntervalsAlignment)               | Quantization interval    | Yes      | Yes     |
+| [PrecisionPreserved](@ref openvino_docs_OV_UG_lpt_PrecisionPreserved)               | Precision                | Yes      | Yes     |
+| [Precisions](@ref openvino_docs_OV_UG_lpt_Precisions)                               | Precision                | Yes      | Yes     |
+| [QuantizationAlignment](@ref openvino_docs_OV_UG_lpt_QuantizationAlignment)         | Quantization granularity | Yes      | Yes     |
+| [QuantizationGranularity](@ref openvino_docs_OV_UG_lpt_QuantizationGranularity)     | Quantization granularity | Yes      | No      |
 
 > `Target` attribute group defines attribute usage during model transformation for the best performance:
 >  - `Precision` - the attribute defines the most optimal output port precision.
 >  - `Quantization interval` - the attribute defines quantization interval.
->  - `Quantization alignment` - the attribute defines quantization alignment: per-channel or per-tensor quantization.
+>  - `Quantization alignment` - the attribute defines quantization granularity in runtime: per-channel or per-tensor quantization.
+>  - `Quantization granularity` - the attribute is set by plugin to define quantization granularity: per-channel or per-tensor quantization.
 >
 > `Required` attribute group defines if attribute usage is required to get an optimal model during transformation:
 >  - `Yes` - the attribute is used by all OpenVINO plugins for low-precision optimization.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/pipeline/step1_prerequisites.md

@@ -1,6 +1,6 @@
-# Step 1. Prerequisites Transformations {#openvino_docs_IE_DG_lpt_step1_prerequisites}
+# Step 1. Prerequisites Transformations {#openvino_docs_OV_UG_lpt_step1_prerequisites}
 
 Prerequisites transformations are optional. The transformations prepare a model before running other low precision transformations. The transformations do not operate with dequantization operations or update precisions. Prerequisites transformations include:
-* [PullReshapeThroughDequantization](@ref openvino_docs_IE_DG_lpt_PullReshapeThroughDequantization)
-* [PullTransposeThroughDequantization](@ref openvino_docs_IE_DG_lpt_PullTransposeThroughDequantization)
-* [LinOpSequenceFusion](@ref openvino_docs_IE_DG_lpt_LinOpSequenceFusion)
+* [PullReshapeThroughDequantization](@ref openvino_docs_OV_UG_lpt_PullReshapeThroughDequantization)
+* [PullTransposeThroughDequantization](@ref openvino_docs_OV_UG_lpt_PullTransposeThroughDequantization)
+* [LinOpSequenceFusion](@ref openvino_docs_OV_UG_lpt_LinOpSequenceFusion)

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/pipeline/step2_markup.md

@@ -1,14 +1,14 @@
-# Step 2. Markup Transformations {#openvino_docs_IE_DG_lpt_step2_markup}
+# Step 2. Markup Transformations {#openvino_docs_OV_UG_lpt_step2_markup}
 
 This step defines the optimal `FakeQuantize` decomposition precisions for the best inference performance via operations markup with runtime attribute instances. Attributes are created for input and output ports and operations. Transformations do not change the operation output port precisions. A model markup low precision logic is decomposed and implemented into the following common markup transformations. The order of transformations is important:
 
-1. [MarkupCanBeQuantized](@ref openvino_docs_IE_DG_lpt_MarkupCanBeQuantized)
-2. [MarkupPrecisions](@ref openvino_docs_IE_DG_lpt_MarkupPrecisions)
-3. [MarkupPerTensorQuantization](@ref openvino_docs_IE_DG_lpt_MarkupPerTensorQuantization)
-4. [MarkupAvgPoolPrecisionPreserved](@ref openvino_docs_IE_DG_lpt_MarkupAvgPoolPrecisionPreserved)
-5. [PropagatePrecisions](@ref openvino_docs_IE_DG_lpt_PropagatePrecisions)
-6. [AlignQuantizationIntervals](@ref openvino_docs_IE_DG_lpt_AlignQuantizationIntervals)
-7. [AlignQuantizationParameters](@ref openvino_docs_IE_DG_lpt_AlignQuantizationParameters)
+1. [MarkupCanBeQuantized](@ref openvino_docs_OV_UG_lpt_MarkupCanBeQuantized)
+2. [MarkupPrecisions](@ref openvino_docs_OV_UG_lpt_MarkupPrecisions)
+3. [MarkupPerTensorQuantization](@ref openvino_docs_OV_UG_lpt_MarkupPerTensorQuantization)
+4. [MarkupAvgPoolPrecisionPreserved](@ref openvino_docs_OV_UG_lpt_MarkupAvgPoolPrecisionPreserved)
+5. [PropagatePrecisions](@ref openvino_docs_OV_UG_lpt_PropagatePrecisions)
+6. [AlignQuantizationIntervals](@ref openvino_docs_OV_UG_lpt_AlignQuantizationIntervals)
+7. [AlignQuantizationParameters](@ref openvino_docs_OV_UG_lpt_AlignQuantizationParameters)
 
 The table of transformations and used attributes:
 
@@ -25,11 +25,11 @@ The table of transformations and used attributes:
 > **Note:** the same type of attribute instances can be created in different transformations. This approach is the result of the transformation single-responsibility principle. For example, `Precision` attribute instances are created in `MarkupCanBeQuantized` and `MarkupPrecisions` transformations, but the reasons for their creation are different
 
 Common markup transformations can be decomposed into simpler utility markup transformations. The order of Markup utility transformations is not important:
-* [CreateAttribute](@ref openvino_docs_IE_DG_lpt_CreateAttribute)
-* [CreatePrecisionsDependentAttribute](@ref openvino_docs_IE_DG_lpt_CreatePrecisionsDependentAttribute)
-* [PropagateThroughPrecisionPreserved](@ref openvino_docs_IE_DG_lpt_PropagateThroughPrecisionPreserved)
-* [PropagateToInput](@ref openvino_docs_IE_DG_lpt_PropagateToInput)
-* [UpdateSharedPrecisionPreserved](@ref openvino_docs_IE_DG_lpt_UpdateSharedPrecisionPreserved)
+* [CreateAttribute](@ref openvino_docs_OV_UG_lpt_CreateAttribute)
+* [CreatePrecisionsDependentAttribute](@ref openvino_docs_OV_UG_lpt_CreatePrecisionsDependentAttribute)
+* [PropagateThroughPrecisionPreserved](@ref openvino_docs_OV_UG_lpt_PropagateThroughPrecisionPreserved)
+* [PropagateToInput](@ref openvino_docs_OV_UG_lpt_PropagateToInput)
+* [UpdateSharedPrecisionPreserved](@ref openvino_docs_OV_UG_lpt_UpdateSharedPrecisionPreserved)
 
 Let's explore all transformations and their relations in detail, using one and the same model:
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/pipeline/step3_main.md

@@ -1,36 +1,36 @@
-# Step 3. Main Transformations {#openvino_docs_IE_DG_lpt_step3_main}
+# Step 3. Main Transformations {#openvino_docs_OV_UG_lpt_step3_main}
 
 Main transformations are the majority of low precision transformations. Transformations operate with dequantization operations. Main transformations include:
-* [AddTransformation](@ref openvino_docs_IE_DG_lpt_AddTransformation)
-* [AvgPoolTransformation](@ref openvino_docs_IE_DG_lpt_AvgPoolTransformation)
-* [ClampTransformation](@ref openvino_docs_IE_DG_lpt_AvgPoolTransformation)
-* [ConcatTransformation](@ref openvino_docs_IE_DG_lpt_ConcatTransformation)
-* [ConvolutionTransformation](@ref openvino_docs_IE_DG_lpt_ConvolutionTransformation)
-* [ConvolutionBackpropDataTransformation](@ref openvino_docs_IE_DG_lpt_ConvolutionBackpropDataTransformation)
-* [DepthToSpaceTransformation](@ref openvino_docs_IE_DG_lpt_DepthToSpaceTransformation)
-* [FakeQuantizeDecompositionTransformation](@ref openvino_docs_IE_DG_lpt_FakeQuantizeDecompositionTransformation)
-* [FakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FakeQuantizeTransformation)
-* [InterpolateTransformation](@ref openvino_docs_IE_DG_lpt_InterpolateTransformation)
-* [GroupConvolutionTransformation](@ref openvino_docs_IE_DG_lpt_GroupConvolutionTransformation)
-* [MatMulTransformation](@ref openvino_docs_IE_DG_lpt_MatMulTransformation)
-* [MaxPoolTransformation](@ref openvino_docs_IE_DG_lpt_MaxPoolTransformation)
-* [MultiplyTransformation](@ref openvino_docs_IE_DG_lpt_MultiplyTransformation)
-* [MVNTransformation](@ref openvino_docs_IE_DG_lpt_MVNTransformation)
-* [NormalizeL2Transformation](@ref openvino_docs_IE_DG_lpt_NormalizeL2Transformation)
-* [PReluTransformation](@ref openvino_docs_IE_DG_lpt_PReluTransformation)
-* [ReduceMaxTransformation](@ref openvino_docs_IE_DG_lpt_ReduceMaxTransformation)
-* [ReduceMeanTransformation](@ref openvino_docs_IE_DG_lpt_ReduceMeanTransformation)
-* [ReduceMinTransformation](@ref openvino_docs_IE_DG_lpt_ReduceMinTransformation)
-* [ReduceSumTransformation](@ref openvino_docs_IE_DG_lpt_ReduceSumTransformation)
-* [ReluTransformation](@ref openvino_docs_IE_DG_lpt_ReluTransformation)
-* [ReshapeTransformation](@ref openvino_docs_IE_DG_lpt_ReshapeTransformation)
-* [SqueezeTransformation](@ref openvino_docs_IE_DG_lpt_SqueezeTransformation)
-* [ShuffleChannelsTransformation](@ref openvino_docs_IE_DG_lpt_ShuffleChannelsTransformation)
-* [SplitTransformation](@ref openvino_docs_IE_DG_lpt_SplitTransformation)
-* [StridedSliceTransformation](@ref openvino_docs_IE_DG_lpt_StridedSliceTransformation)
-* [TransposeTransformation](@ref openvino_docs_IE_DG_lpt_TransposeTransformation)
-* [UnsqueezeTransformation](@ref openvino_docs_IE_DG_lpt_UnsqueezeTransformation)
-* [VariadicSplitTransformation](@ref openvino_docs_IE_DG_lpt_VariadicSplitTransformation)
+* [AddTransformation](@ref openvino_docs_OV_UG_lpt_AddTransformation)
+* [AvgPoolTransformation](@ref openvino_docs_OV_UG_lpt_AvgPoolTransformation)
+* [ClampTransformation](@ref openvino_docs_OV_UG_lpt_AvgPoolTransformation)
+* [ConcatTransformation](@ref openvino_docs_OV_UG_lpt_ConcatTransformation)
+* [ConvolutionTransformation](@ref openvino_docs_OV_UG_lpt_ConvolutionTransformation)
+* [ConvolutionBackpropDataTransformation](@ref openvino_docs_OV_UG_lpt_ConvolutionBackpropDataTransformation)
+* [DepthToSpaceTransformation](@ref openvino_docs_OV_UG_lpt_DepthToSpaceTransformation)
+* [FakeQuantizeDecompositionTransformation](@ref openvino_docs_OV_UG_lpt_FakeQuantizeDecompositionTransformation)
+* [FakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FakeQuantizeTransformation)
+* [InterpolateTransformation](@ref openvino_docs_OV_UG_lpt_InterpolateTransformation)
+* [GroupConvolutionTransformation](@ref openvino_docs_OV_UG_lpt_GroupConvolutionTransformation)
+* [MatMulTransformation](@ref openvino_docs_OV_UG_lpt_MatMulTransformation)
+* [MaxPoolTransformation](@ref openvino_docs_OV_UG_lpt_MaxPoolTransformation)
+* [MultiplyTransformation](@ref openvino_docs_OV_UG_lpt_MultiplyTransformation)
+* [MVNTransformation](@ref openvino_docs_OV_UG_lpt_MVNTransformation)
+* [NormalizeL2Transformation](@ref openvino_docs_OV_UG_lpt_NormalizeL2Transformation)
+* [PReluTransformation](@ref openvino_docs_OV_UG_lpt_PReluTransformation)
+* [ReduceMaxTransformation](@ref openvino_docs_OV_UG_lpt_ReduceMaxTransformation)
+* [ReduceMeanTransformation](@ref openvino_docs_OV_UG_lpt_ReduceMeanTransformation)
+* [ReduceMinTransformation](@ref openvino_docs_OV_UG_lpt_ReduceMinTransformation)
+* [ReduceSumTransformation](@ref openvino_docs_OV_UG_lpt_ReduceSumTransformation)
+* [ReluTransformation](@ref openvino_docs_OV_UG_lpt_ReluTransformation)
+* [ReshapeTransformation](@ref openvino_docs_OV_UG_lpt_ReshapeTransformation)
+* [SqueezeTransformation](@ref openvino_docs_OV_UG_lpt_SqueezeTransformation)
+* [ShuffleChannelsTransformation](@ref openvino_docs_OV_UG_lpt_ShuffleChannelsTransformation)
+* [SplitTransformation](@ref openvino_docs_OV_UG_lpt_SplitTransformation)
+* [StridedSliceTransformation](@ref openvino_docs_OV_UG_lpt_StridedSliceTransformation)
+* [TransposeTransformation](@ref openvino_docs_OV_UG_lpt_TransposeTransformation)
+* [UnsqueezeTransformation](@ref openvino_docs_OV_UG_lpt_UnsqueezeTransformation)
+* [VariadicSplitTransformation](@ref openvino_docs_OV_UG_lpt_VariadicSplitTransformation)
 
 Let's explore some main transformations on the example model. Original model:
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/pipeline/step4_cleanup.md

@@ -1,8 +1,8 @@
-# Step 4. Cleanup Transformations {#openvino_docs_IE_DG_lpt_step4_cleanup}
+# Step 4. Cleanup Transformations {#openvino_docs_OV_UG_lpt_step4_cleanup}
 
-* [FoldConvertTransformation](@ref openvino_docs_IE_DG_lpt_FoldConvertTransformation)
-* [FoldFakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FoldFakeQuantizeTransformation)
-* [FuseConvertTransformation](@ref openvino_docs_IE_DG_lpt_FuseConvertTransformation)
-* [FuseMultiplyToFakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FuseMultiplyToFakeQuantizeTransformation)
-* [FuseSubtractToFakeQuantizeTransformation](@ref openvino_docs_IE_DG_lpt_FuseSubtractToFakeQuantizeTransformation)
-* [MultiplyToGroupConvolutionTransformation](@ref openvino_docs_IE_DG_lpt_MultiplyToGroupConvolutionTransformation)
+* [FoldConvertTransformation](@ref openvino_docs_OV_UG_lpt_FoldConvertTransformation)
+* [FoldFakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FoldFakeQuantizeTransformation)
+* [FuseConvertTransformation](@ref openvino_docs_OV_UG_lpt_FuseConvertTransformation)
+* [FuseMultiplyToFakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FuseMultiplyToFakeQuantizeTransformation)
+* [FuseSubtractToFakeQuantizeTransformation](@ref openvino_docs_OV_UG_lpt_FuseSubtractToFakeQuantizeTransformation)
+* [MultiplyToGroupConvolutionTransformation](@ref openvino_docs_OV_UG_lpt_MultiplyToGroupConvolutionTransformation)

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step1_prerequisites/convert_subtract_constant.md

@@ -1,3 +1,3 @@
-# ConvertSubtractConstant transformation {#openvino_docs_IE_DG_lpt_ConvertSubtractConstant}
+# ConvertSubtractConstant transformation {#openvino_docs_OV_UG_lpt_ConvertSubtractConstant}
 
 ngraph::pass::low_precision::ConvertSubtractConstant class represents the `ConvertSubtractConstant` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step1_prerequisites/lin_op_sequence_fusion.md

@@ -1,4 +1,4 @@
-# LinOpSequenceFusion transformation {#openvino_docs_IE_DG_lpt_LinOpSequenceFusion}
+# LinOpSequenceFusion transformation {#openvino_docs_OV_UG_lpt_LinOpSequenceFusion}
 
 ngraph::pass::LinOpSequenceFusion class represents the `LinOpSequenceFusion` transformation.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step1_prerequisites/pull_reshape_through_dequantization.md

@@ -1,3 +1,3 @@
-# PullReshapeThroughDequantization transformation {#openvino_docs_IE_DG_lpt_PullReshapeThroughDequantization}
+# PullReshapeThroughDequantization transformation {#openvino_docs_OV_UG_lpt_PullReshapeThroughDequantization}
 
 ngraph::pass::low_precision::PullReshapeThroughDequantization class represents the `PullReshapeThroughDequantization` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step1_prerequisites/pull_transpose_through_dequantization.md

@@ -1,3 +1,3 @@
-# PullTransposeThroughDequantization transformation {#openvino_docs_IE_DG_lpt_PullTransposeThroughDequantization}
+# PullTransposeThroughDequantization transformation {#openvino_docs_OV_UG_lpt_PullTransposeThroughDequantization}
 
 ngraph::pass::low_precision::PullTransposeThroughDequantization class represents the `PullTransposeThroughDequantization` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/align_quantization_intervals.md

@@ -1,3 +1,3 @@
-# AlignQuantizationIntervals transformation {#openvino_docs_IE_DG_lpt_AlignQuantizationIntervals}
+# AlignQuantizationIntervals transformation {#openvino_docs_OV_UG_lpt_AlignQuantizationIntervals}
 
 ngraph::pass::low_precision::AlignQuantizationIntervals class represents the `AlignQuantizationIntervals` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/align_quantization_parameters.md

@@ -1,3 +1,3 @@
-# AlignQuantizationParameters transformation {#openvino_docs_IE_DG_lpt_AlignQuantizationParameters}
+# AlignQuantizationParameters transformation {#openvino_docs_OV_UG_lpt_AlignQuantizationParameters}
 
 ngraph::pass::low_precision::AlignQuantizationParameters class represents the `AlignQuantizationParameters` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/create_attribute.md

@@ -1,3 +1,3 @@
-# CreateAttribute transformation {#openvino_docs_IE_DG_lpt_CreateAttribute}
+# CreateAttribute transformation {#openvino_docs_OV_UG_lpt_CreateAttribute}
 
 ngraph::pass::low_precision::CreateAttribute class represents the `CreateAttribute` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/create_precisions_dependent_attribute.md

@@ -1,3 +1,3 @@
-# CreatePrecisionsDependentAttribute transformation {#openvino_docs_IE_DG_lpt_CreatePrecisionsDependentAttribute}
+# CreatePrecisionsDependentAttribute transformation {#openvino_docs_OV_UG_lpt_CreatePrecisionsDependentAttribute}
 
 ngraph::pass::low_precision::CreatePrecisionsDependentAttribute class represents the `CreatePrecisionsDependentAttribute` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/markup_avg_pool_precision_preserved.md

@@ -1,3 +1,3 @@
-# MarkupAvgPoolPrecisionPreserved transformation {#openvino_docs_IE_DG_lpt_MarkupAvgPoolPrecisionPreserved}
+# MarkupAvgPoolPrecisionPreserved transformation {#openvino_docs_OV_UG_lpt_MarkupAvgPoolPrecisionPreserved}
 
 ngraph::pass::low_precision::MarkupAvgPoolPrecisionPreserved class represents the `MarkupAvgPoolPrecisionPreserved` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/markup_can_be_quantized.md

@@ -1,3 +1,3 @@
-# MarkupCanBeQuantized transformation {#openvino_docs_IE_DG_lpt_MarkupCanBeQuantized}
+# MarkupCanBeQuantized transformation {#openvino_docs_OV_UG_lpt_MarkupCanBeQuantized}
 
 ngraph::pass::low_precision::MarkupCanBeQuantized class represents the `MarkupCanBeQuantized` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/markup_per_tensor_quantization.md

@@ -1,3 +1,3 @@
-# MarkupPerTensorQuantization transformation {#openvino_docs_IE_DG_lpt_MarkupPerTensorQuantization}
+# MarkupPerTensorQuantization transformation {#openvino_docs_OV_UG_lpt_MarkupPerTensorQuantization}
 
 ngraph::pass::low_precision::MarkupPerTensorQuantization class represents the `MarkupPerTensorQuantization` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/markup_precisions.md

@@ -1,3 +1,3 @@
-# MarkupPrecisions transformation {#openvino_docs_IE_DG_lpt_MarkupPrecisions}
+# MarkupPrecisions transformation {#openvino_docs_OV_UG_lpt_MarkupPrecisions}
 
 ngraph::pass::low_precision::MarkupPrecisions class represents the `MarkupPrecisions` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/propagate_precisions.md

@@ -1,3 +1,3 @@
-# PropagatePrecisions transformation {#openvino_docs_IE_DG_lpt_PropagatePrecisions}
+# PropagatePrecisions transformation {#openvino_docs_OV_UG_lpt_PropagatePrecisions}
 
 ngraph::pass::low_precision::PropagatePrecisions class represents the `PropagatePrecisions` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/propagate_shared_value.md

@@ -1,3 +1,3 @@
-# PropagateSharedValue transformation {#openvino_docs_IE_DG_lpt_PropagateSharedValue}
+# PropagateSharedValue transformation {#openvino_docs_OV_UG_lpt_PropagateSharedValue}
 
 ngraph::pass::low_precision::PropagateSharedValue class represents the `PropagateSharedValue` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/propagate_through_precision_preserved.md

@@ -1,3 +1,3 @@
-# PropagateThroughPrecisionPreserved transformation {#openvino_docs_IE_DG_lpt_PropagateThroughPrecisionPreserved}
+# PropagateThroughPrecisionPreserved transformation {#openvino_docs_OV_UG_lpt_PropagateThroughPrecisionPreserved}
 
 ngraph::pass::low_precision::PropagateThroughPrecisionPreserved class represents the `PropagateThroughPrecisionPreserved` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/propagate_to_input.md

@@ -1,3 +1,3 @@
-# PropagateToInput transformation {#openvino_docs_IE_DG_lpt_PropagateToInput}
+# PropagateToInput transformation {#openvino_docs_OV_UG_lpt_PropagateToInput}
 
 ngraph::pass::low_precision::PropagateToInput class represents the `PropagateToInput` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step2_markup/update_shared_precision_preserved.md

@@ -1,3 +1,3 @@
-# UpdateSharedPrecisionPreserved transformation {#openvino_docs_IE_DG_lpt_UpdateSharedPrecisionPreserved}
+# UpdateSharedPrecisionPreserved transformation {#openvino_docs_OV_UG_lpt_UpdateSharedPrecisionPreserved}
 
 ngraph::pass::low_precision::UpdateSharedPrecisionPreserved class represents the `UpdateSharedPrecisionPreserved` transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/activation/clamp.md

@@ -1,3 +1,3 @@
-# ClampTransformation transformation {#openvino_docs_IE_DG_lpt_ClampTransformation}
+# ClampTransformation transformation {#openvino_docs_OV_UG_lpt_ClampTransformation}
 
 ngraph::pass::low_precision::ClampTransformation class represents the `Clamp` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/activation/prelu.md

@@ -1,3 +1,3 @@
-# PReluTransformation transformation {#openvino_docs_IE_DG_lpt_PReluTransformation}
+# PReluTransformation transformation {#openvino_docs_OV_UG_lpt_PReluTransformation}
 
 ngraph::pass::low_precision::PReluTransformation class represents the `PRelu` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/activation/relu.md

@@ -1,3 +1,3 @@
-# ReluTransformation transformation {#openvino_docs_IE_DG_lpt_ReluTransformation}
+# ReluTransformation transformation {#openvino_docs_OV_UG_lpt_ReluTransformation}
 
 ngraph::pass::low_precision::ReluTransformation class represents the `Relu` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/arithmetic/add.md

@@ -1,4 +1,4 @@
-# AddTransformation transformation {#openvino_docs_IE_DG_lpt_AddTransformation}
+# AddTransformation transformation {#openvino_docs_OV_UG_lpt_AddTransformation}
 
 ngraph::pass::low_precision::AddTransformation class represents the `Add` operation transformation.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/arithmetic/multiply.md

@@ -1,3 +1,3 @@
-# MultiplyTransformation transformation {#openvino_docs_IE_DG_lpt_MultiplyTransformation}
+# MultiplyTransformation transformation {#openvino_docs_OV_UG_lpt_MultiplyTransformation}
 
 ngraph::pass::low_precision::MultiplyTransformation class represents the `Multiply` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/arithmetic/subtract.md

@@ -1,3 +1,3 @@
-# SubtractTransformation transformation {#openvino_docs_IE_DG_lpt_SubtractTransformation}
+# SubtractTransformation transformation {#openvino_docs_OV_UG_lpt_SubtractTransformation}
 
 ngraph::pass::low_precision::SubtractTransformation class represents the `Subtract` operation transformation.

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/convolution/convolution.md

@@ -1,4 +1,4 @@
-# ConvolutionTransformation transformation {#openvino_docs_IE_DG_lpt_ConvolutionTransformation}
+# ConvolutionTransformation transformation {#openvino_docs_OV_UG_lpt_ConvolutionTransformation}
 
 ngraph::pass::low_precision::ConvolutionTransformation class represents the `Convolution` operation transformation.
 

docs/IE_PLUGIN_DG/plugin_transformation_pipeline/low_precision_transformations/transformations/step3_main/convolution/convolution_backprop_data.md

@@ -1,3 +1,3 @@
-# ConvolutionBackpropDataTransformation transformation {#openvino_docs_IE_DG_lpt_ConvolutionBackpropDataTransformation}
+# ConvolutionBackpropDataTransformation transformation {#openvino_docs_OV_UG_lpt_ConvolutionBackpropDataTransformation}
 
 ngraph::pass::low_precision::ConvolutionBackpropDataTransformation class represents the `ConvolutionBackpropData` operation transformation.