Removed confusing ONNX RT EP deprecation note (#2400)

* Added Conda CentOS documentation 2020.4

* Added OS

.ci/azure/linux.yml

@@ -1,161 +0,0 @@
-jobs:
-- job: Lin
-  # About 150% of total time
-  timeoutInMinutes: 90
-
-  pool:
-    name: LIN_VMSS_VENV_F16S_WU2
-
-  variables:
-    system.debug: true
-    VSTS_HTTP_RETRY: 5
-    VSTS_HTTP_TIMEOUT: 200
-    WORKERS_NUMBER: 16
-    BUILD_TYPE: Release
-    REPO_DIR: $(Build.Repository.LocalPath)
-    WORK_DIR: $(Pipeline.Workspace)/_w
-    BUILD_DIR: $(WORK_DIR)/build
-    BIN_DIR: $(REPO_DIR)/bin/intel64/$(BUILD_TYPE)
-
-  steps:
-  - script: |
-      curl -H Metadata:true --noproxy "*" "http://169.254.169.254/metadata/instance?api-version=2019-06-01"
-      whoami
-      uname -a
-      echo Python3 info ; which python3 ; python3 --version
-      echo Python info ; which python ; python --version
-      echo Java info ; which java ; java -version
-      echo gcc info ; which gcc ; gcc --version
-      lsb_release
-      env
-      cat /proc/cpuinfo
-      cat /proc/meminfo
-      cat /etc/fstab
-      vmstat -s
-      df
-      lsblk -o NAME,HCTL,SIZE,MOUNTPOINT | grep -i "sd"
-      free -h
-    displayName: 'System info'
-
-  - script: |
-      rm -rf $(WORK_DIR) ; mkdir $(WORK_DIR)
-      rm -rf $(BUILD_DIR) ; mkdir $(BUILD_DIR)
-    displayName: 'Make dir'
-
-  - checkout: self
-    clean: true
-    lfs: false
-    submodules: recursive
-    path: openvino
-
-  - script: |
-      sudo apt --assume-yes install libusb-1.0-0-dev
-      python3 -m pip install -r $(REPO_DIR)/inference-engine/ie_bridges/python/requirements.txt
-      # For running Python API tests
-      python3 -m pip install -r $(REPO_DIR)/inference-engine/ie_bridges/python/src/requirements-dev.txt
-      # Speed up build
-      wget https://github.com/ninja-build/ninja/releases/download/v1.10.0/ninja-linux.zip
-      unzip ninja-linux.zip
-      sudo cp -v ninja /usr/local/bin/
-      # Speed up tests
-      git clone https://github.com/google/gtest-parallel.git
-    workingDirectory: $(WORK_DIR)
-    displayName: 'Install dependencies'
-
-  - task: CMake@1
-    inputs:
-      # CMake must get Python 3.x version by default
-      cmakeArgs: -GNinja -DVERBOSE_BUILD=ON -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) -DENABLE_PYTHON=ON -DPYTHON_EXECUTABLE=/usr/bin/python3.6 -DENABLE_TESTS=ON $(REPO_DIR)
-      workingDirectory: $(BUILD_DIR)
-
-  - script: ninja
-    workingDirectory: $(BUILD_DIR)
-    displayName: 'Build Lin'
-
-  - script: ls -alR $(REPO_DIR)/bin/
-    displayName: 'List files'
-
-  - script: $(BIN_DIR)/unit-test --gtest_print_time=1 --gtest_filter=-backend_api.config_unsupported:*IE_GPU* --gtest_output=xml:TEST-NGraphUT.xml
-    displayName: 'nGraph UT'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/InferenceEngineUnitTests --gtest_print_time=1 --gtest_output=xml:TEST-InferenceEngineUnitTests.xml
-    displayName: 'IE UT old'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/ieUnitTests --gtest_output=xml:TEST-ieUnitTests.xml
-    displayName: 'IE UT'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/cpuUnitTests --gtest_output=xml:TEST-cpuUnitTests.xml
-    displayName: 'CPU UT'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/gnaUnitTests --gtest_output=xml:TEST-gnaUnitTests.xml
-    displayName: 'GNA UT'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/vpuUnitTests --gtest_output=xml:TEST-vpuUnitTests.xml
-    displayName: 'VPU UT'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/onnxImporterUnitTests --gtest_output=xml:TEST-onnxImporterUnitTests.xml
-    displayName: 'ONNX Importer UT'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/ieFuncTests --gtest_output=xml:TEST-ieFuncTests.xml
-    displayName: 'IE FuncTests'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/cpuFuncTests --gtest_filter=*smoke* --gtest_print_time=1 --gtest_output=xml:TEST-cpuFuncTests.xml
-    displayName: 'CPU FuncTests'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/MklDnnBehaviorTests --gtest_output=xml:TEST-MklDnnBehaviorTests.xml
-    displayName: 'MklDnnBehaviorTests'
-    continueOnError: false
-
-  - script: |
-      git clone https://github.com/openvinotoolkit/testdata.git
-    workingDirectory: $(WORK_DIR)
-    displayName: 'Clone testdata'
-
-  - script: |
-      export DATA_PATH=$(WORK_DIR)/testdata
-      export MODELS_PATH=$(WORK_DIR)/testdata
-      python3 $(WORK_DIR)/gtest-parallel/gtest-parallel $(BIN_DIR)/MklDnnFunctionalTests --workers=$(WORKERS_NUMBER) --dump_json_test_results=MklDnnFunctionalTests.json --gtest_filter=*smoke* -- --gtest_print_time=1
-    workingDirectory: $(WORK_DIR)
-    displayName: 'MklDnnFunctionalTests'
-    continueOnError: false
-
-  - script: |
-      export DATA_PATH=$(WORK_DIR)/testdata
-      export MODELS_PATH=$(WORK_DIR)/testdata
-      $(BIN_DIR)/InferenceEngineCAPITests --gtest_output=xml:TEST-InferenceEngineCAPITests.xml
-    displayName: 'IE CAPITests'
-    continueOnError: false
-
-  - script: |
-      export DATA_PATH=$(WORK_DIR)/testdata
-      export MODELS_PATH=$(WORK_DIR)/testdata
-      export LD_LIBRARY_PATH=$(BIN_DIR)/lib
-      export PYTHONPATH=$(BIN_DIR)/lib/python_api/python3.6
-      env
-      cd $(REPO_DIR)/inference-engine/ie_bridges/python/tests
-      pytest pytest --junitxml=TEST-PythonAPI.xml
-    displayName: 'Python API Tests'
-    continueOnError: false
-    enabled: false
-
-  - task: PublishTestResults@2
-    condition: always()
-    inputs:
-      testResultsFormat: 'JUnit' # Options: JUnit, NUnit, VSTest, xUnit, cTest
-      testResultsFiles: '**/TEST-*.xml'
-      #searchFolder: '$(BUILD_DIR)'
-      mergeTestResults: false # Optional
-      #failTaskOnFailedTests: false # Optional
-      #testRunTitle: 'Pre/Post-Commit' # Optional
-      buildPlatform: 'x64' # Optional
-      buildConfiguration: 'Linux' # Optional
-      #publishRunAttachments: true # Optional

.ci/azure/mac.yml

@@ -1,144 +0,0 @@
-jobs:
-- job: Mac
-  # About 200% of total time (perfomace of Mac hosts is unstable)
-  timeoutInMinutes: 240
-
-  pool:
-    vmImage: 'macOS-10.15'
-
-  variables:
-    system.debug: true
-    VSTS_HTTP_RETRY: 5
-    VSTS_HTTP_TIMEOUT: 200
-    WORKERS_NUMBER: 3
-    BUILD_TYPE: Release
-    REPO_DIR: $(Build.Repository.LocalPath)
-    WORK_DIR: $(Pipeline.Workspace)/_w
-    BUILD_DIR: $(WORK_DIR)/build
-    BIN_DIR: $(REPO_DIR)/bin/intel64/$(BUILD_TYPE)
-
-  steps:
-  - script: |
-      whoami
-      uname -a
-      which python3
-      python3 --version
-      which java
-      java -version
-      gcc --version
-      xcrun --sdk macosx --show-sdk-version
-      env
-      sysctl -a
-    displayName: 'System info'
-
-  - script: |
-      rm -rf $(WORK_DIR) ; mkdir $(WORK_DIR)
-      rm -rf $(BUILD_DIR) ; mkdir $(BUILD_DIR)
-    displayName: 'Make dir'
-
-  - checkout: self
-    clean: true
-    lfs: false
-    submodules: recursive
-    path: openvino
-
-  - task: UsePythonVersion@0
-    inputs:
-      versionSpec: '3.7'
-
-  - script: |
-      brew install cython
-      brew install automake
-      # Speed up build
-      brew install ninja
-      # Speed up tests
-      git clone https://github.com/google/gtest-parallel.git
-    workingDirectory: $(WORK_DIR)
-    displayName: 'Install dependencies'
-
-  - script: |
-      export PATH="/usr/local/opt/cython/bin:$PATH"
-      export CC=gcc
-      export CXX=g++
-      # Disable errors with Ninja
-      export CXXFLAGS="-Wno-error=unused-command-line-argument"
-      export CFLAGS="-Wno-error=unused-command-line-argument"
-      cmake -GNinja -DVERBOSE_BUILD=ON -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) -DENABLE_PYTHON=ON -DENABLE_TESTS=ON $(REPO_DIR)
-    workingDirectory: $(BUILD_DIR)
-    displayName: 'CMake'
-
-  - script: ninja
-    workingDirectory: $(BUILD_DIR)
-    displayName: 'Build Mac'
-
-  - script: ls -alR $(REPO_DIR)/bin/
-    displayName: 'List files'
-
-  - script: $(BIN_DIR)/unit-test --gtest_print_time=1 --gtest_filter=-backend_api.config_unsupported:*IE_GPU*:IE_CPU.onnx_model_sigmoid --gtest_output=xml:TEST-NGraphUT.xml
-    displayName: 'nGraph UT'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/InferenceEngineUnitTests --gtest_print_time=1 --gtest_output=xml:TEST-InferenceEngineUnitTests.xml
-    displayName: 'IE UT old'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/ieUnitTests --gtest_output=xml:TEST-ieUnitTests.xml
-    displayName: 'IE UT'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/cpuUnitTests --gtest_output=xml:TEST-cpuUnitTests.xml
-    displayName: 'CPU UT'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/vpuUnitTests --gtest_output=xml:TEST-vpuUnitTests.xml
-    displayName: 'VPU UT'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/onnxImporterUnitTests --gtest_output=xml:TEST-onnxImporterUnitTests.xml
-    displayName: 'ONNX Importer UT'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/ieFuncTests --gtest_output=xml:TEST-ieFuncTests.xml
-    displayName: 'IE FuncTests'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/cpuFuncTests --gtest_filter=*smoke* --gtest_print_time=1 --gtest_output=xml:TEST-cpuFuncTests.xml
-    displayName: 'CPU FuncTests'
-    continueOnError: false
-
-  - script: $(BIN_DIR)/MklDnnBehaviorTests --gtest_output=xml:TEST-MklDnnBehaviorTests.xml
-    displayName: 'MklDnnBehaviorTests'
-    continueOnError: false
-
-  - script: |
-      git clone --single-branch --branch releases/2021/2 https://github.com/openvinotoolkit/testdata.git
-    workingDirectory: $(WORK_DIR)
-    displayName: 'Clone testdata'
-
-  - script: |
-      export DATA_PATH=$(WORK_DIR)/testdata
-      export MODELS_PATH=$(WORK_DIR)/testdata
-      python3 $(WORK_DIR)/gtest-parallel/gtest-parallel $(BIN_DIR)/MklDnnFunctionalTests --workers=$(WORKERS_NUMBER) --dump_json_test_results=MklDnnFunctionalTests.json --gtest_filter=*smoke*:-smoke_MobileNet/ModelTransformationsTest.LPT/mobilenet_v2_tf_depthwise_batch1_inPluginDisabled_inTestDisabled_asymmetric* -- --gtest_print_time=1
-    workingDirectory: $(WORK_DIR)
-    displayName: 'MklDnnFunctionalTests'
-    continueOnError: false
-
-  - script: |
-      export DATA_PATH=$(WORK_DIR)/testdata
-      export MODELS_PATH=$(WORK_DIR)/testdata
-      $(BIN_DIR)/InferenceEngineCAPITests --gtest_output=xml:TEST-InferenceEngineCAPITests.xml
-    displayName: 'IE CAPITests'
-    continueOnError: false
-
-  - task: PublishTestResults@2
-    condition: always()
-    inputs:
-      testResultsFormat: 'JUnit' # Options: JUnit, NUnit, VSTest, xUnit, cTest
-      testResultsFiles: '**/TEST-*.xml'
-      #searchFolder: '$(BUILD_DIR)'
-      mergeTestResults: false # Optional
-      #failTaskOnFailedTests: false # Optional
-      #testRunTitle: 'Pre/Post-Commit' # Optional
-      buildPlatform: 'x64' # Optional
-      buildConfiguration: 'Mac' # Optional
-      #publishRunAttachments: true # Optional

.ci/azure/windows.yml

@@ -1,174 +0,0 @@
-jobs:
-- job: Win
-  # About 150% of total time
-  timeoutInMinutes: 120
-
-  pool:
-    name: WIN_VMSS_VENV_F8S_WU2
-
-  variables:
-    system.debug: true
-    VSTS_HTTP_RETRY: 5
-    VSTS_HTTP_TIMEOUT: 200
-    WORKERS_NUMBER: 8
-    BUILD_TYPE: Release
-    REPO_DIR: $(Build.Repository.LocalPath)
-    WORK_DIR: $(Pipeline.Workspace)\_w
-    BUILD_DIR: D:\build
-    BIN_DIR: $(REPO_DIR)\bin\intel64
-    MSVS_VARS_PATH: C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat
-    MSVC_COMPILER_PATH: C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Tools\MSVC\14.24.28314\bin\Hostx64\x64\cl.exe
-
-  steps:
-  - script: |
-      powershell -command "Invoke-RestMethod -Headers @{\"Metadata\"=\"true\"} -Method GET -Uri http://169.254.169.254/metadata/instance/compute?api-version=2019-06-01 | format-custom"
-      where python3
-      where python
-      python --version
-      where java
-      java -version
-      wmic computersystem get TotalPhysicalMemory
-      wmic cpu list
-      wmic logicaldisk get description,name
-      wmic VOLUME list
-      set
-    displayName: 'System info'
-
-  - script: |
-      rd /Q /S $(WORK_DIR) & mkdir $(WORK_DIR)
-      rd /Q /S $(BUILD_DIR) & mkdir $(BUILD_DIR)
-    displayName: 'Make dir'
-
-  - checkout: self
-    clean: true
-    lfs: false
-    submodules: recursive
-    path: openvino
-
-  - script: |
-      certutil -urlcache -split -f https://github.com/ninja-build/ninja/releases/download/v1.10.0/ninja-win.zip ninja-win.zip
-      powershell -command "Expand-Archive -Force ninja-win.zip"
-      git clone https://github.com/google/gtest-parallel.git
-    workingDirectory: $(WORK_DIR)
-    displayName: 'Install dependencies'
-
-  - script: |
-      certutil -urlcache -split -f https://incredibuilddiag1wu2.blob.core.windows.net/incredibuild/install_ib_console.bat install_ib_console.bat
-      call install_ib_console.bat
-    workingDirectory: $(WORK_DIR)
-    displayName: 'Install IncrediBuild'
-
-  - script: |
-      set PATH=$(WORK_DIR)\ninja-win;%PATH%
-      call "$(MSVS_VARS_PATH)" && cmake -GNinja -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) -DENABLE_TESTS=ON -DCMAKE_C_COMPILER:PATH="$(MSVC_COMPILER_PATH)" -DCMAKE_CXX_COMPILER:PATH="$(MSVC_COMPILER_PATH)" $(REPO_DIR)
-    workingDirectory: $(BUILD_DIR)
-    displayName: 'CMake'
-
-  - script: |
-      set PATH=$(WORK_DIR)\ninja-win;%PATH%
-      call "$(MSVS_VARS_PATH)" && "C:\Program Files (x86)\IncrediBuild\BuildConsole.exe" /COMMAND="ninja" /MaxCPUS=40
-    workingDirectory: $(BUILD_DIR)
-    displayName: 'Build Win'
-
-  - script: echo Stop IncrediBuild_Agent && net stop IncrediBuild_Agent
-    displayName: Stop IncrediBuild
-    continueOnError: true
-
-  - script: dir $(REPO_DIR)\bin\ /s
-    displayName: 'List files'
-
-  - script: |
-      set PATH=$(REPO_DIR)\inference-engine\temp\tbb\bin;%PATH%
-      $(BIN_DIR)\unit-test --gtest_print_time=1 --gtest_filter=-backend_api.config_unsupported:*IE_GPU* --gtest_output=xml:TEST-NGraphUT.xml
-    displayName: 'nGraph UT'
-    continueOnError: false
-
-  - script: |
-      set PATH=$(REPO_DIR)\inference-engine\temp\tbb\bin;%PATH%
-      $(BIN_DIR)\InferenceEngineUnitTests --gtest_print_time=1 --gtest_output=xml:TEST-InferenceEngineUnitTests.xml
-    displayName: 'IE UT old'
-    continueOnError: false
-
-  - script: |
-      set PATH=$(REPO_DIR)\inference-engine\temp\tbb\bin;%PATH%
-      $(BIN_DIR)\ieUnitTests --gtest_output=xml:TEST-ieUnitTests.xml
-    displayName: 'IE UT'
-    continueOnError: false
-
-  - script: |
-      set PATH=$(REPO_DIR)\inference-engine\temp\tbb\bin;%PATH%
-      $(BIN_DIR)\cpuUnitTests --gtest_output=xml:TEST-cpuUnitTests.xml
-    displayName: 'CPU UT'
-    continueOnError: false
-
-  - script: |
-      set PATH=$(REPO_DIR)\inference-engine\temp\tbb\bin;%PATH%
-      $(BIN_DIR)\gnaUnitTests --gtest_output=xml:TEST-gnaUnitTests.xml
-    displayName: 'GNA UT'
-    continueOnError: false
-
-  - script: |
-      set PATH=$(REPO_DIR)\inference-engine\temp\tbb\bin;%PATH%
-      $(BIN_DIR)\vpuUnitTests --gtest_output=xml:TEST-vpuUnitTests.xml
-    displayName: 'VPU UT'
-    continueOnError: false
-
-  - script: |
-      set PATH=$(REPO_DIR)\inference-engine\temp\tbb\bin;%PATH%
-      $(BIN_DIR)\onnxImporterUnitTests --gtest_output=xml:TEST-onnxImporterUnitTests.xml
-    displayName: 'ONNX Importer UT'
-    continueOnError: false
-
-  - script: |
-      set PATH=$(REPO_DIR)\inference-engine\temp\tbb\bin;%PATH%
-      $(BIN_DIR)\ieFuncTests --gtest_output=xml:TEST-ieFuncTests.xml
-    displayName: 'IE FuncTests'
-    continueOnError: false
-
-  - script: |
-      set PATH=$(REPO_DIR)\inference-engine\temp\tbb\bin;%PATH%
-      $(BIN_DIR)\cpuFuncTests --gtest_filter=*smoke* --gtest_print_time=1 --gtest_output=xml:TEST-cpuFuncTests.xml
-    displayName: 'CPU FuncTests'
-    continueOnError: false
-
-  - script: |
-      set PATH=$(REPO_DIR)\inference-engine\temp\tbb\bin;%PATH%
-      $(BIN_DIR)\MklDnnBehaviorTests  --gtest_output=xml:TEST-MklDnnBehaviorTests.xml
-    displayName: 'MklDnnBehaviorTests'
-    continueOnError: false
-
-  - script: |
-      git clone https://github.com/openvinotoolkit/testdata.git
-    workingDirectory: $(BUILD_DIR)
-    displayName: 'Clone testdata'
-
-    # Add for gtest-parallel, it hangs now (CVS-33386)
-    #python $(BUILD_DIR)\gtest-parallel\gtest-parallel $(BIN_DIR)\MklDnnFunctionalTests --workers=$(WORKERS_NUMBER) --dump_json_test_results=MklDnnFunctionalTests.json --gtest_filter=*smoke* -- --gtest_print_time=1
-  - script: |
-      set PATH=$(REPO_DIR)\inference-engine\temp\tbb\bin;$(REPO_DIR)\inference-engine\temp\opencv_4.5.1\opencv\bin;%PATH%
-      set DATA_PATH=$(BUILD_DIR)\testdata
-      set MODELS_PATH=$(BUILD_DIR)\testdata
-      $(BIN_DIR)\MklDnnFunctionalTests --gtest_filter=*smoke* --gtest_print_time=1 --gtest_output=xml:TEST-MklDnnFunctionalTests.xml
-    displayName: 'MklDnnFunctionalTests'
-    continueOnError: false
-
-  - script: |
-      set PATH=$(REPO_DIR)\inference-engine\temp\tbb\bin;$(REPO_DIR)\inference-engine\temp\opencv_4.5.1\opencv\bin;%PATH%
-      set DATA_PATH=$(BUILD_DIR)\testdata
-      set MODELS_PATH=$(BUILD_DIR)\testdata
-      $(BIN_DIR)\InferenceEngineCAPITests --gtest_output=xml:TEST-InferenceEngineCAPITests.xml
-    displayName: 'IE CAPITests'
-    continueOnError: false
-
-  - task: PublishTestResults@2
-    condition: always()
-    inputs:
-      testResultsFormat: 'JUnit' # Options: JUnit, NUnit, VSTest, xUnit, cTest
-      testResultsFiles: '**/TEST-*.xml'
-      #searchFolder: '$(BUILD_DIR)'
-      mergeTestResults: false # Optional
-      #failTaskOnFailedTests: false # Optional
-      #testRunTitle: 'Pre/Post-Commit' # Optional
-      buildPlatform: 'x64' # Optional
-      buildConfiguration: 'Windows' # Optional
-      #publishRunAttachments: true # Optional

.ci/openvino-onnx/Dockerfile

@@ -1,83 +0,0 @@
-FROM ubuntu:20.04
-
-LABEL version=2020.07.09.1
-
-ARG http_proxy
-ARG https_proxy
-ENV http_proxy ${http_proxy}
-ENV https_proxy ${https_proxy}
-
-ENV CI=true
-ENV DEBIAN_FRONTEND=noninteractive
-ENV PYTHONUNBUFFERED 1
-
-# Install base dependencies
-RUN apt-get update && apt-get install -y locales && apt-get clean autoclean && apt-get autoremove -y
-
-# Set the locale to en_US.UTF-8
-RUN locale-gen en_US.UTF-8
-ENV LANG en_US.UTF-8
-ENV LANGUAGE en_US:en
-ENV LC_ALL en_US.UTF-8
-
-RUN apt-get update && apt-get -y --no-install-recommends install \
-# OpenVINO dependencies
-        autoconf \
-        automake \
-        build-essential \
-        cmake \
-        curl \
-        git \
-        libtool \
-        ocl-icd-opencl-dev \
-        pkg-config \
-        unzip \
-        wget \
-# Python dependencies
-        python3 \
-        python3-pip \
-        python3-dev \
-        python3-virtualenv \
-        cython3 \
-        tox \
-# ONNX dependencies
-        git-lfs \
-        protobuf-compiler \
-        libprotobuf-dev && \
-    apt-get clean autoclean && \
-    apt-get autoremove -y
-
-# Build OpenVINO
-COPY . /openvino/
-WORKDIR /openvino/build
-RUN cmake .. \
-    -DCMAKE_BUILD_TYPE=Release \
-    -DENABLE_VPU=OFF \
-    -DENABLE_GNA=OFF \
-    -DENABLE_OPENCV=OFF \
-    -DENABLE_CPPLINT=OFF \
-    -DENABLE_TESTS=OFF \
-    -DENABLE_BEH_TESTS=OFF \
-    -DENABLE_FUNCTIONAL_TESTS=OFF \
-    -DENABLE_MKL_DNN=ON \
-    -DENABLE_CLDNN=OFF \
-    -DENABLE_PROFILING_ITT=OFF \
-    -DENABLE_SAMPLES=OFF \
-    -DENABLE_SPEECH_DEMO=OFF \
-    -DENABLE_PYTHON=ON \
-    -DPYTHON_EXECUTABLE=/usr/bin/python3 \
-    -DNGRAPH_ONNX_IMPORT_ENABLE=ON \
-    -DNGRAPH_INTERPRETER_ENABLE=ON \
-    -DNGRAPH_DEBUG_ENABLE=OFF \
-    -DNGRAPH_DYNAMIC_COMPONENTS_ENABLE=ON \
-    -DCMAKE_INSTALL_PREFIX=/openvino/dist
-RUN make -j $(nproc) install
-
-# Run tests via tox
-WORKDIR /openvino/ngraph/python
-ENV NGRAPH_CPP_BUILD_PATH=/openvino/dist
-ENV LD_LIBRARY_PATH=/openvino/dist/lib
-ENV NGRAPH_ONNX_IMPORT_ENABLE=TRUE
-ENV PYTHONPATH=/openvino/bin/intel64/Release/lib/python_api/python3.8:${PYTHONPATH}
-RUN git clone --recursive https://github.com/pybind/pybind11.git -b v2.5.0 --depth 1
-CMD tox

.ci/openvino-onnx/Jenkinsfile

@@ -1,152 +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"
-
-// workaround for aborting previous builds on PR update
-@NonCPS
- def stopPreviousRunningBuilds() {
-     def jobname = env.JOB_NAME
-     if (jobname.startsWith("onnx/openvino_ci/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) {
-    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) {
-    dir ("${WORKDIR}/${repository_name}") {
-        sh  label: "Init ${repository_name} submodules",
-            script:
-        """
-            git submodule init && git submodule update \
-                --init \
-                --no-fetch \
-                --recursive 
-        """
-    }
-}
-
-def buildDockerImage() {
-    sh """
-        docker build --tag=${DOCKER_IMAGE_TAG}  --file=.ci/openvino-onnx/Dockerfile \
-        --build-arg http_proxy=http://proxy-chain.intel.com:911/ \
-        --build-arg https_proxy=http://proxy-chain.intel.com:912/ .
-    """
-}
-
-def runTests() {
-    sh """
-        docker run --name ${DOCKER_CONTAINER_NAME} \
-        --volume ${HOME}/ONNX_CI/onnx-models-28-Oct/.onnx/model_zoo:/root/.onnx/model_zoo \
-        --volume ${HOME}/ONNX_CI/onnx-models/.onnx/model_zoo/MSFT:/root/.onnx/model_zoo/MSFT \
-        ${DOCKER_IMAGE_TAG}
-    """
-}
-
-pipeline {
-    agent {
-        label "OpenVino"
-    }
-    environment {
-        PROJECT_NAME = "openvino"
-        WORKDIR = "${WORKSPACE}/${BUILD_NUMBER}"
-    }
-    options {
-        skipDefaultCheckout true
-        timeout(activity: true, time: 10, unit: 'MINUTES')
-    }
-    stages {
-        stage("Clone repository") {
-            steps{
-                stopPreviousRunningBuilds()
-                dir("${WORKDIR}") {
-                    checkout scm
-                }
-                gitSubmoduleUpdate(PROJECT_NAME)
-            }
-        }
-        stage("Prepare Docker environment") {
-            steps{
-                dir("${WORKDIR}") {
-                    buildDockerImage()
-                }
-            }
-        }
-        stage("Run tests") {
-            options {
-                  timeout(time: 15, unit: 'MINUTES')
-              }
-            steps{
-                runTests()
-            }
-        }
-    }
-    post {
-        failure {
-            script {
-                gitPrInfo = getGitPrInfo(PROJECT_NAME)
-                notifyByEmail(gitPrInfo)
-            }
-        }
-        cleanup {
-            dir("${WORKDIR}") {
-                deleteDir()
-                sh """
-                    docker image prune -f
-                    docker rm -f ${DOCKER_CONTAINER_NAME}
-                """
-            }
-        }
-    }
-}

.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-2020 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-2020 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-2020 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-2020 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-2020 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/ISSUE_TEMPLATE/bug.md

@@ -1,58 +0,0 @@
----
-name: Bug
-about: Create a report to help us improve
-title: "[Bug]"
-labels: bug, support_request
-assignees: ''
-
----
-
-##### System information (version)
-<!-- Example
-- OpenVINO => 2020.4
-- Operating System / Platform => Windows 64 Bit
-- Compiler => Visual Studio 2017
-- Problem classification: Model Conversion
-- Framework: TensorFlow (if applicable)
-- Model name: ResNet50 (if applicable)
--->
-
-- OpenVINO=> :grey_question:
-- Operating System / Platform => :grey_question:
-- Compiler => :grey_question:
-- Problem classification => :grey_question:
-
-##### Detailed description
-<!-- your description -->
-
-##### Steps to reproduce
-
-<!--
-   Describe your problem and steps you've done before you got to this point.    
-   to add code example fence it with triple backticks and optional file extension
-    ```.cpp
-    // C++ code example
-    ```
- or attach as .txt or .zip file
--->
-
-##### Issue submission checklist
-
- - [ ] I report the issue, it's not a question
-   <!--
-   OpenVINO team works with support forum, Stack Overflow and other communities
-   to discuss problems. Tickets with question without real issue statement will be
-   closed.
-   -->
- - [ ] I checked the problem with documentation, FAQ, open issues, Stack Overflow, etc and have not found solution
-   <!--
-   Places to check:
-   * OpenVINO documentation: https://docs.openvinotoolkit.org/
-   * OpenVINO forum: https://community.intel.com/t5/Intel-Distribution-of-OpenVINO/bd-p/distribution-openvino-toolkit
-   * OpenVINO issue tracker: https://github.com/openvinotoolkit/openvino/issues?q=is%3Aissue
-   * Stack Overflow branch: https://stackoverflow.com/questions/tagged/openvino
-   -->
- - [ ] There is reproducer code and related data files: images, videos, models, etc.
-   <!--
-   The best reproducer -- test case for OpenVINO that we can add to the library.
-   -->

.github/dependabot.yml

@@ -1,13 +0,0 @@
-version: 2
-updates:
-- package-ecosystem: pip
-  directory: "/ngraph/python"
-  schedule:
-    interval: weekly
-    day: monday
-    time: "13:00"
-  open-pull-requests-limit: 10
-  reviewers:
-  - postrational
-  labels:
-  - dependencies

.github/org_control/check_org.py

@@ -1,51 +0,0 @@
-# Copyright (C) 2020 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-"""
-Check GitHub organization and invite members
-"""
-
-# pylint: disable=fixme,no-member
-
-from argparse import ArgumentParser
-
-import github_api
-from configs import Config
-
-
-def main():
-    """The main entry point function"""
-    arg_parser = ArgumentParser()
-    arg_parser.add_argument("--cfg-file", metavar="PATH", default=Config.default_cfg_path,
-                            help=f"Path to json configuration file, e.g. {Config.default_cfg_path}")
-    arg_parser.add_argument("--teams", action="store_true", help="Check GitHub teams")
-    args, unknown_args = arg_parser.parse_known_args()
-
-    Config(args.cfg_file, unknown_args)
-    gh_api = github_api.GithubOrgApi()
-
-    if args.teams:
-        gh_api.get_org_teams()
-    else:
-        dev_emails = github_api.get_dev_emails()
-        print(f'\nDeveloper emails {len(dev_emails)}:', '; '.join(dev_emails))
-
-        org_emails = gh_api.get_org_emails()
-        print(f'\nOrg emails {len(org_emails)}:', '; '.join(org_emails))
-
-        org_pendig_invitation_emails = gh_api.get_org_invitation_emails()
-
-        invite_emails = dev_emails.difference(org_emails).difference(org_pendig_invitation_emails)
-        print(f'\nInvite emails {len(invite_emails)}:', '; '.join(invite_emails))
-
-        no_in_dev_emails = org_emails.difference(dev_emails)
-        print(f'\nOrg members - no in developers list {len(no_in_dev_emails)}:',
-              '; '.join(no_in_dev_emails))
-
-        valid_github_users = gh_api.get_valid_github_users(invite_emails)
-
-        gh_api.invite_users(valid_github_users)
-
-
-if __name__ == '__main__':
-    main()

.github/org_control/check_pr.py

@@ -1,149 +0,0 @@
-# Copyright (C) 2020 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-"""
-Check GitHub PRs and set labels by type and categories, e.g. 'ExternalPR', 'category: ci'
-"""
-
-# pylint: disable=fixme,no-member
-
-import re
-import datetime
-from argparse import ArgumentParser
-from enum import Enum
-
-import github_api
-from configs import Config
-
-
-class PrType(Enum):
-    """Constants for type of GitHub pull request by author membership"""
-    EXTERNAL = 'ExternalPR'
-    INTEL = 'ExternalIntelPR'
-    ORG = 'OpenvinoPR'
-    BAD = 'BadPR'
-
-
-def get_pr_labels(pull):
-    """Gets PR labels as set"""
-    pr_lables = set()
-    for label in pull.labels:
-        pr_lables.add(label.name)
-    return pr_lables
-
-
-def set_pr_labels(pull, labels):
-    """Sets PR labels"""
-    if not labels or Config().DRY_RUN:
-        return
-    print(f'Set PR labels:', labels)
-    pull.set_labels(labels)
-
-
-def get_pr_type_by_labels(pull):
-    """Gets PR type using labels"""
-    pr_lables = get_pr_labels(pull)
-    pr_types = set(type.value for type in PrType)
-    pr_types_labels = pr_lables & pr_types
-    if not pr_types_labels:
-        return None
-    if len(pr_types_labels) > 1:
-        print(f'Duplicated labels: {pr_types_labels}')
-        return PrType.BAD
-    return PrType(PrType(pr_types_labels.pop()))
-
-
-def get_label_by_team_name_re(team_name):
-    """Generates label by PR reviwer team name using regular expressions"""
-    if 'admins' in team_name:
-        return 'category: ci'
-    re_compile_label = re.compile(rf'{Config().GITHUB_REPO}-(.+)-maintainers')
-    re_label = re_compile_label.match(team_name)
-    if re_label:
-        return f'category: {re_label.group(1).strip()}'
-    return None
-
-
-def get_label_by_team_name_map(team_name):
-    """Generates label by PR reviwer team name using config map"""
-    return Config().TEAM_TO_LABEL.get(team_name)
-
-
-def get_category_labels(pull):
-    """Gets list of category labels by all PR reviwer teams"""
-    labels = []
-    pr_lables = get_pr_labels(pull)
-    for reviewer_team in pull.get_review_requests()[1]:
-        reviewer_label = get_label_by_team_name_map(reviewer_team.name)
-        if reviewer_label and reviewer_label not in pr_lables:
-            labels.append(reviewer_label)
-    return labels
-
-
-def main():
-    """The main entry point function"""
-    arg_parser = ArgumentParser()
-    arg_parser.add_argument("--cfg-file", metavar="PATH", default=Config.default_cfg_path,
-                            help=f"Path to json configuration file, e.g. {Config.default_cfg_path}")
-    arg_parser.add_argument("--pr", metavar="NUMBER",
-                            help="Get GitHub pull request with the number")
-    arg_parser.add_argument("--pr-state", default="open", choices=["open", "closed"],
-                            help="Set GitHub pull request state")
-    arg_parser.add_argument("--newer", metavar="MINUTES",
-                            help="Get newly created GitHub pull request only")
-    args, unknown_args = arg_parser.parse_known_args()
-
-    Config(args.cfg_file, unknown_args)
-    gh_api = github_api.GithubOrgApi()
-
-    if args.pr:
-        pulls = [gh_api.repo.get_pull(int(args.pr))]
-    else:
-        pulls = gh_api.repo.get_pulls(state=args.pr_state)
-        print(f'\nPRs count ({args.pr_state}):', pulls.totalCount)
-
-    if args.newer:
-        pr_created_after = datetime.datetime.now() - datetime.timedelta(minutes=int(args.newer))
-        print('PRs created after:', pr_created_after)
-    non_org_intel_pr_users = set()
-    non_org_pr_users = set()
-    for pull in pulls:
-        if args.newer and pull.created_at <= pr_created_after:
-            print(f'\nIGNORE: {pull} - Created: {pull.created_at}')
-            continue
-        pr_lables = get_pr_labels(pull)
-        pr_type_by_labels = get_pr_type_by_labels(pull)
-        set_labels = []
-        print(f'\n{pull} - Created: {pull.created_at} - Labels: {pr_lables} -',
-              f'Type: {pr_type_by_labels}', end='')
-
-        # Checks PR source type
-        if gh_api.is_org_user(pull.user):
-            print(' - Org user')
-        elif github_api.is_intel_email(pull.user.email) or \
-             github_api.is_intel_company(pull.user.company):
-            print(' - Non org user with Intel email or company')
-            non_org_intel_pr_users.add(pull.user)
-            if pr_type_by_labels is not PrType.INTEL:
-                print(f'NO "{PrType.INTEL.value}" label: ', end='')
-                github_api.print_users(pull.user)
-                set_labels.append(PrType.INTEL.value)
-        else:
-            print(f' - Non org user with NO Intel email or company')
-            non_org_pr_users.add(pull.user)
-            if pr_type_by_labels is not PrType.EXTERNAL:
-                print(f'NO "{PrType.EXTERNAL.value}" label: ', end='')
-                github_api.print_users(pull.user)
-                set_labels.append(PrType.EXTERNAL.value)
-
-        set_labels += get_category_labels(pull)
-        set_pr_labels(pull, set_labels)
-
-    print(f'\nNon org user with Intel email or company:')
-    github_api.print_users(non_org_intel_pr_users)
-    print(f'\nNon org user with NO Intel email or company:')
-    github_api.print_users(non_org_pr_users)
-
-
-if __name__ == '__main__':
-    main()

.github/org_control/config.json

@@ -1,36 +0,0 @@
-{
-    "GITHUB_TOKEN": "<Put token here or set as arg or as env variable>",
-    "GITHUB_ORGANIZATION": "openvinotoolkit",
-    "GITHUB_REPO": "openvino",
-    "IGNORE_LOGINS": [
-        "openvino-ci",
-        "openvino-pushbot",
-        "lab-nerval",
-        "lab-nerval-onnx-ci"
-    ],
-    "EMAILS_FILE_PATH": "dev_emails-test.txt",
-    "PROXIES": {
-        "HTTP_PROXY": null,
-        "HTTPS_PROXY": null,
-        "NO_PROXY": "localhost,127.0.0.1,.intel.com"
-    },
-    "DRY_RUN": false,
-    "TEAM_TO_LABEL": {
-        "openvino-admins": "category: CI",
-        "openvino-maintainers": "category: IE common",
-        "openvino-docs-maintainers": "category: docs",
-        "openvino-ie-maintainers": "category: IE common",
-        "openvino-ie-cpu-maintainers": "category: CPU",
-        "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-python-api-maintainers": "category: python api",
-        "openvino-ie-tests-maintainers": "category: IE Tests",
-        "openvino-ie-vpu-maintainers": "category: VPU",
-        "openvino-mo-maintainers": "category: MO",
-        "openvino-ngraph-maintainers": "category: nGraph",
-        "openvino-tests-maintainers": "category: IE Tests",
-        "openvino-tools-maintainers": "category: tools"
-    }
-}

.github/org_control/configs.py

@@ -1,113 +0,0 @@
-# Copyright (C) 2020 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-"""
-Configurations management
-"""
-
-# pylint: disable=fixme,broad-except
-
-import os
-import sys
-import ast
-import json
-from pathlib import Path
-
-
-if sys.hexversion < 0x3060000:
-    raise Exception('Python version must be >= 3.6')
-
-
-class ConfigException(Exception):
-    """Base configuration exception"""
-
-
-class Config:
-    """Configuration wrapper"""
-    _instance = None
-    properties = None
-    default_cfg_path = Path(__file__).resolve().parent / 'config.json'
-
-    def __new__(cls, *_args, **_kwargs):
-        if not Config._instance:
-            Config._instance = super(Config, cls).__new__(cls)
-        return Config._instance
-
-    def __init__(self, file_path=None, cli_args=None):
-        """
-        :param file_path: Path to json configuration file
-        :type file_path: String
-
-        :param args: List of argparse arguments with patterns: 'name=value' or 'name'
-        :type args: list
-        """
-        if Config.properties:
-            return
-
-        self._file_path = file_path or Config.default_cfg_path
-        self._cli_args = cli_args or []
-
-        self._json_cfg = {}
-        self._args = {}
-
-        self._load_cfg()
-        self._parse_cli_args()
-
-        Config.properties = {}
-        for name, value in self._json_cfg.items():
-            if hasattr(self, name):
-                raise ConfigException(f'Duplicating prosperity: {name}')
-            prosperity_value = self._args.get(name) or os.getenv(name)
-            if prosperity_value:
-                # Try to set prosperity_value as Python literal structures, e.g. DRY_RUN=False
-                try:
-                    prosperity_value = ast.literal_eval(prosperity_value)
-                except Exception:
-                    pass
-                if not isinstance(prosperity_value, type(value)):
-                    raise ConfigException(f'Python type of {name} parameter must be {type(value)}')
-            else:
-                prosperity_value = value
-            setattr(self, name, prosperity_value)
-            Config.properties[name] = prosperity_value
-
-        self.set_proxy()
-
-    def _load_cfg(self):
-        """Load the json configuration file"""
-        try:
-            with open(self._file_path) as conf:
-                self._json_cfg = json.load(conf)
-        except:
-            print('Failed to load configuration from:', self._file_path)
-            raise
-
-    def _parse_cli_args(self):
-        """Parse argparse arguments with patterns: 'name=value' or 'name'"""
-        for cli_arg in self._cli_args:
-            arg = cli_arg.split('=')
-            if arg[0] not in self._json_cfg:
-                raise ConfigException(f'Unsupported argument: {arg}')
-            self._args[arg[0]] = True if len(arg) == 1 else '='.join(arg[1:])
-
-    def get_properties(self):
-        """Get all properties as Dict"""
-        return self.properties
-
-    def set_proxy(self):
-        """Set proxies"""
-        for proxy_name, url in self.properties['PROXIES'].items():
-            if url is not None:
-                print(f'Set proxy: {proxy_name}={url}')
-                os.environ[proxy_name] = url
-
-
-def _test():
-    """Test and debug"""
-    print('Config.default_cfg_path:', Config.default_cfg_path)
-    cfg = Config(cli_args=['DRY_RUN=True'])
-    print('Config.properties:', cfg.get_properties())
-
-
-if __name__ == '__main__':
-    _test()

.github/org_control/dev_emails-test.txt

@@ -1,9 +0,0 @@
-# good comment
-Last_name, First_name <first_name.last_name@intel.com>
-first_name.last_name@intel.com
-openvino_pushbot@intel.com
-
-# Wrong emails
-foo@foo.com
-  foo1  foo2
-foo1 foo2@intel.com

.github/org_control/github_api.py

@@ -1,287 +0,0 @@
-# Copyright (C) 2020 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-
-"""
-GitHub API for controlling organization
-"""
-
-# pylint: disable=fixme,no-member
-
-import re
-import time
-
-from github import Github, GithubException, RateLimitExceededException, IncompletableObject
-from github import UnknownObjectException
-from github.PaginatedList import PaginatedList
-
-from configs import Config
-
-
-def is_valid_user(user):
-    """Checks that user is valid github.Github object"""
-    try:
-        return user and user.login
-    except IncompletableObject:
-        return False
-
-
-def is_user_ignored(user):
-    """Checks that user should be ignored"""
-    cfg = Config()
-    if is_valid_user(user) and user.login.lower() not in cfg.properties['IGNORE_LOGINS']:
-        return False
-    return True
-
-
-def is_valid_name(name):
-    """Checks that GitHub user's name is valid"""
-    return name and len(name) >= 3 and ' ' in name
-
-
-def is_intel_email(email):
-    """Checks that email is valid Intel email"""
-    return email and len(email) > 10 and ' ' not in email and email.lower().endswith('@intel.com')
-
-
-def is_intel_company(company):
-    """Checks that company contains intel"""
-    return company and 'intel' in company.lower()
-
-
-def is_valid_intel_user(user):
-    """Checks that user is valid GitHub and Intel user"""
-    return is_valid_user(user) and (is_valid_name(user.name) and is_intel_email(user.email) or
-                                    is_user_ignored(user))
-
-
-def print_users(users):
-    """Print list of users in different formats: list, set, PaginatedList"""
-    if isinstance(users, (list, set, PaginatedList)):
-        users_count = users.totalCount if isinstance(users, PaginatedList) else len(users)
-        print(f'\nGitHub users {users_count} (login - name - company - email - valid):')
-    else:
-        users = [users]
-    for user in users:
-        if not is_valid_user(user):
-            print('WRONG GitHub user: ???')
-            continue
-        valid_check = 'OK' if is_valid_intel_user(user) else 'FIX'
-        if not is_intel_email(user.email):
-            valid_check += ' email'
-        if not is_valid_name(user.name):
-            valid_check += ' name'
-        print(f'{user.login} - "{user.name}" - "{user.company}" - {user.email} - {valid_check}')
-
-
-def get_dev_emails():
-    """
-    Read a file with developer emails. Supported email formats
-    first_name.last_name@intel.com
-    Import from Outlook: Last_name, First_name <first_name.last_name@intel.com>
-    """
-    re_email = re.compile(r'.+<(.+)>')
-    emails = set()
-    cfg = Config()
-    with open(cfg.properties['EMAILS_FILE_PATH']) as file_obj:
-        for line in file_obj:
-            line = line.strip().lower()
-            if not line or line.startswith('#'):
-                continue
-            re_outlook_email = re_email.match(line)
-            if re_outlook_email:
-                line = re_outlook_email.group(1).strip()
-            if not is_intel_email(line):
-                print(f'Wrong email in {cfg.properties["EMAILS_FILE_PATH"]}: {line}')
-                continue
-            emails.add(line)
-    return emails
-
-
-class GithubOrgApi:
-    """Common API for GitHub organization"""
-
-    def __init__(self):
-        self._cfg = Config()
-        self.github = Github(self._cfg.GITHUB_TOKEN)
-        self.github_org = self.github.get_organization(self._cfg.GITHUB_ORGANIZATION)
-        self.repo = self.github.get_repo(f'{self._cfg.GITHUB_ORGANIZATION}/'
-                                         f'{self._cfg.GITHUB_REPO}')
-
-    def is_org_user(self, user):
-        """Checks that user is a member of GitHub organization"""
-        if is_valid_user(user):
-            try:
-                membership = user.get_organization_membership(self.github_org)
-                # membership.role can be 'member' or 'admin'
-                if membership.state == 'active' and membership.role:
-                    return True
-            except UnknownObjectException:
-                pass
-        return False
-
-    def get_org_emails(self):
-        """Gets and prints all emails of GitHub organization members"""
-        org_members = self.github_org.get_members()
-        org_emails = set()
-        org_members_fix = set()
-        org_emails_fix_name = set()
-        org_logins_fix_intel_email = set()
-
-        print(f'\nOrg members {org_members.totalCount} (login - name - company - email - valid):')
-        for org_member in org_members:
-            print_users(org_member)
-            if is_user_ignored(org_member):
-                continue
-            if is_intel_email(org_member.email):
-                org_emails.add(org_member.email.lower())
-                if not is_valid_name(org_member.name):
-                    org_members_fix.add(org_member)
-                    org_emails_fix_name.add(org_member.email.lower())
-            else:
-                org_members_fix.add(org_member)
-                org_logins_fix_intel_email.add(org_member.login.lower())
-
-        print_users(org_members_fix)
-        print(f'\nOrg members - no Intel emails {len(org_logins_fix_intel_email)}:',
-              '; '.join(org_logins_fix_intel_email))
-        print(f'\nOrg members - no real name {len(org_emails_fix_name)}:',
-              '; '.join(org_emails_fix_name))
-        return org_emails
-
-    def get_org_invitation_emails(self):
-        """Gets GitHub organization teams prints info"""
-        org_invitations = self.github_org.invitations()
-        org_invitation_emails = set()
-
-        print(f'\nOrg invitations {org_invitations.totalCount} (login - name - email - valid):')
-        for org_invitation in org_invitations:
-            # TODO: investigate GithubException while access to user name and enable print_users()
-            # github.GithubException.IncompletableObject: 400 "Returned object contains no URL"
-            #print_users(org_invitation)
-            print(f'{org_invitation.login} - ??? - {org_invitation.email} - ???')
-            if is_user_ignored(org_invitation):
-                continue
-            if is_intel_email(org_invitation.email):
-                org_invitation_emails.add(org_invitation.email.lower())
-            else:
-                print('Strange org invitation:', org_invitation)
-
-        print(f'\nOrg invitation emails {len(org_invitation_emails)}:',
-              '; '.join(org_invitation_emails))
-        return org_invitation_emails
-
-    def get_org_teams(self):
-        """Gets GitHub organization teams prints info"""
-        teams = []
-        org_teams = self.github_org.get_teams()
-        print('\nOrg teams count:', org_teams.totalCount)
-        for team in org_teams:
-            teams.append(team.name)
-            print(f'\nTeam: {team.name} - parent: {team.parent}')
-
-            repos = team.get_repos()
-            print('Repos:')
-            for repo in repos:
-                print(f'    {repo.name} -', team.get_repo_permission(repo))
-
-            team_maintainers = team.get_members(role='maintainer')
-            team_maintainer_logins = set()
-            for maintainer in team_maintainers:
-                team_maintainer_logins.add(maintainer.login)
-            team_members = team.get_members(role='member')
-            team_member_logins = set()
-            for member in team_members:
-                team_member_logins.add(member.login)
-            members = team.get_members(role='all')
-            member_emails = []
-            print('Members (role - login - name - company - email - valid):')
-            for user in members:
-                if user.login in team_maintainer_logins:
-                    print('    Maintainer - ', end='')
-                elif user.login in team_member_logins:
-                    print('    Member - ', end='')
-                else:
-                    # It is not possible to check child teams members
-                    print('    ??? - ', end='')
-                print_users(user)
-                if is_intel_email(user.email) and not is_user_ignored(user):
-                    member_emails.append(user.email.lower())
-            print(f'Intel emails {len(member_emails)}:', '; '.join(member_emails))
-        return teams
-
-    def get_valid_github_users(self, emails):
-        """Gets valid GitHub users by email and prints status"""
-        valid_users = set()
-        no_account_emails = set()
-        print(f'\nGitHub users from {len(emails)} invite emails (email - status):')
-        for email in emails:
-            if not is_intel_email(email):
-                print(f'{email} - Non Intel email')
-                continue
-
-            # You can make up to 30 requests per minute; https://developer.github.com/v3/search/
-            # Sleep 2.4 sec is about 25 requests per minute
-            time.sleep(2.4)
-            try:
-                users = self.github.search_users(f'{email} in:email')
-            except RateLimitExceededException:
-                time.sleep(5)
-                users = self.github.search_users(f'{email} in:email')
-
-            if users.totalCount == 0:
-                print(f'{email} - No valid GitHub account')
-                no_account_emails.add(email)
-                continue
-            if users.totalCount > 1:
-                print(f'{email} - Found {users.totalCount} GitHub accounts')
-            for user in users:
-                if user.email and user.email.lower() == email:
-                    print(f'{email} - OK')
-                    valid_users.add(user)
-                else:
-                    print(f'{email} - Non public or wrong email - login: {user.login} - '
-                          f'email: {user.email}')
-        print('Valid users count:', len(valid_users))
-        print_users(valid_users)
-        print(f'\nIntel emails - No valid GitHub account {len(no_account_emails)}:',
-              '; '.join(no_account_emails))
-        return valid_users
-
-    def invite_users(self, users):
-        """Invites users and prints status"""
-        if isinstance(users, (list, set)):
-            print(f'\nInvite {len(users)} users:')
-        else:
-            users = [users]
-
-        for user in users:
-            if isinstance(user, str):
-                print(f'Email: {user}')
-                self.github_org.invite_user(email=user)
-            else:
-                print(f'{user.login} - "{user.name}" - {user.email} - ', end='')
-                try:
-                    if is_user_ignored(user):
-                        print('Ignored')
-                        continue
-                    if not self._cfg.DRY_RUN:
-                        self.github_org.invite_user(user=user)
-                        print('OK')
-                    else:
-                        print('Dry run')
-                except GithubException as exc:
-                    print(f'FAIL: {exc.data["errors"][0]["message"]}')
-
-
-def _test():
-    """Test and debug"""
-    Config(cli_args=['DRY_RUN=True'])
-    dev_emails = get_dev_emails()
-    print('dev_emails:', dev_emails)
-
-    gh_api = GithubOrgApi()
-    gh_api.get_org_emails()
-
-
-if __name__ == '__main__':
-    _test()

.github/org_control/requirements.txt

@@ -1 +0,0 @@
-PyGithub==1.51

.github/org_control/requirements_dev.txt

@@ -1 +0,0 @@
-pylint==2.3.0

.github/workflows/code_style.yml

@@ -1,92 +0,0 @@
-name: Code Style
-on: [push, pull_request]
-
-jobs:
-  nGraph:
-    runs-on: ubuntu-18.04
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: recursive
-
-      - name: Install clang-format-3.9
-        run: sudo apt --assume-yes install clang-format-3.9
-
-      - name: Install dependencies
-        run: |
-          sudo apt --assume-yes install libusb-1.0-0-dev
-          python3 -m pip install -r ./inference-engine/ie_bridges/python/requirements.txt
-
-      - name: CMake
-        run: |
-          mkdir build
-          cd build
-          cmake ..
-
-      - name: Check code style
-        run: make style-check
-        working-directory: build
-
-      - name: Create code style diff
-        if: failure()
-        run: |
-          ngraph/maint/apply-code-format.sh
-          git diff >ngraph_code_style_diff.patch
-
-      - uses: actions/upload-artifact@v2
-        if: failure()
-        with:
-          name: ngraph_code_style_diff
-          path: ngraph_code_style_diff.patch
-
-  ShellCheck:
-    runs-on: ubuntu-18.04
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: recursive
-
-      - name: Install ShellCheck
-        run: sudo apt --assume-yes install shellcheck
-
-      - name: Install dependencies
-        run: |
-          sudo apt --assume-yes install libusb-1.0-0-dev
-          python3 -m pip install -r ./inference-engine/ie_bridges/python/requirements.txt
-
-      - name: CMake
-        run: |
-          mkdir build
-          cd build
-          cmake ..
-
-      - name: ShellCheck
-        run: make ie_shellcheck
-        working-directory: build
-
-  Java:
-    runs-on: ubuntu-18.04
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-java@v1
-        with:
-          java-version: '11'
-
-      - name: Install dependencies
-        run: |
-          wget -nc https://github.com/google/google-java-format/releases/download/google-java-format-1.9/google-java-format-1.9-all-deps.jar
-
-      - name: Check code style
-        run: |
-          java -jar google-java-format-1.9-all-deps.jar --set-exit-if-changed -a -i $(find . -type f -name "*.java")
-
-      - name: Create code style diff
-        if: failure()
-        run: |
-          git diff >java_code_style_diff.patch
-
-      - uses: actions/upload-artifact@v2
-        if: failure()
-        with:
-          name: java_code_style_diff
-          path: java_code_style_diff.patch

.github/workflows/files_size.yml

@@ -1,17 +0,0 @@
-name: Files Size
-on: [push, pull_request]
-
-jobs:
-  Check-Files-Size:
-    runs-on: ubuntu-18.04
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: git ls-tree
-        run: |
-          git ls-tree -r -t -l --full-name HEAD | sort -n -r -k 4
-
-      - name: git lfs ls-files
-        run: |
-          git lfs ls-files --size
-          

.github/workflows/mo.yml

@@ -12,9 +12,6 @@ jobs:
     runs-on: ubuntu-18.04
     steps:
       - uses: actions/checkout@v2
-        with:
-          submodules: recursive
-
       - name: Set up Python ${{ matrix.python-version }}
         uses: actions/setup-python@v1
         with:
@@ -35,25 +32,19 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip setuptools
+          # For Pylint
+          pip install tensorflow==1.14.0 tensorboard==1.14.0 tensorflow-estimator==1.14.0
           # For UT
           pip install unittest-xml-reporting==3.0.2
           # MO requirements
           pip install -r requirements.txt
           pip install -r requirements_dev.txt
-          # requrements for CMake
-          sudo apt --assume-yes install libusb-1.0-0-dev
         working-directory: model-optimizer
 
       - name: Pylint
         run: pylint -d C,R,W mo/ mo.py extensions/
         working-directory: model-optimizer
 
-      - name: CMake
-        run: |
-          mkdir build
-          cd build
-          cmake ..
-
       - name: UT
         run: |
           export PYTHONPATH=$PYTHONPATH:`pwd`

CMakeLists.txt

@@ -2,7 +2,23 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
+cmake_policy(SET CMP0054 NEW)
+
+# TODO: for make instal / package we need to use 3.13.3 version because
+# it allows to install targets created outside of current projects
+# See https://blog.kitware.com/cmake-3-13-0-available-for-download/
+
+if (APPLE)
+    if(CMAKE_GENERATOR STREQUAL "Xcode")
+        # due to https://gitlab.kitware.com/cmake/cmake/issues/14254
+        cmake_minimum_required(VERSION 3.12.0 FATAL_ERROR)
+    else()
+        # due to https://cmake.org/cmake/help/v3.12/policy/CMP0068.html
+        cmake_minimum_required(VERSION 3.9 FATAL_ERROR)
+    endif()
+else()
+    cmake_minimum_required(VERSION 3.7.2 FATAL_ERROR)
+endif()
 
 project(OpenVINO)
 
@@ -16,7 +32,8 @@ include(features)
 # include developer package
 include(developer_package)
 
-# These options are shared with 3rdparty plugins by means of developer package
+# These options are shared with 3rdparty plugins
+# by means of developer package
 include(check_features)
 include(dependencies)
 
@@ -33,10 +50,6 @@ message (STATUS "CMAKE_BUILD_TYPE ...................... " ${CMAKE_BUILD_TYPE})
 file(REMOVE "${CMAKE_BINARY_DIR}/targets_developer.cmake")
 file(REMOVE "${CMAKE_BINARY_DIR}/targets.cmake")
 
-#
-# Build
-#
-
 function(build_ngraph)
     function(ngraph_set option value)
         if(NOT DEFINED ${option})
@@ -53,44 +66,23 @@ function(build_ngraph)
         ngraph_set(NGRAPH_ADDRESS_SANITIZER FALSE)
     endif ()
     ngraph_set(NGRAPH_PYTHON_BUILD_ENABLE FALSE)
-
-    if(ENABLE_TESTS AND NOT ANDROID)
-        ngraph_set(NGRAPH_UNIT_TEST_ENABLE TRUE)
-    else()
-        ngraph_set(NGRAPH_UNIT_TEST_ENABLE FALSE)
-    endif()
-
-    if(NOT (ANDROID OR WINDOWS_STORE OR (MSVC AND (ARM OR AARCH64)) ))
+    if (NOT ANDROID)
+        if(ENABLE_TESTS)
+            ngraph_set(NGRAPH_UNIT_TEST_ENABLE TRUE)
+            ngraph_set(NGRAPH_IE_ENABLE TRUE)
+        else()
+            ngraph_set(NGRAPH_UNIT_TEST_ENABLE FALSE)
+            ngraph_set(NGRAPH_IE_ENABLE FALSE)
+        endif()
         ngraph_set(NGRAPH_ONNX_IMPORT_ENABLE TRUE)
     else()
+        ngraph_set(NGRAPH_UNIT_TEST_ENABLE FALSE)
+        ngraph_set(NGRAPH_TEST_UTIL_ENABLE FALSE)
+        ngraph_set(NGRAPH_IE_ENABLE FALSE)
         ngraph_set(NGRAPH_ONNX_IMPORT_ENABLE FALSE)
     endif()
     ngraph_set(NGRAPH_INTERPRETER_ENABLE TRUE)
 
-    if(TREAT_WARNING_AS_ERROR)
-        ngraph_set(NGRAPH_WARNINGS_AS_ERRORS ON)
-    else()
-        ngraph_set(NGRAPH_WARNINGS_AS_ERRORS OFF)
-    endif()
-
-    if(COVERAGE)
-        ngraph_set(NGRAPH_CODE_COVERAGE_ENABLE ON)
-    else()
-        ngraph_set(NGRAPH_CODE_COVERAGE_ENABLE OFF)
-    endif()
-
-    if(ENABLE_SANITIZER)
-        ngraph_set(NGRAPH_ADDRESS_SANITIZER_ENABLE ON)
-    else()
-        ngraph_set(NGRAPH_ADDRESS_SANITIZER_ENABLE OFF)
-    endif()
-
-    if(ENABLE_THREAD_SANITIZER)
-        ngraph_set(NGRAPH_THREAD_SANITIZER_ENABLE ON)
-    else()
-        ngraph_set(NGRAPH_THREAD_SANITIZER_ENABLE OFF)
-    endif()
-
     if(CMAKE_CXX_COMPILER_ID MATCHES "^(Apple)?Clang$")
         ie_add_compiler_flags(-Wno-error=uninitialized -Wno-error=literal-conversion)
     elseif(UNIX)
@@ -106,9 +98,9 @@ function(build_ngraph)
     elseif(WIN32)
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4308 /wd4146 /wd4703 /wd4244 /wd4819")
     endif()
-    
+
     if(ENABLE_LTO)
-        set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)
+        ie_enable_lto()
     endif()
 
     ie_cpack_add_component(ngraph)
@@ -119,60 +111,13 @@ function(build_ngraph)
     set(NGRAPH_LIBRARIES ngraph PARENT_SCOPE)
 endfunction()
 
-file(REMOVE "${CMAKE_BINARY_DIR}/openvino_targets_developer.cmake")
-
-unset(OpenVINODeveloperPackageTargets CACHE)
-
-function(openvino_developer_export_targets)
-    set(OpenVINODeveloperPackageTargets "${OpenVINODeveloperPackageTargets};${ARGV}")
-
-    # to allow exporting of aliased targets with the original names
-    foreach(target_name ${OpenVINODeveloperPackageTargets})
-        if(TARGET "${target_name}")
-            get_target_property(original_name ${target_name} ALIASED_TARGET)
-            if(TARGET "${original_name}")
-                message(STATUS "The name ${target_name} is an ALIAS for ${original_name}. "
-                        "It will be exported to the InferenceEngineDeveloperPackage with the original name.")
-                list(REMOVE_ITEM OpenVINODeveloperPackageTargets ${target_name})
-                list(APPEND OpenVINODeveloperPackageTargets ${original_name})
-            endif()
-        endif()
-    endforeach()
-
-    list(REMOVE_DUPLICATES OpenVINODeveloperPackageTargets)
-    set(OpenVINODeveloperPackageTargets "${OpenVINODeveloperPackageTargets}" CACHE INTERNAL
-        "Paths to extra Inference Engine plugins" FORCE)
-endfunction()
-
-add_subdirectory(openvino)
-
 build_ngraph()
 
 add_subdirectory(inference-engine)
 
-add_subdirectory(model-optimizer)
 add_subdirectory(docs)
 
-#
-# Shellcheck
-#
-
-ie_shellcheck_process(DIRECTORY "${OpenVINO_MAIN_SOURCE_DIR}"
-                      SKIP "${OpenVINO_MAIN_SOURCE_DIR}/bin"
-                           "${OpenVINO_MAIN_SOURCE_DIR}/build"
-                           "${IE_MAIN_SOURCE_DIR}/tests/ie_test_utils/common_test_utils/gtest"
-                           "${IE_MAIN_SOURCE_DIR}/samples/thirdparty"
-                           "${IE_MAIN_SOURCE_DIR}/thirdparty"
-                           "${IE_MAIN_SOURCE_DIR}/temp"
-                           # TODO fix and enable back:
-                           "${OpenVINO_MAIN_SOURCE_DIR}/scripts/install_dependencies"
-                           "${OpenVINO_MAIN_SOURCE_DIR}/scripts/demo"
-                           "${OpenVINO_MAIN_SOURCE_DIR}/ngraph"
-                           "${IE_MAIN_SOURCE_DIR}/scripts")
-
-#
 # cpack
-#
 
 # install setupvars
 

CODEOWNERS

@@ -8,18 +8,13 @@ CODEOWNERS  @openvinotoolkit/openvino-admins @openvinotoolkit/openvino-maintaine
 Jenkinsfile  @openvinotoolkit/openvino-admins
 azure-pipelines.yml  @openvinotoolkit/openvino-admins
 /.github/  @openvinotoolkit/openvino-admins
-/.ci/  @openvinotoolkit/openvino-admins
 
 # QA Tests:
 /tests/  @openvinotoolkit/openvino-tests-maintainers
 
-# OpenVINO Scripts
-/scripts/ @openvinotoolkit/openvino-admins @openvinotoolkit/openvino-scripts-maintainers
-
 # IE Core:
 /inference-engine/  @openvinotoolkit/openvino-ie-maintainers
-/inference-engine/ie_bridges/python @openvinotoolkit/openvino-ie-python-api-maintainers
-/inference-engine/src/transformations/  @GlebKazantaev @ilyachur
+/inference-engine/src/transformations/  @GlebKazantaev @ichuraev
 /inference-engine/src/legacy_api/  @openvinotoolkit/openvino-ngraph-maintainers
 /inference-engine/src/readers/  @openvinotoolkit/openvino-ngraph-maintainers
 
@@ -69,7 +64,3 @@ azure-pipelines.yml  @openvinotoolkit/openvino-admins
 
 # Tools
 /tools/  @openvinotoolkit/openvino-tools-maintainers
-
-# Documentation
-/docs/  @openvinotoolkit/openvino-docs-maintainers
-*.md  @openvinotoolkit/openvino-docs-maintainers

CONTRIBUTING.md

@@ -0,0 +1,18 @@
+# How to Contribute
+We welcome community contributions to the OpenVINO™ repository.
+If you have an idea how to improve the product, please share it 
+with us doing the following steps:
+
+* Make sure you can build the product and run all tests and samples with your patch
+* In case of a larger feature, provide relevant unit tests and one or more sample
+* Submit a pull request at https://github.com/openvinotoolkit/openvino/pulls
+
+## OpenVINO™ Coding Style Guide
+We basically use the Google style (https://google.github.io/styleguide/cppguide.html) with some exceptions:
+* 4 spaces instead of 2 spaces for indentations
+* Limitation of 160 symbols for the line length
+* Exceptions are allowed
+* Using namespace are allowed in cpp and prohibited in headers
+* Underscore symbol before member in classes/structures
+* thisStyleForFunctions()
+* theSameStyleForVariables

Jenkinsfile

@@ -1,15 +1,10 @@
 #!groovy
-
 properties([
     parameters([
         booleanParam(defaultValue: true,
                      description: 'Cancel the rest of parallel stages if one of them fails and return status immediately',
-                     name: 'failFast'),
-        string(defaultValue: '',
-               description: 'Pipeline shared library version (branch/tag/commit). Determined automatically if empty',
-               name: 'library_version')
+                     name: 'failFast')
     ])
 ])
-loadOpenVinoLibrary {
-    entrypoint(this)
-}
+
+dldtPipelineEntrypoint(this)

README.md

@@ -1,40 +1,42 @@
 # [OpenVINO™ Toolkit](https://01.org/openvinotoolkit) - Deep Learning Deployment Toolkit repository
-[![Stable release](https://img.shields.io/badge/version-2021.1-green.svg)](https://github.com/openvinotoolkit/openvino/releases/tag/2021.1)
+[![Stable release](https://img.shields.io/badge/version-2020.4-green.svg)](https://github.com/openvinotoolkit/openvino/releases/tag/2020.4.0)
 [![Apache License Version 2.0](https://img.shields.io/badge/license-Apache_2.0-green.svg)](LICENSE)
-![Azure DevOps builds (branch)](https://img.shields.io/azure-devops/build/openvinoci/b2bab62f-ab2f-4871-a538-86ea1be7d20f/9/master?label=Public%20CI)
 
-This toolkit allows developers to deploy pre-trained deep learning models
-through a high-level C++ Inference Engine API integrated with application logic.
+This toolkit allows developers to deploy pre-trained deep learning models 
+through a high-level C++ Inference Engine API integrated with application logic. 
 
-This open source version includes several components: namely [Model Optimizer], [ngraph] and
-[Inference Engine], 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 Caffe\*, TensorFlow\*,
-MXNet\* and ONNX\*.
+This open source version includes two components: namely [Model Optimizer] and 
+[Inference Engine], as well as CPU, GPU 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 Caffe\*, TensorFlow\*, 
+MXNet\* and ONNX\*. 
 
 ## Repository components:
 * [Inference Engine]
-* [ngraph]
 * [Model Optimizer]
 
 ## License
 Deep Learning Deployment Toolkit is licensed under [Apache License Version 2.0](LICENSE).
-By contributing to the project, you agree to the license and copyright terms therein
+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.openvinotoolkit.org/
-* Wiki: https://github.com/openvinotoolkit/openvino/wiki
-* Issue tracking: https://github.com/openvinotoolkit/openvino/issues
-* Additional OpenVINO modules: https://github.com/openvinotoolkit/openvino_contrib
-* [HomePage](https://software.intel.com/content/www/us/en/develop/tools/openvino-toolkit.html)
+## Documentation
 * [OpenVINO™ Release Notes](https://software.intel.com/en-us/articles/OpenVINO-RelNotes)
+* [OpenVINO™ Inference Engine Build Instructions](build-instruction.md)
+* [Get Started with Deep Learning Deployment Toolkit on Linux](get-started-linux.md)\*
+* [Introduction to Deep Learning Deployment Toolkit](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Introduction.html)
+* [Inference Engine Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Deep_Learning_Inference_Engine_DevGuide.html)
+* [Model Optimizer Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html)
+
+## How to Contribute
+See [CONTRIBUTING](./CONTRIBUTING.md) for details. Thank you!
 
 ## 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` [tag on StackOverflow]\*
+* [GitHub* Issues](https://github.com/openvinotoolkit/openvino/issues) 
 * [Forum](https://software.intel.com/en-us/forums/computer-vision)
 
 ---
@@ -44,4 +46,3 @@ Please report questions, issues and suggestions using:
 [Inference Engine]:https://software.intel.com/en-us/articles/OpenVINO-InferEngine
 [Model Optimizer]:https://software.intel.com/en-us/articles/OpenVINO-ModelOptimizer
 [tag on StackOverflow]:https://stackoverflow.com/search?q=%23openvino
-[ngraph]:https://docs.openvinotoolkit.org/latest/openvino_docs_nGraph_DG_DevGuide.html

SECURITY.md

@@ -1,12 +0,0 @@
-# Security Policy
-
-## Report a Vulnerability
-
-Please report security issues or vulnerabilities to the [Intel® Security Center].
-
-For more information on how Intel® works to resolve security issues, see
-[Vulnerability Handling Guidelines].
-
-[Intel® Security Center]:https://www.intel.com/security
-
-[Vulnerability Handling Guidelines]:https://www.intel.com/content/www/us/en/security-center/vulnerability-handling-guidelines.html

azure-pipelines.yml

@@ -0,0 +1,333 @@
+jobs:
+- job: Lin
+  # About 150% of total time
+  timeoutInMinutes: 75
+  pool:
+    #vmImage: 'ubuntu-18.04'
+    name: LIN_VMSS_VENV_F8S_WU2
+  variables:
+    BUILD_TYPE: Release
+    BIN_DIR: ../bin/intel64/$(BUILD_TYPE)
+  steps:
+  - script: |
+      whoami
+      uname -a
+      which python3
+      gcc --version
+      lsb_release
+      env
+      cat /proc/cpuinfo
+      cat /proc/meminfo
+      vmstat -s
+      df
+    displayName: 'System properties'
+  - script: |
+      sudo apt --assume-yes install libusb-1.0-0-dev
+      python3 -m pip install -r ./inference-engine/ie_bridges/python/requirements.txt
+      # For running Python API tests
+      python3 -m pip install -r ./inference-engine/ie_bridges/python/src/requirements-dev.txt
+    displayName: 'Install dependencies'
+  - script: |
+      wget https://github.com/ninja-build/ninja/releases/download/v1.10.0/ninja-linux.zip
+      unzip ninja-linux.zip
+      sudo cp -v ninja /usr/local/bin/
+    displayName: 'Install Ninja'
+  - script: git submodule update --init --recursive --jobs 8
+    displayName: 'Clone submodules'
+  - script: |
+      mkdir dldt-build
+      cd dldt-build
+    displayName: 'Create build directory'
+  - task: CMake@1
+    inputs:
+      workingDirectory: dldt-build
+      # CMake must get Python 3.x version by default
+      cmakeArgs: .. -GNinja -DVERBOSE_BUILD=ON -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) -DENABLE_PYTHON=ON -DPYTHON_EXECUTABLE=/usr/bin/python3.6 -DENABLE_TESTS=ON
+  - script: ninja
+    workingDirectory: dldt-build
+    displayName: 'Build Lin'
+  - script: ls -alR ../bin/
+    workingDirectory: dldt-build
+    displayName: 'List files'
+  - script: $(BIN_DIR)/unit-test --gtest_print_time=1 --gtest_filter=-backend_api.config_unsupported:*IE_GPU*
+    workingDirectory: dldt-build
+    displayName: 'nGraph UT'
+    continueOnError: false
+  - script: $(BIN_DIR)/InferenceEngineUnitTests
+    workingDirectory: dldt-build
+    displayName: 'IE UT old'
+    continueOnError: false
+  - script: $(BIN_DIR)/ieUnitTests
+    workingDirectory: dldt-build
+    displayName: 'IE UT'
+    continueOnError: false
+  - script: $(BIN_DIR)/cpuUnitTests
+    workingDirectory: dldt-build
+    displayName: 'CPU UT'
+    continueOnError: false
+  - script: $(BIN_DIR)/gnaUnitTests
+    workingDirectory: dldt-build
+    displayName: 'GNA UT'
+    continueOnError: false
+  - script: $(BIN_DIR)/vpuUnitTests
+    workingDirectory: dldt-build
+    displayName: 'VPU UT'
+    continueOnError: false
+  - script: $(BIN_DIR)/ieFuncTests
+    workingDirectory: dldt-build
+    displayName: 'IE FuncTests'
+    continueOnError: false
+  - script: $(BIN_DIR)/cpuFuncTests
+    workingDirectory: dldt-build
+    displayName: 'CPU FuncTests'
+    continueOnError: false
+  - script: $(BIN_DIR)/MklDnnBehaviorTests
+    workingDirectory: dldt-build
+    displayName: 'MklDnnBehaviorTests'
+    continueOnError: false
+  - script: git clone https://github.com/openvinotoolkit/testdata.git
+    displayName: 'Clone testdata'
+  - script: |
+      export DATA_PATH=`pwd`/../testdata
+      export MODELS_PATH=`pwd`/../testdata
+      $(BIN_DIR)/MklDnnFunctionalTests --gtest_filter=*smoke*:-smoke_MobileNet/ModelTransformationsTest.LPT/mobilenet_v2_tf_depthwise_batch1_inPluginDisabled_inTestDisabled_asymmetric*
+    workingDirectory: dldt-build
+    displayName: 'MklDnnFunctionalTests'
+    continueOnError: false
+  - script: |
+      export DATA_PATH=`pwd`/../testdata
+      export MODELS_PATH=`pwd`/../testdata
+      $(BIN_DIR)/InferenceEngineCAPITests
+    workingDirectory: dldt-build
+    displayName: 'IE CAPITests'
+    continueOnError: false
+  - script: |
+      export DATA_PATH=`pwd`/../testdata
+      export MODELS_PATH=`pwd`/../testdata
+      export LD_LIBRARY_PATH=`pwd`/$(BIN_DIR)/lib
+      export PYTHONPATH=`pwd`/$(BIN_DIR)/lib/python_api/python3.6
+      env
+      cd ../inference-engine/ie_bridges/python/tests
+      pytest
+    workingDirectory: dldt-build
+    displayName: 'Python API Tests'
+    continueOnError: false
+    enabled: false
+
+- job: Mac
+  # About 200% of total time (perfomace of Mac hosts is unstable)
+  timeoutInMinutes: 180
+  pool:
+    vmImage: 'macOS-10.15'
+  variables:
+    BUILD_TYPE: Release
+    BIN_DIR: ../bin/intel64/$(BUILD_TYPE)
+  steps:
+  - task: UsePythonVersion@0
+    inputs:
+      versionSpec: '3.7'
+  - script: |
+      whoami
+      uname -a
+      which python3
+      gcc --version
+      xcrun --sdk macosx --show-sdk-version
+      env
+      sysctl -a
+    displayName: 'System properties'
+  - script: |
+      brew install cython
+      brew install automake
+    displayName: 'Install dependencies'
+  - script: brew install ninja
+    displayName: 'Install Ninja'
+  - script: git submodule update --init --recursive --jobs 8
+    displayName: 'Clone submodules'
+  - script: |
+      mkdir dldt-build
+      cd dldt-build
+    displayName: 'Create build directory'
+  - script: |
+      export PATH="/usr/local/opt/cython/bin:$PATH"
+      export CC=gcc
+      export CXX=g++
+      # Disable errors with Ninja
+      export CXXFLAGS="-Wno-error=unused-command-line-argument"
+      export CFLAGS="-Wno-error=unused-command-line-argument"
+      cmake .. -GNinja -DVERBOSE_BUILD=ON -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) -DENABLE_PYTHON=ON -DENABLE_TESTS=ON
+    workingDirectory: dldt-build
+    displayName: 'CMake'
+  - script: ninja
+    workingDirectory: dldt-build
+    displayName: 'Build Mac'
+  - script: ls -alR ../bin/
+    workingDirectory: dldt-build
+    displayName: 'List files'
+  - script: $(BIN_DIR)/unit-test --gtest_print_time=1 --gtest_filter=-backend_api.config_unsupported:*IE_GPU*:IE_CPU.onnx_model_sigmoid
+    workingDirectory: dldt-build
+    displayName: 'nGraph UT'
+    continueOnError: false
+  - script: $(BIN_DIR)/InferenceEngineUnitTests
+    workingDirectory: dldt-build
+    displayName: 'IE UT old'
+    continueOnError: false
+  - script: $(BIN_DIR)/ieUnitTests
+    workingDirectory: dldt-build
+    displayName: 'IE UT'
+    continueOnError: false
+  - script: $(BIN_DIR)/cpuUnitTests
+    workingDirectory: dldt-build
+    displayName: 'CPU UT'
+    continueOnError: false
+  - script: $(BIN_DIR)/vpuUnitTests
+    workingDirectory: dldt-build
+    displayName: 'VPU UT'
+    continueOnError: false
+  - script: $(BIN_DIR)/ieFuncTests
+    workingDirectory: dldt-build
+    displayName: 'IE FuncTests'
+    continueOnError: false
+  - script: $(BIN_DIR)/cpuFuncTests
+    workingDirectory: dldt-build
+    displayName: 'CPU FuncTests'
+    continueOnError: false
+  - script: $(BIN_DIR)/MklDnnBehaviorTests
+    workingDirectory: dldt-build
+    displayName: 'MklDnnBehaviorTests'
+    continueOnError: false
+  - script: git clone https://github.com/openvinotoolkit/testdata.git
+    displayName: 'Clone testdata'
+  - script: |
+      export DATA_PATH=`pwd`/../testdata
+      export MODELS_PATH=`pwd`/../testdata
+      $(BIN_DIR)/MklDnnFunctionalTests --gtest_filter=*smoke*:-smoke_MobileNet/ModelTransformationsTest.LPT/mobilenet_v2_tf_depthwise_batch1_inPluginDisabled_inTestDisabled_asymmetric*
+    workingDirectory: dldt-build
+    displayName: 'MklDnnFunctionalTests'
+    continueOnError: false
+  - script: |
+      export DATA_PATH=`pwd`/../testdata
+      export MODELS_PATH=`pwd`/../testdata
+      $(BIN_DIR)/InferenceEngineCAPITests
+    workingDirectory: dldt-build
+    displayName: 'IE CAPITests'
+    continueOnError: false
+
+- job: Win
+  # About 150% of total time
+  timeoutInMinutes: 120
+  pool:
+    #vmImage: 'vs2017-win2016'
+    name: WIN_VMSS_VENV_F8S_WU2
+  variables:
+    BUILD_TYPE: Release
+    BUILD_DIR: D:\dldt-build
+    BIN_DIR: ..\bin\intel64
+    MSVS_VARS_PATH: C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat
+    MSVC_COMPILER_PATH: C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Tools\MSVC\14.24.28314\bin\Hostx64\x64\cl.exe
+  steps:
+  - script: |
+      where python3
+      wmic computersystem get TotalPhysicalMemory
+      wmic cpu list
+      wmic logicaldisk get description,name
+      wmic VOLUME list
+      set
+    displayName: 'System properties'
+  - script: |
+      certutil -urlcache -split -f https://github.com/ninja-build/ninja/releases/download/v1.10.0/ninja-win.zip ninja-win.zip
+      powershell -command "Expand-Archive -Force ninja-win.zip"
+    displayName: Install Ninja
+  - script: git submodule update --init --recursive --jobs 8
+    displayName: 'Clone submodules'
+  - script: |
+      rd /Q /S $(BUILD_DIR)
+      mkdir $(BUILD_DIR)\bin
+      rd /Q /S dldt-build
+      mkdir dldt-build
+    displayName: 'Create build directory'
+  - script: |
+      set PATH=$(Build.Repository.LocalPath)\ninja-win;%PATH%
+      call "$(MSVS_VARS_PATH)" && cmake -GNinja -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) -DENABLE_TESTS=ON -DCMAKE_C_COMPILER:PATH="$(MSVC_COMPILER_PATH)" -DCMAKE_CXX_COMPILER:PATH="$(MSVC_COMPILER_PATH)" $(Build.Repository.LocalPath)
+    workingDirectory: $(BUILD_DIR)
+    displayName: 'CMake'
+  - script: |
+      set PATH=$(Build.Repository.LocalPath)\ninja-win;%PATH%
+      call "$(MSVS_VARS_PATH)" && ninja
+    workingDirectory: $(BUILD_DIR)
+    displayName: 'Build Win'
+  - script: dir ..\bin\ /s /b
+    workingDirectory: dldt-build
+    displayName: 'List files'
+  - script: |
+      set PATH=$(Build.Repository.LocalPath)\inference-engine\temp\tbb\bin;%PATH%
+      $(BIN_DIR)\unit-test --gtest_print_time=1 --gtest_filter=-backend_api.config_unsupported:*IE_GPU*
+    workingDirectory: dldt-build
+    displayName: 'nGraph UT'
+    continueOnError: false
+  - script: |
+      set PATH=$(Build.Repository.LocalPath)\inference-engine\temp\tbb\bin;%PATH%
+      $(BIN_DIR)\InferenceEngineUnitTests
+    workingDirectory: dldt-build
+    displayName: 'IE UT old'
+    continueOnError: false
+  - script: |
+      set PATH=$(Build.Repository.LocalPath)\inference-engine\temp\tbb\bin;%PATH%
+      $(BIN_DIR)\ieUnitTests
+    workingDirectory: dldt-build
+    displayName: 'IE UT'
+    continueOnError: false
+  - script: |
+      set PATH=$(Build.Repository.LocalPath)\inference-engine\temp\tbb\bin;%PATH%
+      $(BIN_DIR)\cpuUnitTests
+    workingDirectory: dldt-build
+    displayName: 'CPU UT'
+    continueOnError: false
+  - script: |
+      set PATH=$(Build.Repository.LocalPath)\inference-engine\temp\tbb\bin;%PATH%
+      $(BIN_DIR)\gnaUnitTests
+    workingDirectory: dldt-build
+    displayName: 'GNA UT'
+    continueOnError: false
+  - script: |
+      set PATH=$(Build.Repository.LocalPath)\inference-engine\temp\tbb\bin;%PATH%
+      $(BIN_DIR)\vpuUnitTests
+    workingDirectory: dldt-build
+    displayName: 'VPU UT'
+    continueOnError: false
+  - script: |
+      set PATH=$(Build.Repository.LocalPath)\inference-engine\temp\tbb\bin;%PATH%
+      $(BIN_DIR)\ieFuncTests
+    workingDirectory: dldt-build
+    displayName: 'IE FuncTests'
+    continueOnError: false
+  - script: |
+      set PATH=$(Build.Repository.LocalPath)\inference-engine\temp\tbb\bin;%PATH%
+      $(BIN_DIR)\cpuFuncTests
+    workingDirectory: dldt-build
+    displayName: 'CPU FuncTests'
+    continueOnError: false
+  - script: |
+      set PATH=$(Build.Repository.LocalPath)\inference-engine\temp\tbb\bin;%PATH%
+      $(BIN_DIR)\MklDnnBehaviorTests
+    workingDirectory: dldt-build
+    displayName: 'MklDnnBehaviorTests'
+    continueOnError: false
+  - script: git clone https://github.com/openvinotoolkit/testdata.git
+    workingDirectory: $(BUILD_DIR)
+    displayName: 'Clone testdata'
+  - script: |
+      set PATH=$(Build.Repository.LocalPath)\inference-engine\temp\tbb\bin;$(Build.Repository.LocalPath)\inference-engine\temp\opencv_4.3.0\opencv\bin;%PATH%
+      set DATA_PATH=$(BUILD_DIR)\testdata
+      set MODELS_PATH=$(BUILD_DIR)\testdata
+      $(BIN_DIR)\MklDnnFunctionalTests --gtest_filter=*smoke*:-smoke_MobileNet/ModelTransformationsTest.LPT/mobilenet_v2_tf_depthwise_batch1_inPluginDisabled_inTestDisabled_asymmetric*
+    workingDirectory: dldt-build
+    displayName: 'MklDnnFunctionalTests'
+    continueOnError: false
+  - script: |
+      set PATH=$(Build.Repository.LocalPath)\inference-engine\temp\tbb\bin;$(Build.Repository.LocalPath)\inference-engine\temp\opencv_4.3.0\opencv\bin;%PATH%
+      set DATA_PATH=$(BUILD_DIR)\testdata
+      set MODELS_PATH=$(BUILD_DIR)\testdata
+      $(BIN_DIR)\InferenceEngineCAPITests
+    workingDirectory: dldt-build
+    displayName: 'IE CAPITests'
+    continueOnError: false

build-instruction.md

@@ -0,0 +1,704 @@
+# Build OpenVINO™ Inference Engine
+
+## Contents
+
+- [Introduction](#introduction)
+- [Build on Linux\* Systems](#build-on-linux-systems)
+  - [Software Requirements](#software-requirements)
+  - [Build Steps](#build-steps)
+  - [Additional Build Options](#additional-build-options)
+- [Build for Raspbian* Stretch OS](#build-for-raspbian-stretch-os)
+  - [Hardware Requirements](#hardware-requirements)
+  - [Native Compilation](#native-compilation)
+  - [Cross Compilation Using Docker\*](#cross-compilation-using-docker)
+  - [Additional Build Options](#additional-build-options-1)
+- [Build on Windows* Systems](#build-on-windows-systems)
+  - [Software Requirements](#software-requirements-1)
+  - [Build Steps](#build-steps-1)
+  - [Additional Build Options](#additional-build-options-2)
+  - [Building Inference Engine with Ninja* Build System](#building-inference-engine-with-ninja-build-system)
+- [Build on macOS\* Systems](#build-on-macos-systems)
+  - [Software Requirements](#software-requirements-2)
+  - [Build Steps](#build-steps-2)
+  - [Additional Build Options](#additional-build-options-3)
+- [Build on Android\* Systems](#build-on-android-systems)
+  - [Software Requirements](#software-requirements-3)
+  - [Build Steps](#build-steps-3)
+- [Use Custom OpenCV Builds for Inference Engine](#use-custom-opencv-builds-for-inference-engine)
+- [Add Inference Engine to Your Project](#add-inference-engine-to-your-project)
+- [(Optional) Additional Installation Steps for the Intel® Movidius™ Neural Compute Stick and Neural Compute Stick 2](#optional-additional-installation-steps-for-the-intel-movidius-neural-compute-stick-and-neural-compute-stick-2)
+  - [For Linux, Raspbian Stretch* OS](#for-linux-raspbian-stretch-os)
+- [Next Steps](#next-steps)
+- [Additional Resources](#additional-resources)
+
+## Introduction
+
+The Inference Engine can infer models in different formats with various input
+and output formats.
+
+The open source version of Inference Engine includes the following plugins:
+
+| PLUGIN               | DEVICE TYPES |
+| ---------------------| -------------|
+| CPU plugin           | Intel® Xeon® with Intel® AVX2 and AVX512, Intel® Core™ Processors with Intel® AVX2, Intel® Atom® Processors with Intel® SSE |
+| GPU plugin           | Intel® Processor Graphics, including Intel® HD Graphics and Intel® Iris® Graphics |
+| GNA plugin           | Intel® Speech Enabling Developer Kit, Amazon Alexa\* Premium Far-Field Developer Kit, Intel® Pentium® Silver processor J5005, Intel® Celeron® processor J4005, Intel® Core™ i3-8121U processor |
+| MYRIAD plugin        | Intel® Movidius™ Neural Compute Stick powered by the Intel® Movidius™ Myriad™ 2, Intel® Neural Compute Stick 2 powered by the Intel® Movidius™ Myriad™ X |
+| Heterogeneous plugin | Heterogeneous plugin enables computing for inference on one network on several Intel® devices. |
+
+Inference Engine plugin for Intel® FPGA is distributed only in a binary form,
+as a part of [Intel® Distribution of OpenVINO™].
+
+## Build on Linux\* Systems
+
+The software was validated on:
+- Ubuntu\* 18.04 (64-bit) with default GCC\* 7.5.0
+- Ubuntu\* 16.04 (64-bit) with default GCC\* 5.4.0
+- CentOS\* 7.4 (64-bit) with default GCC\* 4.8.5
+
+### Software Requirements
+- [CMake]\* 3.11 or higher
+- GCC\* 4.8 or higher to build the Inference Engine
+- Python 3.5 or higher for Inference Engine Python API wrapper
+- (Optional) [Install Intel® Graphics Compute Runtime for OpenCL™ Driver package 19.41.14441].
+
+### Build Steps
+1. Clone submodules:
+    ```sh
+    cd openvino
+    git submodule update --init --recursive
+    ```
+2. Install build dependencies using the `install_dependencies.sh` script in the
+   project root folder.
+   ```sh
+   chmod +x install_dependencies.sh
+   ```
+   ```sh
+   ./install_dependencies.sh
+   ```
+3. By default, the build enables the Inference Engine GPU plugin to infer models
+   on your Intel® Processor Graphics. This requires you to
+   [Install Intel® Graphics Compute Runtime for OpenCL™ Driver package 19.41.14441]
+   before running the build. If you don't want to use the GPU plugin, use the
+   `-DENABLE_CLDNN=OFF` CMake build option and skip the installation of the
+   Intel® Graphics Compute Runtime for OpenCL™ Driver.
+4. Create a build folder:
+```sh
+  mkdir build && cd build
+```
+5. Inference Engine uses a CMake-based build system. In the created `build`
+   directory, run `cmake` to fetch project dependencies and create Unix
+   makefiles, then run `make` to build the project:
+```sh
+  cmake -DCMAKE_BUILD_TYPE=Release ..
+  make --jobs=$(nproc --all)
+```
+
+### Additional Build Options
+
+You can use the following additional build options:
+
+- The default build uses an internal JIT GEMM implementation.
+
+- To switch to an OpenBLAS\* implementation, use the `GEMM=OPENBLAS` option with
+  `BLAS_INCLUDE_DIRS` and `BLAS_LIBRARIES` CMake options to specify a path to the
+  OpenBLAS headers and library. For example, the following options on CentOS\*:
+  `-DGEMM=OPENBLAS -DBLAS_INCLUDE_DIRS=/usr/include/openblas -DBLAS_LIBRARIES=/usr/lib64/libopenblas.so.0`.
+
+- To switch to the optimized MKL-ML\* GEMM implementation, use `-DGEMM=MKL`
+  and `-DMKLROOT=<path_to_MKL>` CMake options to specify a path to unpacked
+  MKL-ML with the `include` and `lib` folders. MKL-ML\* package can be downloaded
+  from the Intel® [MKL-DNN repository].
+
+- Threading Building Blocks (TBB) is used by default. To build the Inference
+  Engine with OpenMP\* threading, set the `-DTHREADING=OMP` option.
+
+- Required versions of TBB and OpenCV packages are downloaded automatically by
+  the CMake-based script. If you want to use the automatically downloaded
+  packages but you already have installed TBB or OpenCV packages configured in
+  your environment, you may need to clean the `TBBROOT` and `OpenCV_DIR`
+  environment variables before running the `cmake` command, otherwise they
+  will not be downloaded and the build may fail if incompatible versions were
+  installed.
+
+- If the CMake-based build script can not find and download the OpenCV package
+  that is supported on your platform, or if you want to use a custom build of
+  the OpenCV library, refer to the
+  [Use Custom OpenCV Builds](#use-custom-opencv-builds-for-inference-engine)
+  section for details.
+
+- To build the Python API wrapper:
+  1. Install all additional packages listed in the
+     `/inference-engine/ie_bridges/python/requirements.txt` file:
+     ```sh
+     pip install -r requirements.txt  
+     ```
+  2. Use the `-DENABLE_PYTHON=ON` option. To specify an exact Python version, use the following
+     options:
+     ```
+     -DPYTHON_EXECUTABLE=`which python3.7` \
+     -DPYTHON_LIBRARY=/usr/lib/x86_64-linux-gnu/libpython3.7m.so \
+     -DPYTHON_INCLUDE_DIR=/usr/include/python3.7
+     ```
+
+- To switch the CPU and GPU plugins off/on, use the `cmake` options
+  `-DENABLE_MKL_DNN=ON/OFF` and `-DENABLE_CLDNN=ON/OFF` respectively.
+
+- nGraph-specific compilation options:
+  `-DNGRAPH_ONNX_IMPORT_ENABLE=ON` enables the building of the nGraph ONNX importer.
+  `-DNGRAPH_JSON_ENABLE=ON` enables nGraph JSON-based serialization.
+  `-DNGRAPH_DEBUG_ENABLE=ON` enables additional debug prints.
+
+## Build for Raspbian Stretch* OS
+
+> **NOTE**: Only the MYRIAD plugin is supported.
+
+### Hardware Requirements
+* Raspberry Pi\* 2 or 3 with Raspbian\* Stretch OS (32-bit). Check that it's CPU supports ARMv7 instruction set (`uname -m` command returns `armv7l`).
+
+  > **NOTE**: Despite the Raspberry Pi\* CPU is ARMv8, 32-bit OS detects ARMv7 CPU instruction set. The default `gcc` compiler applies ARMv6 architecture flag for compatibility with lower versions of boards. For more information, run the `gcc -Q --help=target` command and refer to the description of the `-march=` option.
+
+You can compile the Inference Engine for Raspberry Pi\* in one of the two ways:
+* [Native Compilation](#native-compilation), which is the simplest way, but time-consuming
+* [Cross Compilation Using Docker*](#cross-compilation-using-docker), which is the recommended way
+
+### Native Compilation
+Native compilation of the Inference Engine is the most straightforward solution. However, it might take at least one hour to complete on Raspberry Pi\* 3.
+
+1. Install dependencies:
+
+  ```bash
+  sudo apt-get update
+  sudo apt-get install -y git cmake libusb-1.0-0-dev
+  ```
+
+2. Go to the cloned `openvino` repository:
+
+  ```bash
+  cd openvino
+  ```
+
+3. Initialize submodules:
+
+  ```bash
+  git submodule update --init --recursive
+  ```
+
+4. Create a build folder:
+
+  ```bash
+  mkdir build && cd build
+  ```
+
+5. Build the Inference Engine:
+
+  ```bash
+  cmake -DCMAKE_BUILD_TYPE=Release \
+        -DENABLE_SSE42=OFF \
+        -DTHREADING=SEQ \
+        -DENABLE_GNA=OFF .. && make
+  ```
+
+### Cross Compilation Using Docker*
+
+  This compilation was tested on the following configuration:
+
+  * Host: Ubuntu\* 18.04 (64-bit, Intel® Core™ i7-6700K CPU @ 4.00GHz × 8)
+  * Target: Raspbian\* Stretch (32-bit, ARMv7, Raspberry Pi\* 3)
+
+1. Install Docker\*:
+
+  ```bash
+  sudo apt-get install -y docker.io
+  ```
+
+2. Add a current user to `docker` group:
+
+  ```bash
+  sudo usermod -a -G docker $USER
+  ```
+
+  Log out and log in for this to take effect.
+
+3. Create a directory named `ie_cross_armhf` and add a text file named `Dockerfile`
+with the following content:
+
+  ```docker
+  FROM debian:stretch
+
+  USER root
+
+  RUN dpkg --add-architecture armhf && \
+      apt-get update && \
+      apt-get install -y --no-install-recommends \
+      build-essential \
+      crossbuild-essential-armhf \
+      git \
+      wget \
+      libusb-1.0-0-dev:armhf \
+      libgtk-3-dev:armhf \
+      libavcodec-dev:armhf \
+      libavformat-dev:armhf \
+      libswscale-dev:armhf \
+      libgstreamer1.0-dev:armhf \
+      libgstreamer-plugins-base1.0-dev:armhf \
+      libpython3-dev:armhf \
+      python3-pip
+
+  RUN wget https://www.cmake.org/files/v3.14/cmake-3.14.3.tar.gz && \
+      tar xf cmake-3.14.3.tar.gz && \
+      (cd cmake-3.14.3 && ./bootstrap --parallel=$(nproc --all) && make --jobs=$(nproc --all) && make install) && \
+      rm -rf cmake-3.14.3 cmake-3.14.3.tar.gz
+  ```
+
+  It uses the Debian\* Stretch (Debian 9) OS for compilation because it is a base of the Raspbian\* Stretch.
+
+4. Build a Docker\* image:
+
+  ```bash
+  docker image build -t ie_cross_armhf ie_cross_armhf
+  ```
+
+5. Run Docker\* container with mounted source code folder from host:
+
+  ```bash
+  docker run -it -v /absolute/path/to/openvino:/openvino ie_cross_armhf /bin/bash
+  ```
+
+6. While in the container:
+
+    1. Go to the cloned `openvino` repository:
+
+      ```bash
+      cd openvino
+      ```
+
+    2. Create a build folder:
+
+      ```bash
+      mkdir build && cd build
+      ```
+
+    3. Build the Inference Engine:
+
+      ```bash
+      cmake -DCMAKE_BUILD_TYPE=Release \
+          -DCMAKE_TOOLCHAIN_FILE="../cmake/arm.toolchain.cmake" \
+          -DTHREADS_PTHREAD_ARG="-pthread" \
+          -DENABLE_SSE42=OFF \
+          -DTHREADING=SEQ \
+          -DENABLE_GNA=OFF .. && make --jobs=$(nproc --all)
+      ```
+
+7. Press **Ctrl+D** to exit from Docker. You can find the resulting binaries
+   in the `openvino/bin/armv7l/` directory and the OpenCV*
+   installation in the `openvino/inference-engine/temp`.
+
+>**NOTE**: Native applications that link to cross-compiled Inference Engine
+library require an extra compilation flag `-march=armv7-a`.
+
+### Additional Build Options
+
+You can use the following additional build options:
+
+- Required versions of OpenCV packages are downloaded automatically by the
+  CMake-based script. If you want to use the automatically downloaded packages
+  but you already have installed OpenCV packages configured in your environment,
+  you may need to clean the `OpenCV_DIR` environment variable before running
+  the `cmake` command; otherwise they won't be downloaded and the build may
+  fail if incompatible versions were installed.
+
+- If the CMake-based build script cannot find and download the OpenCV package
+  that is supported on your platform, or if you want to use a custom build of
+  the OpenCV library, see: [Use Custom OpenCV Builds](#use-custom-opencv-builds-for-inference-engine)
+  for details.
+
+- To build Python API wrapper, install `libpython3-dev:armhf` and `python3-pip`
+  packages using `apt-get`; then install `numpy` and `cython` python modules
+  via `pip3`, adding the following options:
+   ```sh
+   -DENABLE_PYTHON=ON \
+   -DPYTHON_EXECUTABLE=/usr/bin/python3.5 \
+   -DPYTHON_LIBRARY=/usr/lib/arm-linux-gnueabihf/libpython3.5m.so \
+   -DPYTHON_INCLUDE_DIR=/usr/include/python3.5
+   ```
+
+- nGraph-specific compilation options:
+  `-DNGRAPH_ONNX_IMPORT_ENABLE=ON` enables the building of the nGraph ONNX importer.
+  `-DNGRAPH_JSON_ENABLE=ON` enables nGraph JSON-based serialization.
+  `-DNGRAPH_DEBUG_ENABLE=ON` enables additional debug prints.
+
+## Build on Windows* Systems
+
+The software was validated on:
+- Microsoft\* Windows\* 10 (64-bit) with Visual Studio 2017 and Intel® C++
+  Compiler 2018 Update 3
+
+### Software Requirements
+- [CMake]\*3.11 or higher
+- Microsoft\* Visual Studio 2017, 2019 or [Intel® C++ Compiler] 18.0
+- (Optional) Intel® Graphics Driver for Windows* (26.20) [driver package].
+- Python 3.5 or higher for Inference Engine Python API wrapper
+
+### Build Steps
+
+1. Clone submodules:
+    ```sh
+    git submodule update --init --recursive
+    ```
+2. By default, the build enables the Inference Engine GPU plugin to infer models
+   on your Intel® Processor Graphics. This requires you to [download and install
+   the Intel® Graphics Driver for Windows (26.20) [driver package] before
+   running the build. If you don't want to use the GPU plugin, use the
+   `-DENABLE_CLDNN=OFF` CMake build option and skip the installation of the
+   Intel® Graphics Driver.    
+3. Create build directory:
+    ```sh
+    mkdir build
+    ```
+4. In the `build` directory, run `cmake` to fetch project dependencies and
+   generate a Visual Studio solution.
+
+   For Microsoft\* Visual Studio 2017:
+```sh
+cmake -G "Visual Studio 15 2017 Win64" -DCMAKE_BUILD_TYPE=Release ..
+```
+
+   For Microsoft\* Visual Studio 2019:
+```sh
+cmake -G "Visual Studio 16 2019" -A x64 -DCMAKE_BUILD_TYPE=Release ..
+```
+
+   For Intel® C++ Compiler 18:
+```sh
+cmake -G "Visual Studio 15 2017 Win64" -T "Intel C++ Compiler 18.0" ^
+    -DCMAKE_BUILD_TYPE=Release ^
+    -DICCLIB="C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\compiler\lib" ..
+```
+
+5. Build generated solution in Visual Studio or run
+   `cmake --build . --config Release` to build from the command line.
+
+6. Before running the samples, add paths to the TBB and OpenCV binaries used for
+   the build to the `%PATH%` environment variable. By default, TBB binaries are
+   downloaded by the CMake-based script to the `<openvino_repo>/inference-engine/temp/tbb/bin`
+   folder, OpenCV binaries to the `<openvino_repo>/inference-engine/temp/opencv_4.3.0/opencv/bin`
+   folder.
+
+### Additional Build Options
+
+- Internal JIT GEMM implementation is used by default.
+
+- To switch to OpenBLAS GEMM implementation, use the `-DGEMM=OPENBLAS` CMake
+  option and specify path to OpenBLAS using the `-DBLAS_INCLUDE_DIRS=<OPENBLAS_DIR>\include`
+  and `-DBLAS_LIBRARIES=<OPENBLAS_DIR>\lib\libopenblas.dll.a` options. Download
+  a prebuilt OpenBLAS\* package via the [OpenBLAS] link. mingw64* runtime
+  dependencies can be downloaded via the [mingw64\* runtime dependencies] link.
+
+- To switch to the optimized MKL-ML\* GEMM implementation, use the
+  `-DGEMM=MKL` and `-DMKLROOT=<path_to_MKL>` CMake options to specify a path to
+  unpacked MKL-ML with the `include` and `lib` folders. MKL-ML\* package can be
+  downloaded from the Intel&reg; [MKL-DNN repository for Windows].
+
+- Threading Building Blocks (TBB) is used by default. To build the Inference
+  Engine with OpenMP* threading, set the `-DTHREADING=OMP` option.
+
+- Required versions of TBB and OpenCV packages are downloaded automatically by
+  the CMake-based script. If you want to use the automatically-downloaded
+  packages but you already have installed TBB or OpenCV packages configured in
+  your environment, you may need to clean the `TBBROOT` and `OpenCV_DIR`
+  environment variables before running the `cmake` command; otherwise they won't
+  be downloaded and the build may fail if incompatible versions were installed.
+
+- If the CMake-based build script can not find and download the OpenCV package
+  that is supported on your platform, or if you want to use a custom build of
+  the OpenCV library, refer to the [Use Custom OpenCV Builds](#use-custom-opencv-builds-for-inference-engine)
+  section for details.
+
+- To switch off/on the CPU and GPU plugins, use the `cmake` options
+  `-DENABLE_MKL_DNN=ON/OFF` and `-DENABLE_CLDNN=ON/OFF` respectively.
+
+- To build the Python API wrapper, use the `-DENABLE_PYTHON=ON` option. To
+  specify an exact Python version, use the following options:
+   ```sh
+   -DPYTHON_EXECUTABLE="C:\Program Files\Python37\python.exe" ^
+   -DPYTHON_LIBRARY="C:\Program Files\Python37\libs\python37.lib" ^
+   -DPYTHON_INCLUDE_DIR="C:\Program Files\Python37\include"
+   ```
+
+- nGraph-specific compilation options:
+  `-DNGRAPH_ONNX_IMPORT_ENABLE=ON` enables the building of the nGraph ONNX importer.
+  `-DNGRAPH_JSON_ENABLE=ON` enables nGraph JSON-based serialization.
+  `-DNGRAPH_DEBUG_ENABLE=ON` enables additional debug prints.
+
+### Building Inference Engine with Ninja* Build System
+
+```sh
+call "C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\bin\ipsxe-comp-vars.bat" intel64 vs2017
+set CXX=icl
+set CC=icl
+:: clean TBBROOT value set by ipsxe-comp-vars.bat, required TBB package will be downloaded by openvino cmake script
+set TBBROOT=
+cmake -G Ninja -Wno-dev -DCMAKE_BUILD_TYPE=Release ..
+cmake --build . --config Release
+```
+
+## Build on macOS* Systems
+
+> **NOTE**: The current version of the OpenVINO™ toolkit for macOS* supports
+inference on Intel CPUs only.
+
+The software was validated on:
+- macOS\* 10.14, 64-bit
+
+### Software Requirements
+
+- [CMake]\* 3.11 or higher
+- Clang\* compiler from Xcode\* 10.1 or higher
+- Python\* 3.5 or higher for the Inference Engine Python API wrapper
+
+### Build Steps
+
+1. Clone submodules:
+    ```sh
+    cd openvino
+    git submodule update --init --recursive
+    ```
+2. Install build dependencies using the `install_dependencies.sh` script in the
+   project root folder:
+   ```sh
+   chmod +x install_dependencies.sh
+   ```
+   ```sh
+   ./install_dependencies.sh
+   ```
+3. Create a build folder:
+```sh
+  mkdir build
+```
+4. Inference Engine uses a CMake-based build system. In the created `build`
+   directory, run `cmake` to fetch project dependencies and create Unix makefiles,
+   then run `make` to build the project:
+```sh
+  cmake -DCMAKE_BUILD_TYPE=Release ..
+  make --jobs=$(nproc --all)
+```
+### Additional Build Options
+
+You can use the following additional build options:
+
+- Internal JIT GEMM implementation is used by default.
+
+- To switch to the optimized MKL-ML\* GEMM implementation, use `-DGEMM=MKL` and
+  `-DMKLROOT=<path_to_MKL>` cmake options to specify a path to unpacked MKL-ML
+  with the `include` and `lib` folders. MKL-ML\* [package for Mac] can be downloaded
+  [here](https://github.com/intel/mkl-dnn/releases/download/v0.19/mklml_mac_2019.0.5.20190502.tgz)
+
+- Threading Building Blocks (TBB) is used by default. To build the Inference
+  Engine with OpenMP* threading, set the `-DTHREADING=OMP` option.
+
+- Required versions of TBB and OpenCV packages are downloaded automatically by
+  the CMake-based script. If you want to use the automatically downloaded
+  packages but you already have installed TBB or OpenCV packages configured in
+  your environment, you may need to clean the `TBBROOT` and `OpenCV_DIR`
+  environment variables before running the `cmake` command, otherwise they won't
+  be downloaded and the build may fail if incompatible versions were installed.
+
+- If the CMake-based build script can not find and download the OpenCV package
+  that is supported on your platform, or if you want to use a custom build of
+  the OpenCV library, refer to the
+  [Use Custom OpenCV Builds](#use-custom-opencv-builds-for-inference-engine)
+  section for details.
+
+- To build the Python API wrapper, use the `-DENABLE_PYTHON=ON` option. To
+  specify an exact Python version, use the following options:
+```sh
+  -DPYTHON_EXECUTABLE=/Library/Frameworks/Python.framework/Versions/3.7/bin/python3.7 \
+  -DPYTHON_LIBRARY=/Library/Frameworks/Python.framework/Versions/3.7/lib/libpython3.7m.dylib \
+  -DPYTHON_INCLUDE_DIR=/Library/Frameworks/Python.framework/Versions/3.7/include/python3.7m
+```
+
+- nGraph-specific compilation options:
+  `-DNGRAPH_ONNX_IMPORT_ENABLE=ON` enables the building of the nGraph ONNX importer.
+  `-DNGRAPH_JSON_ENABLE=ON` enables nGraph JSON-based serialization.
+  `-DNGRAPH_DEBUG_ENABLE=ON` enables additional debug prints.
+
+## Build on Android* Systems
+
+This section describes how to build Inference Engine for Android x86 (64-bit) operating systems.
+
+### Software Requirements
+
+- [CMake]\* 3.11 or higher
+- Android NDK (this guide has been validated with r20 release)
+
+### Build Steps
+
+1. Download and unpack Android NDK: https://developer.android.com/ndk/downloads. Let's assume that `~/Downloads` is used as a working folder.
+  ```sh
+  cd ~/Downloads
+  wget https://dl.google.com/android/repository/android-ndk-r20-linux-x86_64.zip
+
+  unzip android-ndk-r20-linux-x86_64.zip
+  mv android-ndk-r20 android-ndk
+  ```
+
+2. Clone submodules
+  ```sh
+  cd openvino
+  git submodule update --init --recursive
+  ```
+
+3. Create a build folder:
+  ```sh
+    mkdir build
+  ```
+
+4. Change working directory to `build` and run `cmake` to create makefiles. Then run `make`.
+  ```sh
+  cd build
+
+  cmake .. \
+    -DCMAKE_TOOLCHAIN_FILE=~/Downloads/android-ndk/build/cmake/android.toolchain.cmake \
+    -DANDROID_ABI=x86_64 \
+    -DANDROID_PLATFORM=21 \
+    -DANDROID_STL=c++_shared \
+    -DENABLE_OPENCV=OFF
+
+  make --jobs=$(nproc --all)
+  ```
+
+  * `ANDROID_ABI` specifies target architecture (`x86_64`)
+  * `ANDROID_PLATFORM` - Android API version
+  * `ANDROID_STL` specifies that shared C++ runtime is used. Copy `~/Downloads/android-ndk/sources/cxx-stl/llvm-libc++/libs/x86_64/libc++_shared.so` from Android NDK along with built binaries
+
+
+## Use Custom OpenCV Builds for Inference Engine
+
+> **NOTE**: The recommended and tested version of OpenCV is 4.4.0.
+
+Required versions of OpenCV packages are downloaded automatically during the
+building Inference Engine library. If the build script can not find and download
+the OpenCV package that is supported on your platform, you can use one of the
+following options:
+
+* Download the most suitable version from the list of available pre-build
+  packages from [https://download.01.org/opencv/2020/openvinotoolkit] from the
+  `<release_version>/inference_engine` directory.
+
+* Use a system-provided OpenCV package (e.g with running the
+  `apt install libopencv-dev` command). The following modules must be enabled:
+  `imgcodecs`, `videoio`, `highgui`.
+
+* Get the OpenCV package using a package manager: pip, conda, conan etc. The
+  package must have the development components included (header files and CMake
+  scripts).
+
+* Build OpenCV from source using the [build instructions](https://docs.opencv.org/master/df/d65/tutorial_table_of_content_introduction.html) on the OpenCV site.
+
+After you got the built OpenCV library, perform the following preparation steps
+before running the Inference Engine build:
+
+1. Set the `OpenCV_DIR` environment variable to the directory where the
+   `OpenCVConfig.cmake` file of you custom OpenCV build is located.
+2. Disable the package automatic downloading with using the `-DENABLE_OPENCV=OFF`
+   option for CMake-based build script for Inference Engine.
+
+## Add Inference Engine to Your Project
+
+For CMake projects, set the `InferenceEngine_DIR` environment variable:
+
+```sh
+export InferenceEngine_DIR=/path/to/openvino/build/
+```
+
+Then you can find Inference Engine by `find_package`:
+
+```cmake
+find_package(InferenceEngine)
+include_directories(${InferenceEngine_INCLUDE_DIRS})
+target_link_libraries(${PROJECT_NAME} ${InferenceEngine_LIBRARIES} dl)
+```
+
+## (Optional) Additional Installation Steps for the Intel® Movidius™ Neural Compute Stick and Neural Compute Stick 2
+
+> **NOTE**: These steps are only required if you want to perform inference on
+Intel® Movidius™ Neural Compute Stick or the Intel® Neural Compute Stick 2 using
+the Inference Engine MYRIAD Plugin. See also [Intel® Neural Compute Stick 2 Get Started].
+
+### For Linux, Raspbian\* Stretch OS
+
+1. Add the current Linux user to the `users` group; you will need to log out and
+   log in for it to take effect:
+```sh
+sudo usermod -a -G users "$(whoami)"
+```
+
+2. To perform inference on Intel® Movidius™ Neural Compute Stick and Intel®
+   Neural Compute Stick 2, install the USB rules as follows:
+```sh
+cat <<EOF > 97-myriad-usbboot.rules
+SUBSYSTEM=="usb", ATTRS{idProduct}=="2150", ATTRS{idVendor}=="03e7", GROUP="users", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
+SUBSYSTEM=="usb", ATTRS{idProduct}=="2485", ATTRS{idVendor}=="03e7", GROUP="users", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
+SUBSYSTEM=="usb", ATTRS{idProduct}=="f63b", ATTRS{idVendor}=="03e7", GROUP="users", MODE="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
+EOF
+```
+```sh
+sudo cp 97-myriad-usbboot.rules /etc/udev/rules.d/
+```
+```sh
+sudo udevadm control --reload-rules
+```
+```sh
+sudo udevadm trigger
+```
+```sh
+sudo ldconfig
+```
+```sh
+rm 97-myriad-usbboot.rules
+```
+
+## Next Steps
+
+Congratulations, you have built the Inference Engine. To get started with the
+OpenVINO™, proceed to the Get Started guides:
+
+* [Get Started with Deep Learning Deployment Toolkit on Linux*](get-started-linux.md)
+
+## Notice
+
+To enable some additional nGraph features and use your custom nGraph library with the OpenVINO™ binary package,
+make sure the following:
+- nGraph library was built with the same version which is used in the Inference Engine.
+- nGraph library and the Inference Engine were built with the same compilers. Otherwise you might face application binary interface (ABI) problems.
+
+To prepare your custom nGraph library for distribution, which includes collecting all headers, copy
+binaries, and so on, use the `install` CMake target.
+This target collects all dependencies, prepares the nGraph package and copies it to a separate directory.
+
+## Additional Resources
+
+* [OpenVINO™ Release Notes](https://software.intel.com/en-us/articles/OpenVINO-RelNotes)
+* [Introduction to Intel® Deep Learning Deployment Toolkit](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Introduction.html)
+* [Inference Engine Samples Overview](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Samples_Overview.html)
+* [Inference Engine Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Deep_Learning_Inference_Engine_DevGuide.html)
+* [Model Optimizer Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html)
+
+---
+\* Other names and brands may be claimed as the property of others.
+
+
+[Intel® Distribution of OpenVINO™]:https://software.intel.com/en-us/openvino-toolkit
+[CMake]:https://cmake.org/download/
+[Install Intel® Graphics Compute Runtime for OpenCL™ Driver package 19.41.14441]:https://github.com/intel/compute-runtime/releases/tag/19.41.14441
+[MKL-DNN repository]:https://github.com/intel/mkl-dnn/releases/download/v0.19/mklml_lnx_2019.0.5.20190502.tgz
+[MKL-DNN repository for Windows]:(https://github.com/intel/mkl-dnn/releases/download/v0.19/mklml_win_2019.0.5.20190502.zip)
+[OpenBLAS]:https://sourceforge.net/projects/openblas/files/v0.2.14/OpenBLAS-v0.2.14-Win64-int64.zip/download
+[mingw64\* runtime dependencies]:https://sourceforge.net/projects/openblas/files/v0.2.14/mingw64_dll.zip/download
+[https://download.01.org/opencv/2020/openvinotoolkit]:https://download.01.org/opencv/2020/openvinotoolkit
+[build instructions]:https://docs.opencv.org/master/df/d65/tutorial_table_of_content_introduction.html
+[driver package]:https://downloadcenter.intel.com/download/29335/Intel-Graphics-Windows-10-DCH-Drivers
+[Intel® Neural Compute Stick 2 Get Started]:https://software.intel.com/en-us/neural-compute-stick/get-started
+[Intel® C++ Compiler]:https://software.intel.com/en-us/intel-parallel-studio-xe
+[OpenBLAS]:https://sourceforge.net/projects/openblas/files/v0.2.14/OpenBLAS-v0.2.14-Win64-int64.zip/download

cmake/api_validator/api_validator.cmake

@@ -1,128 +0,0 @@
-# Copyright (C) 2020 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-if(WIN32)
-    set(PROGRAMFILES_ENV "ProgramFiles(X86)")
-    file(TO_CMAKE_PATH $ENV{${PROGRAMFILES_ENV}} PROGRAMFILES)
-    set(UWP_SDK_PATH "${PROGRAMFILES}/Windows Kits/10/bin/${CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION}/x64")
-
-    message(STATUS "Trying to find apivalidator in: ${UWP_SDK_PATH}")
-    find_host_program(UWP_API_VALIDATOR
-                      NAMES apivalidator
-                      PATHS "${UWP_SDK_PATH}"
-                      DOC "ApiValidator for UWP compliance")
-
-    if(UWP_API_VALIDATOR)
-        message(STATUS "Found apivalidator: ${UWP_API_VALIDATOR}")
-    endif()
-endif()
-
-function(_ie_add_api_validator_post_build_step_recursive)
-    cmake_parse_arguments(API_VALIDATOR "" "TARGET" "" ${ARGN})
-
-    list(APPEND API_VALIDATOR_TARGETS ${API_VALIDATOR_TARGET})
-    set(API_VALIDATOR_TARGETS ${API_VALIDATOR_TARGETS} PARENT_SCOPE)
-
-    get_target_property(IS_IMPORTED ${API_VALIDATOR_TARGET} IMPORTED)
-    if(IS_IMPORTED)
-        return()
-    endif()
-
-    get_target_property(LIBRARY_TYPE ${API_VALIDATOR_TARGET} TYPE)
-    if(LIBRARY_TYPE STREQUAL "EXECUTABLE" OR LIBRARY_TYPE STREQUAL "SHARED_LIBRARY")
-        get_target_property(LINKED_LIBRARIES ${API_VALIDATOR_TARGET} LINK_LIBRARIES)
-        if(LINKED_LIBRARIES)
-            foreach(ITEM IN LISTS LINKED_LIBRARIES)
-                if(NOT TARGET ${ITEM})
-                    continue()
-                endif()
-                get_target_property(LIBRARY_TYPE_DEPENDENCY ${ITEM} TYPE)
-                if(LIBRARY_TYPE_DEPENDENCY STREQUAL "SHARED_LIBRARY")
-                    _ie_add_api_validator_post_build_step_recursive(TARGET ${ITEM})
-                endif()
-            endforeach()
-        endif()
-    endif()
-
-    set(API_VALIDATOR_TARGETS ${API_VALIDATOR_TARGETS} PARENT_SCOPE)
-endfunction()
-
-set(VALIDATED_LIBRARIES "" CACHE INTERNAL "")
-
-function(_ie_add_api_validator_post_build_step)
-    set(UWP_API_VALIDATOR_APIS "${PROGRAMFILES}/Windows Kits/10/build/universalDDIs/x64/UniversalDDIs.xml")
-    set(UWP_API_VALIDATOR_EXCLUSION "${UWP_SDK_PATH}/BinaryExclusionlist.xml")
-
-    if((NOT UWP_API_VALIDATOR) OR (WINDOWS_STORE OR WINDOWS_PHONE))
-        return()
-    endif()
-
-    cmake_parse_arguments(API_VALIDATOR "" "TARGET" "" ${ARGN})
-
-    if(NOT API_VALIDATOR_TARGET)
-        message(FATAL_ERROR "RunApiValidator requires TARGET to validate!")
-    endif()
-
-    if(NOT TARGET ${API_VALIDATOR_TARGET})
-        message(FATAL_ERROR "${API_VALIDATOR_TARGET} is not a TARGET in the project tree.")
-    endif()
-
-    # collect targets
-
-    _ie_add_api_validator_post_build_step_recursive(TARGET ${API_VALIDATOR_TARGET})
-
-    # remove targets which were tested before
-
-    foreach(item IN LISTS VALIDATED_LIBRARIES)
-        list(REMOVE_ITEM API_VALIDATOR_TARGETS ${item})
-    endforeach()
-
-    list(REMOVE_DUPLICATES API_VALIDATOR_TARGETS)
-
-    if(NOT API_VALIDATOR_TARGETS)
-        return()
-    endif()
-
-    # apply check
-
-    macro(api_validator_get_target_name)
-        get_target_property(IS_IMPORTED ${target} IMPORTED)
-        if(IS_IMPORTED)
-            get_target_property(target_location ${target} LOCATION)  
-            get_filename_component(target_name "${target_location}" NAME_WE)
-        else()
-            set(target_name ${target})
-        endif()
-    endmacro()
-
-    foreach(target IN LISTS API_VALIDATOR_TARGETS)
-        api_validator_get_target_name()
-        set(output_file "${CMAKE_BINARY_DIR}/api_validator/${target_name}.txt")
-
-        add_custom_command(TARGET ${API_VALIDATOR_TARGET} POST_BUILD
-            COMMAND ${CMAKE_COMMAND}
-                -D UWP_API_VALIDATOR=${UWP_API_VALIDATOR}
-                -D UWP_API_VALIDATOR_TARGET=$<TARGET_FILE:${target}>
-                -D UWP_API_VALIDATOR_APIS=${UWP_API_VALIDATOR_APIS}
-                -D UWP_API_VALIDATOR_EXCLUSION=${UWP_API_VALIDATOR_EXCLUSION}
-                -D UWP_API_VALIDATOR_OUTPUT=${output_file}
-                -D CMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}
-                -P "${OpenVINO_MAIN_SOURCE_DIR}/cmake/api_validator/api_validator_run.cmake"
-            BYPRODUCTS ${output_file}
-            COMMENT "[apiValidator] Check ${target_name} for OneCore compliance"
-            VERBATIM)
-    endforeach()
-
-    # update list of validated libraries
-
-    list(APPEND VALIDATED_LIBRARIES ${API_VALIDATOR_TARGETS})
-    set(VALIDATED_LIBRARIES "${VALIDATED_LIBRARIES}" CACHE INTERNAL "" FORCE)
-endfunction()
-
-#
-# ie_add_api_validator_post_build_step(TARGET <name>)
-#
-macro(ie_add_api_validator_post_build_step)
-    _ie_add_api_validator_post_build_step(${ARGV})
-endmacro()

cmake/api_validator/api_validator_run.cmake

@@ -1,73 +0,0 @@
-# Copyright (C) 2018-2020 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-cmake_policy(SET CMP0012 NEW)
-
-foreach(var UWP_API_VALIDATOR UWP_API_VALIDATOR_TARGET
-            UWP_API_VALIDATOR_APIS UWP_API_VALIDATOR_EXCLUSION
-            UWP_API_VALIDATOR_OUTPUT CMAKE_TOOLCHAIN_FILE)
-    if(NOT DEFINED ${var})
-        message(FATAL_ERROR "Variable ${var} is not defined")
-    endif()
-endforeach()
-
-# create command
-
-if(NOT EXISTS "${UWP_API_VALIDATOR_APIS}")
-    message(FATAL_ERROR "${UWP_API_VALIDATOR_APIS} does not exist")
-endif()
-
-set(command "${UWP_API_VALIDATOR}"
-        -SupportedApiXmlFiles:${UWP_API_VALIDATOR_APIS}
-        -DriverPackagePath:${UWP_API_VALIDATOR_TARGET})
-if(EXISTS "${UWP_API_VALIDATOR_EXCLUSION}")
-    list(APPEND command
-        -BinaryExclusionListXmlFile:${UWP_API_VALIDATOR_EXCLUSION}
-        -StrictCompliance:TRUE)
-    set(UWP_HAS_BINARY_EXCLUSION ON)
-endif()
-
-# execute
-
-execute_process(COMMAND ${command}
-                OUTPUT_VARIABLE output_message
-                ERROR_VARIABLE error_message
-                RESULT_VARIABLE exit_code
-                OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-file(WRITE "${UWP_API_VALIDATOR_OUTPUT}" "${output_message}\n\n\n${error_message}")
-
-# post-process output
-
-get_filename_component(name "${UWP_API_VALIDATOR_TARGET}" NAME)
-
-if(NOT UWP_HAS_BINARY_EXCLUSION)
-    if(CMAKE_TOOLCHAIN_FILE MATCHES "onecoreuap.toolchain.cmake$")
-        # empty since we compile with static MSVC runtime
-    else()
-        set(exclusion_dlls "msvcp140.dll" "vcruntime140.dll")
-    endif()
-
-    # remove exclusions from error_message
-
-    foreach(dll IN LISTS exclusion_dlls)
-        string(REGEX REPLACE
-                "ApiValidation: Error: ${name} has unsupported API call to \"${dll}![^\"]+\"\n"
-                "" error_message "${error_message}")
-    endforeach()
-
-    # throw error if error_message still contains any errors
-
-    if(error_message)
-        message(FATAL_ERROR "${error_message}")
-    endif()
-endif()
-
-# write output
-
-if(UWP_HAS_BINARY_EXCLUSION AND NOT exit_code EQUAL 0)
-    message(FATAL_ERROR "${error_message}")
-endif()
-
-message("ApiValidator: ${name} has passed the OneCore compliance")

cmake/check_features.cmake

@@ -15,6 +15,10 @@ else()
     SET(ARCH_64 OFF)
 endif()
 
+if (NOT ENABLE_MKL_DNN)
+    set(ENABLE_MKL OFF)
+endif()
+
 if(ENABLE_AVX512F)
     if ((CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") AND (MSVC_VERSION VERSION_LESS 1920))
         # 1920 version of MSVC 2019. In MSVC 2017 AVX512F not work

cmake/coverage/coverage_clean.cmake

@@ -3,28 +3,28 @@
 #
 
 if(NOT DEFINED IE_COVERAGE_REPORTS)
-    message(FATAL_ERROR "IE_COVERAGE_REPORTS variable is not defined")
-    return()
+	message(FATAL_ERROR "IE_COVERAGE_REPORTS variable is not defined")
+	return()
 endif()
 
 file(REMOVE_RECURSE "${IE_COVERAGE_REPORTS}")
 
 if(NOT DEFINED IE_COVERAGE_DIRECTORY)
-    message(FATAL_ERROR "IE_COVERAGE_DIRECTORY variable is not defined")
-    return()
+	message(FATAL_ERROR "IE_COVERAGE_DIRECTORY variable is not defined")
+	return()
 endif()
 
 # remove .gcno files which are kept from the previous build
 
 file(GLOB_RECURSE gcno_files "${IE_COVERAGE_DIRECTORY}/*.gcno")
 foreach(file IN LISTS gcno_files)
-    string(REPLACE ".gcno" "" temp_file "${file}")
-    string(REGEX REPLACE "CMakeFiles/.+dir/" "" temp_file "${temp_file}")
-    string(REPLACE "${CMAKE_BINARY_DIRECTORY}" "${CMAKE_SOURCE_DIRECTORY}" source_file "${temp_file}")
+	string(REPLACE ".gcno" "" temp_file "${file}")
+	string(REGEX REPLACE "CMakeFiles/.+dir/" "" temp_file "${temp_file}")
+	string(REPLACE "${CMAKE_BINARY_DIRECTORY}" "${CMAKE_SOURCE_DIRECTORY}" source_file "${temp_file}")
 
-    if(NOT EXISTS "${source_file}")
-        file(REMOVE "${file}")
-        string(REPLACE "${CMAKE_BINARY_DIRECTORY}/" "" file "${file}")
-        message("Removing ${file}")
-    endif()
+	if(NOT EXISTS "${source_file}")
+		file(REMOVE "${file}")
+		string(REPLACE "${CMAKE_BINARY_DIRECTORY}/" "" file "${file}")
+		message("Removing ${file}")
+	endif()
 endforeach()

cmake/dependencies.cmake

@@ -6,20 +6,20 @@ set_temp_directory(TEMP "${IE_MAIN_SOURCE_DIR}")
 
 include(dependency_solver)
 
-if(CMAKE_CROSSCOMPILING AND NGRAPH_ONNX_IMPORT_ENABLE)
-    if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*")
-        set(HOST_X86_64 ON)
-    endif()
+if(CMAKE_CROSSCOMPILING)
+	if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*")
+	    set(HOST_X86_64 ON)
+	endif()
 
-    set(protoc_version "3.7.1")
-    if(CMAKE_HOST_SYSTEM_NAME MATCHES Linux)
-        RESOLVE_DEPENDENCY(SYSTEM_PROTOC_ROOT
-                           ARCHIVE_LIN "protoc-${protoc_version}-linux-x86_64.tar.gz"
-                           TARGET_PATH "${TEMP}/protoc-${protoc_version}-linux-x86_64")
-        debug_message(STATUS "host protoc-${protoc_version} root path = " ${SYSTEM_PROTOC_ROOT})
-    else()
-        message(FATAL_ERROR "Unsupported host system (${CMAKE_HOST_SYSTEM_NAME}) and arch (${CMAKE_HOST_SYSTEM_PROCESSOR}) for cross-compilation")
-    endif()
+	set(protoc_version "3.7.1")
+	if(CMAKE_HOST_SYSTEM_NAME MATCHES Linux)
+	    RESOLVE_DEPENDENCY(SYSTEM_PROTOC_ROOT
+			               ARCHIVE_LIN "protoc-${protoc_version}-linux-x86_64.tar.gz"
+			               TARGET_PATH "${TEMP}/protoc-${protoc_version}-linux-x86_64")
+	    debug_message(STATUS "host protoc-${protoc_version} root path = " ${SYSTEM_PROTOC_ROOT})
+	else()
+		message(FATAL_ERROR "Unsupported host system (${CMAKE_HOST_SYSTEM_NAME}) and arch (${CMAKE_HOST_SYSTEM_PROCESSOR}) for cross-compilation")
+	endif()
 
     reset_deps_cache(SYSTEM_PROTOC)
 

cmake/developer_package.cmake

@@ -2,29 +2,10 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-cmake_minimum_required(VERSION 3.13)
-
-# Detect target
-include(target_flags)
-
-string(TOLOWER ${CMAKE_SYSTEM_PROCESSOR} ARCH_FOLDER)
-if(X86_64)
-    set(ARCH_FOLDER intel64)
-elseif(X86)
-    set(ARCH_FOLDER ia32)
-elseif(MSVC AND ARM)
-    set(ARCH_FOLDER arm)
-elseif(MSVC AND AARCH64)
-    set(ARCH_FOLDER arm64)
-endif()
-
 list(APPEND CMAKE_MODULE_PATH
         "${OpenVINO_MAIN_SOURCE_DIR}/cmake/download"
-        "${OpenVINO_MAIN_SOURCE_DIR}/cmake/cross_compile")
-
-#
-# CPack
-#
+        "${OpenVINO_MAIN_SOURCE_DIR}/cmake/cross_compile"
+        )
 
 include(CPackComponent)
 unset(IE_CPACK_COMPONENTS_ALL CACHE)
@@ -50,14 +31,21 @@ endif()
 # Set library directory for cpack
 #
 function(ie_cpack_set_library_dir)
+    string(TOLOWER ${CMAKE_SYSTEM_PROCESSOR} ARCH)
+    if(ARCH STREQUAL "x86_64" OR ARCH STREQUAL "amd64") # Windows detects Intel's 64-bit CPU as AMD64
+        set(ARCH intel64)
+    elseif(ARCH STREQUAL "i386")
+        set(ARCH ia32)
+    endif()
+
     if(WIN32)
-        set(IE_CPACK_LIBRARY_PATH ${IE_CPACK_IE_DIR}/lib/${ARCH_FOLDER}/${CMAKE_BUILD_TYPE} PARENT_SCOPE)
-        set(IE_CPACK_RUNTIME_PATH ${IE_CPACK_IE_DIR}/bin/${ARCH_FOLDER}/${CMAKE_BUILD_TYPE} PARENT_SCOPE)
-        set(IE_CPACK_ARCHIVE_PATH ${IE_CPACK_IE_DIR}/lib/${ARCH_FOLDER}/${CMAKE_BUILD_TYPE} PARENT_SCOPE)
+        set(IE_CPACK_LIBRARY_PATH ${IE_CPACK_IE_DIR}/lib/${ARCH}/${CMAKE_BUILD_TYPE} PARENT_SCOPE)
+        set(IE_CPACK_RUNTIME_PATH ${IE_CPACK_IE_DIR}/bin/${ARCH}/${CMAKE_BUILD_TYPE} PARENT_SCOPE)
+        set(IE_CPACK_ARCHIVE_PATH ${IE_CPACK_IE_DIR}/lib/${ARCH}/${CMAKE_BUILD_TYPE} PARENT_SCOPE)
     else()
-        set(IE_CPACK_LIBRARY_PATH ${IE_CPACK_IE_DIR}/lib/${ARCH_FOLDER} PARENT_SCOPE)
-        set(IE_CPACK_RUNTIME_PATH ${IE_CPACK_IE_DIR}/lib/${ARCH_FOLDER} PARENT_SCOPE)
-        set(IE_CPACK_ARCHIVE_PATH ${IE_CPACK_IE_DIR}/lib/${ARCH_FOLDER} PARENT_SCOPE)
+        set(IE_CPACK_LIBRARY_PATH ${IE_CPACK_IE_DIR}/lib/${ARCH} PARENT_SCOPE)
+        set(IE_CPACK_RUNTIME_PATH ${IE_CPACK_IE_DIR}/lib/${ARCH} PARENT_SCOPE)
+        set(IE_CPACK_ARCHIVE_PATH ${IE_CPACK_IE_DIR}/lib/${ARCH} PARENT_SCOPE)
     endif()
 endfunction()
 
@@ -119,27 +107,35 @@ function(set_temp_directory temp_variable source_tree_dir)
     endif()
 endfunction()
 
-#
-# Common scripts
-#
-
 include(coverage/coverage)
-include(shellcheck/shellcheck)
 
 # External dependencies
 find_package(Threads)
 
+# Detect target
+include(target_flags)
+
 # printing debug messages
 include(debug)
 
+# linking libraries without discarding symbols
+include(whole_archive)
+
+string(TOLOWER ${CMAKE_SYSTEM_PROCESSOR} ARCH_FOLDER)
+if(ARCH_FOLDER STREQUAL "x86_64" OR ARCH_FOLDER STREQUAL "amd64") # Windows detects Intel's 64-bit CPU as AMD64
+    set(ARCH_FOLDER intel64)
+elseif(ARCH_FOLDER STREQUAL "i386")
+    set(ARCH_FOLDER ia32)
+endif()
+
 if(OS_FOLDER)
-    message ("**** OS FOLDER IS: [${OS_FOLDER}]")
-    if("${OS_FOLDER}" STREQUAL "ON")
-        message ("**** USING OS FOLDER: [${CMAKE_SYSTEM_NAME}]")
-        set(BIN_FOLDER "bin/${CMAKE_SYSTEM_NAME}/${ARCH_FOLDER}")
-    else()
-        set(BIN_FOLDER "bin/${OS_FOLDER}/${ARCH_FOLDER}")
-    endif()
+	message ("**** OS FOLDER IS: [${OS_FOLDER}]")
+	if("${OS_FOLDER}" STREQUAL "ON")
+		message ("**** USING OS FOLDER: [${CMAKE_SYSTEM_NAME}]")
+		set(BIN_FOLDER "bin/${CMAKE_SYSTEM_NAME}/${ARCH_FOLDER}")
+	else()
+		set(BIN_FOLDER "bin/${OS_FOLDER}/${ARCH_FOLDER}")
+	endif()
 else()
     set(BIN_FOLDER "bin/${ARCH_FOLDER}")
 endif()
@@ -217,29 +213,10 @@ set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
 set(CMAKE_POLICY_DEFAULT_CMP0054 NEW)
 
-# LTO
-
-set(CMAKE_POLICY_DEFAULT_CMP0069 NEW)
-include(CheckIPOSupported)
-
-check_ipo_supported(RESULT IPO_SUPPORTED
-                    OUTPUT OUTPUT_MESSAGE
-                    LANGUAGES C CXX)
-
-if(NOT IPO_SUPPORTED)
-    set(ENABLE_LTO "OFF" CACHE STRING "Enable Link Time Optmization" FORCE)
-    message(WARNING "IPO / LTO is not supported: ${OUTPUT_MESSAGE}")
-endif()
-
-# General flags
-
 include(sdl)
 include(os_flags)
 include(sanitizer)
 include(cross_compiled_func)
-include(faster_build)
-include(whole_archive)
-include(api_validator/api_validator)
 
 function(set_ci_build_number)
     set(OpenVINO_MAIN_SOURCE_DIR "${CMAKE_SOURCE_DIR}")
@@ -247,5 +224,3 @@ function(set_ci_build_number)
     set(CI_BUILD_NUMBER "${CI_BUILD_NUMBER}" PARENT_SCOPE)
 endfunction()
 set_ci_build_number()
-
-include(vs_version/vs_version)

cmake/download/download_and_check.cmake

@@ -22,11 +22,8 @@ function (DownloadAndCheck from to fatal result)
           Download(${from} ${to} ${fatal} ${result} output)
           list(GET output 0 status_code)
         else()
-          message(STATUS "${WGET_EXECUTABLE} --no-cache --no-check-certificate 
-            --retry-connrefused --waitretry=1 --read-timeout=20 --timeout=15 --tries=5 ${from}")
-          execute_process(COMMAND ${WGET_EXECUTABLE} "--no-cache" "--no-check-certificate" 
-            "--retry-connrefused" "--waitretry=1" "--read-timeout=20" "--timeout=15" "--tries=5" 
-            "${from}" "-O" "${to}"
+          message(STATUS "${WGET_EXECUTABLE} --no-cache ${from}")
+          execute_process(COMMAND ${WGET_EXECUTABLE} "--no-cache" "--no-check-certificate" "${from}" "-O" "${to}"
             TIMEOUT 2000
             RESULT_VARIABLE status_code)
         endif()

cmake/faster_build.cmake

@@ -1,26 +0,0 @@
-# Copyright (C) 2020 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-include(CMakeParseArguments)
-
-function(ie_faster_build TARGET_NAME)
-    if(NOT ENABLE_FASTER_BUILD)
-        return()
-    endif()
-
-    cmake_parse_arguments(IE_FASTER_BUILD "UNITY" "" "PCH" ${ARGN})
-
-    if(IE_FASTER_BUILD_UNITY)
-        set_target_properties(${TARGET_NAME}
-            PROPERTIES
-                UNITY_BUILD ON
-        )
-    endif()
-
-    if(IE_FASTER_BUILD_PCH)
-        target_precompile_headers(${TARGET_NAME}
-            ${IE_FASTER_BUILD_PCH}
-        )
-    endif()
-endfunction()

cmake/features.cmake

@@ -17,19 +17,17 @@ ie_option (ENABLE_TESTS "unit, behavior and functional tests" OFF)
 
 ie_option (ENABLE_MKL_DNN "MKL-DNN plugin for inference engine" ${ENABLE_MKL_DNN_DEFAULT})
 
-ie_dependent_option (ENABLE_CLDNN "clDnn based plugin for inference engine" ON "X86_64;NOT APPLE;NOT MINGW;NOT WINDOWS_STORE;NOT WINDOWS_PHONE" OFF)
+ie_dependent_option (ENABLE_CLDNN "clDnn based plugin for inference engine" ON "WIN32 OR X86_64;NOT APPLE;NOT MINGW" OFF)
 
 # 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 OR WIN32;NOT CMAKE_CROSSCOMPILING" OFF)
 
 ie_option (OS_FOLDER "create OS dedicated folder in output" OFF)
 
 # FIXME: ARM cross-compiler generates several "false positive" warnings regarding __builtin_memcpy buffer overflow
 ie_dependent_option (TREAT_WARNING_AS_ERROR "Treat build warnings as errors" ON "X86 OR X86_64" OFF)
 
-ie_option (ENABLE_INTEGRITYCHECK "build DLLs with /INTEGRITYCHECK flag" OFF)
-
 ie_option (ENABLE_SANITIZER "enable checking memory errors via AddressSanitizer" OFF)
 
 ie_option (ENABLE_THREAD_SANITIZER "enable checking data races via ThreadSanitizer" OFF)
@@ -43,10 +41,3 @@ ie_dependent_option (ENABLE_SSE42 "Enable SSE4.2 optimizations" ON "X86_64 OR X8
 ie_dependent_option (ENABLE_AVX2 "Enable AVX2 optimizations" ON "X86_64 OR X86" OFF)
 
 ie_dependent_option (ENABLE_AVX512F "Enable AVX512 optimizations" ON "X86_64 OR X86" OFF)
-
-ie_option (ENABLE_PROFILING_ITT "Build with ITT tracing. Optionally configure pre-built ittnotify library though INTEL_VTUNE_DIR variable." OFF)
-
-# Documentation build
-ie_option (ENABLE_DOCS "build docs using Doxygen" OFF)
-
-ie_dependent_option (ENABLE_FASTER_BUILD "Enable build features (PCH, UNITY) to speed up build time" OFF "CMAKE_VERSION VERSION_GREATER_EQUAL 3.16" OFF)

cmake/onecoreuap.toolchain.cmake

@@ -1,97 +0,0 @@
-# Copyright (C) 2018-2020 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-#
-# Define CMAKE_SYSTEM_VERSION if not defined
-#
-
-if(NOT DEFINED CMAKE_SYSTEM_VERSION)
-    # Sometimes CMAKE_HOST_SYSTEM_VERSION has form 10.x.y while we need
-    # form 10.x.y.z Adding .0 at the end fixes the issue
-    if(CMAKE_HOST_SYSTEM_VERSION MATCHES "^10\.0\.[0-9]+$")
-        set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}.0")
-    else()
-        set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}")
-    endif()
-endif()
-
-if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
-    set(CMAKE_SYSTEM_PROCESSOR ${CMAKE_HOST_SYSTEM_PROCESSOR})
-endif()
-
-message(STATUS "Building for Windows OneCore compliance (using OneCoreUap.lib, ${CMAKE_SYSTEM_VERSION})")
-
-#
-# OneCore flags
-#
-
-set(_onecoreuap_arch "x64")
-if(CMAKE_GENERATOR_PLATFORM)
-    set(_onecoreuap_arch ${CMAKE_GENERATOR_PLATFORM})
-endif()
-
-if(_onecoreuap_arch STREQUAL "x64")
-    # Forcefull make VS search for C++ libreries in these folders prior to other c++ standard libraries localizations.
-    add_link_options("/LIBPATH:\"\$\(VC_LibraryPath_VC_x64_OneCore\)\"")
-
-    set(CMAKE_C_STANDARD_LIBRARIES "\$\(UCRTContentRoot\)lib/\$\(TargetUniversalCRTVersion\)/um/\$\(Platform\)/OneCoreUap.lib" CACHE STRING "" FORCE)
-    set(CMAKE_CXX_STANDARD_LIBRARIES "\$\(UCRTContentRoot\)lib/\$\(TargetUniversalCRTVersion\)/um/\$\(Platform\)/OneCoreUap.lib" CACHE STRING "" FORCE)
-elseif(_onecoreuap_arch STREQUAL "X86")
-    add_link_options("/LIBPATH:\"\$\(VCInstallDir\)lib/onecore\"")
-    add_link_options("/LIBPATH:\"\$\(VC_LibraryPath_VC_x86_OneCore\)\"")
-
-    set(CMAKE_C_STANDARD_LIBRARIES "\$\(UCRTContentRoot\)lib/\$\(TargetUniversalCRTVersion\)/um/x86/OneCoreUap.lib" CACHE STRING "" FORCE)
-    set(CMAKE_CXX_STANDARD_LIBRARIES "\$\(UCRTContentRoot\)lib/\$\(TargetUniversalCRTVersion\)/um/x86/OneCoreUap.lib" CACHE STRING "" FORCE)
-else()
-    message(FATAL_ERROR "Unsupported architecture ${_onecoreuap_arch}. Only X86 or X86_64 are supported")
-endif()
-
-unset(_onecoreuap_arch)
-
-# compile flags
-
-set(includes "/I\"\$\(UniversalCRT_IncludePath\)\"")
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${includes}")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${includes}")
-unset(includes)
-
-# linker flags
-
-foreach(lib kernel32 user32 advapi32 ole32 mscoree combase)
-    set(linker_flags "/NODEFAULTLIB:${lib}.lib ${linker_flags}")
-endforeach()
-
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${linker_flags}")
-set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${linker_flags}")
-unset(linker_flags)
-
-#
-# Flags for 3rd party projects
-#
-
-set(use_static_runtime ON)
-
-if(use_static_runtime)
-    foreach(lang C CXX)
-        foreach(build_type "" "_DEBUG" "_MINSIZEREL" "_RELEASE" "_RELWITHDEBINFO")
-            set(flag_var "CMAKE_${lang}_FLAGS${build_type}")
-            string(REPLACE "/MD" "/MT" ${flag_var} "${${flag_var}}")
-        endforeach()
-    endforeach()
-endif()
-
-function(onecoreuap_set_runtime var)
-    set(${var} ${use_static_runtime} CACHE BOOL "" FORCE)
-endfunction()
-
-# ONNX
-onecoreuap_set_runtime(ONNX_USE_MSVC_STATIC_RUNTIME)
-# pugixml
-onecoreuap_set_runtime(STATIC_CRT)
-# protobuf
-onecoreuap_set_runtime(protobuf_MSVC_STATIC_RUNTIME)
-# clDNN
-onecoreuap_set_runtime(CLDNN__COMPILE_LINK_USE_STATIC_RUNTIME)
-
-unset(use_static_runtime)

cmake/os_flags.cmake

@@ -126,35 +126,44 @@ function(ie_avx512_optimization_flags flags)
     endif()
 endfunction()
 
-function(ie_arm_neon_optimization_flags flags)
-    if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
-        message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-        # nothing
-    elseif(ANDROID)
-        if(ANDROID_ABI STREQUAL "arm64-v8a")
-            set(${flags} "-mfpu=neon" PARENT_SCOPE)
-        elseif(ANDROID_ABI STREQUAL "armeabi-v7a-hard with NEON")
-            set(${flags} "-march=armv7-a -mfloat-abi=hard -mhard-float -D_NDK_MATH_NO_SOFTFP=1 -mfpu=neon" PARENT_SCOPE)
-        elseif((ANDROID_ABI STREQUAL "armeabi-v7a with NEON") OR
-               (ANDROID_ABI STREQUAL "armeabi-v7a" AND
-                DEFINED CMAKE_ANDROID_ARM_NEON AND CMAKE_ANDROID_ARM_NEON))
-            set(${flags} "-march=armv7-a -mfloat-abi=softfp -mfpu=neon" PARENT_SCOPE)
-        endif()
-    else()
-        if(AARCH64)
-            set(${flags} "-O2 -ftree-vectorize" PARENT_SCOPE)
-        elseif(ARM)
-            set(${flags} "-mfpu=neon" PARENT_SCOPE)
-        endif()
-    endif()
-endfunction()
-
 #
 # Enables Link Time Optimization compilation
 #
 macro(ie_enable_lto)
-    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE ON)
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel" AND OFF)
+        ProcessorCount(N)
+        if(UNIX)
+            set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ipo")
+            set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ipo")
+            set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -ipo-jobs${N}")
+            set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -ipo-jobs${N}")
+            set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} -ipo-jobs${N}")
+        else()
+            set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Qipo")
+            set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /Qipo")
+            set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /Qipo-jobs:${N}")
+            set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /Qipo-jobs:${N}")
+            set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} /Qipo-jobs:${N}")
+        endif()
+    elseif(UNIX)
+        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -flto")
+        # LTO causes issues with gcc 4.8.5 during cmake pthread check
+        if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 4.9)
+            set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -flto")
+        endif()
+
+        # modify linker and ar
+        if(LINUX)
+            set(CMAKE_AR  "gcc-ar")
+            set(CMAKE_RANLIB "gcc-ranlib")
+        endif()
+    elseif(MSVC AND OFF)
+        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GL")
+        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /GL")
+        set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /LTCG:STATUS")
+        set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /LTCG:STATUS")
+        set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} /LTCG:STATUS")
+    endif()
 endmacro()
 
 #
@@ -186,12 +195,13 @@ if(NOT DEFINED CMAKE_CXX_STANDARD)
 endif()
 
 if(ENABLE_COVERAGE)
-    ie_add_compiler_flags(--coverage)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage")
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
 endif()
 
-if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-    ie_add_compiler_flags(-fsigned-char)
+if(NOT MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsigned-char")
 endif()
 
 set(CMAKE_POLICY_DEFAULT_CMP0063 NEW)
@@ -217,7 +227,6 @@ if(WIN32)
     # Compiler specific flags
 
     ie_add_compiler_flags(/bigobj)
-    ie_add_compiler_flags(/MP)
 
     # Disable noisy warnings
 
@@ -229,17 +238,16 @@ if(WIN32)
     endif()
 
     if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
-        # 161: unrecognized pragma
-        # 177: variable was declared but never referenced
-        # 556: not matched type of assigned function pointer
+        # 161 unrecognized pragma
+        # 177 variable was declared but never referenced
+        # 556 not matched type of assigned function pointer
         # 1744: field of class type without a DLL interface used in a class with a DLL interface
-        # 1879: unimplemented pragma ignored
-        # 2586: decorated name length exceeded, name was truncated
+        # 2586 decorated name length exceeded, name was truncated
         # 2651: attribute does not apply to any entity
-        # 3180: unrecognized OpenMP pragma
+        # 3180 unrecognized OpenMP pragma
         # 11075: To get full report use -Qopt-report:4 -Qopt-report-phase ipo
-        # 15335: was not vectorized: vectorization possible but seems inefficient. Use vector always directive or /Qvec-threshold0 to override
-        ie_add_compiler_flags(/Qdiag-disable:161,177,556,1744,1879,2586,2651,3180,11075,15335)
+        # 15335 was not vectorized: vectorization possible but seems inefficient. Use vector always directive or /Qvec-threshold0 to override
+        ie_add_compiler_flags(/Qdiag-disable:161,177,556,1744,2586,2651,3180,11075,15335)
     endif()
 
     # Debug information flags
@@ -256,7 +264,6 @@ else()
     ie_add_compiler_flags(-ffunction-sections -fdata-sections)
     ie_add_compiler_flags(-fdiagnostics-show-option)
     ie_add_compiler_flags(-Wundef)
-    ie_add_compiler_flags(-Wreturn-type)
 
     # Disable noisy warnings
 

cmake/sanitizer.cmake

@@ -15,9 +15,7 @@ if (ENABLE_SANITIZER)
     if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
         set(SANITIZER_LINKER_FLAGS "${SANITIZER_LINKER_FLAGS} -fuse-ld=gold")
     elseif(CMAKE_CXX_COMPILER_ID MATCHES "^(Apple)?Clang$" AND NOT WIN32)
-        if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.0)
-            set(SANITIZER_LINKER_FLAGS "${SANITIZER_LINKER_FLAGS} -fuse-ld=lld")
-        endif()
+        set(SANITIZER_LINKER_FLAGS "${SANITIZER_LINKER_FLAGS} -fuse-ld=lld")
     endif()
 
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SANITIZER_COMPILER_FLAGS}")

cmake/sdl.cmake

@@ -14,7 +14,9 @@ if (CMAKE_BUILD_TYPE STREQUAL "Release")
         endif()
 
         if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-            set(IE_LINKER_FLAGS "${IE_LINKER_FLAGS} -z noexecstack -z relro -z now")
+            set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -z noexecstack -z relro -z now")
+            set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} -z noexecstack -z relro -z now")
+            set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -z noexecstack -z relro -z now")
             if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9)
                 set(IE_C_CXX_FLAGS "${IE_C_CXX_FLAGS} -fstack-protector-all")
             else()
@@ -30,21 +32,14 @@ if (CMAKE_BUILD_TYPE STREQUAL "Release")
                 set(IE_C_CXX_FLAGS "${IE_C_CXX_FLAGS} -Wl,--strip-all")
             endif()
             set(IE_C_CXX_FLAGS "${IE_C_CXX_FLAGS} -fstack-protector-strong")
-            set(IE_LINKER_FLAGS "${IE_LINKER_FLAGS} -z noexecstack -z relro -z now")
-        endif()
-    else()
-        if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-            set(IE_C_CXX_FLAGS "${IE_C_CXX_FLAGS} /sdl")
-        endif()
-        set(IE_C_CXX_FLAGS "${IE_C_CXX_FLAGS} /guard:cf")
-        if(ENABLE_INTEGRITYCHECK)
-            set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /INTEGRITYCHECK")
+            set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -z noexecstack -z relro -z now")
+            set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} -z noexecstack -z relro -z now")
+            set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -z noexecstack -z relro -z now")
         endif()
+    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+        set(IE_C_CXX_FLAGS "${IE_C_CXX_FLAGS} /sdl /guard:cf")
     endif()
 
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${IE_C_CXX_FLAGS}")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${IE_C_CXX_FLAGS}")
-    set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} ${IE_LINKER_FLAGS}")
-    set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} ${IE_LINKER_FLAGS}")
-    set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${IE_LINKER_FLAGS}")
 endif()

cmake/shellcheck/shellcheck.cmake

@@ -1,49 +0,0 @@
-# Copyright (C) 2018-2020 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-include(CMakeParseArguments)
-
-find_host_program(shellcheck_PROGRAM NAMES shellcheck DOC "Path to shellcheck tool")
-
-function(ie_shellcheck_process)
-    if(NOT shellcheck_PROGRAM)
-        message(WARNING "shellcheck tool is not found")
-        return()
-    endif()
-
-    cmake_parse_arguments(IE_SHELLCHECK "" "DIRECTORY" "SKIP" ${ARGN})
-
-    set(IE_SHELLCHECK_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/cmake/shellcheck/shellcheck_process.cmake")
-    file(GLOB_RECURSE scripts "${IE_SHELLCHECK_DIRECTORY}/*.sh")
-    foreach(script IN LISTS scripts)
-        # check if we need to skip scripts
-        unset(skip_script)
-        foreach(skip_directory IN LISTS IE_SHELLCHECK_SKIP)
-            if(script MATCHES "${skip_directory}/*")
-                set(skip_script ON)
-            endif()
-        endforeach()
-        if(skip_script)
-            continue()
-        endif()
-
-        get_filename_component(dir_name "${script}" DIRECTORY)
-        string(REPLACE "${IE_SHELLCHECK_DIRECTORY}" "${CMAKE_BINARY_DIR}/shellcheck" output_file ${script})
-        set(output_file "${output_file}.txt")
-        get_filename_component(script_name "${script}" NAME)
-
-        add_custom_command(OUTPUT ${output_file} 
-                           COMMAND ${CMAKE_COMMAND}
-                             -D IE_SHELLCHECK_PROGRAM=${shellcheck_PROGRAM}
-                             -D IE_SHELL_SCRIPT=${script}
-                             -D IE_SHELLCHECK_OUTPUT=${output_file}
-                             -P ${IE_SHELLCHECK_SCRIPT}
-                           DEPENDS ${script} ${IE_SHELLCHECK_SCRIPT}
-                           COMMENT "Check script ${script_name}"
-                           VERBATIM)
-        list(APPEND outputs ${output_file})
-    endforeach()
-
-    add_custom_target(ie_shellcheck DEPENDS ${outputs})
-endfunction()

cmake/shellcheck/shellcheck_process.cmake

@@ -1,27 +0,0 @@
-# Copyright (C) 2018-2020 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-if(NOT DEFINED IE_SHELLCHECK_PROGRAM)
-    message(FATAL_ERROR "IE_SHELLCHECK_PROGRAM is not defined")
-endif()
-
-if(NOT DEFINED IE_SHELL_SCRIPT)
-    message(FATAL_ERROR "IE_SHELL_SCRIPT is not defined")
-endif()
-
-if(NOT DEFINED IE_SHELLCHECK_OUTPUT)
-    message(FATAL_ERROR "IE_SHELLCHECK_OUTPUT is not defined")
-endif()
-
-set(rules "SC1091,SC2164,SC2162,SC1090")
-execute_process(COMMAND ${IE_SHELLCHECK_PROGRAM} --exclude=${rules} ${IE_SHELL_SCRIPT}
-                OUTPUT_VARIABLE error_message
-                RESULT_VARIABLE exit_code
-                OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-file(WRITE "${IE_SHELLCHECK_OUTPUT}" "${error_message}")
-
-if(NOT exit_code EQUAL 0)
-    message(FATAL_ERROR "${error_message}")
-endif()

cmake/target_flags.cmake

@@ -16,25 +16,10 @@ if(WIN32 AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
   endif()
 endif()
 
-macro(_ie_process_msvc_generator_platform flag_name)
-  # if cmake -A <ARM|ARM64> is passed
-  if(CMAKE_GENERATOR_PLATFORM STREQUAL "ARM64")
-    set(AARCH64 ON)
-  elseif(CMAKE_GENERATOR_PLATFORM STREQUAL "ARM")
-    set(ARM ON)
-  elseif(CMAKE_GENERATOR_PLATFORM STREQUAL "x64")
-    set(X86_64 ON)
-  elseif(CMAKE_GENERATOR_PLATFORM STREQUAL "Win32")
-    set(X86 ON)
-  else()
-    set(${flag_name} ON)
-  endif()
-endmacro()
-
 if(MSVC64 OR MINGW64)
-  _ie_process_msvc_generator_platform(X86_64)
+  set(X86_64 ON)
 elseif(MINGW OR (MSVC AND NOT CMAKE_CROSSCOMPILING))
-  _ie_process_msvc_generator_platform(X86)
+  set(X86 ON)
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*")
   set(X86_64 ON)
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "i686.*|i386.*|x86.*|amd64.*|AMD64.*")
@@ -45,13 +30,6 @@ elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64.*|AARCH64.*)")
   set(AARCH64 ON)
 endif()
 
-# in case of cross-compilation (or -m32) CMAKE_SYSTEM_PROCESSOR is equal to
-# CMAKE_HOST_SYSTEM_PROCESSOR which is X86_64; patch this until a better solution
-if(CMAKE_SIZEOF_VOID_P EQUAL 4 AND X86_64)
-  unset(X86_64)
-  set(X86 ON)
-endif()
-
 if(UNIX AND NOT APPLE)
     set(LINUX ON)
 endif()

cmake/uwp.toolchain.cmake

@@ -1,38 +0,0 @@
-# Copyright (C) 2018-2020 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-set(CMAKE_SYSTEM_NAME WindowsStore)
-
-#
-# Define CMAKE_SYSTEM_VERSION if not defined
-#
-
-if(NOT DEFINED CMAKE_SYSTEM_VERSION)
-    # Sometimes CMAKE_HOST_SYSTEM_VERSION has form 10.x.y while we need
-    # form 10.x.y.z Adding .0 at the end fixes the issue
-    if(CMAKE_HOST_SYSTEM_VERSION MATCHES "^10\.0\.[0-9]+$")
-        set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}.0")
-    else()
-        set(CMAKE_SYSTEM_VERSION "${CMAKE_HOST_SYSTEM_VERSION}")
-    endif()
-endif()
-
-if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
-    set(CMAKE_SYSTEM_PROCESSOR ${CMAKE_HOST_SYSTEM_PROCESSOR})
-endif()
-
-#
-# Compilation flags
-#
-
-file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/src/uwp.hpp"
-    "#ifdef WINAPI_FAMILY\n"
-    "#undef WINAPI_FAMILY\n"
-    "#define WINAPI_FAMILY WINAPI_FAMILY_DESKTOP_APP\n"
-    "#endif\n")
-
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /FI\"${CMAKE_CURRENT_BINARY_DIR}/src/uwp.hpp\"")
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /FI\"${CMAKE_CURRENT_BINARY_DIR}/src/uwp.hpp\"")
-
-set(CMAKE_VS_GLOBALS "WindowsTargetPlatformMinVersion=${CMAKE_SYSTEM_VERSION}")

cmake/vs_version/vs_version.cmake

@@ -1,87 +0,0 @@
-# Copyright (C) 2020 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-macro(ie_parse_ci_build_number)
-    if(CI_BUILD_NUMBER MATCHES "^([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_VS_VER_HAS_VERSION 1)
-    else()
-        set(IE_VS_VER_HAS_VERSION 0)
-    endif()
-endmacro()
-
-ie_parse_ci_build_number()
-
-if(IE_VS_VER_HAS_VERSION)
-    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")
-endif()
-
-set(IE_VS_VER_PRODUCTVERSION_STR "${CI_BUILD_NUMBER}")
-set(IE_VS_VER_PRODUCTNAME_STR "OpenVINO toolkit")
-set(IE_VS_VER_COPYRIGHT_STR "Copyright (C) 2018-2020, Intel Corporation")
-set(IE_VS_VER_COMMENTS_STR "https://docs.openvinotoolkit.org/")
-
-#
-# ie_add_vs_version_file(NAME <name>
-#                        FILEDESCRIPTION <file description>
-#                        [FILEVERSION <file version>]
-#                        [INTERNALNAME <internal name>]
-#                        [COPYRIGHT <name>]
-#                        [PRODUCTNAME <name>]
-#                        [PRODUCTVERSION <name>]
-#                        [COMMENTS <name>]
-#                        [FILEVERSION_QUAD <name>]
-#                        [PRODUCTVERSION_QUAD <name>])
-#
-function(ie_add_vs_version_file)
-    if(NOT WIN32)
-        return()
-    endif()
-
-    cmake_parse_arguments(VS_VER "" "NAME;FILEDESCRIPTION;FILEVERSION;INTERNALNAME;COPYRIGHT;PRODUCTNAME;PRODUCTVERSION;COMMENTS;FILEVERSION_QUAD;PRODUCTVERSION_QUAD" "" ${ARGN})
-
-    if(NOT TARGET ${VS_VER_NAME})
-        message(FATAL_ERROR "${VS_VER_NAME} must define a target")
-    endif()
-
-    macro(_vs_ver_update_variable name)
-        if(VS_VER_NAME AND DEFINED IE_${VS_VER_NAME}_VS_VER_${name})
-            set(IE_VS_VER_${name} "${IE_${VS_VER_NAME}_VS_VER_${name}}")
-        elseif(VS_VER_${name})
-            set(IE_VS_VER_${name} "${VS_VER_${name}}")
-        endif()
-    endmacro()
-
-    _vs_ver_update_variable(FILEVERSION_QUAD)
-    _vs_ver_update_variable(PRODUCTVERSION_QUAD)
-
-    macro(_vs_ver_update_str_variable name)
-        if(VS_VER_NAME AND DEFINED IE_${VS_VER_NAME}_VS_VER_${name})
-            set(IE_VS_VER_${name}_STR "${IE_${VS_VER_NAME}_VS_VER_${name}}")
-        elseif(VS_VER_${name})
-            set(IE_VS_VER_${name}_STR "${VS_VER_${name}}")
-        endif()
-    endmacro()
-
-    _vs_ver_update_str_variable(FILEDESCRIPTION)
-    _vs_ver_update_str_variable(FILEVERSION)
-    _vs_ver_update_str_variable(INTERNALNAME)
-    _vs_ver_update_str_variable(COPYRIGHT)
-    _vs_ver_update_str_variable(PRODUCTNAME)
-    _vs_ver_update_str_variable(PRODUCTVERSION)
-    _vs_ver_update_str_variable(COMMENTS)
-
-    set(IE_VS_VER_ORIGINALFILENAME_STR "${CMAKE_SHARED_LIBRARY_PREFIX}${VS_VER_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}")
-    set(IE_VS_VER_INTERNALNAME_STR ${VS_VER_NAME})
-
-    set(vs_version_output "${CMAKE_CURRENT_BINARY_DIR}/vs_version.rc")
-    configure_file("${OpenVINO_MAIN_SOURCE_DIR}/cmake/vs_version/vs_version.rc.in" "${vs_version_output}" @ONLY)
-
-    source_group("src" FILES ${vs_version_output})
-    target_sources(${VS_VER_NAME} PRIVATE ${vs_version_output})
-endfunction()

cmake/vs_version/vs_version.rc.in

@@ -1,38 +0,0 @@
-#include <winver.h>
-
-VS_VERSION_INFO         VERSIONINFO
-#if @IE_VS_VER_HAS_VERSION@
-  FILEVERSION           @IE_VS_VER_FILEVERSION_QUAD@
-  PRODUCTVERSION        @IE_VS_VER_PRODUCTVERSION_QUAD@
-#endif
-  FILEFLAGSMASK         VS_FFI_FILEFLAGSMASK
-#ifdef _DEBUG
-  FILEFLAGS             1
-#else
-  FILEFLAGS             0
-#endif
-  FILEOS                VOS__WINDOWS32
-  FILETYPE              VFT_DLL
-  FILESUBTYPE           0
-BEGIN
-  BLOCK "StringFileInfo"
-  BEGIN
-    BLOCK "040904E4"
-    BEGIN
-      VALUE "FileDescription", "@IE_VS_VER_FILEDESCRIPTION_STR@\0"
-#if @IE_VS_VER_HAS_VERSION@
-      VALUE "FileVersion", "@IE_VS_VER_FILEVERSION_STR@\0"
-#endif
-      VALUE "InternalName", "@IE_VS_VER_INTERNALNAME_STR@\0"
-      VALUE "LegalCopyright", "@IE_VS_VER_COPYRIGHT_STR@\0"
-      VALUE "OriginalFilename", "@IE_VS_VER_ORIGINALFILENAME_STR@\0"
-      VALUE "ProductName", "@IE_VS_VER_PRODUCTNAME_STR@\0"
-      VALUE "ProductVersion", "@IE_VS_VER_PRODUCTVERSION_STR@\0"
-      VALUE "Comments", "@IE_VS_VER_COMMENTS_STR@\0"
-    END
-  END
-  BLOCK "VarFileInfo"
-  BEGIN
-    VALUE "Translation", 0x0409, 1252
-  END
-END

docs/CMakeLists.txt

@@ -2,191 +2,59 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-if(NOT ENABLE_DOCKER)
-    add_subdirectory(snippets)
+add_subdirectory(examples)
 
-    # Detect nGraph
-    find_package(ngraph QUIET)
-    if(NOT ngraph_FOUND)
-        set(ngraph_DIR ${CMAKE_BINARY_DIR}/ngraph)
-    endif()
-
-    # Detect InferenceEngine
-    find_package(InferenceEngine QUIET)
-    if(NOT InferenceEngine_FOUND)
-        set(InferenceEngine_DIR ${CMAKE_BINARY_DIR})
-    endif()
-
-    if (NGRAPH_ONNX_IMPORT_ENABLE)
-        add_subdirectory(onnx_custom_op)
-    endif()
-    add_subdirectory(template_extension)
-
-    set(all_docs_targets
-        ie_docs_snippets
-        template_extension
-        templatePlugin TemplateBehaviorTests TemplateFunctionalTests)
-    foreach(target_name IN LISTS all_docs_targets)
-        if (TARGET ${target_name})
-            set_target_properties(${target_name} PROPERTIES FOLDER docs)
-        endif()
-    endforeach()
+# Detect nGraph
+find_package(ngraph QUIET)
+if(NOT ngraph_FOUND)
+    set(ngraph_DIR ${CMAKE_BINARY_DIR}/ngraph)
 endif()
 
-function(build_docs)
-    find_package(Doxygen REQUIRED dot)
-    find_package(Python3 COMPONENTS Interpreter)
-    find_package(LATEX)
+# Detect InferenceEngine
+find_package(InferenceEngine QUIET)
+if(NOT InferenceEngine_FOUND)
+    set(InferenceEngine_DIR ${CMAKE_BINARY_DIR})
+endif()
 
-    if(NOT DOXYGEN_FOUND)
-        message(FATAL_ERROR "Doxygen is required to build the documentation")
+add_subdirectory(template_extension)
+
+set(all_docs_targets
+    ie_docs_examples
+    template_extension
+    templatePlugin TemplateBehaviorTests TemplateFunctionalTests)
+foreach(target_name IN LISTS all_docs_targets)
+    if (TARGET ${target_name})
+        set_target_properties(${target_name} PROPERTIES FOLDER docs)
     endif()
+endforeach()
 
-    if(NOT Python3_FOUND)
-        message(FATAL_ERROR "Python3 is required to build the documentation")
-    endif()
+# OpenVINO docs
 
-    if(NOT LATEX_FOUND)
-        message(FATAL_ERROR "LATEX is required to build the documentation")
-    endif()
+set(OPENVINO_DOCS_PATH "" CACHE PATH "Path to openvino-documentation local repository")
+set(args "")
 
-    set(DOCS_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
-    set(DOXYGEN_DIR "${OpenVINO_MAIN_SOURCE_DIR}/docs/doxygen")
-    set(IE_SOURCE_DIR "${OpenVINO_MAIN_SOURCE_DIR}/inference-engine")
-    set(PYTHON_API_IN "${IE_SOURCE_DIR}/ie_bridges/python/src/openvino/inference_engine/ie_api.pyx")
-    set(PYTHON_API_OUT "${DOCS_BINARY_DIR}/python_api/ie_api.pyx")
-    set(C_API "${IE_SOURCE_DIR}/ie_bridges/c/include")
-    set(PLUGIN_API_DIR "${DOCS_BINARY_DIR}/IE_PLUGIN_DG")
+if(OPENVINO_DOCS_PATH)
+    set(args "${args} ovinodoc_path:${OPENVINO_DOCS_PATH}")
+endif()
 
-    # Preprocessing scripts
-    set(DOXY_MD_FILTER "${DOXYGEN_DIR}/doxy_md_filter.py")
-    set(PYX_FILTER "${DOXYGEN_DIR}/pyx_filter.py")
+file(GLOB_RECURSE docs_files "${OpenVINO_MAIN_SOURCE_DIR}/docs")
+file(GLOB_RECURSE include_files "${OpenVINO_MAIN_SOURCE_DIR}/inference-engine/include")
+file(GLOB_RECURSE ovino_files "${OPENVINO_DOCS_PATH}")
 
-    file(GLOB_RECURSE doc_source_files
-        LIST_DIRECTORIES true RELATIVE ${OpenVINO_MAIN_SOURCE_DIR}
-        "${OpenVINO_MAIN_SOURCE_DIR}/docs/*.md" 
-        "${OpenVINO_MAIN_SOURCE_DIR}/docs/*.png" 
-        "${OpenVINO_MAIN_SOURCE_DIR}/docs/*.gif" 
-        "${OpenVINO_MAIN_SOURCE_DIR}/docs/*.jpg" 
-        "${OpenVINO_MAIN_SOURCE_DIR}/inference-engine/*.md"
-        "${OpenVINO_MAIN_SOURCE_DIR}/inference-engine/*.png"
-        "${OpenVINO_MAIN_SOURCE_DIR}/inference-engine/*.gif"
-        "${OpenVINO_MAIN_SOURCE_DIR}/inference-engine/*.jpg")
+add_custom_target(ie_docs
+                  COMMAND ./build_docs.sh ${args}
+                  WORKING_DIRECTORY "${OpenVINO_MAIN_SOURCE_DIR}/docs/build_documentation"
+                  COMMENT "Generating OpenVINO documentation"
+                  SOURCES ${docs_files} ${include_files} ${ovino_files}
+                  VERBATIM)
+set_target_properties(ie_docs PROPERTIES FOLDER docs)
 
-    configure_file(${PYTHON_API_IN} ${PYTHON_API_OUT} @ONLY)
-
-    set(IE_CONFIG_SOURCE "${DOXYGEN_DIR}/ie_docs.config")
-    set(C_CONFIG_SOURCE "${DOXYGEN_DIR}/ie_c_api.config")
-    set(PY_CONFIG_SOURCE "${DOXYGEN_DIR}/ie_py_api.config")
-    set(PLUGIN_CONFIG_SOURCE "${DOXYGEN_DIR}/ie_plugin_api.config")
-
-    set(IE_CONFIG_BINARY "${DOCS_BINARY_DIR}/ie_docs.config")
-    set(C_CONFIG_BINARY "${DOCS_BINARY_DIR}/ie_c_api.config")
-    set(PY_CONFIG_BINARY "${DOCS_BINARY_DIR}/ie_py_api.config")
-    set(PLUGIN_CONFIG_BINARY "${DOCS_BINARY_DIR}/ie_plugin_api.config")
-
-    set(IE_LAYOUT_SOURCE "${DOXYGEN_DIR}/ie_docs.xml")
-    set(C_LAYOUT_SOURCE "${DOXYGEN_DIR}/ie_c_api.xml")
-    set(PY_LAYOUT_SOURCE "${DOXYGEN_DIR}/ie_py_api.xml")
-    set(PLUGIN_LAYOUT_SOURCE "${DOXYGEN_DIR}/ie_plugin_api.xml")
-
-    set(IE_LAYOUT_BINARY "${DOCS_BINARY_DIR}/ie_docs.xml")
-    set(C_LAYOUT_BINARY "${DOCS_BINARY_DIR}/ie_c_api.xml")
-    set(PY_LAYOUT_BINARY "${DOCS_BINARY_DIR}/ie_py_api.xml")
-    set(PLUGIN_LAYOUT_BINARY "${DOCS_BINARY_DIR}/ie_plugin_api.xml")
-
-    # Tables of contents
-    configure_file(${IE_LAYOUT_SOURCE} ${IE_LAYOUT_BINARY} @ONLY)
-    configure_file(${C_LAYOUT_SOURCE} ${C_LAYOUT_BINARY} @ONLY)
-    configure_file(${PY_LAYOUT_SOURCE} ${PY_LAYOUT_BINARY} @ONLY)
-    configure_file(${PLUGIN_LAYOUT_SOURCE} ${PLUGIN_LAYOUT_BINARY} @ONLY)
-
-    # Doxygen config files
-    configure_file(${IE_CONFIG_SOURCE} ${IE_CONFIG_BINARY} @ONLY)
-    configure_file(${C_CONFIG_SOURCE} ${C_CONFIG_BINARY} @ONLY)
-    configure_file(${PY_CONFIG_SOURCE} ${PY_CONFIG_BINARY} @ONLY)
-    configure_file(${PLUGIN_CONFIG_SOURCE} ${PLUGIN_CONFIG_BINARY} @ONLY)
-
-    # Preprocessing scripts
-    set(DOXY_MD_FILTER "${DOXYGEN_DIR}/doxy_md_filter.py")
-    set(PYX_FILTER "${DOXYGEN_DIR}/pyx_filter.py")
-
-    # C API
-
-    add_custom_target(c_api
-                      COMMAND ${DOXYGEN_EXECUTABLE} ${C_CONFIG_BINARY}
-                      WORKING_DIRECTORY ${DOCS_BINARY_DIR}
-                      COMMENT "Generating C API Reference"
-                      VERBATIM)
-
-    # Python API
-
-    add_custom_target(py_api
-                      COMMAND ${DOXYGEN_EXECUTABLE} ${PY_CONFIG_BINARY}
-                      WORKING_DIRECTORY ${DOCS_BINARY_DIR}
-                      COMMENT "Generating Python API Reference"
-                      VERBATIM)
-
-    add_custom_command(TARGET py_api
-                       PRE_BUILD
-                       COMMAND ${Python3_EXECUTABLE} ${PYX_FILTER} ${PYTHON_API_OUT}
-                       COMMENT "Pre-process Python API")
-
-    # Preprocess docs
-
-    add_custom_target(preprocess_docs
-                      COMMENT "Pre-process docs"
-                      VERBATIM)
-
-    foreach(source_file ${doc_source_files})
-        list(APPEND commands COMMAND ${CMAKE_COMMAND} -E copy
-            "${OpenVINO_MAIN_SOURCE_DIR}/${source_file}" "${DOCS_BINARY_DIR}/${source_file}")
-    endforeach()
-
-    add_custom_command(TARGET preprocess_docs
-                       PRE_BUILD
-                       ${commands}
-                       COMMAND ${Python3_EXECUTABLE} ${DOXY_MD_FILTER} ${DOCS_BINARY_DIR}
-                       COMMENT "Pre-process markdown and image links")
-
-    # IE dev guide and C++ API
-
-    add_custom_target(ie_docs
-                      DEPENDS preprocess_docs
-                      COMMAND ${DOXYGEN_EXECUTABLE} ${IE_CONFIG_BINARY}
-                      WORKING_DIRECTORY ${DOCS_BINARY_DIR}
-                      VERBATIM)
-
-    # Plugin API
-
-    add_custom_target(plugin_api
+find_program(browser NAMES xdg-open)
+if(browser)
+    add_custom_target(ie_docs_open
+                      COMMAND ${browser} "${OpenVINO_MAIN_SOURCE_DIR}/doc/html/index.html"
                       DEPENDS ie_docs
-                      COMMAND ${DOXYGEN_EXECUTABLE} ${PLUGIN_CONFIG_BINARY}
-                      WORKING_DIRECTORY ${DOCS_BINARY_DIR}
-                      COMMENT "Generating Plugin API Reference"
+                      COMMENT "Open OpenVINO documentation"
                       VERBATIM)
-
-    # Umbrella OpenVINO target
-
-    add_custom_target(openvino_docs
-                      DEPENDS c_api py_api ie_docs plugin_api
-                      COMMENT "Generating OpenVINO documentation"
-                      VERBATIM)
-
-    set_target_properties(openvino_docs ie_docs c_api py_api preprocess_docs plugin_api
-                          PROPERTIES FOLDER docs)
-
-    find_program(browser NAMES xdg-open)
-    if(browser)
-        add_custom_target(ie_docs_open
-                          COMMAND ${browser} "${OpenVINO_MAIN_SOURCE_DIR}/docs/html/index.html"
-                          DEPENDS ie_docs
-                          COMMENT "Open OpenVINO documentation"
-                          VERBATIM)
-        set_target_properties(ie_docs_open PROPERTIES FOLDER docs)
-    endif()
-endfunction()
-
-if(ENABLE_DOCS)
-    build_docs()
+    set_target_properties(ie_docs_open PROPERTIES FOLDER docs)
 endif()

docs/HOWTO/Custom_Layers_Guide.md

@@ -1,6 +1,6 @@
 # Custom Layers Guide {#openvino_docs_HOWTO_Custom_Layers_Guide}
 
-The Intel® Distribution of OpenVINO™ toolkit supports neural network model layers in multiple frameworks including TensorFlow*, Caffe*, MXNet*, Kaldi* and ONNX*. The list of known layers is different for each of the supported frameworks. To see the layers supported by your framework, refer to [supported frameworks](../MO_DG/prepare_model/Supported_Frameworks_Layers.md).
+The Intel® Distribution of OpenVINO™ toolkit supports neural network model layers in multiple frameworks including TensorFlow*, Caffe*, MXNet*, Kaldi* and ONYX*. The list of known layers is different for each of the supported frameworks. To see the layers supported by your framework, refer to [supported frameworks](../MO_DG/prepare_model/Supported_Frameworks_Layers.md).
 
 Custom layers are layers that are not included in the list of known layers. If your topology contains any layers that are not in the list of known layers, the Model Optimizer classifies them as custom.
 
@@ -21,11 +21,11 @@ The original format will be a supported framework such as TensorFlow, Caffe, or
 
 ## Custom Layer Overview
 
-The [Model Optimizer](../MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md) searches the list of known layers for each layer contained in the input model topology before building the model's internal representation, optimizing the model, and producing the Intermediate Representation files.  
+The [Model Optimizer](https://docs.openvinotoolkit.org/2019_R1.1/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html) searches the list of known layers for each layer contained in the input model topology before building the model's internal representation, optimizing the model, and producing the Intermediate Representation files.  
 
-The [Inference Engine](../IE_DG/Deep_Learning_Inference_Engine_DevGuide.md) loads the layers from the input model IR files into the specified device plugin, which will search a list of known layer implementations for the device.  If your topology contains layers that are not in the list of known layers for the device, the Inference Engine considers the layer to be unsupported and reports an error.  To see the layers that are supported by each device plugin for the Inference Engine, refer to the [Supported Devices](../IE_DG/supported_plugins/Supported_Devices.md) documentation.  
+The [Inference Engine](https://docs.openvinotoolkit.org/2019_R1.1/_docs_IE_DG_Deep_Learning_Inference_Engine_DevGuide.html) loads the layers from the input model IR files into the specified device plugin, which will search a list of known layer implementations for the device.  If your topology contains layers that are not in the list of known layers for the device, the Inference Engine considers the layer to be unsupported and reports an error.  To see the layers that are supported by each device plugin for the Inference Engine, refer to the [Supported Devices](https://docs.openvinotoolkit.org/2019_R1.1/_docs_IE_DG_supported_plugins_Supported_Devices.html) documentation.  
 <br>
-> **NOTE:** If a device doesn't support a particular layer, an alternative to creating a new custom layer is to target an additional device using the HETERO plugin. The [Heterogeneous Plugin](../IE_DG/supported_plugins/HETERO.md) may be used to run an inference model on multiple devices allowing the unsupported layers on one device to "fallback" to run on another device (e.g., CPU) that does support those layers.
+**Note:** If a device doesn't support a particular layer, an alternative to creating a new custom layer is to target an additional device using the HETERO plugin. The [Heterogeneous Plugin](https://docs.openvinotoolkit.org/2019_R1.1/_docs_IE_DG_supported_plugins_HETERO.html) may be used to run an inference model on multiple devices allowing the unsupported layers on one device to "fallback" to run on another device (e.g., CPU) that does support those layers.
 
 ## Custom Layer Implementation Workflow
 
@@ -40,7 +40,7 @@ The following figure shows the basic processing steps for the Model Optimizer hi
 
 The Model Optimizer first extracts information from the input model which includes the topology of the model layers along with parameters, input and output format, etc., for each layer.  The model is then optimized from the various known characteristics of the layers, interconnects, and data flow which partly comes from the layer operation providing details including the shape of the output for each layer.  Finally, the optimized model is output to the model IR files needed by the Inference Engine to run the model.  
 
-The Model Optimizer starts with a library of known extractors and operations for each [supported model framework](../MO_DG/prepare_model/Supported_Frameworks_Layers.md) which must be extended to use each unknown custom layer.  The custom layer extensions needed by the Model Optimizer are:
+The Model Optimizer starts with a library of known extractors and operations for each [supported model framework](https://docs.openvinotoolkit.org/2019_R1.1/_docs_MO_DG_prepare_model_Supported_Frameworks_Layers.html) which must be extended to use each unknown custom layer.  The custom layer extensions needed by the Model Optimizer are:
 
 - Custom Layer Extractor
    - Responsible for identifying the custom layer operation and extracting the parameters for each instance of the custom layer.  The layer parameters are stored per instance and used by the layer operation before finally appearing in the output IR.  Typically the input layer parameters are unchanged, which is the case covered by this tutorial. 
@@ -182,10 +182,10 @@ There are two options to convert your MXNet* model that contains custom layers:
 2.  If you have sub-graphs that should not be expressed with the analogous sub-graph in the Intermediate Representation, but another sub-graph should appear in the model, the Model Optimizer provides such an option. In MXNet the function is actively used for ssd models provides an opportunity to  for the necessary subgraph sequences and replace them. To read more, see [Sub-graph Replacement in the Model Optimizer](../MO_DG/prepare_model/customize_model_optimizer/Subgraph_Replacement_Model_Optimizer.md).
 
 ## Kaldi\* Models with Custom Layers <a name="Kaldi-models-with-custom-layers"></a>
-For information on converting your Kaldi* model containing custom layers see [Converting a Kaldi Model in the Model Optimizer Developer Guide](../MO_DG/prepare_model/convert_model/Convert_Model_From_Kaldi.md). 
+For information on converting your Kaldi* model containing custom layers see [Converting a Kaldi Model in the Model Optimizer Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_Kaldi.html). 
 
 ## ONNX\* Models with Custom Layers <a name="ONNX-models-with-custom-layers"></a>
-For information on converting your ONNX* model containing custom layers see [Converting an ONNX Model in the Model Optimizer Developer Guide](../MO_DG/prepare_model/convert_model/Convert_Model_From_ONNX.md). 
+For information on converting your ONNX* model containing custom layers see [Converting an ONNX Model in the Model Optimizer Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_prepare_model_convert_model_Convert_Model_From_ONNX.html). 
 
 ## Step-by-Step Custom Layers Tutorial
 For a step-by-step walk-through creating and executing a custom layer, see [Custom Layer Implementation Tutorial for Linux and Windows.](https://github.com/david-drew/OpenVINO-Custom-Layers/tree/master/2019.r2.0) 
@@ -194,10 +194,10 @@ For a step-by-step walk-through creating and executing a custom layer, see [Cust
 
 - Intel® Distribution of OpenVINO™ toolkit home page: [https://software.intel.com/en-us/openvino-toolkit](https://software.intel.com/en-us/openvino-toolkit)
 - OpenVINO™ toolkit online documentation: [https://docs.openvinotoolkit.org](https://docs.openvinotoolkit.org)
-- [Model Optimizer Developer Guide](../MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md)
-- [Inference Engine Extensibility Mechanism](../IE_DG/Extensibility_DG/Intro.md)
-- [Inference Engine Samples Overview](../IE_DG/Samples_Overview.md)
-- [Overview of OpenVINO™ Toolkit Pre-Trained Models](@ref omz_models_intel_index)
+- [Model Optimizer Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html)
+- [Kernel Extensivility in the Inference Engine Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Integrate_your_kernels_into_IE.html)
+- [Inference Engine Samples Overview](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Samples_Overview.html)
+- [Overview of OpenVINO™ Toolkit Pre-Trained Models](https://docs.openvinotoolkit.org/latest/_intel_models_index.html)
 - [Inference Engine Tutorials](https://github.com/intel-iot-devkit/inference-tutorials-generic)
 - For IoT Libraries and Code Samples see the [Intel® IoT Developer Kit](https://github.com/intel-iot-devkit).
 

docs/HOWTO/add_regression_test_vpu.md

@@ -0,0 +1,83 @@
+# Regression tests howto {#openvino_docs_HOWTO_add_regression_test_vpu}
+
+## Purpose
+
+This document contains instructions for correctly modifying a set of regression tests.
+
+## Common
+
+Regression tests for Myriad and HDDL plugins are on the path:
+`inference-engine/tests/functional/vpu/regression_tests/`
+
+The tests are divided into 4 groups:
+* Classification
+* Detection
+* Raw-results
+* Compilation
+* VPU hetero
+
+Testing  framework – [Google Test](https://github.com/google/googletest/).
+Each group contains [parameterized](https://github.com/google/googletest/blob/master/googletest/docs/advanced.md) tests. The main idea is that to add a new test, you only need to add a new parameter. Except for scenarios different from the generalized case.
+
+## Classsification and Detection tests
+
+These groups contains two cases:
+
+* For generalized scenario (` VpuNoClassificationRegression, VpuNoDetectionRegression`)
+* For specific scenario (` VpuNoClassificationRegressionSpecific, VpuNoDetectionRegressionSpecific`)
+
+### Generalized scenario
+
+If You want test new parameter(batch, precision, model and etc.) then You need to edit the existing initialization of parameterized tests or create a new one.  
+Example of initialization of parameterized tests:
+
+``` c++
+INSTANTIATE_TEST_CASE_P(
+        VPURegTestWithResources_nightly,
+        VpuNoClassificationRegression,
+        Combine(ValuesIn(VpuTestParamsContainer::testingPlugin()),
+                Values(Precision::FP16),
+                Values(1),  // batches
+                Values(true), //IsHwAdaptiveMode
+                Values(false), //DoReshape
+                Values(3, 5, 7), //Resources
+                Values(false), //IsIgnoreStatistic
+                Values(ClassificationSrcParam{ModelName::GoogleNetV1, SourceImages::kCat3, 0.01, Regression::EMean::eValues})),
+        VpuNoClassificationRegression::getTestCaseName);
+```
+
+### Specific scenario
+
+If You need a test to perform some actions that are not provided in the generalized scenario, then add a specific test case. As with the generalized scenario You can change parameters for these tests.  
+Example of specific test case:
+
+``` c++
+TEST_P(VpuNoClassificationRegressionSpecific, onAlexNetWithNetworkConfig) {
+    DISABLE_ON_WINDOWS_IF(HDDL_PLUGIN);
+    DISABLE_IF(do_reshape_);
+
+    if (!hw_adaptive_mode_) {
+        config_[VPU_CONFIG_KEY(NETWORK_CONFIG)] = "data=data,scale=1";
+    }
+
+    assertThat().classificationResultsForInferRequestAPI()
+            .on(SourceImages::kDog2)
+            .withInputPrecision(in_precision_)
+            .times(batch_)
+            .withBatch(batch_)
+            .onModel(ModelName::AlexNet)
+            .setMean(Regression::EMean::eImage)
+            .onFP16()
+            .withTopK(1)
+            .withPluginConfig(config_)
+            .equalToReferenceWithDelta(0.04);
+}
+```
+
+## Raw-results tests
+
+There is no generalized scenario and recommendations are the same as for specific test cases for Classification/Detection groups.
+
+## Compilation tests
+
+The tests are in the `vpu_classification_regression.cpp` file and contains only one scenario ` VpuNoRegressionWithCompilation `. To add a new test just update parameters just as in generalized scenarion of Classification/Detection test groups.

docs/HOWTO/fuzzing-HOWTO.md

@@ -0,0 +1,94 @@
+# Fuzzing howto {#openvino_docs_HOWTO_fuzzing_HOWTO}
+
+## Intended Audience
+
+This document is for a developer who wants to contribute fuzz tests.
+
+## Purpose
+
+This document walks you through creating your first fuzzer, running it and evaluating its quality.
+
+## Prerequisites
+
+- Linux OS or Mac OS.
+
+- [American Fuzzy Loop](http://lcamtuf.coredump.cx/afl/) if building   with GCC.
+
+## Steps
+
+1. Create a fuzz test in the existing project at `./tests/fuzz`. Fuzz test must
+   follow `<test name>-fuzzer.cc` naming scheme and implement a
+   `LLVMFuzzerTestOneInput` entry point.
+
+``` bash
+cat << EOF > ./tests/fuzz/test_name-fuzzer.cc
+#include <stdint.h>
+#include <cstdlib>
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  // put your fuzzing code here and use data+size as input.
+  return 0;  // always return 0
+}
+EOF
+```
+
+2. Implement test logic under `LLVMFuzzerTestOneInput`.
+
+See example fuzz test at `tests/fuzz/read_network-fuzzer.cc`.
+
+3. Build fuzz tests with `-DENABLE_FUZZING=ON` flag for cmake.
+
+``` bash
+    mkdir -p build && \
+    (cd build && \
+    CXX=afl-g++ CC=afl-gcc cmake -DCMAKE_BUILD_TYPE=Debug -DENABLE_FUZZING=ON -DENABLE_TESTS=ON .. && \
+    make fuzz --jobs=$(getconf _NPROCESSORS_ONLN))
+```
+
+4. Prepare sample inputs for your fuzz test to teach fuzzer engine on input
+   structure
+
+``` bash
+(cd bin/intel64/Debug && \
+mkdir test_name-corpus && \
+echo sample input > test_name-corpus/in1.txt)
+```
+
+5. Evaluate fuzz test with `afl-fuzz` fuzzing engine
+
+Run fuzz test:
+
+``` bash
+(cd bin/intel64/Debug && \
+afl-fuzz -i test_name-corpus -o test_name-out -- ./test_name-fuzzer @@
+```
+
+While fuzz test is running it prints out statistics. Besides just crashes `uniq
+crashes` and hangs `uniq hangs` you should care about fuzz test quality:
+
+- Fuzz test should be fast - speed of execution `exec speed` should be at least
+  100 exec/s. Speed less than 20 exec/s is not acceptable.
+
+- Fuzz test should be able to explore new code paths `map coverage` and
+  `findings in depth`. Confirm it is increasing while fuzz test is running.
+
+6. Reproduce fuzz test findings
+
+All issues found by fuzz test are stored as a file in output folder specified
+earlier via `-o` afl-fuzz option. To reproduce an issue run fuzz test executable
+with an issue file as an argument.
+
+## Summary
+
+We have created a simple fuzz test, run it and asses its results.
+
+## Extension
+
+Try run parallel fuzzing with the help of
+[afl-utils](https://gitlab.com/rc0r/afl-utils).
+
+## Tips or FAQs
+
+GCC 7 in Ubuntu 18.04 LTS has a
+[defect](https://bugs.launchpad.net/ubuntu/+source/afl/+bug/1774816). Upgrade
+GCC 7 for AFL to work. GCC version `Ubuntu 7.3.0-27ubuntu1~18.04` works OK.

docs/IE_DG/API_Changes.md

@@ -2,145 +2,6 @@
 
 The sections below contain detailed list of changes made to the Inference Engine API in recent releases.
 
-## 2021.2
-
-### New API
-
- **State API**
-
- * InferenceEngine::InferRequest::QueryState query state value of network on current infer request
- * InferenceEngine::IVariableState class instead of IMemoryState (rename)
- * InferenceEngine::IVariableState::GetState instead of IMemoryState::GetLastState (rename)
-
- **BatchedBlob** - represents a InferenceEngine::BatchedBlob containing other blobs - one per batch.
-
- **Transformations API** - added a new header `ie_transformations.hpp` which contains transformations for InferenceEngine::CNNNetwork object. Such transformations can be called prior to loading network for compilation for particular device:
-
- * InferenceEngine::LowLatency
-
-### Deprecated API
-
- **State API**
-
- * InferenceEngine::ExecutableNetwork::QueryState - use InferenceEngine::InferRequest::QueryState
- * InferenceEngine::IVariableState::GetLastState - use InferenceEngine::IVariableState::GetState
-
-## 2021.1
-
-### Deprecated API
-
- **Utility functions to convert Unicode paths**
-
- * InferenceEngine::stringToFileName - use OS-specific native conversion functions
- * InferenceEngine::fileNameToString - use OS-specific native conversion functions
-
-### Removed API
-
- **Plugin API:**
-
- * InferenceEngine::InferencePlugin C++ plugin wrapper class
- * InferenceEngine::IInferencePlugin plugin interface
- * InferenceEngine::PluginDispatcher class
- * InferenceEngine::InferenceEnginePluginPtr typedef
- * InferenceEngine::ICNNNetReader reader interface
- * InferenceEngine::CNNNetReader class
-
- **Extensibility API:**
-
- * InferenceEngine::ILayerImplFactory class
- * InferenceEngine::IShapeInferImpl class
- * InferenceEngine::IShapeInferExtension class
- * InferenceEngine::IExtension::getFactoryFor(ILayerImplFactory\*& factory, const CNNLayer\* cnnLayer, ResponseDesc\* resp) noexcept method
- * InferenceEngine::IExtension::getPrimitiveTypes(char\*\*& types, unsigned int& size, ResponseDesc\* resp) noexcept method
- * InferenceEngine::ShapeInferImpl class
- * InferenceEngine::Extension::getFactoryFor(ILayerImplFactory\*& factory, const CNNLayer\* cnnLayer, ResponseDesc\* resp) noexcept method
- * InferenceEngine::Extension::getPrimitiveTypes(char\*\*& types, unsigned int& size, ResponseDesc\* resp) noexcept method
-
- **Network API:**
-
- * InferenceEngine::details::CNNNetworkIterator class
- * InferenceEngine::CNNNetwork::getPrecision() const method
- * InferenceEngine::CNNNetwork::getLayerByName(const char\* layerName) const method
- * InferenceEngine::CNNNetwork::size() const method
- * InferenceEngine::CNNNetwork::begin() const method
- * InferenceEngine::CNNNetwork::end() const method
- * InferenceEngine::CNNNetwork::AddExtension(const IShapeInferExtensionPtr& extension) method
- * InferenceEngine::ICNNNetwork::getPrecision() const noexcept method
- * InferenceEngine::ICNNNetwork::getName(char\* pName, size_t len) const noexcept method
- * InferenceEngine::ICNNNetwork::getData(const char\* dname) noexcept method
- * InferenceEngine::ICNNNetwork::addLayer(const CNNLayerPtr& layer) noexcept method
- * InferenceEngine::ICNNNetwork::getLayerByName(const char\* layerName, CNNLayerPtr& out, ResponseDesc\* resp) const noexcept method
- * InferenceEngine::ICNNNetwork::AddExtension(const IShapeInferExtensionPtr& extension, ResponseDesc\* resp) noexcept method
- * InferenceEngine::ICNNNetwork::getStats(ICNNNetworkStats\*\* stats, ResponseDesc\* resp) const noexcept method
- * InferenceEngine::ICNNNetworkStats class
- * InferenceEngine::NetworkNodeStats class
- * InferenceEngine::Data::getCreatorLayer() method
- * InferenceEngine::Data::getInputTo() method
- * InferenceEngine::LayerParams class
-
- **Layer API:**
-
- * InferenceEngine::CNNLayer class
- * InferenceEngine::WeightableLayer class
- * InferenceEngine::BatchNormalizationLayer class
- * InferenceEngine::BatchToSpaceLayer class
- * InferenceEngine::BinaryConvolutionLayer class
- * InferenceEngine::BroadcastLayer class
- * InferenceEngine::BucketizeLayer class
- * InferenceEngine::ClampLayer class
- * InferenceEngine::ConcatLayer class
- * InferenceEngine::ConvolutionLayer class
- * InferenceEngine::CropLayer class
- * InferenceEngine::DeconvolutionLayer class
- * InferenceEngine::DeformableConvolutionLayer class
- * InferenceEngine::DepthToSpaceLayer class
- * InferenceEngine::EltwiseLayer class
- * InferenceEngine::ExperimentalDetectronPriorGridGenerator class
- * InferenceEngine::ExperimentalDetectronPriorGridGeneratorLayer class
- * InferenceEngine::ExperimentalSparseWeightedReduceLayer class
- * InferenceEngine::FillLayer class
- * InferenceEngine::FullyConnectedLayer class
- * InferenceEngine::GRNLayer class
- * InferenceEngine::GRUCell class
- * InferenceEngine::GatherLayer class
- * InferenceEngine::GemmLayer class
- * InferenceEngine::LSTMCell class
- * InferenceEngine::MVNLayer class
- * InferenceEngine::MathLayer class
- * InferenceEngine::NonMaxSuppression class
- * InferenceEngine::NormLayer class
- * InferenceEngine::OneHotLayer class
- * InferenceEngine::PReLULayer class
- * InferenceEngine::PadLayer class
- * InferenceEngine::PoolingLayer class
- * InferenceEngine::PowerLayer class
- * InferenceEngine::QuantizeLayer class
- * InferenceEngine::RNNCell class
- * InferenceEngine::RNNCellBase class
- * InferenceEngine::RNNSequenceLayer class
- * InferenceEngine::RangeLayer class
- * InferenceEngine::ReLU6Layer class
- * InferenceEngine::ReLULayer class
- * InferenceEngine::ReduceLayer class
- * InferenceEngine::ReshapeLayer class
- * InferenceEngine::ReverseSequenceLayer class
- * InferenceEngine::ScaleShiftLayer class
- * InferenceEngine::ScatterLayer class
- * InferenceEngine::SelectLayer class
- * InferenceEngine::ShuffleChannelsLayer class
- * InferenceEngine::SoftMaxLayer class
- * InferenceEngine::SpaceToBatchLayer class
- * InferenceEngine::SpaceToDepthLayer class
- * InferenceEngine::SparseFillEmptyRowsLayer class
- * InferenceEngine::SparseSegmentReduceLayer class
- * InferenceEngine::SparseToDenseLayer class
- * InferenceEngine::SplitLayer class
- * InferenceEngine::StridedSliceLayer class
- * InferenceEngine::TensorIterator class
- * InferenceEngine::TileLayer class
- * InferenceEngine::TopKLayer class
- * InferenceEngine::UniqueLayer class
-
 ## 2020.4
 
 ### New API

docs/IE_DG/Bfloat16Inference.md

@@ -20,7 +20,10 @@ There are two ways to check if CPU device can support bfloat16 computations for
 1. Query the instruction set via system `lscpu | grep avx512_bf16` or `cat /proc/cpuinfo | grep avx512_bf16`.
 2. Use [Query API](InferenceEngine_QueryAPI.md) with `METRIC_KEY(OPTIMIZATION_CAPABILITIES)`, which should return `BF16` in the list of CPU optimization options:
 
-@snippet snippets/Bfloat16Inference0.cpp part0
+```cpp
+InferenceEngine::Core core;
+auto cpuOptimizationCapabilities = core.GetMetric("CPU", METRIC_KEY(OPTIMIZATION_CAPABILITIES)).as<std::vector<std::string>>();
+```
 
 Current Inference Engine solution for bfloat16 inference uses Intel® Math Kernel Library for Deep Neural Networks (Intel® MKL-DNN) and supports inference of the following layers in BF16 computation mode:
 * Convolution
@@ -46,11 +49,18 @@ Bfloat16 data usage provides the following benefits that increase performance:
 For default optimization on CPU, source model converts from FP32 or FP16 to BF16 and executes internally on platforms with native BF16 support. In that case, `KEY_ENFORCE_BF16` is set to `YES`.
 The code below demonstrates how to check if the key is set:
 
-@snippet snippets/Bfloat16Inference1.cpp part1
+```cpp
+InferenceEngine::Core core;
+auto exeNetwork = core.LoadNetwork(network, "CPU");
+auto enforceBF16 = exeNetwork.GetConfig(PluginConfigParams::KEY_ENFORCE_BF16).as<std::string>();
+```
 
 To disable BF16 internal transformations, set the `KEY_ENFORCE_BF16` to `NO`. In this case, the model infers AS IS without modifications with precisions that were set on each layer edge.
 
-@snippet snippets/Bfloat16Inference2.cpp part2
+```cpp
+InferenceEngine::Core core;
+core.SetConfig({ { CONFIG_KEY(ENFORCE_BF16), CONFIG_VALUE(NO) } }, "CPU");
+```
 
 An exception with message `Platform doesn't support BF16 format` is formed in case of setting `KEY_ENFORCE_BF16` to `YES` on CPU without native BF16 support.
 

docs/IE_DG/Deep_Learning_Inference_Engine_DevGuide.md

@@ -10,7 +10,7 @@ and mixed-reality headsets.
 The OpenVINO™ toolkit:
 
 * Enables CNN-based deep learning inference on the edge
-* Supports heterogeneous execution across an Intel® CPU, Intel® Integrated Graphics, Intel® Neural Compute Stick 2
+* Supports heterogeneous execution across an Intel® CPU, Intel® Integrated Graphics, Intel® Movidius™ Neural Compute Stick and Intel® Neural Compute Stick 2
 * Speeds time-to-market via an easy-to-use library of computer vision functions and pre-optimized kernels
 * Includes optimized calls for computer vision standards including OpenCV\*, OpenCL™, and OpenVX\*
 
@@ -22,7 +22,7 @@ The OpenVINO™ toolkit includes the following components:
     TensorFlow*, MXNet*, Kaldi*, ONNX* models.
     - [Deep Learning Inference Engine](inference_engine_intro.md) — A unified API to allow high performance inference on many hardware types
     including Intel® CPU, Intel® Processor Graphics, Intel® FPGA, Intel® Neural Compute Stick 2.
-    - [nGraph](../nGraph_DG/nGraph_dg.md) — graph representation and manipulation engine which is used to represent a model inside Inference Engine and allows the run-time model construction without using Model Optimizer.
+    - [nGraph](nGraph_Flow.md) — graph representation and manipulation engine which is used to represent a model inside Inference Engine and allows the run-time model construction without using Model Optimizer.
 * [OpenCV](https://docs.opencv.org/) — OpenCV* community version compiled for Intel® hardware.
 Includes PVL libraries for computer vision.
 * Drivers and runtimes for OpenCL™ version 2.1
@@ -35,17 +35,21 @@ optimized for running on Intel® hardware (CPU, GPU, IPU).
 This Guide provides overview of the Inference Engine describing the typical workflow for performing
 inference of a pre-trained and optimized deep learning model and a set of sample applications.
 
-> **NOTES:**
+> **NOTES:** 
 > - Before you perform inference with the Inference Engine, your models should be converted to the Inference Engine format using the Model Optimizer or built directly in run-time using nGraph API. To learn about how to use Model Optimizer, refer to the [Model Optimizer Developer Guide](../MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md). To learn about the pre-trained and optimized models delivered with the OpenVINO™ toolkit, refer to [Pre-Trained Models](@ref omz_models_intel_index).
 > - [Intel® System Studio](https://software.intel.com/en-us/system-studio) is an all-in-one, cross-platform tool suite, purpose-built to simplify system bring-up and improve system and IoT device application performance on Intel® platforms. If you are using the Intel® Distribution of OpenVINO™ with Intel® System Studio, go to [Get Started with Intel® System Studio](https://software.intel.com/en-us/articles/get-started-with-openvino-and-intel-system-studio-2019).
 
 
 ## Table of Contents
 
+* [Introduction to Intel® Deep Learning Deployment Toolkit](Introduction.md)
+
 * [Inference Engine API Changes History](API_Changes.md)
 
 * [Introduction to Inference Engine](inference_engine_intro.md)
 
+* [Introduction to nGraph Flow](nGraph_Flow.md)
+
 * [Understanding Inference Engine Memory Primitives](Memory_primitives.md)
 
 * [Introduction to Inference Engine Device Query API](InferenceEngine_QueryAPI.md)
@@ -54,7 +58,7 @@ inference of a pre-trained and optimized deep learning model and a set of sample
 
 * [Integrating Inference Engine in Your Application](Integrate_with_customer_application_new_API.md)
 
-* [[DEPRECATED] Migration from Inference Engine Plugin API to Core API](Migration_CoreAPI.md)
+* [Migration from Inference Engine Plugin API to Core API](Migration_CoreAPI.md)
 
 * [Introduction to Performance Topics](Intro_to_Performance.md)
 
@@ -74,15 +78,16 @@ inference of a pre-trained and optimized deep learning model and a set of sample
 * [Supported Devices](supported_plugins/Supported_Devices.md)
     * [GPU](supported_plugins/CL_DNN.md)
     * [CPU](supported_plugins/CPU.md)
+    * [FPGA](supported_plugins/FPGA.md)
     * [VPU](supported_plugins/VPU.md)
       * [MYRIAD](supported_plugins/MYRIAD.md)
       * [HDDL](supported_plugins/HDDL.md)
     * [Heterogeneous execution](supported_plugins/HETERO.md)
     * [GNA](supported_plugins/GNA.md)
-    * [MULTI](supported_plugins/MULTI.md)
+    * **NEW!** [MULTI](supported_plugins/MULTI.md)
 
 * [Pre-Trained Models](@ref omz_models_intel_index)
 
 * [Known Issues](Known_Issues_Limitations.md)
 
-**Typical Next Step:** [Introduction to Inference Engine](inference_engine_intro.md)
+**Typical Next Step:** [Introduction to Intel® Deep Learning Deployment Toolkit](Introduction.md)

docs/IE_DG/DynamicBatching.md

@@ -17,8 +17,39 @@ dynamically in all of its infer requests using <code>SetBatch()</code> method.
 The batch size that was set in passed <code>CNNNetwork</code> object will be used as a maximum batch size limit.
 
 Here is a code example:
+```cpp
+int dynBatchLimit = FLAGS_bl;	//take dynamic batch limit from command line option
 
-@snippet snippets/DynamicBatching.cpp part0
+// Read network model
+Core core;
+CNNNetwork network = core.ReadNetwork(modelFileName, weightFileName);
+
+// enable dynamic batching and prepare for setting max batch limit
+const std::map<std::string, std::string> dyn_config = 
+{ { PluginConfigParams::KEY_DYN_BATCH_ENABLED, PluginConfigParams::YES } };
+network.setBatchSize(dynBatchLimit);
+
+// create executable network and infer request
+auto executable_network = core.LoadNetwork(network, "CPU", dyn_config);
+auto infer_request = executable_network.CreateInferRequest();
+
+
+...
+
+
+// process a set of images
+// dynamically set batch size for subsequent Infer() calls of this request
+size_t batchSize = imagesData.size();
+infer_request.SetBatch(batchSize);
+infer_request.Infer();
+
+...
+
+// process another set of images
+batchSize = imagesData2.size();
+infer_request.SetBatch(batchSize);
+infer_request.Infer();
+```
 
 
 ## Limitations

docs/IE_DG/Extensibility_DG/AddingNGraphOps.md

@@ -12,15 +12,13 @@ To add your custom nGraph operation, create a new class that extends `ngraph::Op
 
 3. Override the shape inference method `validate_and_infer_types`. This method is called multiple times during graph manipulations to determine the shapes and element types of the outputs of the operations. You can access the input shapes through the `get_input_partial_shape()` method and input element types through the `get_input_element_type()` method of `ngraph::Node`. Set the inferred shape and element type of the output using `set_output_type`.
 
-4. Override the `clone_with_new_inputs` method, which allows graph manipulation routines to create copies of this operation and connect it to different nodes during optimization.
+4. Override the `copy_with_new_args` method, which allows graph manipulation routines to create copies of this operation and connect it to different nodes during optimization.
 
 5. Override the `visit_attributes` method, which allows serialization and deserialization of 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 nGraph defined types.
 
-6. Override `evaluate`, which is an optional method that enables the application of constant folding if there is a custom operation on the constant branch.
-
 Based on that, declaration of a operation class can look as follows:
 
-@snippet template_extension/op.hpp op:header
+@snippet op.hpp op:header
 
 ### Class Fields
 
@@ -33,37 +31,31 @@ The provided implementation has several fields:
 
 nGraph operation contains two constructors: a default constructor, which allows to create operation without attributes and a constructor that creates and validates operation with specified inputs and attributes.
 
-@snippet template_extension/op.cpp op:ctor
+@snippet op.cpp op:ctor
 
 ### `validate_and_infer_types()`
 
 `ngraph::Node::validate_and_infer_types` method validates operation attributes and calculates output shapes using attributes of operation.
 
-@snippet template_extension/op.cpp op:validate
+@snippet op.cpp op:validate
 
-### `clone_with_new_inputs()`
+### `copy_with_new_args()`
 
-`ngraph::Node::clone_with_new_inputs` method creates a copy of nGraph operation with new inputs.
+`ngraph::Node::copy_with_new_args` method creates a copy of nGraph operation with new inputs.
 
-@snippet template_extension/op.cpp op:copy
+@snippet op.cpp op:copy
 
 ### `visit_attributes()`
 
 `ngraph::Node::visit_attributes` method allows to visit all operation attributes.
 
-@snippet template_extension/op.cpp op:visit_attributes
-
-### `evaluate()`
-
-`ngraph::Node::evaluate` method allows to apply constant folding to an operation.
-
-@snippet template_extension/op.cpp op:evaluate
+@snippet op.cpp op:visit_attributes
 
 ## Register Custom Operations in Extension Class
 
 To add custom operations to the [Extension](Extension.md) class, create an operation set with custom operations and implement the `InferenceEngine::IExtension::getOpSets` method:
 
-@snippet template_extension/extension.cpp extension:getOpSets
+@snippet extension.cpp extension:getOpSets
 
 This method returns a map of opsets that exist in the extension library.
 
@@ -77,4 +69,4 @@ When specifying opset names, follow the rules below:
 * `opset1` is the name of default operations set.
 Operations from the default opset cannot be redefined.
 
-Use a custom opset to create a new operation or extend functionality of an existing operation from another opset.
+Use a custom opset to create a new operation or extend functionality of an existing operation from another opset.

docs/IE_DG/Extensibility_DG/Building.md

@@ -4,7 +4,7 @@ Inference Engine build infrastructure provides the Inference Engine Package for
 
 To build an extension library, use the following CMake script:
 
-@snippet template_extension/CMakeLists.txt cmake:extension
+@snippet CMakeLists.txt cmake:extension
 
 This CMake script finds the Inference Engine and nGraph using the `find_package` CMake command.
 

docs/IE_DG/Extensibility_DG/CPU_Kernel.md

@@ -7,7 +7,7 @@ The primary vehicle for the performance of the CPU codepath in the Inference Eng
 All custom kernels for the CPU plugin should be inherited from the InferenceEngine::ILayerExecImpl interface.
 Based on that, declaration of a kernel implementation class can look as follows:
 
-@snippet template_extension/cpu_kernel.hpp cpu_implementation:header
+@snippet cpu_kernel.hpp cpu_implementation:header
 
 ### Class Fields
 
@@ -22,25 +22,25 @@ The provided implementation has several fields:
 
 An implementation constructor checks parameters of nGraph operation, stores needed attributes, and stores an error message in the case of an error.
 
-@snippet template_extension/cpu_kernel.cpp cpu_implementation:ctor
+@snippet cpu_kernel.cpp cpu_implementation:ctor
 
 ### `getSupportedConfigurations`
 
 InferenceEngine::ILayerExecImpl::getSupportedConfigurations method returns all supported configuration formats (input/output tensor layouts) for your implementation. To specify formats of data, use InferenceEngine::TensorDesc. Refer to the [Memory Primitives](../Memory_primitives.md) section for instructions on how to do it.
 
-@snippet template_extension/cpu_kernel.cpp cpu_implementation:getSupportedConfigurations
+@snippet cpu_kernel.cpp cpu_implementation:getSupportedConfigurations
 
 ### `init`
 
 InferenceEngine::ILayerExecImpl::init method gets a runtime-selected configuration from a vector that is populated from the `getSupportedConfigurations` method and checks the parameters:
 
-@snippet template_extension/cpu_kernel.cpp cpu_implementation:init
+@snippet cpu_kernel.cpp cpu_implementation:init
 
 ### `execute`
 
 InferenceEngine::ILayerExecImpl::execute method accepts and processes the actual tenors as input/output blobs:
 
-@snippet template_extension/cpu_kernel.cpp cpu_implementation:execute
+@snippet cpu_kernel.cpp cpu_implementation:execute
 
 ## Register Implementation in `Extension` Class
 
@@ -52,18 +52,23 @@ To register custom kernel implementation in the [Extension](Extension.md) class,
 
 InferenceEngine::IExtension::getImplTypes returns a vector of implementation types for an operation.
 
-@snippet template_extension/extension.cpp extension:getImplTypes
+@snippet extension.cpp extension:getImplTypes
 
 ### <a name="getImplementation"><code>getImplementation</code></a>
 
 InferenceEngine::IExtension::getImplementation returns the kernel implementation with a specified type for an operation.
 
-@snippet template_extension/extension.cpp extension:getImplementation
+@snippet extension.cpp extension:getImplementation
 
 
 ## Load Extension with Executable Kernels to Plugin
 
 Use the `AddExtension` method of the general plugin interface to load your primitives:
-
-@snippet snippets/CPU_Kernel.cpp part0
+```cpp
+InferenceEngine::Core core;
+// Load CPU extension as a shared library
+auto extension_ptr = make_so_pointer<InferenceEngine::IExtension>("<shared lib path>");
+// Add extension to the CPU device
+core.AddExtension(extension_ptr, "CPU");
+```
 

docs/IE_DG/Extensibility_DG/Custom_ONNX_Ops.md

@@ -1,57 +0,0 @@
-# Custom ONNX operators {#openvino_docs_IE_DG_Extensibility_DG_Custom_ONNX_Ops}
-
-ONNX importer provides mechanism to register custom ONNX operators based on predefined or user-defined nGraph operations.
-The function responsible for registering a new operator is called `ngraph::onnx_import::register_operator` and is defined in `onnx_import/onnx_utils.hpp`.
-
-## Registering custom ONNX operator based on predefined nGraph operations
-
-The steps below explain how to register a custom ONNX operator, for example, CustomRelu, in a domain called com.example.
-CustomRelu is defined as follows:
-```
-x >= 0 => f(x) = x * alpha
-x < 0  => f(x) = x * beta
-```
-where alpha, beta are float constants.
-
-1. Include headers:
-@snippet onnx_custom_op/onnx_custom_op.cpp onnx_custom_op:headers
-
-2. Register the CustomRelu operator in the ONNX importer:
-@snippet onnx_custom_op/onnx_custom_op.cpp onnx_custom_op:register_operator
-The `register_operator` function takes four arguments: op_type, opset version, domain, and a function object.
-The function object is a user-defined function that takes `ngraph::onnx_import::Node` as an input and based on that, returns a graph with nGraph operations.
-The `ngraph::onnx_import::Node` class represents a node in ONNX model. It provides functions to fetch input node(s) (`get_ng_inputs`), fetch attribute value (`get_attribute_value`) and many more (please refer to `onnx_import/core/node.hpp` for full class declaration).
-New operator registration must happen before the ONNX model is read, for example, if an ONNX model uses the 'CustomRelu' operator, `register_operator("CustomRelu", ...)` must be called before InferenceEngine::Core::ReadNetwork.
-Re-registering ONNX operators within the same process is supported. During registration of the existing operator, a warning is printed.
-
-The example below demonstrates an examplary model that requires previously created 'CustomRelu' operator:
-@snippet onnx_custom_op/onnx_custom_op.cpp onnx_custom_op:model
-
-
-For a reference on how to create a graph with nGraph operations, visit [nGraph tutorial](../nGraphTutorial.md).
-For a complete list of predefined nGraph operators, visit [available operations sets](../../ops/opset.md).
-
-If operator is no longer needed, it can be unregistered by calling `unregister_operator`. The function takes three arguments `op_type`, `version`, and `domain`.
-@snippet onnx_custom_op/onnx_custom_op.cpp onnx_custom_op:unregister_operator
-
-## Registering custom ONNX operator based on custom nGraph operations
-
-The same principles apply when registering custom ONNX operator based on custom nGraph operations.
-This example shows how to register custom ONNX operator based on `Operation` presented in [this tutorial](AddingNGraphOps.md), which is used in [TemplateExtension](Extension.md).
-@snippet template_extension/extension.cpp extension:ctor
-
-Here, the `register_operator` function is called in Extension's constructor, which makes sure that it is called before InferenceEngine::Core::ReadNetwork (since InferenceEngine::Core::AddExtension must be called before a model with custom operator is read).
-
-The example below demonstrates how to unregister operator from Extension's destructor:
-@snippet template_extension/extension.cpp extension:dtor
-Note that it is mandatory to unregister custom ONNX operator if it is defined in dynamic shared library.
-
-## Requirements for building with CMake
-
-Program that uses the `register_operator` functionality, requires (in addition to Inference Engine) `ngraph` and `onnx_importer` libraries.
-The `onnx_importer` is a component of `ngraph` package , so `find_package(ngraph REQUIRED COMPONENTS onnx_importer)` is sufficient to find both.
-The `ngraph` package exposes two variables (`${NGRAPH_LIBRARIES}` and `${ONNX_IMPORTER_LIBRARIES}`), which reference `ngraph` and `onnx_importer` libraries.
-Those variables need to be passed to the `target_link_libraries` command in the CMakeLists.txt file.
-
-See below CMakeLists.txt for reference:
-@snippet onnx_custom_op/CMakeLists.txt cmake:onnx_custom_op

docs/IE_DG/Extensibility_DG/Extension.md

@@ -5,11 +5,11 @@ All extension libraries should be inherited from this interface.
 
 Based on that, declaration of an extension class can look as follows:
 
-@snippet template_extension/extension.hpp extension:header
+@snippet extension.hpp extension:header
 
 The extension library should contain and export the method InferenceEngine::CreateExtension, which creates an `Extension` class:
 
-@snippet template_extension/extension.cpp extension:CreateExtension
+@snippet extension.cpp extension:CreateExtension
 
 Also, an `Extension` object should implement the following methods:
 
@@ -17,10 +17,9 @@ Also, an `Extension` object should implement the following methods:
 
 * InferenceEngine::IExtension::GetVersion returns information about version of the library
 
-@snippet template_extension/extension.cpp extension:GetVersion
+@snippet extension.cpp extension:GetVersion
 
 Implement the  InferenceEngine::IExtension::getOpSets method if the extension contains custom layers. 
 Read the [guide about custom operations](AddingNGraphOps.md) for more information.
 
 To understand how integrate execution kernels to the extension library, read the [guide about development of custom CPU kernels](CPU_Kernel.md).
-To understand how to register custom ONNX operator to the extension library, read the [guide about custom ONNX operators](Custom_ONNX_Ops.md).

docs/IE_DG/Extensibility_DG/GPU_Kernel.md

@@ -6,8 +6,11 @@ There are two options of using custom layer configuration file:
 
 * Include a section with your kernels into the global automatically-loaded `cldnn_global_custom_kernels/cldnn_global_custom_kernels.xml` file, which is hosted in the `<INSTALL_DIR>/deployment_tools/inference_engine/bin/intel64/{Debug/Release}` folder
 * Call the `InferenceEngine::Core::SetConfig()` method from your application with the `InferenceEngine::PluginConfigParams::KEY_CONFIG_FILE` key and the configuration file name as a value before loading the network that uses custom layers to the plugin:
-
-@snippet snippets/GPU_Kernel.cpp part0
+```cpp
+InferenceEngine::Core core;
+// Load GPU Extensions
+core.SetConfig({ { InferenceEngine::PluginConfigParams::KEY_CONFIG_FILE, "<path_to_the_xml_file>" } }, "GPU");
+```
 
 All Inference Engine samples, except trivial `hello_classification`,
 feature a dedicated command-line option `-c` to load custom kernels. For example, to load custom layers for the classification sample, run the command below:
@@ -226,9 +229,9 @@ the values set by the Inference Engine, such as tensor sizes,
 floating-point, and integer kernel parameters. To get the dump, add the
 following line to your code that configures the GPU plugin to output the
 custom kernels:
-
-@snippet snippets/GPU_Kernel.cpp part1
-
+```cpp
+core.SetConfig({ { PluginConfigParams::KEY_DUMP_KERNELS, PluginConfigParams::YES } }, "GPU");
+```
 When the Inference Engine compiles the kernels for the specific network,
 it also outputs the resulting code for the custom kernels. In the
 directory of your executable, find files like

docs/IE_DG/Extensibility_DG/Intro.md

@@ -40,6 +40,13 @@ The following pages describe how to integrate custom _kernels_ into the Inferenc
  * [Introduction to development of custom GPU kernels](GPU_Kernel.md)
  * [Introduction to development of custom VPU kernels](VPU_Kernel.md)
 
+## Deprecated Extensibility API
+
+Shape Inference API and some methods of extensibility mechanism was deprecated and will be removed soon.
+Old Extensibility mechanism contains two parts shape inference and execution kernel.
+ * [Shape Inference](deprecated/ShapeInfer.md)
+ * [Execution Kernel](deprecated/Factory.md)
+
 ## Additional Resources
 
 * [Build an extension library using CMake*](Building.md)

docs/IE_DG/Extensibility_DG/VPU_Kernel.md

@@ -445,7 +445,7 @@ from/to a `__blobal` pointer since work-group copying could be done in a vector
      }
    }
    ```
-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 `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.
+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 `n`-th work group itself, while `__dma_postwrite_kernelName` is guarantied 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,

docs/IE_DG/Extensibility_DG/deprecated/Factory.md

@@ -0,0 +1,96 @@
+# Deprecated API for CPU kernels creation {#openvino_docs_IE_DG_Extensibility_DG_deprecated_Factory}
+
+List of deprecated API for kernels development:
+ * `InferenceEngine::IExtension::getPrimitiveTypes(char**& types, unsigned int& size, ResponseDesc* resp)` method
+ * `InferenceEngine::IExtension::getFactoryFor(ILayerImplFactory *&factory, const CNNLayer *cnnLayer, ResponseDesc *resp)` method
+ * `InferenceEngine::ILayerImplFactory` class
+
+>**NOTE**: This guide demonstrates how to use deprecated API for kernels creation. However, keep in mind that this API will be deleted soon.
+
+1. Create your custom layer factory `CustomLayerFactory` class:
+```cpp
+// custom_layer.h
+// A CustomLayerFactory class is an example layer, which makes exponentiation by 2 for the input and does not change dimensions
+class CustomLayerFactory {
+
+};
+```
+2. Inherit it from the abstract `InferenceEngine::ILayerImplFactory` class: 
+```cpp
+// custom_layer.h
+class CustomLayerFactory: public InferenceEngine::ILayerImplFactory {
+
+};
+```
+
+3. Create a constructor, a virtual destructor, and a data member to keep the layer info:
+```cpp
+// custom_layer.h
+class CustomLayerFactory: public InferenceEngine::ILayerImplFactory {
+public:
+    explicit CustomLayerFactory(const CNNLayer *layer): cnnLayer(*layer) {}
+private:
+  CNNLayer cnnLayer;
+};
+```
+
+4. Overload and implement the abstract methods `getShapes` and `getImplementations` of the `InferenceEngine::ILayerImplFactory` class:
+```cpp
+// custom_layer.h
+class CustomLayerFactory: public InferenceEngine::ILayerImplFactory {
+public:
+    // ... constructor and destructor
+
+    StatusCode getShapes(const std::vector<TensorDesc>& inShapes, std::vector<TensorDesc>& outShapes, ResponseDesc *resp) noexcept override {
+        if (cnnLayer == nullptr) {
+            std::string errorMsg = "Cannot get cnn layer!";
+            errorMsg.copy(resp->msg, sizeof(resp->msg) - 1);
+            return GENERAL_ERROR;
+        }
+        if (inShapes.size() != 1) {
+            std::string errorMsg = "Incorrect input shapes!";
+            errorMsg.copy(resp->msg, sizeof(resp->msg) - 1);
+            return GENERAL_ERROR;
+        }
+        outShapes.clear();
+        outShapes.emplace_back(inShapes[0]);
+        return OK;
+    }
+
+    StatusCode getImplementations(std::vector<ILayerImpl::Ptr>& impls, ResponseDesc *resp) noexcept override {
+        // You can add cnnLayer to implementation if it is necessary
+        impls.push_back(ILayerImpl::Ptr(new CustomLayerImpl()));
+        return OK;
+    }
+};
+```
+5. Create your custom layer implementation `CustomLayerImpl` class using the [instruction](../CPU_Kernel.md).
+
+6. Implement methods in the `Extension` class:
+```cpp
+// custom_extension.h
+class CustomExtention : public InferenceEngine::IExtension {
+public:
+    // ... utility methods
+    // Retruns the list of supported kernels/layers
+    StatusCode getPrimitiveTypes(char**& types, unsigned int& size, ResponseDesc* resp) noexcept override {
+        std::string type_name = "CustomLayer";
+        types = new char *[1];
+        size = 1;
+        types[0] = new char[type_name.size() + 1];
+        std::copy(type_name.begin(), type_name.end(), types[0]);
+        types[0][type_name.size()] = '\0';
+        return OK;
+    }
+    // Main function
+    StatusCode getFactoryFor(ILayerImplFactory *&factory, const CNNLayer *cnnLayer, ResponseDesc *resp) noexcept override {
+        if (cnnLayer->type != "CustomLayer") {
+            std::string errorMsg = std::string("Factory for ") + cnnLayer->type + " wasn't found!";
+            errorMsg.copy(resp->msg, sizeof(resp->msg) - 1);
+            return NOT_FOUND;
+        }
+        factory = new CustomLayerFactory(cnnLayer);
+        return OK;
+    }
+};
+```

docs/IE_DG/Extensibility_DG/deprecated/ShapeInfer.md

@@ -0,0 +1,18 @@
+# Old ShapeInference Extensibility API {#openvino_docs_IE_DG_Extensibility_DG_deprecated_ShapeInfer}
+
+The new approach to shape inference suggests a creation of a custom nGraph operation that contains a special method for shape inference. 
+The following classes and methods were deprecated:
+
+ * `InferenceEngine::IShapeInferExtension` class
+ * `InferenceEngine::IShapeInferExtension::getShapeInferTypes(char**&, unsigned int&, ResponseDesc*)` method
+ * `InferenceEngine::IShapeInferExtension::getShapeInferImpl(IShapeInferImpl::Ptr&, const char*, ResponseDesc*)` method
+
+However, the old approach with the `InferenceEngine::IShapeInferExtension` method still works for already existing custom layers.
+Custom Shape Inference functions are registered by calling `InferenceEngine::ICNNNetwork::AddExtension` with the implemented `InferenceEngine::IShapeInferExtension` method, which is a holder of custom implementations. 
+The holder requires to implement two key methods:
+* `InferenceEngine::IShapeInferExtension::getShapeInferImpl` - Returns custom shape inference implementation for the given type. 
+* `InferenceEngine::IShapeInferExtension::getShapeInferTypes` - Provides all custom types.
+
+Custom shape inference implementation is represented by the `InferenceEngine::IShapeInferImpl::inferShapes` method.
+
+It is impossible to overwrite built-in shape inference functions. Custom type must be different from the supported ones. 

docs/IE_DG/GPU_Kernels_Tuning.md

@@ -29,9 +29,12 @@ File with tuned data is the result of this step.
 > **NOTE** If a filename passed to `KEY_TUNING_FILE` points to existing tuned data and you are tuning a new model, then this file will be extended by new data. This allows you to extend existing `cache.json` provided in the OpenVINO™ release package. 
 
 The example below shows how to set and use the key files:
-
-@snippet snippets/GPU_Kernels_Tuning.cpp part0
-
+```cpp
+Core ie;          
+  ie.SetConfig({{ CONFIG_KEY(TUNING_MODE), CONFIG_VALUE(TUNING_CREATE) }}, "GPU");
+  ie.SetConfig({{ CONFIG_KEY(TUNING_FILE), "/path/to/tuning/file.json" }}, "GPU");
+  // Further LoadNetwork calls will use the specified tuning parameters
+```
 ---
 
 You can activate the inference with tuned data by setting `KEY_TUNING_MODE` flag to `TUNING_USE_EXISTING` and

docs/IE_DG/Glossary.md

@@ -64,15 +64,17 @@ Glossary of terms used in the Inference Engine
 | :---                        | :---                |
 | Batch | Number of images to analyze during one call of infer. Maximum batch size is a property of the network and it is set before loading of the network to the plugin. In NHWC, NCHW and NCDHW image data layout representation, the N refers to the number of images in the batch |
 | Blob | Memory container used for storing inputs, outputs of the network, weights and biases of the layers |
-| Device (Affinitity) | A preferred Intel(R) hardware device to run the inference (CPU, GPU, etc.) |
+| Device (Affinitity) | A preferred Intel(R) hardware device to run the inference (CPU, GPU, FPGA, etc.) |
 | Extensibility mechanism, Custom layers | The mechanism that provides you with capabilities to extend the Inference Engine and Model Optimizer so that they can work with topologies containing layers that are not yet supported |
 | <code>ICNNNetwork</code> | An Interface of the Convolutional Neural Network that Inference Engine reads from IR. Consists of topology, weights and biases |
 | <code>IExecutableNetwork</code> | An instance of the loaded network which allows the Inference Engine to request (several) infer requests and perform inference synchronously or asynchronously |
+| <code>IHeteroInferencePlugin</code> |  Interface that is implemented by the heterogeneity plugin to allow the Inference Engine to set the default affinities for layers by devices before loading the network to the heterogeneous plugin. You can modify affinities manually before loading to the plugin. |
+| <code>IInferencePlugin</code> | Interface provided by each plugin to allow the Inference Engine to load <code>ICNNNetwork</code> to the plugin, create Executable network and set special dedicated options for the plugin |
 | <code>IInferRequest</code> | Interface that represents the end point of inference on the model loaded to the plugin and represented by executable network. Inputs are set here, outputs should be requested from this interface as well |
 | <code>InferenceEngineProfileInfo</code> | Represents basic inference profiling information per layer |
 | Inference Engine | A C++ library with a set of classes that you can use in your application to infer input data (images) and get the result |
 | Inference Engine API | The basic default API for all supported devices, which allows you to load a model from Intermediate Representation, set input and output formats and execute the model on various devices |
-| Inference Engine <code>Core</code> | Inference Engine Core is a software component that manages inference on certain Intel(R) hardware devices: CPU, GPU, MYRIAD, GNA, etc. |
+| Inference Engine Plugin | Inference Engine plugin is a software component that contains complete implementation for inference on a certain Intel(R) hardware device: CPU, GPU, VPU, FPGA, etc. Each plugin implements the unified API and provides additional hardware-specific APIs. |
 | Layer catalog or Operations specification | A list of supported layers or operations and its parameters. Sets of supported layers are different for different plugins, please check the documentation on plugins to verify if the Inference Engine supports certain layer on the dedicated hardware |
 | <code>Layout</code> | Image data layout refers to the representation of images batch. Layout shows a sequence of 4D or 5D tensor data in memory. A typical NCHW format represents pixel in horizontal direction, rows by vertical dimension, planes by channel and images into batch |
 | <code>OutputsDataMap</code> | Structure which contains information about output precisions and layouts |

docs/IE_DG/Graph_debug_capabilities.md

@@ -0,0 +1,47 @@
+# Graph Debug Capabilities {#openvino_docs_IE_DG_Graph_debug_capabilities}
+
+Inference Engine supports two different objects for a graph representation: the nGraph function and 
+CNNNetwork. Both representations provide an API to get detailed information about the graph structure.
+
+## nGraph Function
+
+To receive additional messages about applied graph modifications, rebuild the nGraph library with 
+the `-DNGRAPH_DEBUG_ENABLE=ON` option.
+
+To enable serialization and deserialization of the nGraph function to a JSON file, rebuild the 
+nGraph library with the `-DNGRAPH_JSON_ENABLE=ON` option. To serialize or deserialize the nGraph
+function, call the nGraph function as follows:
+
+```cpp
+#include <ngraph/serializer.hpp>
+
+std::shared_ptr<ngraph::Function> nGraph;
+...
+ngraph::serialize("test_json.json", nGraph);        // For graph serialization
+std::ifstream file("test_json.json");               // Open a JSON file
+nGraph = ngraph::deserialize(file);                 // For graph deserialization
+```
+
+To visualize the nGraph function to the xDot format or to an image file, use the 
+`ngraph::pass::VisualizeTree` graph transformation pass:
+```cpp
+#include <ngraph/pass/visualize_tree.hpp>
+
+std::shared_ptr<ngraph::Function> nGraph;
+...
+std::vector<std::shared_ptr<ngraph::Function>> g2{nGraph};
+ngraph::pass::VisualizeTree("after.png").run_on_module(g2);     // Visualize the nGraph function to an image
+```
+
+## CNNNetwork
+
+To serialize the CNNNetwork to the Inference Engine Intermediate Representation (IR) format, use the 
+`CNNNetwork::serialize(...)` method:
+```cpp
+std::shared_ptr<ngraph::Function> nGraph;
+...
+CNNNetwork network(nGraph);
+network.serialize("test_ir.xml", "test_ir.bin");
+```
+> **NOTE**: CNNNetwork created from the nGraph function might differ from the original nGraph 
+> function because the Inference Engine applies some graph transformation.

docs/IE_DG/InferenceEngine_QueryAPI.md

@@ -23,7 +23,10 @@ The `InferenceEngine::ExecutableNetwork` class is also extended to support the Q
 
 ### GetAvailableDevices
 
-@snippet snippets/InferenceEngine_QueryAPI0.cpp part0
+```cpp
+InferenceEngine::Core core;
+std::vector<std::string> availableDevices = ie.GetAvailableDevices();
+```
 
 The function returns list of available devices, for example:
 ```
@@ -46,7 +49,10 @@ Each device name can then be passed to:
 
 The code below demonstrates how to understand whether `HETERO` device dumps `.dot` files with split graphs during the split stage:
 
-@snippet snippets/InferenceEngine_QueryAPI1.cpp part1
+```cpp
+InferenceEngine::Core core;
+bool dumpDotFile = core.GetConfig("HETERO", HETERO_CONFIG_KEY(DUMP_GRAPH_DOT)).as<bool>();
+```
 
 For documentation about common configuration keys, refer to `ie_plugin_config.hpp`. Device specific configuration keys can be found in corresponding plugin folders.
 
@@ -54,7 +60,10 @@ For documentation about common configuration keys, refer to `ie_plugin_config.hp
 
 * To extract device properties such as available device, device name, supported configuration keys, and others, use the `InferenceEngine::Core::GetMetric` method:
 
-@snippet snippets/InferenceEngine_QueryAPI2.cpp part2
+```cpp
+InferenceEngine::Core core;
+std::string cpuDeviceName = core.GetMetric("GPU", METRIC_KEY(FULL_DEVICE_NAME)).as<std::string>();
+```
 
 A returned value looks as follows: `Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz`.
 
@@ -65,18 +74,28 @@ A returned value looks as follows: `Intel(R) Core(TM) i7-8700 CPU @ 3.20GHz`.
 ### GetMetric()
 
 The method is used to get executable network specific metric such as `METRIC_KEY(OPTIMAL_NUMBER_OF_INFER_REQUESTS)`:
-
-@snippet snippets/InferenceEngine_QueryAPI3.cpp part3
+```cpp
+InferenceEngine::Core core;
+auto exeNetwork = core.LoadNetwork(network, "CPU");
+auto nireq = exeNetwork.GetMetric(METRIC_KEY(OPTIMAL_NUMBER_OF_INFER_REQUESTS)).as<unsigned int>();
+```
 
 Or the current temperature of `MYRIAD` device:
-
-@snippet snippets/InferenceEngine_QueryAPI4.cpp part4
+```cpp
+InferenceEngine::Core core;
+auto exeNetwork = core.LoadNetwork(network, "MYRIAD");
+float temperature = exeNetwork.GetMetric(METRIC_KEY(DEVICE_THERMAL)).as<float>();
+```
 
 ### GetConfig()
 
 The method is used to get information about configuration values the executable network has been created with:
 
-@snippet snippets/InferenceEngine_QueryAPI5.cpp part5
+```cpp
+InferenceEngine::Core core;
+auto exeNetwork = core.LoadNetwork(network, "CPU");
+auto ncores = exeNetwork.GetConfig(PluginConfigParams::KEY_CPU_THREADS_NUM).as<std::string>();
+```
 
 ### SetConfig()
 

docs/IE_DG/Int8Inference.md

@@ -86,7 +86,7 @@ This means that 8-bit inference can only be performed with the CPU plugin on the
 For 8-bit integer computations, a model must be quantized. If the model is not quantized then you can use the [Post-Training Optimization Tool](@ref pot_README) to quantize the model. The quantization process adds `FakeQuantize` layers on activations and weights for most layers. Read more about mathematical computations under the hood in the [white paper](https://intel.github.io/mkl-dnn/ex_int8_simplenet.html).
 
 8-bit inference pipeline includes two stages (also refer to the figure below):
-1. *Offline stage*, or *model quantization*. During this stage, `FakeQuantize` layers are added before most layers to have quantized tensors before layers in a way that low-precision accuracy drop for 8-bit integer inference satisfies the specified threshold. The output of this stage is a quantized model. Quantized model precision is not changed, quantized tensors are in original precision range (`fp32`). `FakeQuantize` layer has `Quantization Levels` attribute which defines quants count. Quants count defines precision which is used during inference. For `int8` range `Quantization Levels` attribute value has to be 255 or 256.
+1. *Offline stage*, or *model quantization*. During this stage, `FakeQuantize` layers are added before most layers to have quantized tensors before layers in a way that low-precision accuracy drop for 8-bit integer inference satisfies the specified threshold. The output of this stage is a quantized model. Quantized model precision is not changed, quantized tensors are in original precision range (`fp32`). `FakeQuantize` layer has `Quantization Levels` attribute whic defines quants count. Quants count defines precision which is used during inference. For `int8` range `Quantization Levels` attribute value has to be 255 or 256.
 
 2. *Run-time stage*. This stage is an internal procedure of the [CPU Plugin](supported_plugins/CPU.md). During this stage, the quantized model is loaded to the plugin. The plugin updates each `FakeQuantize` layer on activations and weights to have `FakeQuantize` output tensor values in low precision range. 
 ![int8_flow]

docs/IE_DG/Integrate_with_customer_application_new_API.md

@@ -5,6 +5,9 @@ This section provides a high-level description of the process of integrating the
 Refer to the [Hello Classification Sample](../../inference-engine/samples/hello_classification/README.md) sources
 for example of using the Inference Engine in applications.
 
+> **NOTE**: For 2019 R2 Release, the new Inference Engine Core API is introduced. This guide is updated to reflect the new API approach.
+> The Inference Engine Plugin API is still supported, but is going to be deprecated in future releases. Please, refer to [Migration from Inference Engine Plugin API to Core API](Migration_CoreAPI.md) guide to update your application.
+
 ## Use the Inference Engine API in Your Code
 
 The core `libinference_engine.so` library implements loading and parsing a model Intermediate Representation (IR), and triggers inference using a specified device. The core library has the following API:
@@ -28,22 +31,27 @@ Integration process includes the following steps:
 ![integration_process]
 
 1) **Create Inference Engine Core** to manage available devices and read network objects:
-
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part0
+```cpp
+InferenceEngine::Core core;
+```
 
 2) **Read a model IR** created by the Model Optimizer (.xml is supported format):
-
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part1
-
-**Or read the model from ONNX format** (.onnx and .prototxt are supported formats). You can find more information about the ONNX format support in the document [ONNX format support in the OpenVINO™](./ONNX_Support.md).
-
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part2
+```cpp
+auto network = core.ReadNetwork("Model.xml");
+```
+**Or read the model from ONNX format** (.onnx and .prototxt are supported formats)
+```cpp
+auto network = core.ReadNetwork("model.onnx");
+```
 
 3) **Configure input and output**. Request input and output information using `InferenceEngine::CNNNetwork::getInputsInfo()`, and `InferenceEngine::CNNNetwork::getOutputsInfo()`
 methods:
-
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part3
-
+```cpp
+/** Take information about all topology inputs **/
+InferenceEngine::InputsDataMap input_info = network.getInputsInfo();
+/** Take information about all topology outputs **/
+InferenceEngine::OutputsDataMap output_info = network.getOutputsInfo();
+```
   Optionally, set the number format (precision) and memory layout for inputs and outputs. Refer to the
   [Supported configurations](supported_plugins/Supported_Devices.md) chapter to choose the relevant configuration.
 
@@ -66,8 +74,22 @@ methods:
 > **NOTE**: Batch pre-processing is not supported if input color format is set to `ColorFormat::NV12`.
 
   You can use the following code snippet to configure input and output:
-
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part4
+```cpp
+/** Iterate over all input info**/
+for (auto &item : input_info) {
+    auto input_data = item.second;
+    input_data->setPrecision(Precision::U8);
+    input_data->setLayout(Layout::NCHW);
+    input_data->getPreProcess().setResizeAlgorithm(RESIZE_BILINEAR);
+    input_data->getPreProcess().setColorFormat(ColorFormat::RGB);
+}
+/** Iterate over all output info**/
+for (auto &item : output_info) {
+    auto output_data = item.second;
+    output_data->setPrecision(Precision::FP32);
+    output_data->setLayout(Layout::NC);
+}
+```
 
 > **NOTE**: NV12 input color format pre-processing differs from other color conversions. In case of NV12,
 >  Inference Engine expects two separate image planes (Y and UV). You must use a specific
@@ -90,33 +112,45 @@ methods:
 |Layout               | NCDHW | NCHW | CHW | NC | C  |
 
 4) **Load the model** to the device using `InferenceEngine::Core::LoadNetwork()`:
-
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part5
-
+```cpp
+auto executable_network = core.LoadNetwork(network, "CPU");
+```
     It creates an executable network from a network object. The executable network is associated with single hardware device.
     It is possible to create as many networks as needed and to use them simultaneously (up to the limitation of the hardware resources).
     Third parameter is a configuration for plugin. It is map of pairs: (parameter name, parameter value). Choose device from
      [Supported devices](supported_plugins/Supported_Devices.md) page for more details about supported configuration parameters.
-
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part6
+```cpp
+/** Optional config. E.g. this enables profiling of performance counters. **/
+std::map<std::string, std::string> config = {{ PluginConfigParams::KEY_PERF_COUNT, PluginConfigParams::YES }};
+auto executable_network = core.LoadNetwork(network, "CPU", config);
+```
 
 5) **Create an infer request**:
-
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part7
+```cpp
+auto infer_request = executable_network.CreateInferRequest();
+```
 
 6) **Prepare input**. You can use one of the following options to prepare input:
     * **Optimal way for a single network.** Get blobs allocated by an infer request using `InferenceEngine::InferRequest::GetBlob()`
     and feed an image and the input data to the blobs. In this case, input data must be aligned (resized manually) with a
     given blob size and have a correct color format.
-
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part8
-
+```cpp
+/** Iterate over all input blobs **/
+for (auto & item : inputInfo) {
+    auto input_name = item->first;
+    /** Get input blob **/
+    auto input = infer_request.GetBlob(input_name);
+    /** Fill input tensor with planes. First b channel, then g and r channels **/
+    ...
+}
+```
     * **Optimal way for a cascade of networks (output of one network is input for another).** Get output blob from the first
     request using `InferenceEngine::InferRequest::GetBlob()` and set it as input for the second request using
     `InferenceEngine::InferRequest::SetBlob()`.
-
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part9
-
+```cpp
+auto output = infer_request1->GetBlob(output_name);
+infer_request2->SetBlob(input_name, output);
+```
     * **Optimal way to handle ROI (a ROI object located inside of input of one network is input for another).** It is
     possible to re-use shared input by several networks. You do not need to allocate separate input blob for a network if
     it processes a ROI object located inside of already allocated input of a previous network. For instance, when first
@@ -125,17 +159,38 @@ methods:
     In this case, it is allowed to re-use pre-allocated input blob (used by first network) by second network and just crop
     ROI without allocation of new memory using `InferenceEngine::make_shared_blob()` with passing of
     `InferenceEngine::Blob::Ptr` and `InferenceEngine::ROI` as parameters.
+```cpp
+/** inputBlob points to input of a previous network and
+    cropROI contains coordinates of output bounding box **/
+InferenceEngine::Blob::Ptr inputBlob;
+InferenceEngine::ROI cropRoi;
+...
 
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part10
-
+/** roiBlob uses shared memory of inputBlob and describes cropROI
+    according to its coordinates **/
+auto roiBlob = InferenceEngine::make_shared_blob(inputBlob, cropRoi);
+infer_request2->SetBlob(input_name, roiBlob);
+```
       Make sure that shared input is kept valid during execution of each network. Otherwise, ROI blob may be corrupted if the
       original input blob (that ROI is cropped from) has already been rewritten.
 
     * Allocate input blobs of the appropriate types and sizes, feed an image and the input data to the blobs, and call
     `InferenceEngine::InferRequest::SetBlob()` to set these blobs for an infer request:
+```cpp
+/** Iterate over all input blobs **/
+for (auto & item : inputInfo) {
+    auto input_data = item->second;
+    /** Create input blob **/
+    InferenceEngine::TBlob<unsigned char>::Ptr input;
+    // assuming input precision was asked to be U8 in prev step
+    input = InferenceEngine::make_shared_blob<unsigned char, InferenceEngine::SizeVector>(InferenceEngine::Precision:U8, input_data->getDims());
+    input->allocate();
+    infer_request->SetBlob(item.first, input);
 
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part11
-
+    /** Fill input tensor with planes. First b channel, then g and r channels **/
+    ...
+}
+```
       A blob can be filled before and after `SetBlob()`.
 
 > **NOTE:**
@@ -156,13 +211,15 @@ methods:
 
 7) **Do inference** by calling the `InferenceEngine::InferRequest::StartAsync` and `InferenceEngine::InferRequest::Wait`
 methods for asynchronous request:
-
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part12
+```cpp
+infer_request->StartAsync();
+infer_request.Wait(IInferRequest::WaitMode::RESULT_READY);
+```
 
 or by calling the `InferenceEngine::InferRequest::Infer` method for synchronous request:
-
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part13
-
+```cpp
+sync_infer_request->Infer();
+```
 `StartAsync` returns immediately and starts inference without blocking main thread, `Infer` blocks
  main thread and returns when inference is completed.
 Call `Wait` for waiting result to become available for asynchronous request.
@@ -184,8 +241,17 @@ exception.
 8) Go over the output blobs and **process the results**.
 Note that casting `Blob` to `TBlob` via `std::dynamic_pointer_cast` is not recommended way,
 better to access data via `buffer()` and `as()` methods as follows:
+```cpp
+    for (auto &item : output_info) {
+        auto output_name = item.first;
+        auto output = infer_request.GetBlob(output_name);
+        {
+            auto const memLocker = output->cbuffer(); // use const memory locker
+            // output_buffer is valid as long as the lifetime of memLocker
+            const float *output_buffer = memLocker.as<const float *>();
+            /** output_buffer[] - accessing output blob data **/
 
-@snippet snippets/Integrate_with_customer_application_new_API.cpp part14
+```
 
 ## Build Your Application
 
@@ -206,7 +272,7 @@ build/                  - build directory
 ```
 
 2. **Include Inference Engine, nGraph and OpenCV libraries** in `project/CMakeLists.txt`  
-[OpenCV](https://docs.opencv.org/master/db/df5/tutorial_linux_gcc_cmake.html) integration is needed mostly for pre-processing input data and ngraph for more complex applications using [ngraph API](../nGraph_DG/nGraph_dg.md).
+[OpenCV](https://docs.opencv.org/master/db/df5/tutorial_linux_gcc_cmake.html) integration is needed mostly for pre-processing input data and ngraph for more complex applications using [ngraph API](nGraph_Flow.md).
 ``` cmake
 cmake_minimum_required(VERSION 3.0.0)
 project(project_name)

docs/IE_DG/Intro_to_Performance.md

@@ -27,7 +27,7 @@ latency penalty. So, for more real-time oriented usages, lower batch sizes (as l
 Refer to the [Benchmark App](../../inference-engine/samples/benchmark_app/README.md) sample, which allows latency vs. throughput measuring.
 
 ## Using Async API
-To gain better performance on accelerators, such as VPU, the Inference Engine uses the asynchronous approach (see
+To gain better performance on accelerators, such as VPU or FPGA, the Inference Engine uses the asynchronous approach (see
 [Integrating Inference Engine in Your Application (current API)](Integrate_with_customer_application_new_API.md)).
 The point is amortizing the costs of data transfers, by pipe-lining, see [Async API explained](@ref omz_demos_object_detection_demo_ssd_async_README).
 Since the pipe-lining relies on the availability of the parallel slack, running multiple inference requests in parallel is essential.

docs/IE_DG/Introduction.md

@@ -94,13 +94,13 @@ Refer to a dedicated description about [Intermediate Representation and Operatio
 OpenVINO toolkit is powered by nGraph capabilities for Graph construction API, Graph transformation engine and Reshape.
 nGraph Function is used as an intermediate representation for a model in the run-time underneath the CNNNetwork API.
 The conventional representation for CNNNetwork is still available if requested for backward compatibility when some conventional API methods are used.
-Please refer to the [Overview of nGraph](../nGraph_DG/nGraph_dg.md) describing the details of nGraph representation.
+Please refer to the [Overview of nGraph Flow](nGraph_Flow.md) describing the details of nGraph integration into the Inference Engine and co-existence with the conventional representation.
 
 ## Inference Engine <a name = "IE"></a>
 
 Inference Engine is a runtime that delivers a unified API to integrate the inference with application logic:
 
-* Takes a model as an input. The model can be presented in [the native ONNX format](./ONNX_Support.md) or in the specific form of [Intermediate Representation (IR)](../MO_DG/IR_and_opsets.md)
+* Takes as input the model. The model presented in the specific form of [Intermediate Representation (IR)](../MO_DG/IR_and_opsets.md)
 produced by Model Optimizer.
 * Optimizes inference execution for target hardware.
 * Delivers inference solution with reduced footprint on embedded inference platforms.
@@ -116,7 +116,7 @@ For Intel® Distribution of OpenVINO™ toolkit, the Inference Engine package co
 [sample console applications](Samples_Overview.md) demonstrating how you can use
 the Inference Engine in your applications.
 
-The open source version is available in the [OpenVINO™ toolkit GitHub repository](https://github.com/openvinotoolkit/openvino) and can be built for supported platforms using the <a href="https://github.com/openvinotoolkit/openvino/wiki/BuildingCode">Inference Engine Build Instructions</a>.
+The open source version is available in the [OpenVINO™ toolkit GitHub repository](https://github.com/openvinotoolkit/openvino) and can be built for supported platforms using the <a href="https://github.com/openvinotoolkit/openvino/blob/master/build-instruction.md">Inference Engine Build Instructions</a>.
 ## See Also
 - [Inference Engine Samples](Samples_Overview.md)
 - [Intel&reg; Deep Learning Deployment Toolkit Web Page](https://software.intel.com/en-us/computer-vision-sdk)

docs/IE_DG/Migration_CoreAPI.md

@@ -1,4 +1,4 @@
-[DEPRECATED] Migration from Inference Engine Plugin API to Core API {#openvino_docs_IE_DG_Migration_CoreAPI}
+Migration from Inference Engine Plugin API to Core API {#openvino_docs_IE_DG_Migration_CoreAPI}
 ===============================
 
 For 2019 R2 Release, the new Inference Engine Core API is introduced. This guide is updated to reflect the new API approach. The Inference Engine Plugin API is still supported, but is going to be deprecated in future releases.
@@ -26,45 +26,52 @@ The main responsibility of the `InferenceEngine::Core` class is to hide plugin s
 Common migration process includes the following steps:
 
 1. Migrate from the `InferenceEngine::InferencePlugin` initialization:
-
-@snippet snippets/Migration_CoreAPI.cpp part0
-
+```cpp
+InferenceEngine::InferencePlugin plugin = InferenceEngine::PluginDispatcher({ FLAGS_pp }).getPluginByDevice(FLAGS_d);
+```
 to the `InferenceEngine::Core` class initialization:
-
-@snippet snippets/Migration_CoreAPI.cpp part1
+```cpp
+InferenceEngine::Core core;
+```
 
 2. Instead of using `InferenceEngine::CNNNetReader` to read IR:
-
-@snippet snippets/Migration_CoreAPI.cpp part2
-
+```cpp
+CNNNetReader network_reader;
+network_reader.ReadNetwork(fileNameToString(input_model));
+network_reader.ReadWeights(fileNameToString(input_model).substr(0, input_model.size() - 4) + ".bin");
+CNNNetwork network = network_reader.getNetwork();
+```
 read networks using the Core class:
-
-@snippet snippets/Migration_CoreAPI.cpp part3
-
-The Core class also allows reading models from the ONNX format (more information is [here](./ONNX_Support.md)):
-
-@snippet snippets/Migration_CoreAPI.cpp part4
+```cpp
+CNNNetwork network = core.ReadNetwork(input_model);
+```
+The Core class also allows reading models from ONNX format:
+```cpp
+CNNNetwork network = core.ReadNetwork("model.onnx");
+```
 
 3. Instead of adding CPU device extensions to the plugin:
-
-@snippet snippets/Migration_CoreAPI.cpp part5
-
+```cpp
+plugin.AddExtension(std::make_shared<Extensions::Cpu::CpuExtensions>());
+```
 add extensions to CPU device using the Core class:
-
-@snippet snippets/Migration_CoreAPI.cpp part6
+```cpp
+core.AddExtension(std::make_shared<Extensions::Cpu::CpuExtensions>(), "CPU");
+```
 
 4. Instead of setting configuration keys to a particular plugin, set (key, value) pairs via `InferenceEngine::Core::SetConfig`
-
-@snippet snippets/Migration_CoreAPI.cpp part7
-
+```cpp
+core.SetConfig({{PluginConfigParams::KEY_CONFIG_FILE, FLAGS_c}}, "GPU");
+```
 > **NOTE**: If `deviceName` is omitted as the last argument, configuration is set for all Inference Engine devices.
 
 5. Migrate from loading the network to a particular plugin:
-
-@snippet snippets/Migration_CoreAPI.cpp part8
-
+```cpp
+auto execNetwork = plugin.LoadNetwork(network, { });
+```
 to `InferenceEngine::Core::LoadNetwork` to a particular device:
-
-@snippet snippets/Migration_CoreAPI.cpp part9
+```cpp
+auto execNetwork = core.LoadNetwork(network, deviceName, { });
+```
 
 After you have an instance of `InferenceEngine::ExecutableNetwork`, all other steps are as usual.

docs/IE_DG/ONNX_Support.md

@@ -1,50 +0,0 @@
-# ONNX format support in the OpenVINO™ {#openvino_docs_IE_DG_ONNX_Support}
-
-Starting from the 2020.4 release, OpenVINO™ supports reading native ONNX models.
-`Core::ReadNetwork()` method provides a uniform way to read models from IR or ONNX format, it is a recommended approach to reading models.
-Example:
-
-```cpp
-InferenceEngine::Core core;
-auto network = core.ReadNetwork("model.onnx");
-```
-
-**Reshape feature:**
-
-OpenVINO™ doesn't provide a mechanism to specify pre-processing (like mean values subtraction, reverse input channels) for the ONNX format.
-If an ONNX model contains dynamic shapes for input, please use the `CNNNetwork::reshape` method for shape specialization.
-
-**Weights saved in external files:**
-
-OpenVINO™ supports ONNX models that store weights in external files. It is especially useful for models larger than 2GB because of protobuf limitations.
-To read such models, use the `ReadNetwork` overload which takes `modelPath` as input parameter (both `std::string` and `std::wstring`).
-Note that the `binPath` argument of `ReadNetwork` should be empty in this case, because paths to external weights are saved directly in an ONNX model.
-Otherwise, a runtime exception is thrown.
-Reading models with external weights is not supported by the `ReadNetwork(const std::string& model, const Blob::CPtr& weights)` overload.
-
-Paths to external weight files are saved in an ONNX model; these paths are relative to the model's directory path.
-It means that if a model is located at:
-`home/user/workspace/models/model.onnx`
-and a file that contains external weights:
-`home/user/workspace/models/data/weights.bin`
-the path saved in model should be:
-`data/weights.bin`.
-
-**NOTE**
-
-* A single model can use many external weights files.
-* Data of many tensors can be stored in a single external weights file (it is processed using offset and length values, which can be also saved in a model).
-
-The described mechanism is the only possibility to read weights from external files. The following input parameters of the `ReadNetwork` function overloads are NOT supported for ONNX models and should be passed as empty:
-* `const std::wstring& binPath`
-* `const std::string& binPath`
-* `const Blob::CPtr& weights`
-
-You can find more details about external data mechanism in [ONNX documentation](https://github.com/onnx/onnx/blob/master/docs/ExternalData.md).
-To convert a model to use external data feature, you can use [ONNX helpers functions](https://github.com/onnx/onnx/blob/master/onnx/external_data_helper.py).
-
-**Unsupported types of tensors:**
-
-* `string`,
-* `complex64`,
-* `complex128`.

docs/IE_DG/OnnxImporterTutorial.md

@@ -2,7 +2,7 @@
 
 > **NOTE**: This tutorial is deprecated. Since OpenVINO™ 2020.4 version, Inference Engine enables reading ONNX models via the Inference Engine Core API
 > and there is no need to use directly the low-level ONNX* Importer API anymore. 
-> To read ONNX\* models, it's recommended to use the `Core::ReadNetwork()` method that provide a uniform way to read models from IR or ONNX format.
+> To read ONNX\* models, it's recommended to use the InferenceEngine::Core::ReadNetwork method that provide a uniform way to read models from IR or ONNX format.
 
 This tutorial demonstrates how to use the ONNX\* Importer API.
 This API makes it possible to create an nGraph `Function` object from an imported ONNX model.
@@ -17,9 +17,16 @@ Two categories of API functions:
 
 To list all supported ONNX ops in a specific version and domain, use the `get_supported_operators` 
 as shown in the example below:
+```cpp
+const std::int64_t version = 12;
+const std::string domain = "ai.onnx";
+const std::set<std::string> supported_ops = ngraph::onnx_import::get_supported_operators(version, domain);
 
-@snippet snippets/OnnxImporterTutorial0.cpp part0
-
+for(const auto& op : supported_ops)
+{
+    std::cout << op << std::endl;
+}
+```
 The above code produces a list of all the supported operators for the `version` and `domain` you specified and outputs a list similar to this:
 ```cpp
 Abs
@@ -29,8 +36,14 @@ Xor
 ```
 
 To determine whether a specific ONNX operator in a particular version and domain is supported by the importer, use the `is_operator_supported` function as shown in the example below:
+```cpp
+const std::string op_name = "Abs";
+const std::int64_t version = 12;
+const std::string domain = "ai.onnx";
+const bool is_abs_op_supported = ngraph::onnx_import::is_operator_supported(op_name, version, domain);
 
-@snippet snippets/OnnxImporterTutorial1.cpp part1
+std::cout << "Abs in version 12, domain `ai.onnx`is supported: " << (is_abs_op_supported ? "true" : "false") << std::endl;
+```
 
 ## Import ONNX Model
 
@@ -48,20 +61,40 @@ Refer to the sections below for details.
 > ```
 
 Once you create the `ng_function`, you can use it to run computation on the Inference Engine.
-As it was shown in [Build a Model with nGraph Library](../nGraph_DG/build_function.md), `std::shared_ptr<ngraph::Function>` can be transformed into a `CNNNetwork`.
+As it was shown in [Build a Model with nGraph Library](nGraphTutorial.md), `std::shared_ptr<ngraph::Function>` can be transformed into a `CNNNetwork`.
 
 
 ### <a name="stream">Stream as Input</a>
 
 The code below shows how to convert the ONNX ResNet50 model to the nGraph function using `import_onnx_model` with the stream as an input:
 
-@snippet snippets/OnnxImporterTutorial2.cpp part2
+```cpp
+ const std::string resnet50_path = "resnet50/model.onnx";
+ std::ifstream resnet50_stream(resnet50_path);
+ if(resnet50_stream.is_open())
+ {
+     try
+     {
+         const std::shared_ptr<ngraph::Function> ng_function = ngraph::onnx_import::import_onnx_model(resnet50_stream);
+
+         // Check shape of the first output, for example
+         std::cout << ng_function->get_output_shape(0) << std::endl;
+         // The output is Shape{1, 1000}
+     }
+     catch (const ngraph::ngraph_error& error)
+     {
+         std::cout << "Error when importing ONNX model: " << error.what() << std::endl;
+     }
+ }
+ resnet50_stream.close();
+```
 
 ### <a name="path">Filepath as Input</a>
 
 The code below shows how to convert the ONNX ResNet50 model to the nGraph function using `import_onnx_model` with the filepath as an input:
-
-@snippet snippets/OnnxImporterTutorial3.cpp part3
+```cpp
+const std::shared_ptr<ngraph::Function> ng_function = ngraph::onnx_import::import_onnx_model(resnet50_path);
+```
 
 [onnx_header]: https://github.com/NervanaSystems/ngraph/blob/master/src/ngraph/frontend/onnx_import/onnx.hpp
-[onnx_model_zoo]: https://github.com/onnx/models
+[onnx_model_zoo]: https://github.com/onnx/models

docs/IE_DG/PythonPackage_Overview.md

@@ -12,4 +12,4 @@ The OpenVINO™ Python\* package includes the following sub-packages:
  - `openvino.tools.benchmark` - Measure latency and throughput.
 
 ## See Also
-* [Introduction to Inference Engine](inference_engine_intro.md)
+* [Introduction to Intel's Deep Learning Inference Engine](Introduction.md)

docs/IE_DG/Samples_Overview.md

@@ -25,7 +25,7 @@ Inference Engine sample applications include the following:
 - **Image Classification Sample Async** – Inference of image classification networks like AlexNet and GoogLeNet using Asynchronous Inference Request API (the sample supports only images as inputs). 
    - [Image Classification C++ Sample Async](../../inference-engine/samples/classification_sample_async/README.md)
    - [Image Classification Python* Sample Async](../../inference-engine/ie_bridges/python/sample/classification_sample_async/README.md)
-- **[Image Classification Python* Sample](../../inference-engine/ie_bridges/python/sample/hello_classification/README.md)** – Inference of image classification networks like AlexNet and GoogLeNet using Synchronous Inference Request API (the sample supports only images as inputs).
+- **[Image Classification Python* Sample](../../inference-engine/ie_bridges/python/sample/classification_sample/README.md)** – Inference of image classification networks like AlexNet and GoogLeNet using Synchronous Inference Request API (the sample supports only images as inputs).
 - **Neural Style Transfer Sample** – Style Transfer sample (the sample supports only images as inputs).
    - [Neural Style Transfer C++ Sample](../../inference-engine/samples/style_transfer_sample/README.md)
    - [Neural Style Transfer Python* Sample](../../inference-engine/ie_bridges/python/sample/style_transfer_sample/README.md)
@@ -49,11 +49,9 @@ You can download the [pre-trained models](@ref omz_models_intel_index) using the
 
 The officially supported Linux* build environment is the following:
 
-* Ubuntu* 18.04 LTS 64-bit or CentOS* 7.6 64-bit
-* GCC* 7.5.0 (for Ubuntu* 18.04) or GCC* 4.8.5 (for CentOS* 7.6)
-* CMake* version 3.10 or higher
-
-> **NOTE**: For building samples from the open-source version of OpenVINO™ toolkit, see the [build instructions on GitHub](https://github.com/openvinotoolkit/openvino/wiki/BuildingCode).
+* Ubuntu* 16.04 LTS 64-bit or CentOS* 7.4 64-bit
+* GCC* 5.4.0 (for Ubuntu* 16.04) or GCC* 4.8.5 (for CentOS* 7.4)
+* CMake* version 2.8.12 or higher
 
 To build the C or C++ sample applications for Linux, go to the `<INSTALL_DIR>/inference_engine/samples/c` or `<INSTALL_DIR>/inference_engine/samples/cpp` directory, respectively, and run the `build_samples.sh` script:
 ```sh
@@ -101,7 +99,7 @@ for the debug configuration — in `<path_to_build_directory>/intel64/Debug/`.
 The recommended Windows* build environment is the following:
 * Microsoft Windows* 10
 * Microsoft Visual Studio* 2017, or 2019
-* CMake* version 3.10 or higher
+* CMake* version 2.8.12 or higher
 
 > **NOTE**: If you want to use Microsoft Visual Studio 2019, you are required to install CMake 3.14.
 
@@ -183,4 +181,4 @@ sample, read the sample documentation by clicking the sample name in the samples
 list above.
 
 ## See Also
-* [Introduction to Inference Engine](inference_engine_intro.md)
+* [Introduction to Intel's Deep Learning Inference Engine](Introduction.md)

docs/IE_DG/ShapeInference.md

@@ -1,75 +1,48 @@
 Using Shape Inference {#openvino_docs_IE_DG_ShapeInference}
 ==========================================
 
-OpenVINO™ provides the following methods for runtime model reshaping:
+Inference Engine takes two kinds of model description as an input: [Intermediate Representation (IR)](../MO_DG/IR_and_opsets.md) and [nGraph::Function](nGraph_Flow.md) objects. 
+Both should have fixed input shapes to be successfully loaded to the Inference Engine.
+To feed input data of a shape that is different from the model input shape, resize the model first.
 
-* **Set a new input shape** with the `InferenceEngine::CNNNetwork::reshape` method.<br>
-   The `InferenceEngine::CNNNetwork::reshape` method updates input shapes and propagates them down to the outputs of the model through all intermediate layers. 
-   
-> **NOTES**:
-> - Starting with the 2021.1 release, the Model Optimizer converts topologies keeping shape-calculating sub-graphs by default, which enables correct shape propagation during reshaping in most cases.
-> - Older versions of IRs are not guaranteed to reshape successfully. Please regenerate them with the Model Optimizer of the latest version of OpenVINO™.<br>
-> - If an ONNX model does not have a fully defined input shape and the model was imported with the ONNX importer, reshape the model before loading it to the plugin.
+Model resizing on the stage of <a href="_docs_MO_DG_prepare_model_convert_model_Converting_Model_General.html#when_to_specify_input_shapes">IR generation</a> or [nGraph::Function creation](nGraphTutorial.md) is the recommended approach. 
+OpenVINO™ provides the following experimental methods for runtime model reshaping:
 
-* **Set a new batch dimension value** with the `InferenceEngine::CNNNetwork::setBatchSize` method.<br>     
-   The meaning of a model batch may vary depending on the model design.
-   This method does not deduce batch placement for inputs from the model architecture.
-   It assumes that the batch is placed at the zero index in the shape for all inputs and uses the `InferenceEngine::CNNNetwork::reshape` method to propagate updated shapes through the model.
-
-   The method transforms the model before a new shape propagation to relax a hard-coded batch dimension in the model, if any.
-
-   Use `InferenceEngine::CNNNetwork::reshape` instead of `InferenceEngine::CNNNetwork::setBatchSize` to set new input shapes for the model in case the model has:
-   * Multiple inputs with different zero-index dimension meanings
-   * Input without a batch dimension
-   * 0D, 1D, or 3D shape
-
-   The `InferenceEngine::CNNNetwork::setBatchSize` method is a high-level API method that wraps the `InferenceEngine::CNNNetwork::reshape` method call and works for trivial models from the batch placement standpoint.
-   Use `InferenceEngine::CNNNetwork::reshape` for other models.
-
-   Using the `InferenceEngine::CNNNetwork::setBatchSize` method for models with a non-zero index batch placement or for models with inputs that do not have a batch dimension may lead to undefined behaviour.
+1.  Setting a new input shape with the `InferenceEngine::CNNNetwork::reshape` method
+ 
+	`InferenceEngine::CNNNetwork::reshape` method updates input shapes and propagates them down to the outputs of the model through all intermediate layers.
     
-You can change input shapes multiple times using the `InferenceEngine::CNNNetwork::reshape` and `InferenceEngine::CNNNetwork::setBatchSize` methods in any order.
-If a model has a hard-coded batch dimension, use `InferenceEngine::CNNNetwork::setBatchSize` first to change the batch, then call `InferenceEngine::CNNNetwork::reshape` to update other dimensions, if needed.
+    Shape propagation for `InferenceEngine::CNNNetwork` objects created from `nGraph::Function` or IR of the version 10 works through the `nGraph` shape inference mechanism. 
+    `InferenceEngine::CNNNetwork` objects created from lower IR versions are considered deprecated and may be reshaped incorrectly or give unexpected results.
+ 
+	To keep the v10 IR resizable by the `InferenceEngine::CNNNetwork::reshape` method, convert the model with the additional Model Optimizer key `--keep_shape_ops`.
+ 
+2.  Setting a new batch dimension value with the `InferenceEngine::CNNNetwork::setBatchSize` method
+    
+    The meaning of a model batch may vary depending on choices you made during the model designing. 
+    The `InferenceEngine::CNNNetwork::setBatchSize` method deduces index of batch dimension relying only on the input rank. 
+    This method does not work for models with a non-zero index batch placement or models with inputs without a batch dimension. 
 
-Inference Engine takes three kinds of a model description as an input, which are converted into an `InferenceEngine::CNNNetwork` object:
-1. [Intermediate Representation (IR)](../MO_DG/IR_and_opsets.md) through `InferenceEngine::Core::ReadNetwork`
-2. [ONNX model](../IE_DG/OnnxImporterTutorial.md) through `InferenceEngine::Core::ReadNetwork`
-3. [nGraph::Function](../nGraph_DG/nGraph_dg.md) through the constructor of `InferenceEngine::CNNNetwork`
+    Batch-setting algorithm does not involve shape inference mechanism.
+    Batch of input and output shapes for all layers is set to a new batch value without layer validation.
+    It may cause both positive and negative side effects.
+ 
+    Due to the limitations described above, the current method is recommended for simple image processing models only.
 
-`InferenceEngine::CNNNetwork` keeps an `ngraph::Function` object with the model description internally.
-The object should have fully defined input shapes to be successfully loaded to the Inference Engine plugins.
-To resolve undefined input dimensions of a model, call the `CNNNetwork::reshape` method providing new input shapes before loading to the Inference Engine plugin.
 
-Run the following code right after `InferenceEngine::CNNNetwork` creation to explicitly check for model input names and shapes:
-```cpp
-CNNNetwork network = ... // read IR / ONNX model or create from nGraph::Function explicitly
-const auto parameters = network.getFunction()->get_parameters();
-for (const auto & parameter : parameters) {
-    std::cout << "name: " << parameter->get_friendly_name() << " shape: " << parameter->get_partial_shape() << std::endl;
-    if (parameter->get_partial_shape().is_dynamic())
-        std::cout << "ATTENTION: Input shape is not fully defined. Use the CNNNetwork::reshape method to resolve it." << std::endl;
-}
-```
+Practically, some models are not ready to be resized. In this case, a new input shape cannot be set with the Model Optimizer or the `InferenceEngine::CNNNetwork::reshape` method.
 
-To feed input data of a shape that is different from the model input shape, reshape the model first.
-
-Once the input shape of `InferenceEngine::CNNNetwork` is set, call the `InferenceEngine::Core::LoadNetwork` method to get an `InferenceEngine::ExecutableNetwork` object for inference with updated shapes.
-
-There are other approaches to reshape the model during the stage of <a href="_docs_MO_DG_prepare_model_convert_model_Converting_Model_General.html#when_to_specify_input_shapes">IR generation</a> or [nGraph::Function creation](../nGraph_DG/build_function.md).
-
-Practically, some models are not ready to be reshaped. In this case, a new input shape cannot be set with the Model Optimizer or the `InferenceEngine::CNNNetwork::reshape` method.
-
-## Troubleshooting Reshape Errors
+## Troubleshooting Resize Errors
 
 Operation semantics may impose restrictions on input shapes of the operation. 
 Shape collision during shape propagation may be a sign that a new shape does not satisfy the restrictions. 
 Changing the model input shape may result in intermediate operations shape collision.
 
 Examples of such operations:
-- [`Reshape` operation](../ops/shape/Reshape_1.md) with a hard-coded output shape value
-- [`MatMul` operation](../ops/matrix/MatMul_1.md) with the `Const` second input cannot be resized by spatial dimensions due to operation semantics
+- <a href="_docs_MO_DG_prepare_model_convert_model_IR_V10_opset1.html#Reshape">`Reshape` operation</a> with a hard-coded output shape value
+- <a href="_docs_MO_DG_prepare_model_convert_model_IR_V10_opset1.html#MatMul">`MatMul` operation</a> with the `Const` second input cannot be resized by spatial dimensions due to operation semantics
 
-Model structure and logic should not change significantly after model reshaping.
+Model structure and logic should not change significantly after resizing.
 - The Global Pooling operation is commonly used to reduce output feature map of classification models output.
 Having the input of the shape [N, C, H, W], Global Pooling returns the output of the shape [N, C, 1, 1].
 Model architects usually express Global Pooling with the help of the `Pooling` operation with the fixed kernel size [H, W].
@@ -77,12 +50,12 @@ During spatial reshape, having the input of the shape [N, C, H1, W1], Pooling wi
 It breaks the classification model structure.
 For example, [publicly available Inception family models from TensorFlow*](https://github.com/tensorflow/models/tree/master/research/slim#pre-trained-models) have this issue.
 
-- Changing the model input shape may significantly affect its accuracy.
+- Resizing the model input shape may significantly affect its accuracy.
 For example, Object Detection models from TensorFlow have resizing restrictions by design. 
 To keep the model valid after the reshape, choose a new input shape that satisfies conditions listed in the `pipeline.config` file. 
 For details, refer to the <a href="_docs_MO_DG_prepare_model_convert_model_tf_specific_Convert_Object_Detection_API_Models.html#tf_od_custom_input_shape">Tensorflow Object Detection API models resizing techniques</a>.
 
-## Usage of Reshape Method <a name="usage_of_reshape_method"></a>
+## Usage of Reshape Method
 
 The primary method of the feature is `InferenceEngine::CNNNetwork::reshape`.
 It gets new input shapes and propagates it from input to output for all intermediates layers of the given network.
@@ -97,12 +70,43 @@ The algorithm for resizing network is the following:
 3) **Call reshape**
 
 Here is a code example:
+```cpp
+    InferenceEngine::Core core;
+    // ------------- 0. Read IR and image ----------------------------------------------
+    CNNNetwork network = core.ReadNetwork("path/to/IR/xml");
+    cv::Mat image = cv::imread("path/to/image");
+    // ---------------------------------------------------------------------------------
 
-@snippet snippets/ShapeInference.cpp part0
+    // ------------- 1. Collect the map of input names and shapes from IR---------------
+    auto input_shapes = network.getInputShapes();
+    // ---------------------------------------------------------------------------------
 
+    // ------------- 2. Set new input shapes -------------------------------------------
+    std::string input_name;
+    SizeVector input_shape;
+    std::tie(input_name, input_shape) = *input_shapes.begin(); // let's consider first input only
+    input_shape[0] = batch_size; // set batch size to the first input dimension
+    input_shape[2] = image.rows; // changes input height to the image one
+    input_shape[3] = image.cols; // changes input width to the image one
+    input_shapes[input_name] = input_shape;
+    // ---------------------------------------------------------------------------------
+
+    // ------------- 3. Call reshape ---------------------------------------------------
+    network.reshape(input_shapes);
+    // ---------------------------------------------------------------------------------
+
+    ...
+
+    // ------------- 4. Loading model to the device ------------------------------------
+    std::string device = "CPU";
+    ExecutableNetwork executable_network = core.LoadNetwork(network, device);
+    // ---------------------------------------------------------------------------------
+
+
+```
 Shape Inference feature is used in [Smart classroom sample](@ref omz_demos_smart_classroom_demo_README).
 
 ## Extensibility
 
 Inference Engine provides a special mechanism that allows to add the support of shape inference for custom operations. 
-This mechanism is described in the [Extensibility documentation](Extensibility_DG/Intro.md)
+This mechanism is described in the [Extensibility documentation](Extensibility_DG/Intro.md).

docs/IE_DG/Tools_Overview.md

@@ -14,4 +14,4 @@ The OpenVINO™ toolkit installation includes the following tools:
 
 
 ## See Also
-* [Introduction to Inference Engine](inference_engine_intro.md)
+* [Introduction to Deep Learning Inference Engine](Introduction.md)

docs/IE_DG/inference_engine_intro.md

@@ -3,30 +3,30 @@ Introduction to Inference Engine {#openvino_docs_IE_DG_inference_engine_intro}
 
 After you have used the Model Optimizer to create an Intermediate Representation (IR), use the Inference Engine to infer the result for a given input data.
 
-Inference Engine is a set of C++ libraries providing a common API to deliver inference solutions on the platform of your choice: CPU, GPU, or VPU. Use the Inference Engine API to read the Intermediate Representation, set the input and output formats, and execute the model on devices. While the C++ libraries is the primary implementation, C libraries and Python bindings are also available.
+Inference Engine is a set of C++ libraries providing a common API to deliver inference solutions on the platform of your choice: CPU, GPU, VPU, or FPGA. Use the Inference Engine API to read the Intermediate Representation, set the input and output formats, and execute the model on devices. While the C++ libraries is the primary implementation, C libraries and Python bindings are also available.
 
 For Intel® Distribution of OpenVINO™ toolkit, Inference Engine binaries are delivered within release packages. 
 
-The open source version is available in the [OpenVINO™ toolkit GitHub repository](https://github.com/openvinotoolkit/openvino) and can be built for supported platforms using the <a href="https://github.com/openvinotoolkit/openvino/wiki/BuildingCode">Inference Engine Build Instructions</a>.    
+The open source version is available in the [OpenVINO™ toolkit GitHub repository](https://github.com/openvinotoolkit/openvino) and can be built for supported platforms using the <a href="https://github.com/openvinotoolkit/openvino/blob/master/build-instruction.md">Inference Engine Build Instructions</a>.    
 
 To learn about how to use the Inference Engine API for your application, see the [Integrating Inference Engine in Your Application](Integrate_with_customer_application_new_API.md) documentation.
 
-For complete API Reference, see the [Inference Engine API References](./api_references.html) section.
+For complete API Reference, see the [API Reference](usergroup29.html) section.
 
-Inference Engine uses a plugin architecture. Inference Engine plugin is a software component that contains complete implementation for inference on a certain Intel&reg; hardware device: CPU, GPU, VPU, etc. Each plugin implements the unified API and provides additional hardware-specific APIs.
+Inference Engine uses a plugin architecture. Inference Engine plugin is a software component that contains complete implementation for inference on a certain Intel&reg; hardware device: CPU, GPU, VPU, FPGA, etc. Each plugin implements the unified API and provides additional hardware-specific APIs.
 
 Modules in the Inference Engine component
------------------------------------------
+---------------------------------------
 
 ### Core Inference Engine Libraries ###
 
 Your application must link to the core Inference Engine libraries:
 * Linux* OS:
-    - `libinference_engine.so`, which depends on `libinference_engine_transformations.so`, `libtbb.so`, `libtbbmalloc.so` and `libngraph.so`
+    - `libinference_engine.so`, which depends on `libinference_engine_transformations.so` and `libngraph.so`
+    - `libinference_engine_legacy.so`, which depends on `libtbb.so`
 * Windows* OS:
-    - `inference_engine.dll`, which depends on `inference_engine_transformations.dll`, `tbb.dll`, `tbbmalloc.dll` and `ngraph.dll`
-* macOS*:
-    - `libinference_engine.dylib`, which depends on `libinference_engine_transformations.dylib`, `libtbb.dylib`, `libtbbmalloc.dylib` and `libngraph.dylib`
+    - `inference_engine.dll`, which depends on `inference_engine_transformations.dll` and `ngraph.dll`
+    - `inference_engine_legacy.dll`, which depends on `tbb.dll`
 
 The required C++ header files are located in the `include` directory.
 
@@ -49,26 +49,28 @@ Starting from 2020.4 release, Inference Engine introduced a concept of `CNNNetwo
 
 For each supported target device, Inference Engine provides a plugin — a DLL/shared library that contains complete implementation for inference on this particular device. The following plugins are available:
 
-| Plugin  | Device Type                   |
-| ------- | ----------------------------- |
-|CPU      |	Intel® Xeon® with Intel® AVX2 and AVX512, Intel® Core™ Processors with Intel® AVX2, Intel® Atom® Processors with Intel® SSE |
-|GPU      | Intel® Processor Graphics, including Intel® HD Graphics and Intel® Iris® Graphics |
-|MYRIAD   |	Intel® Neural Compute Stick 2 powered by the Intel® Movidius™ Myriad™ X |
-|GNA      |	Intel&reg; Speech Enabling Developer Kit, Amazon Alexa* Premium Far-Field Developer Kit, Intel&reg; Pentium&reg; Silver J5005 Processor, Intel&reg; Pentium&reg; Silver N5000 Processor, Intel&reg; Celeron&reg; J4005 Processor, Intel&reg; Celeron&reg; J4105 Processor, Intel&reg; Celeron&reg; Processor N4100, Intel&reg; Celeron&reg; Processor N4000, Intel&reg; Core&trade; i3-8121U Processor, Intel&reg; Core&trade; i7-1065G7 Processor, Intel&reg; Core&trade; i7-1060G7 Processor, Intel&reg; Core&trade; i5-1035G4 Processor, Intel&reg; Core&trade; i5-1035G7 Processor, Intel&reg; Core&trade; i5-1035G1 Processor, Intel&reg; Core&trade; i5-1030G7 Processor, Intel&reg; Core&trade; i5-1030G4 Processor, Intel&reg; Core&trade; i3-1005G1 Processor, Intel&reg; Core&trade; i3-1000G1 Processor, Intel&reg; Core&trade; i3-1000G4 Processor |
-|HETERO   | Automatic splitting of a network inference between several devices (for example if a device doesn't support certain layers|
-|MULTI    | Simultaneous inference of the same network on several devices in parallel|
+| Plugin   | Device Type   |
+| ------------- | ------------- |
+|CPU|	Intel® Xeon® with Intel® AVX2 and AVX512, Intel® Core™ Processors with Intel® AVX2, Intel® Atom® Processors with Intel® SSE |
+|GPU| Intel® Processor Graphics, including Intel® HD Graphics and Intel® Iris® Graphics
+|FPGA|	Intel® Programmable Acceleration Card with Intel® Arria® 10 GX FPGA, Intel® Vision Accelerator Design with an Intel® Arria 10 FPGA (Speed Grade 2) |
+|MYRIAD|	Intel® Neural Compute Stick 2 powered by the Intel® Movidius™ Myriad™ X|
+|GNA|	Intel&reg; Speech Enabling Developer Kit, Amazon Alexa* Premium Far-Field Developer Kit, Intel&reg; Pentium&reg; Silver J5005 Processor, Intel&reg; Pentium&reg; Silver N5000 Processor, Intel&reg; Celeron&reg; J4005 Processor, Intel&reg; Celeron&reg; J4105 Processor, Intel&reg; Celeron&reg; Processor N4100, Intel&reg; Celeron&reg; Processor N4000, Intel&reg; Core&trade; i3-8121U Processor, Intel&reg; Core&trade; i7-1065G7 Processor, Intel&reg; Core&trade; i7-1060G7 Processor, Intel&reg; Core&trade; i5-1035G4 Processor, Intel&reg; Core&trade; i5-1035G7 Processor, Intel&reg; Core&trade; i5-1035G1 Processor, Intel&reg; Core&trade; i5-1030G7 Processor, Intel&reg; Core&trade; i5-1030G4 Processor, Intel&reg; Core&trade; i3-1005G1 Processor, Intel&reg; Core&trade; i3-1000G1 Processor, Intel&reg; Core&trade; i3-1000G4 Processor
+|HETERO|Automatic splitting of a network inference between several devices (for example if a device doesn't support certain layers|
+|MULTI| Simultaneous inference of the same network on several devices in parallel|
 
-The table below shows the plugin libraries and additional dependencies for Linux, Windows and macOS platforms.
+The table below shows the plugin libraries and additional dependencies for Linux and Windows platforms.
 
-| Plugin | Library name for Linux      | Dependency libraries for Linux                              | Library name for Windows | Dependency libraries for Windows                                                                       | Library name for macOS       | Dependency libraries for macOS              |
-|--------|-----------------------------|-------------------------------------------------------------|--------------------------|--------------------------------------------------------------------------------------------------------|------------------------------|---------------------------------------------|
-| CPU    | `libMKLDNNPlugin.so`        | `libinference_engine_lp_transformations.so`                 | `MKLDNNPlugin.dll`       | `inference_engine_lp_transformations.dll`                                                              | `libMKLDNNPlugin.dylib`      | `inference_engine_lp_transformations.dylib` |
-| GPU    | `libclDNNPlugin.so`         | `libinference_engine_lp_transformations.so`, `libOpenCL.so` | `clDNNPlugin.dll`        | `OpenCL.dll`, `inference_engine_lp_transformations.dll`                                                |  Is not supported            |  -                                          |
-| MYRIAD | `libmyriadPlugin.so`        | `libusb.so`,                                                | `myriadPlugin.dll`       | `usb.dll`                                                                                              | `libmyriadPlugin.dylib`      | `libusb.dylib`                              |
-| HDDL   | `libHDDLPlugin.so`          | `libbsl.so`, `libhddlapi.so`, `libmvnc-hddl.so`             | `HDDLPlugin.dll`         | `bsl.dll`, `hddlapi.dll`, `json-c.dll`, `libcrypto-1_1-x64.dll`, `libssl-1_1-x64.dll`, `mvnc-hddl.dll` |  Is not supported            |  -                                          |
-| GNA    | `libGNAPlugin.so`           | `libgna.so`,                                                | `GNAPlugin.dll`          | `gna.dll`                                                                                              |  Is not supported            |  -                                          |
-| HETERO | `libHeteroPlugin.so`        | Same as for selected plugins                                | `HeteroPlugin.dll`       | Same as for selected plugins                                                                           | `libHeteroPlugin.dylib`      |  Same as for selected plugins               |
-| MULTI  | `libMultiDevicePlugin.so`   | Same as for selected plugins                                | `MultiDevicePlugin.dll`  | Same as for selected plugins                                                                           | `libMultiDevicePlugin.dylib` |  Same as for selected plugins               |
+| Plugin | Library name for Linux | Dependency libraries for Linux                  | Library name for Windows | Dependency libraries for Windows                                                                       |
+|--------|------------------------|-------------------------------------------------|--------------------------|--------------------------------------------------------------------------------------------------------|
+| CPU    | `libMKLDNNPlugin.so`   | `libinference_engine_lp_transformations.so` | `MKLDNNPlugin.dll`       | `inference_engine_lp_transformations.dll`    |
+| GPU    | `libclDNNPlugin.so`    | `libinference_engine_lp_transformations.so`, `libOpenCL.so`                                  | `clDNNPlugin.dll`        | `OpenCL.dll`, `inference_engine_lp_transformations.dll`                                                                                           |
+| FPGA   | `libdliaPlugin.so`     | `libdla_compiler_core.so`, `libdla_runtime_core.so`, `libcrypto.so`, `libalteracl.so`, `liblpsolve5525.so`, `libprotobuf.so`, `libacl_emulator_kernel_rt.so` | `dliaPlugin.dll`         | `dla_compiler_core.dll`, `dla_runtime_core.dll`, `crypto.dll`, `alteracl.dll`, `lpsolve5525.dll`, `protobuf.dll`, `acl_emulator_kernel_rt.dll`
+| MYRIAD | `libmyriadPlugin.so`   | `libusb.so`, `libinference_engine_lp_transformations.so`                                 | `myriadPlugin.dll`       | `usb.dll`, `inference_engine_lp_transformations.dll`                                                                                        |
+| HDDL   | `libHDDLPlugin.so`     | `libbsl.so`, `libhddlapi.so`, `libmvnc-hddl.so`, `libinference_engine_lp_transformations.so`| `HDDLPlugin.dll`         | `bsl.dll`, `hddlapi.dll`, `json-c.dll`, `libcrypto-1_1-x64.dll`, `libssl-1_1-x64.dll`, `mvnc-hddl.dll`, `inference_engine_lp_transformations.dll` |
+| GNA    | `libGNAPlugin.so`      | `libgna.so`, `libinference_engine_lp_transformations.so`                                 | `GNAPlugin.dll`          | `gna.dll`, `inference_engine_lp_transformations.dll`                                                                                              |
+| HETERO | `libHeteroPlugin.so`   | Same as for selected plugins                    | `HeteroPlugin.dll`       | Same as for selected plugins                                                                           |
+| MULTI  | `libMultiDevicePlugin.so`   | Same as for selected plugins               | `MultiDevicePlugin.dll`  | Same as for selected plugins                                                                           |
 
 > **NOTE**: All plugin libraries also depend on core Inference Engine libraries.
 
@@ -76,16 +78,15 @@ Make sure those libraries are in your computer's path or in the place you pointe
 
 * Linux: `LD_LIBRARY_PATH`
 * Windows: `PATH`
-* macOS: `DYLD_LIBRARY_PATH`
 
-On Linux and macOS, use the script `bin/setupvars.sh` to set the environment variables.
+On Linux, use the script `bin/setupvars.sh` to set the environment variables.
 
 On Windows, run the `bin\setupvars.bat` batch file to set the environment variables.
 
 To learn more about supported devices and corresponding plugins, see the [Supported Devices](supported_plugins/Supported_Devices.md) chapter.
 
 Common Workflow for Using the Inference Engine API
---------------------------------------------------
+---------------------------
 The common workflow contains the following steps:
 
 1. **Create Inference Engine Core object** - Create an `InferenceEngine::Core` object to work with different devices, all device plugins are managed internally by the `Core` object. Register extensions with custom nGraph operations (`InferenceEngine::Core::AddExtension`).

docs/IE_DG/nGraphTutorial.md

@@ -0,0 +1,64 @@
+# Build a Model with nGraph Library {#openvino_docs_IE_DG_nGraphTutorial}
+
+This section illustrates how to construct an nGraph function 
+composed of operations from the `opset3` namespace. Once created, 
+it can wrap into a `CNNNetwork`, creating utility for data scientists 
+or app developers to define a deep-learning model in a neutral way
+that does not depend on existing Deep Learning (DL) frameworks.
+
+Operation Set `opsetX` integrates a list of nGraph pre-compiled operations that work
+for this purpose. In other words, `opsetX` defines a set of operations for building a graph.
+
+For a complete list of operation sets supported by Inference Engine, see [Available Operations Sets](../ops/opset.md).
+
+To add custom nGraph operations to an existing `CNNNetwork`, see 
+the [Add Custom nGraph Operations](Extensibility_DG/Intro.md) document.
+
+Now that you can build graphs with anything from the `opset3` definition, some 
+parameters for shape-relevant (or shape-specific) inputs can be added. The 
+following code prepares a graph for shape-relevant parameters. 
+
+> **NOTE**: `validate_nodes_and_infer_types(ops)` must be included for partial shape inference. 
+
+```cpp
+#include "ngraph/opsets/opset.hpp"
+#include "ngraph/opsets/opset3.hpp"
+
+using namespace std;
+using namespace ngraph;
+
+auto arg0 = make_shared<opset3::Parameter>(element::f32, Shape{7});
+auto arg1 = make_shared<opset3::Parameter>(element::f32, Shape{7});
+// Create an 'Add' operation with two inputs 'arg0' and 'arg1'
+auto add0 = make_shared<opset3::Add>(arg0, arg1);
+auto abs0 = make_shared<opset3::Abs>(add0);
+// Create a node whose inputs/attributes will be specified later
+auto acos0 = make_shared<opset3::Acos>();
+// Create a node using opset factories
+auto add1 = shared_ptr<Node>(get_opset3().create("Add"));
+// Set inputs to nodes explicitly
+acos0->set_argument(0, add0);
+add1->set_argument(0, acos0);
+add1->set_argument(1, abs0);
+
+// Run shape inference on the nodes
+NodeVector ops{arg0, arg1, add0, abs0, acos0, add1};
+validate_nodes_and_infer_types(ops);
+
+// Create a graph with one output (add1) and four inputs (arg0, arg1)
+auto ng_function = make_shared<Function>(OutputVector{add1}, ParameterVector{arg0, arg1});
+
+```
+
+To wrap it into a CNNNetwork, use: 
+```cpp
+CNNNetwork net (ng_function);
+```
+
+## See Also
+
+* [Available Operation Sets](../ops/opset.md)
+* [Operation Set `opset1` Specification](../ops/opset1.md)
+* [Operation Set `opset2` Specification](../ops/opset2.md)
+* [Operation Set `opset3` Specification](../ops/opset3.md)
+* [Inference Engine Extensibility Developer Guide](Extensibility_DG/Intro.md)

docs/IE_DG/nGraph_Flow.md

@@ -0,0 +1,142 @@
+# Introduction to nGraph Flow in Inference Engine {#openvino_docs_IE_DG_nGraph_Flow}
+
+## New Run-Time Intermediate Representation (IR): nGraph
+
+Starting from the OpenVINO™ release 2020.1, the Inference Engine integrates the 
+nGraph Core.
+That implies that the Inference Engine uses a new way to represent a model in run time underneath of 
+the conventional `CNNNetwork` API, which is an instance of `ngraph::Function`.
+
+Besides the representation update, nGraph integration resulted in the following changes and new features:
+
+1. New operations sets. When operations from the nGraph Core were combined with conventional layers 
+from `CNNNetwork`, there were created a [new sets of operations called `opset1`, `opset2` and etc.](../ops/opset.md), 
+which covered both interfaces except several not very important cases.
+Operations from `opset3` are generated by the Model Optimizer and are accepted in the Inference Engine.
+
+2. New version approach that attaches a version to each operation rather than to the entire IR file format. 
+IR is still versioned but has a different meaning. For details, see [Deep Learning Network Intermediate Representation and Operation Sets in OpenVINO™](../MO_DG/IR_and_opsets.md).
+
+3. Creating models in run-time without loading IR from an xml/binary file. You can enable it by creating
+`ngraph::Function` passing it to `CNNNetwork`.
+
+4. Run-time reshape capability and constant folding are implemented through the nGraph code for more operations compared to previous releases.
+As a result, more models can be reshaped. For details, see the [dedicated guide about the reshape capability](ShapeInference.md).
+
+5. Loading model from ONNX format without converting it to the Inference Engine IR.
+
+The conventional flow that is not based on nGraph is still available.
+The complete picture of co-existence of legacy and new flows is presented below.
+The rest of the document describes the coexistence of legacy and new flows showed in the picture below:
+
+![](img/TopLevelNGraphFlow.png)
+
+
+## Read the Intermediate Representation to `CNNNetwork`
+
+As the new operation set is introduced, the Model Optimizer generates the IR version 10 using the new operations by default.
+Each layer generated in the IR has a semantics matching to the corresponding operation from the nGraph namespace `opset3`.
+The IR version 10 automatically triggers the nGraph flow inside the Inference Engine.
+When such IR is read in an application, the Inference Engine IR reader produces `CNNNetwork` that encapsulates the `ngraph::Function` instance underneath.
+Thus the OpenVINO IR becomes a new serialization format for the nGraph IR, and it can be deserialized reading the `CNNNetwork`.
+
+> **IMPORTANT**: Conventional interfaces are used (`CNNNetwork`, the reader), so no changes required in most applications.
+
+> **NOTE**: While you still can use old APIs, there is an independent process of continuous improvements in the Inference Engine API.
+> For example, the Core::Read API is recommended to use instead of `CNNNetworkReader`.
+> These changes are independent of nGraph integration and do not enable or disable new features.
+
+Interpretation of the IR version 10 differs from the old IR version.
+Besides having a different operations set, the IR version 10 ignores the shapes and data types assigned to the ports in an XML file.
+Both shapes and types are reinferred while loading to the Inference Engine using the nGraph shape and type propagation function that is a part of each nGraph operation.
+
+### Legacy IR Versions
+
+You can read old versions of the IR in the Inference Engine.
+Each version below or equal to 7 is treated as an old one.
+When the Inference Engine reader reads an old version of the IR, it does not use the nGraph representation.
+There is no way to activate nGraph flow with an old IR version.
+The rest of this document is not applied in this case.
+
+Model Optimizer generates the IR version 10 by default, and there is the command line key `--generate_deprecated_IR_V7` which switches generation to the legacy IR version 7.
+It is useful when the new nGraph flow does not work for some reason.
+
+## Build a Model in the Application
+
+Alternative method to feed the Inference Engine with a model is to create the model in the run time.
+It is achieved by creation of the `ngraph::Function` construction using nGraph operation classes and optionally user-defined operations.
+For details, see [Add Custom nGraph Operations](Extensibility_DG/AddingNGraphOps.md) and [examples](nGraphTutorial.md).
+At this stage, the code is completely independent of the rest of the Inference Engine code and can be built separately.
+After you construct an instance of `ngraph::Function`, you can use it to create `CNNNetwork` by passing it to the new constructor for this class.
+
+Initializing `CNNNetwork` from the nGraph Function means encapsulating the object and not converting it to a conventional representation.
+Going to low-level details, technically it is achieved by using another class for the `CNNNetwork` internals.
+The old representation that is used for former versions of IR before version 10 uses `CNNNetworkImpl`.
+The new representation that is built around nGraph uses `CNNNetworkNGraphImpl`.
+
+![](img/NewAndOldCNNNetworkImpl.png)
+
+## Automatic Conversion to the Old Representation
+
+The old representation is still required in the cases listed below.
+When old representation is required, the conversion from the `ngraph::Function` to the old representation is called automatically.
+The following methods lead to the automatic conversion:
+
+1. Using the old API, which is expected to produce an old representation. Guaranteed to be read-only. Once you call such a method, the original nGraph representation is preserved and continues to be used in the successive calls.
+    
+    1.1. `CNNNetwork::serialize`. Dumps the old representation after automatically called conversion. Cannot be used to dump IR V10. For details, see [Graph Debug Capabilities](Graph_debug_capabilities.md).
+
+2. Calling `CNNNetwork` methods that modify the model. After that nGraph representation is lost and cannot be used afterwards.
+
+    1.1. `CNNNetwork::addLayer`
+
+    1.2. CNNNetwork::setBatchSize. Still implemented through old logic for backward compatibility without using nGraph capabilities.
+    For details, see [Using Shape Inference](ShapeInference.md).
+
+3. Using methods that return objects inside an old representation.
+Using these methods does not mean modification of the model, but you are not limited by the API to make read-only changes. 
+These methods should be used in the read-only mode with respect to a model representation.
+If the model is changed, for example attribute of some layer is changed or layers are reconnected, the modification is lost whenever any method that uses nGraph is called, including methods inside plugins like CNNNetwork::reshape.
+It is hard to predict whether the nGraph function is used in a plugin or other methods of CNNNetworks, so modifying a network using the following methods is *strongly not recommended*.
+This is an important limitation that is introduced for the old API calls listed below:
+
+    1.1. `Data::getInputTo`
+    
+    1.2. `Data::getCreatorLayer`
+    
+    1.3. `CNNNetwork::getLayerByName`
+    
+    1.4. Iterating over `CNNLayer` objects in `CNNNetwork`: `CNNNetwork::begin`, `details::CNNNetworkIterator` class.
+
+4. Using a conventional plugin that accepts the old representation only.
+
+Though the conversion is always a one-way process, which means there is no method to convert back, there are important caveats.
+
+In the cases [1] and [3], both representations are held underneath and you should use the old representation in the read-only mode only from the caller side.
+It is hard to track from the Inference Engine side whether the API is used in the read-only mode or for modification of the model.
+
+That is why when using potentially modifying methods listed in section [3] above, you should not modify the model via those methods.
+Use a direct manipulation of the nGraph function instead.
+
+## Conversion Function
+
+Inference Engine implements the conversion function that is used when the nGraph function is transformed to the old `CNNNetworkImpl` representation.
+This conversion function is hidden and you cannot call it directly from the application.
+Nevertheless, it is an important component of the model transformation pipeline in the Inference Engine.
+Some issues of models may be caught during the conversion process in this function.
+Exceptions are thrown in this function, and you should know what this function does to find a root cause.
+
+The conversion function performs the following steps:
+
+1. Convert and decompose some operations as the first step of the nGraph function preparation for optimization.
+Reduce operation set to easily optimize it at the next stages.
+For example, decomposing of BatchNormInference happens at this stage.
+
+2. Optimizing transformations that usually happen in the Model Optimizer are called here, because the nGraph function is not always read from an already optimized IR.
+
+3. Changing operation set from `opsetX` to legacy layer semantics described in the [Legacy Layers Catalog](../MO_DG/prepare_model/convert_model/Legacy_IR_Layers_Catalog_Spec.md).
+The model is still represented as the nGraph function at this stage, but the operation set is completely different.
+
+4. One-to-one conversion of nGraph representation to the corresponding `CNNNetworkImpl` without changing its semantics.
+You can see the result of the conversion by calling the `CNNNetwork::serialize` method, which produces legacy IR semantics, which is not nGraph-based even if it is applied to `CNNNetwork` constructed from the nGraph Function.
+It may help in debugging, see [Graph Debug Capabilities](Graph_debug_capabilities.md) to view all options for dumping new and old IR representations.

docs/IE_DG/protecting_model_guide.md

@@ -33,7 +33,14 @@ a temporary memory block for model decryption, and use
 For more information, see the `InferenceEngine::Core` Class
 Reference Documentation.
 
-@snippet snippets/protecting_model_guide.cpp part0
+```cpp
+std::vector<uint8_t> model;
+std::vector<uint8_t> weights;
+
+// Read model files and decrypt them into temporary memory block
+decrypt_file(model_file, password, model);
+decrypt_file(weights_file, password, weights);
+```
 
 Hardware-based protection, such as Intel&reg; Software Guard Extensions
 (Intel&reg; SGX), can be utilized to protect decryption operation secrets and
@@ -43,11 +50,12 @@ Extensions](https://software.intel.com/en-us/sgx).
 Use `InferenceEngine::Core::ReadNetwork()` to set model representations and
 weights respectively.
 
-Currently there are no possibility to read external weights from memory for ONNX models.
-The `ReadNetwork(const std::string& model, const Blob::CPtr& weights)` function
-should be called with `weights` passed as an empty `Blob`.
-
-@snippet snippets/protecting_model_guide.cpp part1
+```cpp
+Core core;
+// Load model from temporary memory block
+std::string strModel(model.begin(), model.end());
+CNNNetwork network = core.ReadNetwork(strModel, make_shared_blob<uint8_t>({Precision::U8, {weights.size()}, C}, weights.data()));
+```
 
 [deploy_encrypted_model]: img/deploy_encrypted_model.png
 
@@ -55,9 +63,9 @@ should be called with `weights` passed as an empty `Blob`.
 
 - Intel® Distribution of OpenVINO™ toolkit home page: [https://software.intel.com/en-us/openvino-toolkit](https://software.intel.com/en-us/openvino-toolkit)
 - OpenVINO™ toolkit online documentation: [https://docs.openvinotoolkit.org](https://docs.openvinotoolkit.org)
-- Model Optimizer Developer Guide: [Model Optimizer Developer Guide](../MO_DG/Deep_Learning_Model_Optimizer_DevGuide.md)
-- Inference Engine Developer Guide: [Inference Engine Developer Guide](Deep_Learning_Inference_Engine_DevGuide.md)
-- For more information on Sample Applications, see the [Inference Engine Samples Overview](Samples_Overview.md)
+- Model Optimizer Developer Guide: [Model Optimizer Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html)
+- Inference Engine Developer Guide: [Inference Engine Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Deep_Learning_Inference_Engine_DevGuide.html)
+- For more information on Sample Applications, see the [Inference Engine Samples Overview](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Samples_Overview.html)
 - For information on a set of pre-trained models, see the [Overview of OpenVINO™ Toolkit Pre-Trained Models](@ref omz_models_intel_index)
 - For information on Inference Engine Tutorials, see the [Inference Tutorials](https://github.com/intel-iot-devkit/inference-tutorials-generic)
 - For IoT Libraries and Code Samples see the [Intel® IoT Developer Kit](https://github.com/intel-iot-devkit).

docs/IE_DG/supported_plugins/CPU.md

@@ -14,8 +14,8 @@ OpenVINO™ toolkit is officially supported and validated on the following platf
 
 | Host              | OS (64-bit)                              |
 | :---              | :---                                     |
-| Development       | Ubuntu* 18.04, CentOS* 7.5, MS Windows* 10 |
-| Target            | Ubuntu* 18.04, CentOS* 7.5, MS Windows* 10 |
+| Development       | Ubuntu* 16.04/CentOS* 7.4/MS Windows* 10 |
+| Target            | Ubuntu* 16.04/CentOS* 7.4/MS Windows* 10 |
 
 The CPU Plugin supports inference on 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).
@@ -114,11 +114,9 @@ CPU-specific settings:
 | :---                        | :---                  | :---               | :--- |
 | KEY_CPU_THREADS_NUM         | positive integer values| 0                 | Specifies the number of threads that CPU plugin should use for inference. Zero (default) means using all (logical) cores|
 | KEY_CPU_BIND_THREAD         | YES/NUMA/NO           | YES                | Binds inference threads to CPU cores. 'YES' (default) binding option maps threads to cores - this works best for static/synthetic scenarios like benchmarks. The 'NUMA' binding is more relaxed, binding inference threads only to NUMA nodes, leaving further scheduling to specific cores to the OS. This option might perform better in the real-life/contended scenarios. Note that for the latency-oriented cases (single execution stream, see below) both YES and NUMA options limit number of inference threads to the number of hardware cores (ignoring hyper-threading) on the multi-socket machines. |
-| KEY_CPU_THROUGHPUT_STREAMS  | KEY_CPU_THROUGHPUT_NUMA, KEY_CPU_THROUGHPUT_AUTO, or positive integer values| 1 | Specifies number of CPU "execution" streams for the throughput mode. Upper bound for the number of inference requests that can be executed simultaneously. All available CPU cores are evenly distributed between the streams. The default value is 1, which implies latency-oriented behavior with all available cores processing requests one by one.<br>KEY_CPU_THROUGHPUT_NUMA creates as many streams as needed to accommodate NUMA and avoid associated penalties.<br>KEY_CPU_THROUGHPUT_AUTO creates bare minimum of streams to improve the performance; this is the most portable option if you don't know how many cores your target machine has (and what would be the optimal number of streams). Note that your application should provide enough parallel slack (for example, run many inference requests) to leverage the throughput mode. <br> Non-negative integer value creates the requested number of streams. If a number of streams is 0, no internal streams are created and user threads are interpreted as stream master threads.|
+| KEY_CPU_THROUGHPUT_STREAMS  | KEY_CPU_THROUGHPUT_NUMA, KEY_CPU_THROUGHPUT_AUTO, or positive integer values| 1 | Specifies number of CPU "execution" streams for the throughput mode. Upper bound for the number of inference requests that can be executed simultaneously. All available CPU cores are evenly distributed between the streams. The default value is 1, which implies latency-oriented behavior with all available cores processing requests one by one.<br>KEY_CPU_THROUGHPUT_NUMA creates as many streams as needed to accommodate NUMA and avoid associated penalties.<br>KEY_CPU_THROUGHPUT_AUTO creates bare minimum of streams to improve the performance; this is the most portable option if you don't know how many cores your target machine has (and what would be the optimal number of streams). Note that your application should provide enough parallel slack (for example, run many inference requests) to leverage the throughput mode. <br> A positive integer value creates the requested number of streams. |
 | KEY_ENFORCE_BF16            | YES/NO| YES | The name for setting to execute in bfloat16 precision whenever it is possible. This option lets plugin know to downscale the precision where it sees performance benefits from bfloat16 execution. Such option does not guarantee accuracy of the network, you need to verify the accuracy in this mode separately, based on performance and accuracy results. It should be your decision whether to use this option or not. |
 
-> **NOTE**: To disable all internal threading, use the following set of configuration parameters: `KEY_CPU_THROUGHPUT_STREAMS=0`, `KEY_CPU_THREADS_NUM=1`, `KEY_CPU_BIND_THREAD=NO`.
-
 ## See Also
 * [Supported Devices](Supported_Devices.md)
 

docs/IE_DG/supported_plugins/FPGA.md

@@ -19,4 +19,294 @@ Intel will be transitioning to the next-generation programmable deep-learning so
 
 Intel® Distribution of OpenVINO™ toolkit 2020.3.X LTS release will continue to support Intel® Vision Accelerator Design with an Intel® Arria® 10 FPGA and the Intel® Programmable Acceleration Card with Intel® Arria® 10 GX FPGA. For questions about next-generation programmable deep-learning solutions based on FPGAs, please talk to your sales representative or contact us to get the latest FPGA updates.
 
-For documentation for the FPGA plugin available in previous releases of Intel® Distribution of OpenVINO™ toolkit with FPGA Support, see documentation for the [2020.4 version](https://docs.openvinotoolkit.org/2020.4/openvino_docs_IE_DG_supported_plugins_FPGA.html) and lower.
+## Introducing FPGA Plugin
+
+The FPGA plugin provides an opportunity for high performance scoring of neural networks on Intel® FPGA devices.
+
+> **NOTE**: Before using the FPGA plugin, ensure that you have installed and configured either the Intel® Vision Accelerator Design with an Intel® Arria® 10 FPGA (Speed Grade 2) or the Intel® Programmable Acceleration Card with Intel® Arria® 10 GX FPGA. For installation and configuration details, see [FPGA installation](Supported_Devices.md).
+
+## Heterogeneous Execution
+
+When your topology contains layers that are not supported by the Intel® FPGA plugin, use [Heterogeneous plugin](HETERO.md) with dedicated fallback device.
+
+If a network has layers that are not supported in the Intel® FPGA plugin or in a fallback plugin, you can implement a custom layer on the CPU/GPU and use the [Extensibility mechanism](../Extensibility_DG/Intro.md).
+In addition to adding custom kernels, you must still point to the CPU plugin or the GPU plugin as fallback devices for heterogeneous plugin.
+
+## Supported Networks
+
+The following network topologies are supported in heterogeneous mode, running on FPGA with fallback to CPU or GPU devices.
+
+> **IMPORTANT**: Use only bitstreams from the current version of the OpenVINO toolkit. Bitstreams from older versions of the OpenVINO toolkit are incompatible with later versions of the OpenVINO toolkit. For example, you cannot use the `1-0-1_A10DK_FP16_Generic` bitstream, when the OpenVINO toolkit supports the `2019R2_PL2_FP16_InceptionV1_SqueezeNet_VGG_YoloV3.aocx` bitstream.
+
+
+| Network                              | Bitstreams (Intel® Vision Accelerator Design with an Intel® Arria® 10 FPGA (Speed Grade 2)) | Bitstreams (Intel® Programmable Acceleration Card with Intel® Arria® 10 GX FPGA) |
+|:-------------------------------------|:-------------------------------------------------------------------|:---------------------------------------------------------------------------------------------|
+| AlexNet                              | 2020-4_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic, 2020-4_PL2_FP11_AlexNet_GoogleNet_Generic | 2020-4_RC_FP16_AlexNet_GoogleNet_Generic, 2020-4_RC_FP11_AlexNet_GoogleNet_Generic |
+| GoogleNet v1                         | 2020-4_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic, 2020-4_PL2_FP11_AlexNet_GoogleNet_Generic | 2020-4_RC_FP16_AlexNet_GoogleNet_Generic, 2020-4_RC_FP11_AlexNet_GoogleNet_Generic |
+| VGG-16                               | 2020-4_PL2_FP16_SqueezeNet_TinyYolo_VGG, 2020-4_PL2_FP11_InceptionV1_ResNet_VGG | 2020-4_RC_FP16_InceptionV1_SqueezeNet_TinyYolo_VGG, 2020-4_RC_FP16_ResNet_TinyYolo_VGG |
+| VGG-19                               | 2020-4_PL2_FP16_SqueezeNet_TinyYolo_VGG, 2020-4_PL2_FP11_InceptionV1_ResNet_VGG | 2020-4_RC_FP16_InceptionV1_SqueezeNet_TinyYolo_VGG, 2020-4_RC_FP16_ResNet_TinyYolo_VGG |
+| SqueezeNet v 1.0                     | 2020-4_PL2_FP16_SqueezeNet_TinyYolo_VGG, 2020-4_PL2_FP11_SqueezeNet | 2020-4_RC_FP16_InceptionV1_SqueezeNet_YoloV3, 2020-4_RC_FP16_InceptionV1_SqueezeNet_YoloV3 |
+| SqueezeNet v 1.1                     | 2020-4_PL2_FP16_SqueezeNet_TinyYolo_VGG, 2020-4_PL2_FP11_SqueezeNet | 2020-4_RC_FP16_InceptionV1_SqueezeNet_YoloV3, 2020-4_RC_FP16_InceptionV1_SqueezeNet_YoloV3 |
+| ResNet-18                            | 2020-4_PL2_FP16_ResNet_YoloV3, 2020-4_PL2_FP11_InceptionV1_ResNet_VGG | 2020-4_RC_FP16_ResNet_YoloV3, 2020-4_RC_FP16_ResNet_TinyYolo_VGG |
+| ResNet-50                            | 2020-4_PL2_FP16_ResNet_YoloV3, 2020-4_PL2_FP11_InceptionV1_ResNet_VGG | 2020-4_RC_FP16_ResNet_YoloV3, 2020-4_RC_FP16_ResNet_TinyYolo_VGG |
+| ResNet-101                           | 2020-4_PL2_FP16_ResNet_YoloV3, 2020-4_PL2_FP11_InceptionV1_ResNet_VGG | 2020-4_RC_FP16_ResNet_YoloV3, 2020-4_RC_FP16_ResNet_TinyYolo_VGG |
+| ResNet-152                           | 2020-4_PL2_FP16_ResNet_YoloV3, 2020-4_PL2_FP11_InceptionV1_ResNet_VGG | 2020-4_RC_FP16_ResNet_YoloV3, 2020-4_RC_FP16_ResNet_TinyYolo_VGG |
+| MobileNet (Caffe)                    | 2020-4_PL2_FP16_MobileNet_Clamp, 2020-4_PL2_FP11_MobileNet_Clamp | 2020-4_RC_FP16_MobileNet_Clamp, 2020-4_RC_FP11_MobileNet_Clamp |
+| MobileNet (TensorFlow)               | 2020-4_PL2_FP16_MobileNet_Clamp, 2020-4_PL2_FP11_MobileNet_Clamp | 2020-4_RC_FP16_MobileNet_Clamp, 2020-4_RC_FP11_MobileNet_Clamp|
+| SqueezeNet-based variant of the SSD* | 2020-4_PL2_FP16_SqueezeNet_TinyYolo_VGG, 2020-4_PL2_FP11_SqueezeNet | 2020-4_RC_FP16_InceptionV1_SqueezeNet_TinyYolo_VGG, 2020-4_RC_FP16_InceptionV1_SqueezeNet_YoloV3 |
+| ResNet-based variant of SSD          | 2020-4_PL2_FP16_ResNet_YoloV3, 2020-4_PL2_FP11_InceptionV1_ResNet_VGG | 2020-4_RC_FP16_ResNet_YoloV3, 2020-4_RC_FP16_ResNet_TinyYolo_VGG |
+| RMNet                                | 2020-4_PL2_FP16_RMNet, 2020-4_PL2_FP11_RMNet | 2020-4_RC_FP16_RMNet, 2020-4_RC_FP11_RMNet |
+| Yolo v3                              | 2020-4_PL2_FP16_ResNet_YoloV3, 2020-4_PL2_FP11_YoloV3_ELU | 2020-4_RC_FP16_ResNet_YoloV3, 2020-4_RC_FP16_InceptionV1_SqueezeNet_YoloV3 |
+
+
+In addition to the list above, arbitrary topologies having big continues subgraphs consisting of layers supported by FPGA plugin are recommended to be executed on FPGA plugin.
+
+## Bitstreams that are Optimal to Use with the Intel's Pre-Trained Models
+
+The table below provides you with a list of Intel® Vision Accelerator Design with an Intel® Arria® 10 FPGA (Speed Grade 2) bitstreams that are optimal to use for the Intel's pre-trained models.  
+
+<details>
+  <summary><strong>Click to expand/collapse the table</strong></summary>
+
+| Model Name | FP11 Bitstreams | FP16 Bitstreams |
+| :---       | :---            | :---            |
+| action-recognition-0001-decoder | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_SwishExcitation.aocx |
+| action-recognition-0001-encoder | 2020-3_PL2_FP11_InceptionV1_ResNet_VGG.aocx | 2020-3_PL2_FP16_ResNet_YoloV3.aocx |
+| age-gender-recognition-retail-0013 | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| asl-recognition-0004 | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| driver-action-recognition-adas-0002-decoder | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| driver-action-recognition-adas-0002-encoder | 2020-3_PL2_FP11_YoloV3_ELU.aocx | 2020-3_PL2_FP16_SwishExcitation.aocx |
+| emotions-recognition-retail-0003 | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_SqueezeNet_TinyYolo_VGG.aocx |
+| face-detection-0100 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| face-detection-0102 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| face-detection-0104 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| face-detection-0105 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| face-detection-0106 | 2020-3_PL2_FP11_InceptionV1_ResNet_VGG.aocx | 2020-3_PL2_FP16_ResNet_YoloV3.aocx |
+| face-detection-adas-0001 | 2020-3_PL2_FP11_YoloV3_ELU.aocx | 2020-3_PL2_FP16_SwishExcitation.aocx |
+| face-detection-adas-binary-0001 | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| face-detection-retail-0004 | 2020-3_PL2_FP11_TinyYolo_SSD300.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| face-detection-retail-0005 | 2020-3_PL2_FP11_YoloV3_ELU.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| face-reidentification-retail-0095 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| facial-landmarks-35-adas-0002 | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| faster-rcnn-resnet101-coco-sparse-60-0001 | 2020-3_PL2_FP11_InceptionV1_ResNet_VGG.aocx | 2020-3_PL2_FP16_SwishExcitation.aocx |
+| gaze-estimation-adas-0002 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| handwritten-japanese-recognition-0001 | 2020-3_PL2_FP11_InceptionV1_ResNet_VGG.aocx | 2020-3_PL2_FP16_ResNet_YoloV3.aocx |
+| handwritten-score-recognition-0003 | 2020-3_PL2_FP11_InceptionV1_ResNet_VGG.aocx | 2020-3_PL2_FP16_SqueezeNet_TinyYolo_VGG.aocx |
+| head-pose-estimation-adas-0001 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| human-pose-estimation-0001 | 2020-3_PL2_FP11_YoloV3_ELU.aocx | 2020-3_PL2_FP16_SwishExcitation.aocx |
+| icnet-camvid-ava-0001 | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| icnet-camvid-ava-sparse-30-0001 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_SwishExcitation.aocx |
+| icnet-camvid-ava-sparse-60-0001 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_SwishExcitation.aocx |
+| image-retrieval-0001 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| instance-segmentation-security-0010 | 2020-3_PL2_FP11_InceptionV1_ResNet_VGG.aocx | 2020-3_PL2_FP16_SqueezeNet_TinyYolo_VGG.aocx |
+| instance-segmentation-security-0050 | 2020-3_PL2_FP11_InceptionV1_ResNet_VGG.aocx | 2020-3_PL2_FP16_ResNet_YoloV3.aocx |
+| instance-segmentation-security-0083 | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| instance-segmentation-security-1025 | 2020-3_PL2_FP11_InceptionV1_ResNet_VGG.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| landmarks-regression-retail-0009 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| license-plate-recognition-barrier-0001 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_SqueezeNet_TinyYolo_VGG.aocx |
+| pedestrian-and-vehicle-detector-adas-0001 | 2020-3_PL2_FP11_YoloV3_ELU.aocx | 2020-3_PL2_FP16_SwishExcitation.aocx |
+| pedestrian-detection-adas-0002 | 2020-3_PL2_FP11_YoloV3_ELU.aocx | 2020-3_PL2_FP16_SwishExcitation.aocx |
+| pedestrian-detection-adas-binary-0001 | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| person-attributes-recognition-crossroad-0230 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| person-detection-action-recognition-0005 | 2020-3_PL2_FP11_YoloV3_ELU.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| person-detection-action-recognition-0006 | 2020-3_PL2_FP11_YoloV3_ELU.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| person-detection-action-recognition-teacher-0002 | 2020-3_PL2_FP11_YoloV3_ELU.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| person-detection-asl-0001 | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| person-detection-raisinghand-recognition-0001 | 2020-3_PL2_FP11_YoloV3_ELU.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| person-detection-retail-0002 | 2020-3_PL2_FP11_InceptionV1_ResNet_VGG.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| person-detection-retail-0013 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| person-reidentification-retail-0031 | 2020-3_PL2_FP11_YoloV3_ELU.aocx | 2020-3_PL2_FP16_ELU.aocx |
+| person-reidentification-retail-0248 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| person-reidentification-retail-0249 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| person-reidentification-retail-0300 | 2020-3_PL2_FP11_InceptionV1_ResNet_VGG.aocx | 2020-3_PL2_FP16_SwishExcitation.aocx |
+| person-vehicle-bike-detection-crossroad-0078 | 2020-3_PL2_FP11_YoloV3_ELU.aocx | 2020-3_PL2_FP16_ELU.aocx |
+| person-vehicle-bike-detection-crossroad-1016 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_SwishExcitation.aocx |
+| product-detection-0001 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| resnet18-xnor-binary-onnx-0001 | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_RMNet.aocx |
+| resnet50-binary-0001 | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| road-segmentation-adas-0001 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| semantic-segmentation-adas-0001 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| single-image-super-resolution-1032 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_RMNet.aocx |
+| single-image-super-resolution-1033 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_RMNet.aocx |
+| text-detection-0003 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| text-detection-0004 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| text-image-super-resolution-0001 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_RMNet.aocx |
+| text-recognition-0012 | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| text-spotting-0002-detector | 2020-3_PL2_FP11_InceptionV1_ResNet_VGG.aocx | 2020-3_PL2_FP16_ResNet_YoloV3.aocx |
+| text-spotting-0002-recognizer-decoder | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| text-spotting-0002-recognizer-encoder | 2020-3_PL2_FP11_InceptionV1_ResNet_VGG.aocx | 2020-3_PL2_FP16_SqueezeNet_TinyYolo_VGG.aocx |
+| unet-camvid-onnx-0001 | 2020-3_PL2_FP11_InceptionV1_ResNet_VGG.aocx | 2020-3_PL2_FP16_SwishExcitation.aocx |
+| vehicle-attributes-recognition-barrier-0039 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_SqueezeNet_TinyYolo_VGG.aocx |
+| vehicle-detection-adas-0002 | 2020-3_PL2_FP11_YoloV3_ELU.aocx | 2020-3_PL2_FP16_SwishExcitation.aocx |
+| vehicle-detection-adas-binary-0001 | 2020-3_PL2_FP11_AlexNet_GoogleNet_Generic.aocx | 2020-3_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic.aocx |
+| vehicle-license-plate-detection-barrier-0106 | 2020-3_PL2_FP11_MobileNet_Clamp.aocx | 2020-3_PL2_FP16_MobileNet_Clamp.aocx |
+| yolo-v2-ava-0001 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_SqueezeNet_TinyYolo_VGG.aocx |
+| yolo-v2-ava-sparse-35-0001 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_SqueezeNet_TinyYolo_VGG.aocx |
+| yolo-v2-ava-sparse-70-0001 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_SqueezeNet_TinyYolo_VGG.aocx |
+| yolo-v2-tiny-ava-0001 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_ResNet_YoloV3.aocx |
+| yolo-v2-tiny-ava-sparse-30-0001 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_ResNet_YoloV3.aocx |
+| yolo-v2-tiny-ava-sparse-60-0001 | 2020-3_PL2_FP11_SqueezeNet.aocx | 2020-3_PL2_FP16_ResNet_YoloV3.aocx |
+
+</details>
+
+## <a name="TranslatingArchtoBitstream"></a>Translate from Architecture to FPGA Bitstream Files
+
+Various FPGA bitstreams that support CNN are available in the OpenVINO&trade; toolkit package for FPGA.
+
+To select the correct bitstream (`.aocx`) file for an architecture, select a network (for example, Resnet-18) from the table above for either the Intel® Vision Accelerator Design with an Intel® Arria 10 FPGA (Speed Grade 1), Intel® Vision Accelerator Design with an Intel® Arria 10 FPGA (Speed Grade 2) or the Intel&reg; Programmable Acceleration Card (PAC) with Intel&reg; Arria&reg; 10 GX FPGA and note the corresponding architecture.
+
+The following table describes several parameters that might help you to select the proper bitstream for your needs:
+
+| Name                                           | Board                                                                           | Precision | LRN Support | Leaky ReLU Support | PReLU Support | Clamp Support | ELU Support |
+|:------------------------------------------|:--------------------------------------------------------------------------------|:----------|:------------|:-------------------|:--------------|:--------------|:------------|
+| 2020-4_PL2_FP11_AlexNet_GoogleNet_Generic | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP11 | true | true | true | false | false |
+| 2020-4_PL2_FP11_SqueezeNet | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP11 | false | true | true | false | false |
+| 2020-4_PL2_FP11_MobileNet_Clamp | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP11 | false | true | true | true | false |
+| 2020-4_PL2_FP11_InceptionV1_ResNet_VGG | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP11 | false | false | false | false | false |
+| 2020-4_PL2_FP11_RMNet | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP11 | false | true | true | false | true |
+| 2020-4_PL2_FP11_TinyYolo_SSD300 | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP11 | true | true | true | false | false |
+| 2020-4_PL2_FP11_YoloV3_ELU | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP11 | false | true | true | false | true |
+| 2020-4_PL2_FP11_Streaming_InternalUseOnly | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP11 | false | false | false | false | false |
+| 2020-4_PL2_FP11_Streaming_Slicing_InternalUseOnly | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP11 | false | false | false | false | false |
+| 2020-4_PL2_FP11_SwishExcitation | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP11 | false | false | false | false | false |
+| 2020-4_PL2_FP16_AlexNet_GoogleNet_SSD300_Generic | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP16 | true | true | true | false | false |
+| 2020-4_PL2_FP16_ELU | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP16 | false | true | true | false | true |
+| 2020-4_PL2_FP16_MobileNet_Clamp | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP16 | false | true | true | true | false |
+| 2020-4_PL2_FP16_ResNet_YoloV3 | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP16 | false | true | true | false | false |
+| 2020-4_PL2_FP16_RMNet | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP16 | false | true | true | false | true |
+| 2020-4_PL2_FP16_SqueezeNet_TinyYolo_VGG | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP16 | false | true | true | false | false |
+| 2020-4_PL2_FP16_SqueezeNet_TinyYolo_VGG | Intel&reg; Vision Accelerator Design with an Intel&reg; Arria&reg; 10 FPGA (Speed Grade 2) | FP16 | false | false | false | false | false |
+| 2020-4_RC_FP11_AlexNet_GoogleNet_Generic | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP11 | true | true | true | false | false |
+| 2020-4_RC_FP11_RMNet | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP11 | false | true | true | false | true |
+| 2020-4_RC_FP11_Streaming_InternalUseOnly | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP11 | true | false | false | false | false |
+| 2020-4_RC_FP11_Streaming_Slicing_InternalUseOnly | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP11 | true | false | false | false | false |
+| 2020-4_RC_FP11_ELU | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP11 | false | true | true | false | true |
+| 2020-4_RC_FP11_SwishExcitation | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP11 | false | false | false | false | false |
+| 2020-4_RC_FP11_InceptionV1_ResNet_SqueezeNet_TinyYolo_YoloV3 | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP11 | false | true | true | false | false |
+| 2020-4_RC_FP11_MobileNet_Clamp | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP11 | false | true | true | true | false |
+| 2020-4_RC_FP16_AlexNet_GoogleNet_Generic | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP16 | true | true | true | false | false |
+| 2020-4_RC_FP16_InceptionV1_SqueezeNet_TinyYolo_VGG | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP16 | false | true | true | false | false |
+| 2020-4_RC_FP16_RMNet | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP16 | false | true | true | false | true |
+| 2020-4_RC_FP16_SwishExcitation | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP16 | false | false | false | false | false |
+| 2020-4_RC_FP16_MobileNet_Clamp | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP16 | false | true | true | true | false |
+| 2020-4_RC_FP16_ResNet_YoloV3 | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP16 | false | true | true | false | false |
+| 2020-4_RC_FP16_InceptionV1_SqueezeNet_YoloV3 | Intel&reg; Programmable Acceleration Card with Intel&reg; Arria&reg; 10 GX FPGA | FP16 | false | true | true | false | false |
+
+## Set Environment for Running the FPGA Plugin
+
+To make the FPGA plugin run directly or through the heterogeneous plugin, set up the environment:
+1. Set up environment to access Intel&reg; FPGA RTE for OpenCL:
+```
+source /opt/altera/aocl-pro-rte/aclrte-linux64/init_opencl.sh
+```
+2. Set the following environment variable and program the board with a DLA bitstream. Programming of the board is not supported during runtime and must be done before running an application.
+
+  | Variable                           | Setting                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+  | :----------------------------------| :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+  | ACL_PCIE_USE_JTAG_PROGRAMMING      | Set this variable to a value of 1 to force FPGA reprogramming using JTAG                                                                                                                                                                                                                                                                                                                                                                      |
+
+## Analyzing Heterogeneous Execution
+
+Besides generation of .dot files, you can use the error listening mechanism:
+
+```cpp
+class FPGA_ErrorListener : public InferenceEngine::IErrorListener
+{
+public:
+    virtual void onError(const char *msg) noexcept override {
+        std::cout << msg;
+    }
+};
+...
+FPGA_ErrorListener err_listener;
+core.SetLogCallback(err_listener); // will be used for FPGA device as well
+```
+If during network loading some layers are decided to be executed on a fallback plugin, the following message is printed:
+
+```cpp
+Layer (Name: detection_out, Type: DetectionOutput) is not supported:
+	custom or unknown.
+	Has (3) sets of inputs, must be 1, or 2.
+	Input dimensions (2) should be 4.
+```
+
+## Multiple FPGA Devices Support
+
+The Inference Engine FPGA plugin provides an ability to load different networks on multiple FPGA devices. For example, to load two networks AlexNet and MobileNet v2 on two different FPGA devices, follow the steps below:
+
+1. Program each FGPA device with a corresponding bitstream:
+```bash
+aocl program acl0 2019R3_PV_PL1_FP16_AlexNet_GoogleNet_InceptionV1_SSD300_Generic.aocx
+```
+```bash
+aocl program acl1 2019R3_PV_PL1_FP16_MobileNet_Clamp.aocx
+```
+For more information about bitstream programming instructions, refer to [Installation Guide for Linux* with Support for FPGA](Supported_Devices.md)
+2. All FPGA devices are enumerated with unique ID starting from `0`. By default, all networks are loaded to the default
+device with ID `0`. If you want to load a network on a particular non-default device, specify the `KEY_DEVICE_ID`
+parameter for C++ and `DEVICE_ID` parameter for Python\*.
+The following code snippets demonstrates how to load the AlexNet network on the FPGA device with ID `0` and the
+MobileNet v2 network on the device with ID `1`:
+    * With C++:
+```cpp
+InferenceEngine::Core core;
+
+// Load AlexNet network on the first FPGA device programmed with bitstream supporting AlexNet
+auto alexnetNetwork = core.ReadNetwork("alexnet.xml");
+auto exeNetwork1 = core.LoadNetwork(alexnetNetwork, "FPGA.0");
+
+// Load MobileNet network on the second FPGA device programmed with MobileNet bitstream
+auto mobilenetNetwork = core.ReadNetwork("mobilenet_v2.xml");
+auto exeNetwork2 = core.LoadNetwork(mobilenetNetwork, "FPGA", { { KEY_DEVICE_ID, "1" } });
+```
+    * With Python:
+```python
+# Load AlexNet network on the first FPGA device programmed with bitstream supporting AlexNet
+net1 = IENetwork(model="alexnet.xml", weights="alexnet.bin")
+plugin.load(network=net1, config={"DEVICE_ID": "0"})
+
+# Load MobileNet network on the second FPGA device programmed with MobileNet bitstream
+net2 = IENetwork(model="mobilenet_v2.xml", weights="mobilenet_v2.bin")
+plugin.load(network=net2, config={"DEVICE_ID": "1"})
+```
+Note that you have to use asynchronous infer requests to utilize several FPGA devices, otherwise the execution on devices is performed sequentially.
+
+## Import and Export Network Flow
+
+Since the 2019 R4 release, FPGA and HETERO plugins support the export and import flow, which allows to export a compiled network from a plugin to a binary blob by running the command below:
+
+```bash
+$ ./compile_tool -m resnet.xml -DLA_ARCH_NAME 4x2x16x32_fp16_sb9408_fcd1024_actk4_poolk4_normk1_owk2_image300x300x8192_mbfr -d HETERO:FPGA,CPU
+Inference Engine: 
+	API version ............ 2.1
+	Build .................. 6db44e09a795cb277a63275ea1395bfcb88e46ac
+	Description ....... API
+Done
+```
+
+Once the command is executed, the binary blob named `resnet.blob` is created at the working directory. Refer to the [Compile tool](../../../inference-engine/tools/compile_tool/README.md) documentation for more details.
+
+A compiled binary blob can be later imported via `InferenceEngine::Core::Import`:
+
+```cpp
+InferenceEngine::Core core;
+std::ifstream strm("resnet.blob");
+auto execNetwork = core.Import(strm);
+```
+
+## How to Interpret Performance Counters
+
+As a result of collecting performance counters using <code>InferenceEngine::InferRequest::GetPerformanceCounts</code> you can find out performance data about execution on FPGA, pre-processing and post-processing data and data transferring from/to FPGA card.
+
+If network is sliced to two parts that are executed on CPU, you can find performance data about Intel&reg; MKL-DNN kernels, their types, and other useful information.
+
+## Limitations of the FPGA Support for CNN
+
+The Inference Engine FPGA plugin has limitations on network topologies, kernel parameters, and batch size.
+
+* Depending on the bitstream loaded on the target device, the FPGA performs calculations with precision rates ranging from FP11 to FP16. This might have accuracy implications. Use the [Accuracy Checker](@ref omz_tools_accuracy_checker_README) to verify the network accuracy on the validation data set.
+* Networks that have many CNN layers that are not supported on FPGA stayed in topologies between supported layers might lead to dividing of graph to many subgraphs that might lead to `CL_OUT_OF_HOST_MEMORY` error. These topologies are not FPGA friendly for this release.
+* When you use the heterogeneous plugin, the affinity and distribution of nodes by devices depends on the FPGA bitstream that you use. Some layers might not be supported by a bitstream or parameters of the layer are not supported by the bitstream.
+
+## See Also
+* [Supported Devices](Supported_Devices.md)

docs/IE_DG/supported_plugins/GNA.md

@@ -2,98 +2,95 @@
 
 ## Introducing the GNA Plugin
 
-Intel® Gaussian & Neural Accelerator is a low-power neural coprocessor for continuous inference at the edge.
+Intel® Gaussian & Neural Accelerator is a low-power neural coprocessor for continuous inference at the edge.
 
-Intel® GNA is not intended to replace classic inference devices such as
-CPU, graphics processing unit (GPU), or vision processing unit (VPU). It is designed for offloading 
+Intel® GNA is not intended to replace classic inference devices such as
+CPU, graphics processing unit (GPU), or vision processing unit (VPU) . It is designed for offloading 
 continuous inference workloads including but not limited to noise reduction or speech recognition 
 to save power and free CPU resources.
 
-The GNA plugin provides a way to run inference on Intel® GNA, as well as in the software execution mode on CPU.
+The GNA plugin provides a way to run inference on Intel® GNA, as well as in the software execution mode on CPU.
 
-## Devices with Intel® GNA
+## Devices with Intel® GNA
 
-Devices with Intel® GNA support:
+Devices with Intel® GNA support:
 
-* [Intel® Speech Enabling Developer Kit](https://www.intel.com/content/www/us/en/support/articles/000026156/boards-and-kits/smart-home.html)
+* [Intel® Speech Enabling Developer Kit](https://www.intel.com/content/www/us/en/support/articles/000026156/boards-and-kits/smart-home.html)
 
-* [Amazon Alexa\* Premium Far-Field Developer Kit](https://developer.amazon.com/en-US/alexa/alexa-voice-service/dev-kits/amazon-premium-voice)
+* [Amazon Alexa* Premium Far-Field Developer Kit](https://developer.amazon.com/en-US/alexa/alexa-voice-service/dev-kits/amazon-premium-voice)
 
-* [Intel® Pentium® Silver Processors N5xxx, J5xxx and Intel® Celeron® Processors N4xxx, J4xxx](https://ark.intel.com/content/www/us/en/ark/products/codename/83915/gemini-lake.html):
-	- 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
+* [Gemini Lake](https://ark.intel.com/content/www/us/en/ark/products/codename/83915/gemini-lake.html):
+	- 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™ Processors (formerly codenamed Cannon Lake)](https://ark.intel.com/content/www/us/en/ark/products/136863/intel-core-i3-8121u-processor-4m-cache-up-to-3-20-ghz.html):
-Intel® Core™ i3-8121U Processor
+* [Cannon Lake](https://ark.intel.com/content/www/us/en/ark/products/136863/intel-core-i3-8121u-processor-4m-cache-up-to-3-20-ghz.html):
+Intel® Core™ i3-8121U Processor
 
-* [10th Generation Intel® Core™ Processors (formerly codenamed Ice Lake)](https://ark.intel.com/content/www/us/en/ark/products/codename/74979/ice-lake.html):
-	- 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
+* [Ice Lake](https://ark.intel.com/content/www/us/en/ark/products/codename/74979/ice-lake.html):
+	- 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
 
-* All [11th Generation Intel® Core™ Processors (formerly codenamed Tiger Lake)](https://ark.intel.com/content/www/us/en/ark/products/codename/88759/tiger-lake.html).
-
-> **NOTE**: On platforms where Intel® GNA is not enabled in the BIOS, the driver cannot be installed, so the GNA plugin uses the software emulation mode only.
+> **NOTE**: On platforms where Intel® GNA is not enabled in the BIOS, the driver cannot be installed, so the GNA plugin uses the software emulation mode only.
 
 ## Drivers and Dependencies
 
-Intel® GNA hardware requires a driver to be installed on the system.
+Intel® GNA hardware requires a driver to be installed on the system.
 
 * Linux\* OS:
-[Download Intel® GNA driver for Ubuntu Linux 18.04.3 LTS (with HWE Kernel version 5.0+)](https://download.01.org/opencv/drivers/gna/)
+[Download Intel® GNA driver for Ubuntu Linux 18.04.3 LTS (with HWE Kernel version 5.0+)](https://download.01.org/opencv/drivers/gna/)
 
 * Windows\* OS:
-Intel® GNA driver for Windows is available through Windows Update\*
+Intel® GNA driver for Windows is available through Windows Update\*
 
 ## Models and Layers Limitations
 
-Because of specifics of hardware architecture, Intel® GNA supports a limited set of layers, their kinds and combinations.
-For example, you should not expect the GNA Plugin to be able to run computer vision models, except those specifically adapted 
-for the GNA Plugin, because the plugin does not fully support 2D convolutions.
-
-For the list of supported layers, see the **GNA** column of the **Supported Layers** section in [Supported Devices](Supported_Devices.md).
+Because of specifics of hardware architecture, Intel® GNA supports a limited set of layers, their kinds and combinations.
+For example, you should not expect the GNA Plugin to be able to run computer vision models, except those specifically adapted for the GNA Plugin, because the plugin does not fully support
+2D convolutions.
 
+The list of supported layers can be found
+[here](Supported_Devices.md) (see the GNA column of Supported Layers section).
 Limitations include:
 
-- Only 1D convolutions are natively supported in the models converted from:
-	- [Kaldi](../../MO_DG/prepare_model/convert_model/Convert_Model_From_Kaldi.md) framework
-	- [TensorFlow](../../MO_DG/prepare_model/convert_model/Convert_Model_From_TensorFlow.md) framework. For TensorFlow models, use the `--disable_nhwc_to_nchw` option when running the Model Optimizer.
-- The number of output channels for convolutions must be a multiple of 4.
-- Permute layer support is limited to the cases where no data reordering is needed or when reordering is happening for two dimensions, at least one of which is not greater than 8.
+- Only 1D convolutions (in the models converted from [Kaldi](../../MO_DG/prepare_model/convert_model/Convert_Model_From_Kaldi.md) framework) are natively supported
+- The number of output channels for convolutions must be a multiple of 4
+- Permute layer support is limited to the cases where no data reordering is needed, or when reordering is happening for 2 dimensions, at least one of which is not greater than 8
+- Power layer only supports the power parameter equal to 1
 
 #### Experimental Support for 2D Convolutions
 
-The Intel® GNA hardware natively supports only 1D convolution.
+The Intel® GNA hardware natively supports only 1D convolution.
 
-However, 2D convolutions can be mapped to 1D when a convolution kernel moves in a single direction. GNA Plugin performs such a transformation for Kaldi `nnet1` convolution. From this perspective, the Intel® GNA hardware convolution operation accepts an `NHWC` input and produces an `NHWC` output. Because OpenVINO™ only supports the `NCHW` layout, you may need to insert `Permute` layers before or after convolutions.
+However, 2D convolutions can be mapped to 1D when a convolution kernel moves in a single direction. Such a transformation is performed by the GNA Plugin for Kaldi `nnet1` convolution. From this perspective, the Intel® GNA hardware convolution operation accepts a `NHWC` input and produces `NHWC` output. Because OpenVINO™ only supports the `NCHW` layout, it may be necessary to insert `Permute` layers before or after convolutions.
 
-For example, the Kaldi model optimizer inserts such a permute after convolution for the [rm_cnn4a network](https://download.01.org/openvinotoolkit/models_contrib/speech/kaldi/rm_cnn4a_smbr/). This `Permute` layer is automatically removed by the GNA Plugin, because the Intel® GNA hardware convolution layer already produces the required `NHWC` result.
+For example, the Kaldi model optimizer inserts such a permute after convolution for the [rm_cnn4a network](https://download.01.org/openvinotoolkit/models_contrib/speech/kaldi/rm_cnn4a_smbr/). This `Permute` layer is automatically removed by the GNA Plugin, because the Intel® GNA hardware convolution layer already produces the required `NHWC` result.
 
 ## Operation Precision
 
-Intel® GNA essentially operates in the low-precision mode, which represents a mix of 8-bit (`I8`), 16-bit (`I16`), and 32-bit (`I32`) integer computations. Outputs calculated using a reduced integer precision are different from the scores calculated using the floating point format, for example, `FP32` outputs calculated on CPU using the Inference Engine [CPU Plugin](CPU.md).
+Intel® GNA essentially operates in the low-precision mode, which represents a mix of 8-bit (`I8`), 16-bit (`I16`), and 32-bit (`I32`) integer computations, so compared to 32-bit floating point (`FP32`) results – for example, calculated on CPU using Inference Engine [CPU Plugin](CPU.md) – outputs calculated using reduced integer precision are different from the scores calculated using floating point.
 
-Unlike other plugins supporting low-precision execution, the GNA plugin calculates quantization factors at the model loading time, so you can run a model without calibration.
+Unlike other plugins supporting low-precision execution, the GNA plugin calculates quantization factors at the model loading time, so a model can run without calibration.
 
-## <a name="execution-modes">Execution Modes</a>
+## <a name="execution-models">Execution Modes</a>
 
 | Mode | Description |
 | :---------------------------------| :---------------------------------------------------------|
-| `GNA_AUTO` | Uses Intel® GNA if available, otherwise uses software execution mode on CPU. |
-| `GNA_HW` | Uses Intel® GNA if available, otherwise raises an error. |
-| `GNA_SW` | *Deprecated*. Executes the GNA-compiled graph on CPU performing calculations in the same precision as the Intel® GNA, but not in the bit-exact mode. |
-| `GNA_SW_EXACT` | Executes the GNA-compiled graph on CPU performing calculations in the same precision as the Intel® GNA in the bit-exact mode. |
+| `GNA_AUTO` | Uses Intel&reg; GNA if available, otherwise uses software execution mode on CPU. |
+| `GNA_HW` | Uses Intel&reg; GNA if available, otherwise raises an error. |
+| `GNA_SW` | *Deprecated*. Executes the GNA-compiled graph on CPU performing calculations in the same precision as the Intel&reg; GNA, but not in the bit-exact mode. |
+| `GNA_SW_EXACT` | Executes the GNA-compiled graph on CPU performing calculations in the same precision as the Intel&reg; GNA in the bit-exact mode. |
 | `GNA_SW_FP32` | Executes the GNA-compiled graph on CPU but substitutes parameters and calculations from low precision to floating point (`FP32`). |
 
 ## Supported Configuration Parameters
@@ -101,42 +98,42 @@ Unlike other plugins supporting low-precision execution, the GNA plugin calculat
 The plugin supports the configuration parameters listed below.
 The parameters are passed as `std::map<std::string, std::string>` on `InferenceEngine::Core::LoadNetwork` or `InferenceEngine::SetConfig`.
 
-You can change the `KEY_GNA_DEVICE_MODE` parameter at run time using `InferenceEngine::ExecutableNetwork::SetConfig`, which works for any value excluding `GNA_SW_FP32`. This enables you to switch the
+The parameter `KEY_GNA_DEVICE_MODE` can also be changed at run time using `InferenceEngine::ExecutableNetwork::SetConfig` (for any values excluding `GNA_SW_FP32`). This allows switching the
 execution between software emulation mode and hardware emulation mode after the model is loaded.
 
 The parameter names below correspond to their usage through API keys, such as `GNAConfigParams::KEY_GNA_DEVICE_MODE` or `PluginConfigParams::KEY_PERF_COUNT`.
-When specifying key values as raw strings, that is, when using Python API, omit the `KEY_` prefix.
+When specifying key values as raw strings (that is, when using Python API), omit the `KEY_` prefix.
 
 | Parameter Name                    | Parameter Values                                          | Default Value     | Description                                                              |
 | :---------------------------------| :---------------------------------------------------------| :-----------| :------------------------------------------------------------------------|
-| `KEY_GNA_COMPACT_MODE`            | `YES`/`NO`                                                | `YES`       | Enables I/O buffers reuse to save space. Makes debugging harder.                 |
-| `KEY_GNA_SCALE_FACTOR`            | `FP32` number                                             | 1.0         | Sets the scale factor to use for input quantization.                               |
-| `KEY_GNA_DEVICE_MODE`             | `GNA_AUTO`/`GNA_HW`/`GNA_SW_EXACT`/`GNA_SW_FP32` | `GNA_AUTO`  | One of the modes described in <a href="#execution-modes">Execution Modes</a> |
-| `KEY_GNA_FIRMWARE_MODEL_IMAGE`    | `std::string`                                             | `""`        | Sets the name for the embedded model binary dump file.                                 |
-| `KEY_GNA_PRECISION`               | `I16`/`I8`                                                | `I16`       | Sets the preferred integer weight resolution for quantization. |
-| `KEY_PERF_COUNT`                  | `YES`/`NO`                                                | `NO`        | Turns on performance counters reporting.                                   |
-| `KEY_GNA_LIB_N_THREADS`           | 1-127 integer number                                      | 1           | Sets the number of GNA accelerator library worker threads used for inference computation in software modes.
+| `KEY_GNA_COMPACT_MODE`            | `YES`/`NO`                                                | `YES`       | Reuse I/O buffers to save space (makes debugging harder)                 |
+| `KEY_GNA_SCALE_FACTOR`            | `FP32` number                                             | 1.0         | Scale factor to use for input quantization                               |
+| `KEY_GNA_DEVICE_MODE`             | `GNA_AUTO`/`GNA_HW`/`GNA_SW_EXACT`/`GNA_SW_FP32` | `GNA_AUTO`  | One of the modes described <a name="execution-models">Execution Models</a> |
+| `KEY_GNA_FIRMWARE_MODEL_IMAGE`    | `std::string`                                             | `""`        | Name for embedded model binary dump file                                 |
+| `KEY_GNA_PRECISION`               | `I16`/`I8`                                                | `I16`       | Hint to GNA plugin: preferred integer weight resolution for quantization |
+| `KEY_PERF_COUNT`                  | `YES`/`NO`                                                | `NO`        | Turn on performance counters reporting                                   |
+| `KEY_GNA_LIB_N_THREADS`           | 1-127 integer number                                      | 1           | Sets the number of GNA accelerator library worker threads used for inference computation in software modes
 
 ## How to Interpret Performance Counters
 
 As a result of collecting performance counters using `InferenceEngine::InferRequest::GetPerformanceCounts`, you can find various performance data about execution on GNA.
-Returned map stores a counter description as a key, and a counter value in the `realTime_uSec` field of the `InferenceEngineProfileInfo` structure. Current GNA implementation calculates counters for the whole utterance scoring and does not provide per-layer information. The API enables you to retrieve counter units in cycles, you can convert cycles to seconds as follows:
+Returned map stores a counter description as a key, counter value is stored in the `realTime_uSec` field of the `InferenceEngineProfileInfo` structure. Current GNA implementation calculates counters for the whole utterance scoring and does not provide per-layer information. API allows to retrieve counter units in cycles, but they can be converted to seconds as follows:
 
 ```
 seconds = cycles / frequency
 ```
 
-Refer to the table below to learn about the frequency of Intel® GNA inside a particular processor.
-Processor | Frequency of Intel® GNA
+Refer to the table below to learn about the frequency of Intel&reg; GNA inside a particular processor.
+Processor | Frequency of Intel&reg; GNA
 ---|---
-Intel® Ice Lake processors| 400MHz
-Intel® Core™ i3-8121U processor| 400MHz
-Intel® Gemini Lake  processors | 200MHz
+Intel&reg; Ice Lake processors| 400MHz
+Intel&reg; Core&trade; i3-8121U processor| 400MHz
+Intel&reg; Gemini Lake  processors | 200MHz
 
 Performance counters provided for the time being:
 
 * Scoring request performance results
-	* Number of total cycles spent on scoring in hardware including compute and memory stall cycles
+	* Number of total cycles spent on scoring in hardware (including compute and memory stall cycles)
 	* Number of stall cycles spent in hardware
 
 ## Multithreading Support in GNA Plugin
@@ -151,40 +148,16 @@ The GNA plugin supports the following configuration parameters for multithreadin
 
 ## Network Batch Size
 
-Intel® GNA plugin supports the processing of context-windowed speech frames in batches of 1-8 frames in one
+Intel&reg; GNA plugin supports the processing of context-windowed speech frames in batches of 1-8 frames in one
 input blob using `InferenceEngine::ICNNNetwork::setBatchSize`. Increasing batch size only improves efficiency of `Fully Connected` layers.
 
 > **NOTE**: For networks with `Convolutional`, `LSTM`, or `Memory` layers, the only supported batch size is 1.
 
 ## Compatibility with Heterogeneous Plugin
 
-Heterogeneous plugin was tested with the Intel® GNA as a primary device and CPU as a secondary device. To run inference of networks with layers unsupported by the GNA plugin, such as Softmax, use the Heterogeneous plugin with the `HETERO:GNA,CPU` configuration.
+Heterogeneous plugin was tested with the Intel&reg; GNA as a primary device and CPU as a secondary device. To run inference of networks with layers unsupported by the GNA plugin (for example, Softmax), use the Heterogeneous plugin with the `HETERO:GNA,CPU` configuration. For the list of supported networks, see the [Supported Frameworks](#supported-frameworks).
 
-> **NOTE:** Due to limitation of the Intel® GNA backend library, heterogenous support is limited to cases where in the resulted sliced graph, only one subgraph is scheduled to run on GNA\_HW or GNA\_SW devices.
-
-## Recovery from Interruption by High-Priority Windows Audio Processes\*
-
-GNA is designed for real-time workloads such as noise reduction.
-For such workloads, processing should be time constrained, otherwise extra delays may cause undesired effects such as
-*audio glitches*. To make sure that processing can satisfy real-time requirements, the GNA driver provides a Quality of Service
-(QoS) mechanism, which interrupts requests that might cause high-priority Windows audio processes to miss
-the schedule, thereby causing long running GNA tasks to terminate early.
-
-Applications should be prepared for this situation.
-If an inference in the `GNA_HW` mode cannot be executed because of such an interruption, then `InferRequest::Wait()` returns status code
-`StatusCode::INFER_NOT_STARTED`. In future releases, it will be changed to a more meaningful status code.
-
-Any application working with GNA must properly react to this code.
-One of the strategies to adapt an application:
-
-1. Immediately switch to the GNA_SW emulation mode:
-```cpp
-std::map<std::string, Parameter> newConfig;
-newConfig[GNAConfigParams::KEY_GNA_DEVICE_MODE] = Parameter("GNA_SW_EXACT");
-executableNet.SetConfig(newConfig);
-
-```
-2. Resubmit and switch back to GNA_HW expecting that the competing application has finished.
+> **NOTE:** Due to limitation of the Intel&reg; GNA backend library, heterogenous support is limited to cases where in the resulted sliced graph, only one subgraph is scheduled to run on GNA\_HW or GNA\_SW devices.
 
 ## See Also
 

docs/IE_DG/supported_plugins/GPU_RemoteBlob_API.md

@@ -102,15 +102,124 @@ Refer to the sections below to see pseudo-code of usage examples.
 
 This example uses the OpenCL context obtained from an executable network object.
 
-@snippet snippets/GPU_RemoteBlob_API0.cpp part0
+```cpp
+#define CL_HPP_MINIMUM_OPENCL_VERSION 120
+#define CL_HPP_TARGET_OPENCL_VERSION 120
+
+#include <CL/cl2.hpp>
+#include <gpu/gpu_context_api_ocl.hpp>
+
+...
+
+// initialize the plugin and load the network 
+InferenceEngine::Core ie;
+auto exec_net = ie.LoadNetwork(net, "GPU", config);
+
+// obtain the RemoteContext pointer from the executable network object
+auto cldnn_context = exec_net.GetContext();
+// obtain the OpenCL context handle from the RemoteContext,
+// get device info and create a queue
+cl::Context ctx = std::dynamic_pointer_cast<ClContext>(cldnn_context);
+_device = cl::Device(_context.getInfo<CL_CONTEXT_DEVICES>()[0].get(), true);
+cl::CommandQueue _queue;
+cl_command_queue_properties props = CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE;
+_queue = cl::CommandQueue(_context, _device, props);
+
+// create the OpenCL buffer within the obtained context
+cl::Buffer shared_buffer(ctx, CL_MEM_READ_WRITE, image_size * num_channels, NULL, &err);
+// wrap the buffer into RemoteBlob
+auto shared_blob = gpu::make_shared_blob(input_info->getTensorDesc(), cldnn_context, shared_buffer);
+
+...
+// execute user kernel
+cl::Kernel kernel(program, kernelName.c_str());
+kernel.setArg(0, shared_buffer);
+queue.enqueueNDRangeKernel(kernel,
+							 cl::NDRange(0),
+							 cl::NDRange(image_size),
+							 cl::NDRange(1),
+							 0, // wait events *
+							 &profileEvent);
+queue.finish();
+...
+
+// pass results to the inference
+inf_req_shared.SetBlob(input_name, shared_blob);
+inf_req_shared.Infer();
+
+```
 
 ### Running GPU Plugin Inference within User-Supplied Shared Context
 
-@snippet snippets/GPU_RemoteBlob_API1.cpp part1
+```cpp
+#define CL_HPP_MINIMUM_OPENCL_VERSION 120
+#define CL_HPP_TARGET_OPENCL_VERSION 120
 
+#include <CL/cl2.hpp>
+#include <gpu/gpu_context_api_ocl.hpp>
+
+...
+
+cl::Context ctx = get_my_OpenCL_context();
+
+// share the context with GPU plugin and compile ExecutableNetwork
+auto remote_context = gpu::make_shared_context(ie, "GPU", ocl_instance->_context.get());
+auto exec_net_shared = ie.LoadNetwork(net, remote_context);
+auto inf_req_shared = exec_net_shared.CreateInferRequest();
+
+...
+// do OpenCL processing stuff
+...
+
+// run the inference
+inf_req_shared.Infer();
+
+```
 ### Direct Consuming of the NV12 VAAPI Video Decoder Surface on Linux
 
-@snippet snippets/GPU_RemoteBlob_API2.cpp part2
+```cpp
+#include <gpu/gpu_context_api_va.hpp>
+#include <cldnn/cldnn_config.hpp>
+
+...
+
+// initialize the objects
+CNNNetwork network = ie.ReadNetwork(xmlFileName, binFileName);
+
+...
+
+auto inputInfoItem = *inputInfo.begin();
+inputInfoItem.second->setPrecision(Precision::U8);
+inputInfoItem.second->setLayout(Layout::NCHW);
+inputInfoItem.second->getPreProcess().setColorFormat(ColorFormat::NV12);
+
+VADisplay disp = get_VA_Device();
+// create the shared context object
+auto shared_va_context = gpu::make_shared_context(ie, "GPU", disp);
+// compile network within a shared context
+ExecutableNetwork executable_network = ie.LoadNetwork(network,
+													  shared_va_context,
+													  { { CLDNNConfigParams::KEY_CLDNN_NV12_TWO_INPUTS,
+													      PluginConfigParams::YES } });
+
+// decode/inference loop
+for (int i = 0; i < nframes; i++) {
+	...
+	// execute decoding and obtain decoded surface handle
+	decoder.DecodeFrame();
+	VASurfaceID va_surface = decoder.get_VA_output_surface();
+	...
+	//wrap decoder output into RemoteBlobs and set it as inference input
+	auto nv12_blob = gpu::make_shared_blob_nv12(ieInHeight,
+												ieInWidth,
+												shared_va_context,
+												va_surface
+												);
+	inferRequests[currentFrame].SetBlob(input_name, nv12_blob);
+	inferRequests[currentFrame].StartAsync();
+	inferRequests[prevFrame].Wait(InferenceEngine::IInferRequest::WaitMode::RESULT_READY);
+}
+```
 
 ## See Also
 

docs/IE_DG/supported_plugins/HDDL.md

@@ -30,7 +30,7 @@ In addition to common parameters for Myriad plugin and HDDL plugin, HDDL plugin
 | KEY_VPU_HDDL_STREAM_ID                | string           | empty string | Allows to execute inference on a specified device.                              |
 | KEY_VPU_HDDL_DEVICE_TAG               | string           | empty string | Allows to allocate/deallocate networks on specified devices.                    |
 | KEY_VPU_HDDL_BIND_DEVICE              | YES/NO           | NO           | Whether the network should bind to a device. Refer to vpu_plugin_config.hpp.    |
-| KEY_VPU_HDDL_RUNTIME_PRIORITY         | signed int       | 0            | Specify the runtime priority of a device among all devices that running a same network Refer to vpu_plugin_config.hpp. |
+| KEY_VPU_HDDL_RUNTIME_PRIORITY         | singed int       | 0            | Specify the runtime priority of a device among all devices that running a same network Refer to vpu_plugin_config.hpp. |
 
 ## See Also
 

docs/IE_DG/supported_plugins/HETERO.md

@@ -9,13 +9,12 @@ Purposes to execute networks in heterogeneous mode
 * To utilize all available hardware more efficiently during one inference
 
 The execution through heterogeneous plugin can be divided to two independent steps:
-* Setting of affinity to layers
+* Setting of affinity to layers (binding them to devices in <code>InferenceEngine::ICNNNetwork</code>)
 * Loading a network to the Heterogeneous plugin, splitting the network to parts, and executing them through the plugin
 
 These steps are decoupled. The setting of affinity can be done automatically using fallback policy or in manual mode.
 
 The fallback automatic policy means greedy behavior and assigns all layers which can be executed on certain device on that device follow priorities.
-Automatic policy does not take into account such plugin peculiarities as inability to infer some layers without other special layers placed before of after that layers. It is plugin responsibility to solve such cases. If device plugin does not support subgraph topology constructed by Hetero plugin affinity should be set manually.
 
 Some of the topologies are not friendly to heterogeneous execution on some devices or cannot be executed in such mode at all.
 Example of such networks might be networks having activation layers which are not supported on primary device.
@@ -26,21 +25,38 @@ In this case you can define heaviest part manually and set affinity thus way to
 ## Annotation of Layers per Device and Default Fallback Policy
 Default fallback policy decides which layer goes to which device automatically according to the support in dedicated plugins (FPGA, GPU, CPU, MYRIAD).
 
-Another way to annotate a network is to set affinity manually using <code>ngraph::Node::get_rt_info</code> with key `"affinity"`:
-
-@snippet snippets/HETERO0.cpp part0
+Another way to annotate a network is setting affinity manually using <code>CNNLayer::affinity</code> field. This field accepts string values of devices like "CPU" or "FPGA".
 
 The fallback policy does not work if even one layer has an initialized affinity. The sequence should be calling of automating affinity settings and then fix manually.
+```cpp
+InferenceEngine::Core core
+auto network = core.ReadNetwork("Model.xml");
 
-> **NOTE**: If you set affinity manually, be careful at the current moment Inference Engine plugins don't support constant (`Constant`->`Result`) and empty (`Parameter`->`Result`) networks. Please avoid such subgraphs when you set affinity manually.
+// This example demonstrates how to perform default affinity initialization and then
+// correct affinity manually for some layers
+const std::string device = "HETERO:FPGA,CPU";
 
-@snippet snippets/HETERO1.cpp part1
+// QueryNetworkResult object contains map layer -> device
+InferenceEngine::QueryNetworkResult res = core.QueryNetwork(network, device, { });
+
+// update default affinities
+res.supportedLayersMap["layerName"] = "CPU";
+
+// set affinities to network
+for (auto && layer : res.supportedLayersMap) {
+	network.getLayerByName(layer->first)->affinity = layer->second;
+}
+
+// load network with affinities set before
+auto executable_network = core.LoadNetwork(network, device);
+```
 
 If you rely on the default affinity distribution, you can avoid calling <code>InferenceEngine::Core::QueryNetwork</code> and just call <code>InferenceEngine::Core::LoadNetwork</code> instead:
-
-@snippet snippets/HETERO2.cpp part2
-
-> **NOTE**: `InferenceEngine::Core::QueryNetwork` does not depend on affinities set by a user, but queries for layer support based on device capabilities.
+```cpp
+InferenceEngine::Core core
+auto network = core.ReadNetwork("Model.xml");
+auto executable_network = core.LoadNetwork(network, "HETERO:FPGA,CPU");
+```
 
 
 ## Details of Splitting Network and Execution
@@ -54,7 +70,9 @@ Precision for inference in heterogeneous plugin is defined by
 
 Examples:
 * If you want to execute GPU with CPU fallback with FP16 on GPU, you need to use only FP16 IR.
-* If you want to execute on FPGA with CPU fallback, you can use any precision for IR. The execution on FPGA is defined by bitstream, the execution on CPU happens in FP32.
+Weight are converted from FP16 to FP32 automatically for execution on CPU by heterogeneous plugin automatically.
+* If you want to execute on FPGA with CPU fallback, you can use any precision for IR. The execution on FPGA is defined by bitstream,
+the execution on CPU happens in FP32.
 
 Samples can be used with the following command:
 
@@ -74,7 +92,16 @@ Heterogeneous plugin can generate two files:
 * `hetero_affinity_<network name>.dot` - annotation of affinities per layer. This file is written to the disk only if default fallback policy was executed
 * `hetero_subgraphs_<network name>.dot` - annotation of affinities per graph. This file is written to the disk during execution of <code>ICNNNetwork::LoadNetwork()</code> for heterogeneous plugin
 
-@snippet snippets/HETERO3.cpp part3
+```cpp
+#include "ie_plugin_config.hpp"
+#include "hetero/hetero_plugin_config.hpp"
+using namespace InferenceEngine::PluginConfigParams;
+using namespace InferenceEngine::HeteroConfigParams;
+
+...
+InferenceEngine::Core core;
+core.SetConfig({ { KEY_HETERO_DUMP_GRAPH_DOT, YES } }, "HETERO");
+```
 
 You can use GraphViz* utility or converters to `.png` formats. On Ubuntu* operating system, you can use the following utilities:
 * `sudo apt-get install xdot`

docs/IE_DG/supported_plugins/MULTI.md

@@ -31,13 +31,33 @@ The only configuration option for the multi-device is prioritized list of device
 You can use name of the configuration directly as a string, or use MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES from the multi/multi_device_config.hpp that defines the same string.
  
 Basically, there are three ways to specify the devices to be use by the "MULTI":
+```cpp
+    Core ie; 
+    //NEW IE-CENTRIC API, the "MULTI" plugin is (globally) pre-configured with the explicit option:
+    ie.SetConfig({{"MULTI_DEVICE_PRIORITIES", "HDDL,GPU"}}, "MULTI");
+    ExecutableNetwork exec0 = ie.LoadNetwork(network, "MULTI", {});
 
-@snippet snippets/MULTI0.cpp part0
-
+    //NEW IE-CENTRIC API, configuration of the "MULTI" is part of the network configuration (and hence specific to the network):
+    ExecutableNetwork exec1 = ie.LoadNetwork(network, "MULTI", {{"MULTI_DEVICE_PRIORITIES", "HDDL,GPU"}});
+    //NEW IE-CENTRIC API, same as previous, but configuration of the "MULTI" is part of the name (so config is empty), also network-specific:
+    ExecutableNetwork exec2 = ie.LoadNetwork(network, "MULTI:HDDL,GPU", {});
+```
 Notice that the priorities of the devices can be changed in real-time for the executable network:
-
-@snippet snippets/MULTI1.cpp part1
-
+```cpp
+    Core ie; 
+    ExecutableNetwork exec = ie.LoadNetwork(network, "MULTI:HDDL,GPU", {});
+    //...
+    exec.SetConfig({{"MULTI_DEVICE_PRIORITIES", "GPU,HDDL"}});
+    // you can even exclude some device
+    exec.SetConfig({{"MULTI_DEVICE_PRIORITIES", "GPU"}});
+    //...
+    // and then return it back
+    exec.SetConfig({{"MULTI_DEVICE_PRIORITIES", "GPU,HDDL"}});
+    //but you cannot add new devices on the fly, the next line will trigger the following exception: 
+    //[ ERROR ] [NOT_FOUND] You can only change device priorities but not add new devices with the Network's SetConfig(MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES.
+    //CPU device was not in the original device list!
+    exec.SetConfig({{"MULTI_DEVICE_PRIORITIES", "CPU,GPU,HDDL"}});
+```
 Finally, there is a way to specify number of requests that the multi-device will internally keep for each device.
 Say if your original app was running 4 cameras with 4 inference requests now you would probably want to share these 4 requests between 2 devices used in the MULTI. The easiest way is to specify a number of requests for each device using parentheses: "MULTI:CPU(2),GPU(2)" and use the same 4 requests in your app. However, such an explicit configuration is not performance portable and hence not recommended. Instead, the better way is to configure the individual devices and query the resulting number of requests to be used in the application level (see [Configuring the Individual Devices and Creating the Multi-Device On Top](#configuring-the-individual-devices-and-creating-the-multi-device-on-top)).
 
@@ -54,9 +74,16 @@ Available devices:
 	Device: HDDL
 ```
 Simple programmatic way to enumerate the devices and use with the multi-device is as follows:
-
-@snippet snippets/MULTI2.cpp part2
-
+```cpp
+        Core ie;
+        std::string allDevices = "MULTI:";
+        std::vector<std::string> availableDevices = ie.GetAvailableDevices();
+        for (auto && device : availableDevices) {
+            allDevices += device;
+            allDevices += ((device == availableDevices[availableDevices.size()-1]) ? "" : ",");
+        }
+        ExecutableNetwork exeNetwork = ie.LoadNetwork(cnnNetwork, allDevices, {});
+```
 Beyond trivial "CPU", "GPU", "HDDL" and so on, when multiple instances of a device are available the names are more qualified.
 For example this is how two Intel® Movidius™ Myriad™ X sticks are listed with the hello_query_sample:
 ```
@@ -67,15 +94,33 @@ For example this is how two Intel® Movidius™ Myriad™ X sticks are listed wi
 ```
 So the explicit configuration to use both would be "MULTI:MYRIAD.1.2-ma2480,MYRIAD.1.4-ma2480".
 Accordingly, the code that loops over all available devices of "MYRIAD" type only is below:
-
-@snippet snippets/MULTI3.cpp part3
+```cpp
+       Core ie;
+        std::string allDevices = "MULTI:";
+        std::vector<std::string> myriadDevices = ie->GetMetric("MYRIAD", METRIC_KEY(myriadDevices)));
+        for (int i = 0; i < myriadDevices.size(); ++i) {
+            allDevices += std::string("MYRIAD.")
+                                  + myriadDevices[i]
+                                  + std::string(i < (myriadDevices.size() -1) ? "," : "");
+        }
+        ExecutableNetwork exeNetwork = ie.LoadNetwork(cnnNetwork, allDevices, {});
+```
 
 
 ## Configuring the Individual Devices and Creating the Multi-Device On Top
 As discussed in the first section, you shall configure each individual device as usual and then just create the "MULTI" device on top:
-
-@snippet snippets/MULTI4.cpp part4
-
+```cpp
+#include <multi/multi_device_config.hpp>
+// configure the HDDL device first
+Core ie; 
+ie.SetConfig(hddl_config, "HDDL"); 
+// configure the GPU device
+ie.SetConfig(gpu_config, "GPU"); 
+// load the network to the multi-device, while specifying the configuration (devices along with priorities):
+ExecutableNetwork exeNetwork = ie.LoadNetwork(cnnNetwork, "MULTI", {{MultiDeviceConfigParams::KEY_MULTI_DEVICE_PRIORITIES, "HDDL,GPU"}});
+// new metric allows to query the optimal number of requests:
+uint32_t nireq = exeNetwork.GetMetric(METRIC_KEY(OPTIMAL_NUMBER_OF_INFER_REQUESTS)).as<unsigned int>();
+```
 Alternatively, you can combine all the individual device settings into single config and load that, allowing the multi-device plugin to parse and apply that to the right devices. See code example in the next section.
 
 Notice that while the performance of accelerators combines really well with multi-device, the CPU+GPU execution poses some performance caveats, as these devices share the power, bandwidth and other resources. For example it is recommended to enable the GPU throttling hint (which save another CPU thread for the CPU inference).
@@ -83,8 +128,12 @@ See section of the [Using the multi-device with OpenVINO samples and benchmarkin
 
 ## Querying the Optimal Number of Inference Requests
 Notice that until R2 you had to calculate number of requests in your application for any device, e.g. you had to know that Intel® Vision Accelerator Design with Intel® Movidius™ VPUs required at least 32 inference requests to perform well. Now you can use the new GetMetric API to query the optimal number of requests. Similarly, when using the multi-device you don't need to sum over included devices yourself, you can query metric directly:
-
-@snippet snippets/MULTI5.cpp part5
+```cpp
+// 'device_name' can be "MULTI:HDDL,GPU" to configure the multi-device to use HDDL and GPU
+ExecutableNetwork exeNetwork = ie.LoadNetwork(cnnNetwork, device_name, full_config);
+// new metric allows to query the optimal number of requests:
+uint32_t nireq = exeNetwork.GetMetric(METRIC_KEY(OPTIMAL_NUMBER_OF_INFER_REQUESTS)).as<unsigned int>();
+```
 
 ## Using the Multi-Device with OpenVINO Samples and Benchmarking the Performance
 Notice that every OpenVINO sample that supports "-d" (which stays for "device") command-line option transparently accepts the multi-device.

docs/IE_DG/supported_plugins/MYRIAD.md

@@ -2,16 +2,15 @@
 
 ## Introducing MYRIAD Plugin
 
-The Inference Engine MYRIAD plugin is developed for inference of neural networks on Intel® Neural Compute Stick 2.
+The Inference Engine MYRIAD plugin is developed for inference of neural networks on Intel® Movidius™ Neural Compute Stick and Intel® Neural Compute Stick 2.
 
 ## Installation on Linux* OS
 
-For installation instructions, refer to the [Installation Guide for Linux*](../../install_guides/installing-openvino-linux.md).
-
+For installation instructions, refer to the [Installation Guide for Linux*](../../../inference-engine/samples/benchmark_app/README.md).
 
 ## Installation on Windows* OS
 
-For installation instructions, refer to the [Installation Guide for Windows*](../../install_guides/installing-openvino-windows.md).
+For installation instructions, refer to the [Installation Guide for Windows*](../../../inference-engine/samples/benchmark_app/README.md).
 
 ## Supported networks
 
@@ -23,10 +22,10 @@ The Inference Engine MYRIAD plugin supports the following networks:
 * GoogleNet (Inception) v1, v2, v4
 * VGG family (VGG16, VGG19)
 * SqueezeNet v1.0, v1.1
-* ResNet v1 family (18\*\*\*, 50, 101, 152)
+* ResNet v1 family (18\*\* \*\*\*, 50, 101, 152)
 * MobileNet (mobilenet-v1-1.0-224, mobilenet-v2)
 * Inception ResNet v2
-* DenseNet family (121,161,169,201)
+* DenseNet family\*\* (121,161,169,201)
 * SSD-300, SSD-512, SSD-MobileNet, SSD-GoogleNet, SSD-SqueezeNet
 
 **TensorFlow\***:
@@ -45,7 +44,7 @@ The Inference Engine MYRIAD plugin supports the following networks:
 
 **MXNet\***:
 * AlexNet and CaffeNet
-* DenseNet family (121,161,169,201)
+* DenseNet family\*\* (121,161,169,201)
 * SqueezeNet v1.1
 * MobileNet v1, v2
 * NiN
@@ -55,6 +54,8 @@ The Inference Engine MYRIAD plugin supports the following networks:
 * VGG family (VGG16, VGG19)
 * SSD-Inception-v3, SSD-MobileNet, SSD-ResNet-50, SSD-300
 
+\*\* Network is tested on Intel® Movidius™ Neural Compute Stick with BatchNormalization fusion optimization disabled during Model Optimizer import
+
 \*\*\* Network is tested on Intel® Neural Compute Stick 2 with BatchNormalization fusion optimization disabled during Model Optimizer import
 
 ## Supported Configuration Parameters
@@ -75,9 +76,9 @@ In addition to common parameters, the MYRIAD plugin accepts the following option
 ## Device allocation <a name="MYRIAD_DEVICE_ALLOC">&nbsp;</a>
 
 Each `IExecutableNetwork` instance tries to allocate new device on `InferenceEngine::Core::LoadNetwork`, but if all available devices are already allocated it will use the one with the minimal number of uploaded networks.
-The maximum number of networks single device can handle depends on device memory capacity and the size of the networks.
+The maximum number of networks single device can handle depends on device memory capacity and the size of the networks. 
 
-If `KEY_VPU_MYRIAD_FORCE_RESET` option is set to `YES` the plugin will reset all VPU devices in the system.
+If `KEY_VPU_MYRIAD_FORCE_RESET` option is set to `YES` the plugin will reset all VPU devices in the system. 
 
 Single device cannot be shared across multiple processes.
 

docs/IE_DG/supported_plugins/Supported_Devices.md

@@ -11,6 +11,7 @@ The Inference Engine provides unique capabilities to infer deep learning models
 |------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------|
 |[GPU plugin](CL_DNN.md)            |Intel® Processor Graphics, including Intel® HD Graphics and Intel® Iris® Graphics                                                            |
 |[CPU plugin](CPU.md)              |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) |
+|[FPGA plugin](FPGA.md) (available in the Intel® Distribution of OpenVINO™ toolkit)           |Intel® Vision Accelerator Design with an Intel® Arria 10 FPGA (Speed Grade 2), Intel® Programmable Acceleration Card with Intel® Arria® 10 GX FPGA |
 |[VPU plugins](VPU.md) (available in the Intel® Distribution of OpenVINO™ toolkit)            |Intel® Neural Compute Stick 2 powered by the Intel® Movidius™ Myriad™ X, Intel® Vision Accelerator Design with Intel® Movidius™ VPUs                                                                                           |
 |[GNA plugin](GNA.md) (available in the Intel® Distribution of OpenVINO™ toolkit)              |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|
 |[Multi-Device plugin](MULTI.md) |Multi-Device plugin enables simultaneous inference of the same network on several Intel® devices in parallel    |   
@@ -52,6 +53,7 @@ For example, the CHW value at index (c,h,w) is physically located at index (c\*H
 |:-------------|:----------------------:|:----------------------:|:----------------------:|
 |CPU plugin    |Supported and preferred |Supported               |Supported               |
 |GPU plugin    |Supported               |Supported and preferred |Supported\*             |
+|FPGA plugin   |Supported               |Supported               |Not supported           |
 |VPU plugins   |Not supported           |Supported               |Not supported           |
 |GNA plugin    |Supported               |Supported               |Not supported           |
 <br>\* - currently, only limited set of topologies might benefit from enabling I8 model on GPU<br>
@@ -64,6 +66,7 @@ the supported models formats depends on the actual underlying devices. _Generall
 |:-------------|:--------:|:-------------:|:-------------:|:-------------:|:------------:|:-------------:|
 |CPU plugin    |Supported |Not supported  |Supported      |Supported      |Not supported |Supported      |
 |GPU plugin    |Supported |Supported\*    |Supported\*    |Supported\*    |Not supported |Supported\*    |
+|FPGA plugin   |Supported |Supported\*    |Supported      |Supported      |Not supported |Supported      |
 |VPU plugins   |Supported |Supported      |Supported      |Not supported  |Not supported |Not supported  |
 |GNA plugin    |Supported |Not supported  |Supported      |Not supported  |Supported     |Supported      |
 
@@ -77,6 +80,7 @@ the supported input precision  depends on the actual underlying devices. _Genera
 |:-------------|:--------:|:------------:|
 |CPU plugin    |Supported |Not supported |
 |GPU plugin    |Supported |Supported     |
+|FPGA plugin   |Supported |Supported     |
 |VPU plugins   |Supported |Supported     |
 |GNA plugin    |Supported |Not supported |
 For [Multi-Device](MULTI.md) and [Heterogeneous](HETERO.md) execution
@@ -88,8 +92,9 @@ the supported output precision  depends on the actual underlying devices. _Gener
 |:-------------|:------------:|:------------:|:------------:|:------------:|
 |CPU plugin    |Supported     |Supported     |Supported     |Supported     |
 |GPU plugin    |Supported     |Supported     |Supported     |Supported     |
+|FPGA plugin   |Not supported |Supported     |Supported     |Not supported |
 |VPU plugins   |Not supported |Supported     |Supported     |Supported     |
-|GNA plugin    |Not supported |Supported     |Supported     |Supported     |
+|GNA plugin    |Not supported |Not supported |Not supported |Supported     |
 
 ### Supported Output Layout
 
@@ -104,152 +109,152 @@ For setting relevant configuration, refer to the
 ### Supported Layers
 The following layers are supported by the plugins and by [Shape Inference feature](../ShapeInference.md):
 
-| Layers                         | GPU           | CPU           | VPU           | GNA           | ShapeInfer    |
-|:-------------------------------|:-------------:|:-------------:|:-------------:|:-------------:|:-------------:|
-| Abs                            | Supported     | Supported\*\* | Supported     | Not Supported | Supported     |
-| Acos                           | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Acosh                          | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Activation-Clamp               | Supported     |Supported\*\*\*| Supported     | Supported     | Supported     |
-| Activation-ELU                 | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Activation-Exp                 | Supported     |Supported\*\*\*| Not Supported | Supported     | Supported     |
-| Activation-Leaky ReLU          | Supported     |Supported\*\*\*| Supported     | Supported     | Supported     |
-| Activation-Not                 | Supported     |Supported\*\*\*| Not Supported | Not Supported | Supported     |
-| Activation-PReLU               | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Activation-ReLU                | Supported     |Supported\*\*\*| Supported     | Supported     | Supported     |
-| Activation-ReLU6               | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Activation-Sigmoid/Logistic    | Supported     |Supported\*\*\*| Supported     | Supported     | Supported     |
-| Activation-TanH                | Supported     |Supported\*\*\*| Supported     | Supported     | Supported     |
-| ArgMax                         | Supported     | Supported\*\* | Supported     | Not Supported | Supported     |
-| Asin                           | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Asinh                          | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Atan                           | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Atanh                          | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| BatchNormalization             | Supported     | Supported     | Supported     | Not Supported | Supported     |
-| BinaryConvolution              | Supported     | Supported     | Not Supported | Not Supported | Supported     |
-| Broadcast                      | Supported     | Supported\*\* | Supported     | Not Supported | Supported     |
-| Ceil                           | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Concat                         | Supported     |Supported\*\*\*| Supported     | Supported     | Supported     |
-| Const                          | Supported     | Supported     | Supported     | Supported     | Not Supported |
-| Convolution-Dilated            | Supported     | Supported     | Supported     | Not Supported | Supported     |
-| Convolution-Dilated 3D         | Supported     | Supported     | Not Supported | Not Supported | Not Supported |
-| Convolution-Grouped            | Supported     | Supported     | Supported     | Not Supported | Supported     |
-| Convolution-Grouped 3D         | Supported     | Supported     | Not Supported | Not Supported | Not Supported |
-| Convolution-Ordinary           | Supported     | Supported     | Supported     | Supported\*   | Supported     |
-| Convolution-Ordinary 3D        | Supported     | Supported     | Not Supported | Not Supported | Not Supported |
-| Cos                            | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Cosh                           | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Crop                           | Supported     | Supported     | Supported     | Supported     | Supported     |
-| CTCGreedyDecoder               | Supported\*\* | Supported\*\* | Supported\*   | Not Supported | Supported     |
-| Deconvolution                  | Supported     | Supported     | Supported     | Not Supported | Supported     |
-| Deconvolution 3D               | Supported     | Supported     | Not Supported | Not Supported | Not Supported |
-| DeformableConvolution          | Supported     | Supported     | Not Supported | Not Supported | Supported     |
-| DepthToSpace                   | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| DetectionOutput                | Supported     | Supported\*\* | Supported\*   | Not Supported | Supported     |
-| Eltwise-And                    | Supported     |Supported\*\*\*| Not Supported | Not Supported | Supported     |
-| Eltwise-Add                    | Supported     |Supported\*\*\*| Not Supported | Not Supported | Supported     |
-| Eltwise-Div                    | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-Equal                  | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-FloorMod               | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-Greater                | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-GreaterEqual           | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-Less                   | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-LessEqual              | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-LogicalAnd             | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-LogicalOr              | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-LogicalXor             | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-Max                    | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-Min                    | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-Mul                    | Supported     |Supported\*\*\*| Supported     | Supported     | Supported     |
-| Eltwise-NotEqual               | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-Pow                    | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-Prod                   | Supported     |Supported\*\*\*| Supported     | Supported     | Supported     |
-| Eltwise-SquaredDiff            | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Eltwise-Sub                    | Supported     |Supported\*\*\*| Supported     | Supported     | Supported     |
-| Eltwise-Sum                    | Supported     |Supported\*\*\*| Supported     | Supported     | Supported     |
-| Erf                            | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Exp                            | Supported     | Supported     | Not Supported | Supported     | Supported     |
-| FakeQuantize                   | Not Supported | Supported     | Not Supported | Not Supported | Supported     |
-| Fill                           | Not Supported | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Flatten                        | Supported     | Supported     | Supported     | Not Supported | Supported     |
-| Floor                          | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| FullyConnected (Inner Product) | Supported     |Supported\*\*\*| Supported     | Supported     | Supported     |
-| Gather                         | Supported     | Supported\*\* | Supported     | Not Supported | Supported     |
-| GatherTree                     | Not Supported | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Gemm                           | Supported     | Supported     | Supported     | Not Supported | Supported     |
-| GRN                            | Supported\*\* | Supported\*\* | Supported     | Not Supported | Supported     |
-| HardSigmoid                    | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Interp                         | Supported\*\* | Supported\*\* | Supported     | Not Supported | Supported\*   |
-| Log                            | Supported     | Supported\*\* | Supported     | Supported     | Supported     |
-| LRN (Norm)                     | Supported     | Supported     | Supported     | Not Supported | Supported     |
-| LSTMCell                       | Supported     | Supported     | Supported     | Supported     | Not Supported |
-| GRUCell                        | Supported     | Supported     | Not Supported | Not Supported | Not Supported |
-| RNNCell                        | Supported     | Supported     | Not Supported | Not Supported | Not Supported |
-| LSTMSequence                   | Supported     | Supported     | Supported     | Not Supported | Not Supported |
-| GRUSequence                    | Supported     | Supported     | Not Supported | Not Supported | Not Supported |
-| RNNSequence                    | Supported     | Supported     | Not Supported | Not Supported | Not Supported |
-| LogSoftmax                     | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported |
-| Memory                         | Not Supported | Supported     | Not Supported | Supported     | Supported     |
-| MVN                            | Supported     | Supported\*\* | Supported\*   | Not Supported | Supported     |
-| Neg                            | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| NonMaxSuppression              | Not Supported | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Normalize                      | Supported     | Supported\*\* | Supported\*   | Not Supported | Supported     |
-| OneHot                         | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Pad                            | Supported     | Supported\*\* | Supported\*   | Not Supported | Supported     |
-| Permute                        | Supported     | Supported     | Supported     | Supported\*   | Supported     |
-| Pooling(AVG,MAX)               | Supported     | Supported     | Supported     | Supported     | Supported     |
-| Pooling(AVG,MAX) 3D            | Supported     | Supported     | Not Supported | Not Supported | Not Supported |
-| Power                          | Supported     | Supported\*\* | Supported     | Supported\*   | Supported     |
-| PowerFile                      | Not Supported | Supported\*\* | Not Supported | Not Supported | Not Supported |
-| PriorBox                       | Supported     | Supported\*\* | Supported     | Not Supported | Supported     |
-| PriorBoxClustered              | Supported\*\* | Supported\*\* | Supported     | Not Supported | Supported     |
-| Proposal                       | Supported     | Supported\*\* | Supported     | Not Supported | Supported     |
-| PSROIPooling                   | Supported     | Supported\*\* | Supported     | Not Supported | Supported     |
-| Range                          | Not Supported | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Reciprocal                     | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| ReduceAnd                      | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| ReduceL1                       | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| ReduceL2                       | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| ReduceLogSum                   | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| ReduceLogSumExp                | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| ReduceMax                      | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| ReduceMean                     | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| ReduceMin                      | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| ReduceOr                       | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| ReduceProd                     | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| ReduceSum                      | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| ReduceSumSquare                | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| RegionYolo                     | Supported     | Supported\*\* | Supported     | Not Supported | Supported     |
-| ReorgYolo                      | Supported     | Supported\*\* | Supported     | Not Supported | Supported     |
-| Resample                       | Supported     | Supported\*\* | Supported     | Not Supported | Supported     |
-| Reshape                        | Supported     |Supported\*\*\*| Supported     | Supported     | Supported\*   |
-| ReverseSequence                | Supported     | Supported\*\* | Supported     | Not Supported | Supported     |
-| RNN                            | Not Supported | Supported     | Supported     | Not Supported | Not Supported |
-| ROIPooling                     | Supported\*   | Supported     | Supported     | Not Supported | Supported     |
-| ScaleShift                     | Supported     |Supported\*\*\*| Supported\*   | Supported     | Supported     |
-| ScatterUpdate                  | Not Supported | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Select                         | Supported     | Supported     | Supported     | Not Supported | Supported     |
-| Selu                           | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| ShuffleChannels                | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Sign                           | Supported     | Supported\*\* | Supported     | Not Supported | Supported     |
-| Sin                            | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Sinh                           | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| SimplerNMS                     | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Slice                          | Supported     |Supported\*\*\*| Supported     | Supported     | Supported     |
-| SoftMax                        | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| Softplus                       | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Softsign                       | Supported     | Supported\*\* | Not Supported | Supported     | Supported     |
-| SpaceToDepth                   | Not Supported | Supported\*\* | Not Supported | Not Supported | Supported     |
-| SpatialTransformer             | Not Supported | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Split                          | Supported     |Supported\*\*\*| Supported     | Supported     | Supported     |
-| Squeeze                        | Supported     | Supported\*\* | Supported     | Supported     | Supported     |
-| StridedSlice                   | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Tan                            | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| TensorIterator                 | Not Supported | Supported     | Supported     | Supported     | Not Supported |
-| Tile                           | Supported\*\* |Supported\*\*\*| Supported     | Not Supported | Supported     |
-| TopK                           | Supported     | Supported\*\* | Not Supported | Not Supported | Supported     |
-| Unpooling                      | Supported     | Not Supported | Not Supported | Not Supported | Not Supported |
-| Unsqueeze                      | Supported     | Supported\*\* | Supported     | Supported     | Supported     |
-| Upsampling                     | Supported     | Not Supported | Not Supported | Not Supported | Not Supported |
+| Layers                         | GPU           | CPU           | VPU           | GNA           | FPGA            | ShapeInfer    |
+|:-------------------------------|:-------------:|:-------------:|:-------------:|:-------------:|:---------------:|:-------------:|
+| Abs                            | Supported     | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported     |
+| Acos                           | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Acosh                          | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Activation-Clamp               | Supported     |Supported\*\*\*| Supported     | Supported     | Supported       | Supported     |
+| Activation-ELU                 | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported       | Supported     |
+| Activation-Exp                 | Supported     |Supported\*\*\*| Not Supported | Supported     | Not Supported   | Supported     |
+| Activation-Leaky ReLU          | Supported     |Supported\*\*\*| Supported     | Supported     | Supported       | Supported     |
+| Activation-Not                 | Supported     |Supported\*\*\*| Not Supported | Not Supported | Not Supported   | Supported     |
+| Activation-PReLU               | Supported     |Supported\*\*\*| Supported     | Not Supported | Supported       | Supported     |
+| Activation-ReLU                | Supported     |Supported\*\*\*| Supported     | Supported     | Supported       | Supported     |
+| Activation-ReLU6               | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Activation-Sigmoid/Logistic    | Supported     |Supported\*\*\*| Supported     | Supported     | Not Supported   | Supported     |
+| Activation-TanH                | Supported     |Supported\*\*\*| Supported     | Supported     | Not Supported   | Supported     |
+| ArgMax                         | Supported     | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported     |
+| Asin                           | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Asinh                          | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Atan                           | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Atanh                          | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| BatchNormalization             | Supported     | Supported     | Supported     | Not Supported | Supported\*     | Supported     |
+| BinaryConvolution              | Supported     | Supported     | Not Supported | Not Supported | Not Supported   | Supported     |
+| Broadcast                      | Supported     | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported     |
+| Ceil                           | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Concat                         | Supported     |Supported\*\*\*| Supported     | Supported     | Supported       | Supported     |
+| Const                          | Supported     | Supported     | Supported     | Supported     | Not Supported   | Not Supported |
+| Convolution-Dilated            | Supported     | Supported     | Supported     | Not Supported | Supported       | Supported     |
+| Convolution-Dilated 3D         | Supported     | Supported     | Not Supported | Not Supported | Not Supported   | Not Supported |
+| Convolution-Grouped            | Supported     | Supported     | Supported     | Not Supported | Supported       | Supported     |
+| Convolution-Grouped 3D         | Supported     | Supported     | Not Supported | Not Supported | Not Supported   | Not Supported |
+| Convolution-Ordinary           | Supported     | Supported     | Supported     | Supported\*   | Supported       | Supported     |
+| Convolution-Ordinary 3D        | Supported     | Supported     | Not Supported | Not Supported | Not Supported   | Not Supported |
+| Cos                            | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Cosh                           | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Crop                           | Supported     | Supported     | Supported     | Supported     | Not Supported   | Supported     |
+| CTCGreedyDecoder               | Supported\*\* | Supported\*\* | Supported\*   | Not Supported | Not Supported   | Supported     |
+| Deconvolution                  | Supported     | Supported     | Supported     | Not Supported | Supported\*     | Supported     |
+| Deconvolution 3D               | Supported     | Supported     | Not Supported | Not Supported | Not Supported   | Not Supported |
+| DeformableConvolution          | Supported     | Supported     | Not Supported | Not Supported | Not Supported   | Supported     |
+| DepthToSpace                   | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| DetectionOutput                | Supported     | Supported\*\* | Supported\*   | Not Supported | Not Supported   | Supported     |
+| Eltwise-And                    | Supported     |Supported\*\*\*| Not Supported | Not Supported | Not Supported   | Supported     |
+| Eltwise-Add                    | Supported     |Supported\*\*\*| Not Supported | Not Supported | Supported       | Supported     |
+| Eltwise-Div                    | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-Equal                  | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-FloorMod               | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-Greater                | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-GreaterEqual           | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-Less                   | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-LessEqual              | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-LogicalAnd             | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-LogicalOr              | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-LogicalXor             | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-Max                    | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-Min                    | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-Mul                    | Supported     |Supported\*\*\*| Supported     | Supported     | Not Supported   | Supported     |
+| Eltwise-NotEqual               | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-Pow                    | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-Prod                   | Supported     |Supported\*\*\*| Supported     | Supported     | Not Supported   | Supported     |
+| Eltwise-SquaredDiff            | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Eltwise-Sub                    | Supported     |Supported\*\*\*| Supported     | Supported     | Supported       | Supported     |
+| Eltwise-Sum                    | Supported     |Supported\*\*\*| Supported     | Supported     | Supported       | Supported     |
+| Erf                            | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Exp                            | Supported     | Supported     | Not Supported | Supported     | Not Supported   | Supported     |
+| FakeQuantize                   | Not Supported | Supported     | Not Supported | Not Supported | Not Supported   | Supported     |
+| Fill                           | Not Supported | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Flatten                        | Supported     | Supported     | Supported     | Not Supported | Not Supported   | Supported     |
+| Floor                          | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| FullyConnected (Inner Product) | Supported     |Supported\*\*\*| Supported     | Supported     | Supported       | Supported     |
+| Gather                         | Supported     | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported     |
+| GatherTree                     | Not Supported | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Gemm                           | Supported     | Supported     | Supported     | Not Supported | Not Supported   | Supported     |
+| GRN                            | Supported\*\* | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported     |
+| HardSigmoid                    | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Interp                         | Supported\*\* | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported\*   |
+| Log                            | Supported     | Supported\*\* | Supported     | Supported     | Not Supported   | Supported     |
+| LRN (Norm)                     | Supported     | Supported     | Supported     | Not Supported | Supported       | Supported     |
+| LSTMCell                       | Supported     | Supported     | Supported     | Supported     | Not Supported   | Not Supported |
+| GRUCell                        | Supported     | Supported     | Not Supported | Not Supported | Not Supported   | Not Supported |
+| RNNCell                        | Supported     | Supported     | Not Supported | Not Supported | Not Supported   | Not Supported |
+| LSTMSequence                   | Supported     | Supported     | Supported     | Not Supported | Not Supported   | Not Supported |
+| GRUSequence                    | Supported     | Supported     | Not Supported | Not Supported | Not Supported   | Not Supported |
+| RNNSequence                    | Supported     | Supported     | Not Supported | Not Supported | Not Supported   | Not Supported |
+| LogSoftmax                     | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Not Supported |
+| Memory                         | Not Supported | Supported     | Not Supported | Supported     | Not Supported   | Supported     |
+| MVN                            | Supported     | Supported\*\* | Supported\*   | Not Supported | Not Supported   | Supported     |
+| Neg                            | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| NonMaxSuppression              | Not Supported | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Normalize                      | Supported     | Supported\*\* | Supported\*   | Not Supported | Not Supported   | Supported     |
+| OneHot                         | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Pad                            | Supported     | Supported\*\* | Supported\*   | Not Supported | Not Supported   | Supported     |
+| Permute                        | Supported     | Supported     | Supported     | Supported\*   | Not Supported   | Supported     |
+| Pooling(AVG,MAX)               | Supported     | Supported     | Supported     | Supported     | Supported       | Supported     |
+| Pooling(AVG,MAX) 3D            | Supported     | Supported     | Not Supported | Not Supported | Not Supported   | Not Supported |
+| Power                          | Supported     | Supported\*\* | Supported     | Supported\*   | Supported\*     | Supported     |
+| PowerFile                      | Not Supported | Supported\*\* | Not Supported | Not Supported | Not Supported   | Not Supported |
+| PriorBox                       | Supported     | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported     |
+| PriorBoxClustered              | Supported\*\* | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported     |
+| Proposal                       | Supported     | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported     |
+| PSROIPooling                   | Supported     | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported     |
+| Range                          | Not Supported | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Reciprocal                     | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| ReduceAnd                      | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| ReduceL1                       | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| ReduceL2                       | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| ReduceLogSum                   | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| ReduceLogSumExp                | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| ReduceMax                      | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| ReduceMean                     | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| ReduceMin                      | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| ReduceOr                       | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| ReduceProd                     | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| ReduceSum                      | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| ReduceSumSquare                | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| RegionYolo                     | Supported     | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported     |
+| ReorgYolo                      | Supported     | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported     |
+| Resample                       | Supported     | Supported\*\* | Supported     | Not Supported | Supported\*     | Supported     |
+| Reshape                        | Supported     |Supported\*\*\*| Supported     | Supported     | Not Supported   | Supported\*   |
+| ReverseSequence                | Supported     | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported     |
+| RNN                            | Not Supported | Supported     | Supported     | Not Supported | Not Supported   | Not Supported |
+| ROIPooling                     | Supported\*   | Supported     | Supported     | Not Supported | Not Supported   | Supported     |
+| ScaleShift                     | Supported     |Supported\*\*\*| Supported\*   | Supported     | Supported       | Supported     |
+| ScatterUpdate                  | Not Supported | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Select                         | Supported     | Supported     | Supported     | Not Supported | Not Supported   | Supported     |
+| Selu                           | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| ShuffleChannels                | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Sign                           | Supported     | Supported\*\* | Supported     | Not Supported | Not Supported   | Supported     |
+| Sin                            | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Sinh                           | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| SimplerNMS                     | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Slice                          | Supported     |Supported\*\*\*| Supported     | Supported     | Supported\*     | Supported     |
+| SoftMax                        | Supported     |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| Softplus                       | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Softsign                       | Supported     | Supported\*\* | Not Supported | Supported     | Not Supported   | Supported     |
+| SpaceToDepth                   | Not Supported | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| SpatialTransformer             | Not Supported | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Split                          | Supported     |Supported\*\*\*| Supported     | Supported     | Supported\*     | Supported     |
+| Squeeze                        | Supported     | Supported\*\* | Supported     | Supported     | Not Supported   | Supported     |
+| StridedSlice                   | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Tan                            | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| TensorIterator                 | Not Supported | Supported     | Supported     | Supported     | Not Supported   | Not Supported |
+| Tile                           | Supported\*\* |Supported\*\*\*| Supported     | Not Supported | Not Supported   | Supported     |
+| TopK                           | Supported     | Supported\*\* | Not Supported | Not Supported | Not Supported   | Supported     |
+| Unpooling                      | Supported     | Not Supported | Not Supported | Not Supported | Not Supported   | Not Supported |
+| Unsqueeze                      | Supported     | Supported\*\* | Supported     | Supported     | Not Supported   | Supported     |
+| Upsampling                     | Supported     | Not Supported | Not Supported | Not Supported | Not Supported   | Not Supported |
 
 \*- support is limited to the specific parameters. Refer to "Known Layers Limitation" section for the device [from the list of supported](Supported_Devices.md).