change repo name to openvino in readme files

Co-authored-by: modav <modav@microsoft.com>

.clang-format

@@ -0,0 +1,19 @@
+BasedOnStyle: Google
+IndentWidth: 4
+UseTab: Never
+---
+Language: Cpp
+Standard: Cpp11
+
+AccessModifierOffset: -4
+AllowAllArgumentsOnNextLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortLambdasOnASingleLine: Empty
+AlwaysBreakBeforeMultilineStrings: false
+ColumnLimit: 120
+DerivePointerAlignment: false
+FixNamespaceComments: true
+IndentCaseLabels: false
+SpaceBeforeCpp11BracedList: true
+SpaceBeforeCtorInitializerColon: false
+---

.gitmodules

@@ -2,7 +2,7 @@
 	path = inference-engine/thirdparty/ade
 	url = https://github.com/opencv/ade.git
 	ignore = dirty
-[submodule "inference-engine/thirdparty/ngraph"]
-	path = inference-engine/thirdparty/ngraph
+[submodule "ngraph"]
+	path = ngraph
 	url = https://github.com/NervanaSystems/ngraph.git
 	ignore = dirty

CMakeLists.txt

@@ -0,0 +1,165 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+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)
+    # due to https://cmake.org/cmake/help/v3.12/policy/CMP0068.html
+    cmake_minimum_required(VERSION 3.9 FATAL_ERROR)
+else()
+    cmake_minimum_required(VERSION 3.7.2 FATAL_ERROR)
+endif()
+
+
+project(OpenVINO)
+
+set(OpenVINO_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(IE_MAIN_SOURCE_DIR ${OpenVINO_MAIN_SOURCE_DIR}/inference-engine)
+set(CMAKE_MODULE_PATH "${OpenVINO_MAIN_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
+
+include(CTest)
+include(features)
+
+# include developer package
+include(developer_package NO_POLICY_SCOPE)
+
+# These options are shared with 3rdparty plugins
+# by means of developer package
+include(check_features)
+include(dependencies)
+
+# resolving dependencies for the project
+message (STATUS "PROJECT ............................... " ${PROJECT_NAME})
+message (STATUS "CMAKE_BINARY_DIR ...................... " ${CMAKE_BINARY_DIR})
+message (STATUS "OpenVINO_MAIN_SOURCE_DIR .............. " ${OpenVINO_MAIN_SOURCE_DIR})
+message (STATUS "IE_MAIN_SOURCE_DIR .............. " ${IE_MAIN_SOURCE_DIR})
+message (STATUS "CMAKE_GENERATOR ....................... " ${CMAKE_GENERATOR})
+message (STATUS "CMAKE_C_COMPILER_ID ................... " ${CMAKE_C_COMPILER_ID})
+message (STATUS "CMAKE_BUILD_TYPE ...................... " ${CMAKE_BUILD_TYPE})
+
+# remove file with exported developer targets to force its regeneration
+file(REMOVE "${CMAKE_BINARY_DIR}/targets_developer.cmake")
+file(REMOVE "${CMAKE_BINARY_DIR}/targets.cmake")
+
+function(build_ngraph)
+    function(ngraph_set option value)
+        if(NOT DEFINED ${option})
+            set(${option} ${value} CACHE BOOL "" FORCE)
+        endif()
+    endfunction()
+
+    set(NGRAPH_BUILD_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY} CACHE STRING "" FORCE)
+    set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${OpenVINO_MAIN_SOURCE_DIR}/ngraph/cmake/Modules/")
+
+    if (ENABLE_SANITIZER)
+        ngraph_set(NGRAPH_ADDRESS_SANITIZER TRUE)
+    else ()
+        ngraph_set(NGRAPH_ADDRESS_SANITIZER FALSE)
+    endif ()
+    ngraph_set(NGRAPH_TOOLS_ENABLE FALSE)
+    ngraph_set(NGRAPH_CPU_ENABLE FALSE)
+    ngraph_set(NGRAPH_INTERPRETER_ENABLE TRUE)
+    ngraph_set(NGRAPH_NOP_ENABLE FALSE)
+    ngraph_set(NGRAPH_GPUH_ENABLE FALSE)
+    ngraph_set(NGRAPH_GENERIC_CPU_ENABLE FALSE)
+    ngraph_set(NGRAPH_ENABLE_CPU_CONV_AUTO FALSE)
+    ngraph_set(NGRAPH_PYTHON_BUILD_ENABLE FALSE)
+    ngraph_set(NGRAPH_PLAIDML_ENABLE FALSE)
+    ngraph_set(NGRAPH_FAST_MATH_ENABLE FALSE)
+    ngraph_set(NGRAPH_JSON_ENABLE FALSE)
+    ngraph_set(NGRAPH_DYNAMIC_COMPONENTS_ENABLE FALSE)
+    ngraph_set(NGRAPH_NATIVE_ARCH_ENABLE FALSE)
+
+    if (NOT ANDROID)
+        ngraph_set(NGRAPH_UNIT_TEST_ENABLE TRUE)
+        ngraph_set(NGRAPH_UNIT_TEST_OPENVINO_ENABLE TRUE)
+        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_UNIT_TEST_OPENVINO_ENABLE FALSE)
+        ngraph_set(NGRAPH_ONNX_IMPORT_ENABLE FALSE)
+    endif()
+
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        ie_add_compiler_flags(-Wno-error=uninitialized -Wno-error=literal-conversion)
+    elseif(UNIX)
+        ie_add_compiler_flags(-Wno-error=maybe-uninitialized -Wno-error=return-type -fPIC)
+    endif()
+    if(ANDROID)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=defaulted-function-deleted -Wno-error=unused-command-line-argument")
+    endif()
+
+    # WA for GCC 7.0
+    if (UNIX)
+        ie_add_compiler_flags(-Wno-error=return-type -Wno-undef)
+    elseif(WIN32)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4308 /wd4146 /wd4703 /wd4244")
+    endif()
+
+    if(ENABLE_LTO)
+        ie_enable_lto()
+    endif()
+
+    ie_cpack_add_component(ngraph)
+
+    set(SDL_cmake_included ON)
+    # set(NGRAPH_COMPONENT_PREFIX "deployment_tools/ngraph/")
+    add_subdirectory(ngraph)
+endfunction()
+
+build_ngraph()
+
+add_subdirectory(inference-engine)
+
+add_subdirectory(docs)
+
+# cpack
+
+# install setupvars
+
+ie_cpack_add_component(setupvars REQUIRED)
+
+if(UNIX)
+    install(PROGRAMS scripts/setupvars/setupvars.sh
+            DESTINATION bin
+            COMPONENT setupvars)
+elseif(WIN32)
+    install(PROGRAMS scripts/setupvars/setupvars.bat
+            DESTINATION bin
+            COMPONENT setupvars)
+endif()
+
+# install install_dependencies
+
+if(UNIX)
+    ie_cpack_add_component(install_dependencies REQUIRED)
+    install(DIRECTORY scripts/install_dependencies/
+            DESTINATION install_dependencies
+            COMPONENT install_dependencies)
+endif()
+
+# install files for demo
+
+ie_cpack_add_component(demo_scripts REQUIRED DEPENDS core)
+
+if(UNIX)
+    install(DIRECTORY scripts/demo/
+            DESTINATION deployment_tools/demo
+            COMPONENT demo_scripts
+            USE_SOURCE_PERMISSIONS
+            PATTERN *.bat EXCLUDE)
+elseif(WIN32)
+    install(DIRECTORY scripts/demo/
+            DESTINATION deployment_tools/demo
+            COMPONENT demo_scripts
+            USE_SOURCE_PERMISSIONS
+            PATTERN *.sh EXCLUDE)
+endif()
+
+ie_cpack(${IE_CPACK_COMPONENTS_ALL})

README.md

@@ -1,42 +1,58 @@
 # [OpenVINO™ Toolkit](https://01.org/openvinotoolkit) - Deep Learning Deployment Toolkit repository
-[![Stable release](https://img.shields.io/badge/version-2019.R3-green.svg)](https://github.com/opencv/dldt/releases/tag/2019_R3)
+[![Stable release](https://img.shields.io/badge/version-2020.3-green.svg)](https://github.com/openvinotoolkit/openvino/releases/tag/2020.3.0)
 [![Apache License Version 2.0](https://img.shields.io/badge/license-Apache_2.0-green.svg)](LICENSE)
 
-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 two components, namely Model Optimizer and Inference Engine, as well as CPU, GPU and heterogeneous plugins to accelerate deep learning inferencing on Intel(R) CPUs and Intel(R) Processor Graphics. It supports pre-trained models from the [Open Model Zoo](https://github.com/opencv/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](https://software.intel.com/en-us/articles/OpenVINO-InferEngine)
-* [Model Optimizer](https://software.intel.com/en-us/articles/OpenVINO-ModelOptimizer)
+* [Inference Engine]
+* [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 
+and release your contribution under these terms.
 
 ## Documentation
 * [OpenVINO™ Release Notes](https://software.intel.com/en-us/articles/OpenVINO-RelNotes)
-* [Inference Engine build instructions](inference-engine/README.md)
-* [Get Started with Deep Learning Deployment Toolkit on Linux*](get-started-linux.md)
+* [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
-We welcome community contributions to the Deep Learning Deployment Toolkit repository. If you have an idea how to improve the product, please share it with us doing the following steps:
+We welcome community contributions to the Deep Learning Deployment Toolkit 
+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 a relevant unit tests and sample
-* Submit a pull request at https://github.com/opencv/dldt/pulls
+* 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
 
-We will review your contribution and, if any additional fixes or modifications are necessary, may give some feedback to guide you. When accepted, your pull request will be merged into GitHub* repositories.
-
-Deep Learning Deployment Toolkit is licensed under Apache License, Version 2.0. By contributing to the project, you agree to the license and copyright terms therein and release your contribution under these terms.
+We will review your contribution and, if any additional fixes or modifications 
+are necessary, may give some feedback to guide you. Your pull request will be 
+merged into GitHub* repositories if accepted.
 
 ## Support
 Please report questions, issues and suggestions using:
-* [\#openvino](https://stackoverflow.com/search?q=%23openvino) tag on StackOverflow*
-* [GitHub* Issues](https://github.com/opencv/dldt/issues) 
+
+* The `openvino` [tag on StackOverflow]\*
+* [GitHub* Issues](https://github.com/openvinotoolkit/openvino/issues) 
 * [Forum](https://software.intel.com/en-us/forums/computer-vision)
 
 ---
-\* Other names and brands may be claimed as the property of others.
+\* Other names and brands may be claimed as the property of others.
+
+[Open Model Zoo]:https://github.com/opencv/open_model_zoo
+[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

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\* 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 2.7 or higher for Inference Engine Python API wrapper
+- (Optional) [Install Intel® Graphics Compute Runtime for OpenCL™ Driver package 20.13.16352].
+
+### 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 20.13.16352]
+   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\* 16.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.4 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.4 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.3. The minimum
+supported version is 3.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 20.13.16352]:https://github.com/intel/compute-runtime/releases/tag/20.13.16352
+[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/arm.toolchain.cmake

@@ -0,0 +1,73 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR armv7l)
+
+set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc)
+set(CMAKE_CXX_COMPILER arm-linux-gnueabihf-g++)
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+macro(__cmake_find_root_save_and_reset)
+    foreach(v
+            CMAKE_FIND_ROOT_PATH_MODE_LIBRARY
+            CMAKE_FIND_ROOT_PATH_MODE_INCLUDE
+            CMAKE_FIND_ROOT_PATH_MODE_PACKAGE
+            CMAKE_FIND_ROOT_PATH_MODE_PROGRAM
+            )
+        set(__save_${v} ${${v}})
+        set(${v} NEVER)
+    endforeach()
+endmacro()
+
+macro(__cmake_find_root_restore)
+    foreach(v
+            CMAKE_FIND_ROOT_PATH_MODE_LIBRARY
+            CMAKE_FIND_ROOT_PATH_MODE_INCLUDE
+            CMAKE_FIND_ROOT_PATH_MODE_PACKAGE
+            CMAKE_FIND_ROOT_PATH_MODE_PROGRAM
+            )
+        set(${v} ${__save_${v}})
+        unset(__save_${v})
+    endforeach()
+endmacro()
+
+
+# macro to find programs on the host OS
+macro(find_host_program)
+    __cmake_find_root_save_and_reset()
+    if(CMAKE_HOST_WIN32)
+        SET(WIN32 1)
+        SET(UNIX)
+    elseif(CMAKE_HOST_APPLE)
+        SET(APPLE 1)
+        SET(UNIX)
+    endif()
+    find_program(${ARGN})
+    SET(WIN32)
+    SET(APPLE)
+    SET(UNIX 1)
+    __cmake_find_root_restore()
+endmacro()
+
+# macro to find packages on the host OS
+macro(find_host_package)
+    __cmake_find_root_save_and_reset()
+    if(CMAKE_HOST_WIN32)
+        SET(WIN32 1)
+        SET(UNIX)
+    elseif(CMAKE_HOST_APPLE)
+        SET(APPLE 1)
+        SET(UNIX)
+    endif()
+    find_package(${ARGN})
+    SET(WIN32)
+    SET(APPLE)
+    SET(UNIX 1)
+    __cmake_find_root_restore()
+endmacro()

cmake/arm64.toolchain.cmake

@@ -0,0 +1,73 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR aarch64)
+
+set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)
+set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+macro(__cmake_find_root_save_and_reset)
+    foreach(v
+            CMAKE_FIND_ROOT_PATH_MODE_LIBRARY
+            CMAKE_FIND_ROOT_PATH_MODE_INCLUDE
+            CMAKE_FIND_ROOT_PATH_MODE_PACKAGE
+            CMAKE_FIND_ROOT_PATH_MODE_PROGRAM
+            )
+        set(__save_${v} ${${v}})
+        set(${v} NEVER)
+    endforeach()
+endmacro()
+
+macro(__cmake_find_root_restore)
+    foreach(v
+            CMAKE_FIND_ROOT_PATH_MODE_LIBRARY
+            CMAKE_FIND_ROOT_PATH_MODE_INCLUDE
+            CMAKE_FIND_ROOT_PATH_MODE_PACKAGE
+            CMAKE_FIND_ROOT_PATH_MODE_PROGRAM
+            )
+        set(${v} ${__save_${v}})
+        unset(__save_${v})
+    endforeach()
+endmacro()
+
+
+# macro to find programs on the host OS
+macro(find_host_program)
+    __cmake_find_root_save_and_reset()
+    if(CMAKE_HOST_WIN32)
+        SET(WIN32 1)
+        SET(UNIX)
+    elseif(CMAKE_HOST_APPLE)
+        SET(APPLE 1)
+        SET(UNIX)
+    endif()
+    find_program(${ARGN})
+    SET(WIN32)
+    SET(APPLE)
+    SET(UNIX 1)
+    __cmake_find_root_restore()
+endmacro()
+
+# macro to find packages on the host OS
+macro(find_host_package)
+    __cmake_find_root_save_and_reset()
+    if(CMAKE_HOST_WIN32)
+        SET(WIN32 1)
+        SET(UNIX)
+    elseif(CMAKE_HOST_APPLE)
+        SET(APPLE 1)
+        SET(UNIX)
+    endif()
+    find_package(${ARGN})
+    SET(WIN32)
+    SET(APPLE)
+    SET(UNIX 1)
+    __cmake_find_root_restore()
+endmacro()

cmake/check_features.cmake

@@ -0,0 +1,35 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+if (VERBOSE_BUILD)
+    set(CMAKE_VERBOSE_MAKEFILE ON CACHE BOOL "" FORCE)
+endif()
+
+#64 bits platform
+if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+    message(STATUS "Detected 64 bit architecture")
+    SET(ARCH_64 ON)
+else()
+    message(STATUS "Detected 32 bit architecture")
+    SET(ARCH_64 OFF)
+endif()
+
+if (NOT ENABLE_MKL_DNN)
+    set(ENABLE_MKL OFF)
+endif()
+
+if(ENABLE_AVX512F)
+    if ((CMAKE_CXX_COMPILER_ID MATCHES MSVC) AND (MSVC_VERSION VERSION_LESS 1920))
+        # 1920 version of MSVC 2019. In MSVC 2017 AVX512F not work
+        set(ENABLE_AVX512F OFF CACHE BOOL "" FORCE)
+    endif()
+    if (CMAKE_CXX_COMPILER_ID MATCHES Clang)
+        set(ENABLE_AVX512F OFF CACHE BOOL "" FORCE)
+    endif()
+    if ((CMAKE_CXX_COMPILER_ID STREQUAL GNU) AND (NOT (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.9)))
+        set(ENABLE_AVX512F OFF CACHE BOOL "" FORCE)
+    endif()
+endif()
+
+print_enabled_features()

cmake/coverage/coverage.cmake

@@ -0,0 +1,194 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+if(NOT TARGET ie_coverage_clean)
+    add_custom_target(ie_coverage_clean)
+endif()
+
+if(NOT TARGET ie_coverage_init)
+    add_custom_target(ie_coverage_init)
+endif()
+
+if(NOT TARGET ie_coverage)
+    add_custom_target(ie_coverage)
+endif()
+
+set(IE_COVERAGE_REPORTS "${CMAKE_BINARY_DIR}/coverage")
+set(IE_COVERAGE_SCRIPT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/cmake/coverage")
+
+include(CMakeParseArguments)
+
+#
+# ie_coverage_clean(REPOSITORY <repo> DIRECTORY <dir>)
+#
+function(ie_coverage_clean)
+    cmake_parse_arguments(IE_COVERAGE "" "REPOSITORY;DIRECTORY" "" ${ARGN})
+
+    add_custom_target(ie_coverage_zerocounters_${IE_COVERAGE_REPOSITORY}
+                  COMMAND lcov --zerocounters --quiet
+                               --directory "${IE_COVERAGE_DIRECTORY}"
+                  COMMENT "Add zero counters for coverage for ${IE_COVERAGE_REPOSITORY}"
+                  VERBATIM)
+
+    add_custom_target(ie_coverage_clean_${IE_COVERAGE_REPOSITORY}
+                      COMMAND ${CMAKE_COMMAND}
+                        -D "IE_COVERAGE_REPORTS=${IE_COVERAGE_REPORTS}"
+                        -D "IE_COVERAGE_DIRECTORY=${IE_COVERAGE_DIRECTORY}"
+                        -D "CMAKE_BINARY_DIRECTORY=${CMAKE_BINARY_DIR}"
+                        -D "CMAKE_SOURCE_DIRECTORY=${CMAKE_SOURCE_DIR}"
+                        -P "${IE_COVERAGE_SCRIPT_DIR}/coverage_clean.cmake"
+                      COMMENT "Clean previously created HTML report files for ${IE_COVERAGE_REPOSITORY}"
+                      DEPENDS "${IE_COVERAGE_SCRIPT_DIR}/coverage_clean.cmake"
+                      VERBATIM)
+
+    add_dependencies(ie_coverage_clean ie_coverage_zerocounters_${IE_COVERAGE_REPOSITORY}
+                                       ie_coverage_clean_${IE_COVERAGE_REPOSITORY})
+endfunction()
+
+#
+# ie_coverage_capture(INFO_FILE <info_file>
+#                     BASE_DIRECTORY <base dir>
+#                     DIRECTORY <gcda dir>)
+#
+function(ie_coverage_capture)
+    cmake_parse_arguments(IE_COVERAGE "" "INFO_FILE;BASE_DIRECTORY;DIRECTORY" "" ${ARGN})
+
+    set(output_file "${IE_COVERAGE_REPORTS}/${IE_COVERAGE_INFO_FILE}.info")
+    set(output_base_file "${IE_COVERAGE_REPORTS}/${IE_COVERAGE_INFO_FILE}_base.info")
+    set(output_tests_file "${IE_COVERAGE_REPORTS}/${IE_COVERAGE_INFO_FILE}_tests.info")
+
+    add_custom_command(OUTPUT ${output_base_file}
+                       COMMAND ${CMAKE_COMMAND} -E make_directory "${IE_COVERAGE_REPORTS}"
+                       COMMAND lcov --no-external --capture --initial --quiet
+                                    --directory "${IE_COVERAGE_DIRECTORY}"
+                                    --base-directory "${IE_COVERAGE_BASE_DIRECTORY}"
+                                    --output-file ${output_base_file}
+                       COMMENT "Capture initial coverage data ${IE_COVERAGE_INFO_FILE}"
+                       VERBATIM)
+
+    add_custom_command(OUTPUT ${output_tests_file}
+                       COMMAND ${CMAKE_COMMAND} -E make_directory "${IE_COVERAGE_REPORTS}"
+                       COMMAND lcov --no-external --capture --quiet
+                                    --directory "${IE_COVERAGE_DIRECTORY}"
+                                    --base-directory "${IE_COVERAGE_BASE_DIRECTORY}"
+                                    --output-file ${output_tests_file}
+                       COMMENT "Capture test coverage data ${IE_COVERAGE_INFO_FILE}"
+                       VERBATIM)
+
+    add_custom_command(OUTPUT ${output_file}
+                       COMMAND ${CMAKE_COMMAND}
+                               -D "IE_COVERAGE_OUTPUT_FILE=${output_file}"
+                               -D "IE_COVERAGE_INPUT_FILES=${output_base_file};${output_tests_file}"
+                               -P "${IE_COVERAGE_SCRIPT_DIR}/coverage_merge.cmake"
+                       COMMENT "Generate total coverage data ${IE_COVERAGE_INFO_FILE}"
+                       DEPENDS ${output_base_file} ${output_tests_file}
+                       VERBATIM)
+
+    add_custom_target(ie_coverage_${IE_COVERAGE_INFO_FILE}_info
+                      DEPENDS ${output_file})
+endfunction()
+
+#
+# ie_coverage_extract(INPUT <info_file> OUTPUT <output_file> PATTERNS <patterns ...>)
+#
+function(ie_coverage_extract)
+    cmake_parse_arguments(IE_COVERAGE "" "INPUT;OUTPUT" "PATTERNS" ${ARGN})
+
+    set(input_file "${IE_COVERAGE_REPORTS}/${IE_COVERAGE_INPUT}.info")
+    set(output_file "${IE_COVERAGE_REPORTS}/${IE_COVERAGE_OUTPUT}.info")
+
+    set(commands lcov --quiet)
+    foreach(pattern IN LISTS IE_COVERAGE_PATTERNS)
+        list(APPEND commands --extract ${input_file} ${pattern})
+    endforeach()
+    list(APPEND commands --output-file ${output_file})
+
+    add_custom_command(OUTPUT ${output_file}
+                       COMMAND ${commands}
+                       COMMENT "Generate coverage data ${IE_COVERAGE_OUTPUT}"
+                       DEPENDS ${input_file}
+                       VERBATIM)
+    add_custom_target(ie_coverage_${IE_COVERAGE_OUTPUT}_info
+                      DEPENDS ${output_file})
+
+    add_dependencies(ie_coverage_${IE_COVERAGE_OUTPUT}_info ie_coverage_${IE_COVERAGE_INPUT}_info)
+endfunction()
+
+#
+# ie_coverage_remove(INPUT <info_file> OUTPUT <output_file> PATTERNS <patterns ...>)
+#
+function(ie_coverage_remove)
+    cmake_parse_arguments(IE_COVERAGE "" "INPUT;OUTPUT" "PATTERNS" ${ARGN})
+
+    set(input_file "${IE_COVERAGE_REPORTS}/${IE_COVERAGE_INPUT}.info")
+    set(output_file "${IE_COVERAGE_REPORTS}/${IE_COVERAGE_OUTPUT}.info")
+
+    set(commands lcov --quiet)
+    foreach(pattern IN LISTS IE_COVERAGE_PATTERNS)
+        list(APPEND commands --remove ${input_file} ${pattern})
+    endforeach()
+    list(APPEND commands --output-file ${output_file})
+
+    add_custom_command(OUTPUT ${output_file}
+                       COMMAND ${commands}
+                       COMMENT "Generate coverage data ${IE_COVERAGE_OUTPUT}"
+                       DEPENDS ${input_file}
+                       VERBATIM)
+    add_custom_target(ie_coverage_${IE_COVERAGE_OUTPUT}_info
+                      DEPENDS ${output_file})
+
+    add_dependencies(ie_coverage_${IE_COVERAGE_OUTPUT}_info ie_coverage_${IE_COVERAGE_INPUT}_info)
+endfunction()
+
+#
+# ie_coverage_merge(OUTPUT <output file> INPUTS <input files ...>)
+#
+function(ie_coverage_merge)
+    cmake_parse_arguments(IE_COVERAGE "" "OUTPUT" "INPUTS" ${ARGN})
+
+    set(output_file "${IE_COVERAGE_REPORTS}/${IE_COVERAGE_OUTPUT}.info")
+    foreach(input_info_file IN LISTS IE_COVERAGE_INPUTS)
+        set(input_file ${IE_COVERAGE_REPORTS}/${input_info_file}.info)
+        list(APPEND dependencies ie_coverage_${input_info_file}_info)
+        list(APPEND input_files ${input_file})
+    endforeach()
+
+    add_custom_command(OUTPUT ${output_file}
+                       COMMAND ${CMAKE_COMMAND}
+                               -D "IE_COVERAGE_OUTPUT_FILE=${output_file}"
+                               -D "IE_COVERAGE_INPUT_FILES=${input_files}"
+                               -P "${IE_COVERAGE_SCRIPT_DIR}/coverage_merge.cmake"
+                       COMMENT "Generate coverage data ${IE_COVERAGE_OUTPUT}"
+                       DEPENDS ${input_files}
+                       VERBATIM)
+    add_custom_target(ie_coverage_${IE_COVERAGE_OUTPUT}_info
+                      DEPENDS ${output_file})
+
+    add_dependencies(ie_coverage_${IE_COVERAGE_OUTPUT}_info ${dependencies})
+endfunction()
+
+#
+# ie_coverage_genhtml(INFO_FILE <info_file> PREFIX <prefix>)
+#
+function(ie_coverage_genhtml)
+    cmake_parse_arguments(IE_COVERAGE "" "INFO_FILE;PREFIX" "" ${ARGN})
+
+    set(input_file "${IE_COVERAGE_REPORTS}/${IE_COVERAGE_INFO_FILE}.info")
+    set(output_directory "${IE_COVERAGE_REPORTS}/${IE_COVERAGE_INFO_FILE}")
+
+    add_custom_command(OUTPUT "${output_directory}/index.html"
+                       COMMAND genhtml ${input_file} --title "${IE_COVERAGE_INFO_FILE}" --legend
+                                       --no-branch-coverage --demangle-cpp
+                                       --output-directory "${output_directory}"
+                                       --num-spaces 4 --quiet
+                                       --prefix "${IE_COVERAGE_PREFIX}"
+                       DEPENDS ${input_file}
+                       COMMENT "Generate HTML report for ${IE_COVERAGE_INFO_FILE}"
+                       VERBATIM)
+    add_custom_target(ie_coverage_${IE_COVERAGE_INFO_FILE}_genhtml
+                      DEPENDS "${output_directory}/index.html")
+
+    add_dependencies(ie_coverage_${IE_COVERAGE_INFO_FILE}_genhtml ie_coverage_${IE_COVERAGE_INFO_FILE}_info)
+    add_dependencies(ie_coverage ie_coverage_${IE_COVERAGE_INFO_FILE}_genhtml)
+endfunction()

cmake/coverage/coverage_clean.cmake

@@ -0,0 +1,30 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+if(NOT DEFINED IE_COVERAGE_REPORTS)
+	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()
+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}")
+
+	if(NOT EXISTS "${source_file}")
+		file(REMOVE "${file}")
+		string(REPLACE "${CMAKE_BINARY_DIRECTORY}/" "" file "${file}")
+		message("Removing ${file}")
+	endif()
+endforeach()

cmake/coverage/coverage_merge.cmake

@@ -0,0 +1,22 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+if(NOT DEFINED IE_COVERAGE_OUTPUT_FILE)
+    message(FATAL_ERROR "IE_COVERAGE_OUTPUT_FILE is not defined")
+endif()
+
+if(NOT DEFINED IE_COVERAGE_INPUT_FILES)
+    message(FATAL_ERROR "IE_COVERAGE_INPUT_FILES is not defined")
+endif()
+
+set(command lcov --quiet)
+foreach(input_info_file IN LISTS IE_COVERAGE_INPUT_FILES)
+    file(SIZE ${input_info_file} size)
+    if(NOT size EQUAL 0)
+        list(APPEND command --add-tracefile "${input_info_file}")
+    endif()
+endforeach()
+list(APPEND command --output-file ${IE_COVERAGE_OUTPUT_FILE})
+
+execute_process(COMMAND ${command})

cmake/debug.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 
@@ -26,11 +26,11 @@ function (log_rpath_remove_top component component_remove_top lib lib_remove_top
 
 #  debug_message(STATUS "LIB-IN=${lib} ")
 #  debug_message(STATUS "TOPLIB-IN=${top_lib_dir} ")
-  get_filename_component(top_lib_dir ${${component}} DIRECTORY)
+  get_filename_component(top_lib_dir "${${component}}" DIRECTORY)
 
   if (${component_remove_top} AND ${component})
   else()
-    get_filename_component(add_name ${${component}} NAME)
+    get_filename_component(add_name "${${component}}" NAME)
     set(top_lib_dir "${top_lib_dir}/${add_name}")
   endif()
   if (${lib_remove_top} AND lib)
@@ -70,4 +70,4 @@ endfunction()
 # This macro is redefined (with additional checks) within the InferenceEngineConfig.cmake file.
 macro(ext_message TRACE_LEVEL)
     message(${TRACE_LEVEL} "${ARGN}")
-endmacro()
+endmacro()

cmake/dependencies.cmake

@@ -0,0 +1,37 @@
+# Copyright (C) 2018 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+set_temp_directory(TEMP "${IE_MAIN_SOURCE_DIR}")
+
+include(dependency_solver)
+
+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()
+
+    reset_deps_cache(SYSTEM_PROTOC)
+
+    message("${SYSTEM_PROTOC_ROOT}/bin")
+    find_program(
+        SYSTEM_PROTOC
+        NAMES protoc
+        PATHS "${SYSTEM_PROTOC_ROOT}/bin"
+        NO_DEFAULT_PATH)
+    if(NOT SYSTEM_PROTOC)
+        message(FATAL_ERROR "[ONNX IMPORTER] Missing host protoc binary")
+    endif()
+
+    update_deps_cache(SYSTEM_PROTOC "${SYSTEM_PROTOC}" "Path to host protoc for ONNX Importer")
+endif()

cmake/developer_package.cmake

@@ -0,0 +1,218 @@
+# Copyright (C) 2018 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+set(CMAKE_MODULE_PATH "${OpenVINO_MAIN_SOURCE_DIR}/cmake/download" ${CMAKE_MODULE_PATH})
+
+include(CPackComponent)
+unset(IE_CPACK_COMPONENTS_ALL CACHE)
+
+set(IE_CPACK_IE_DIR       deployment_tools/inference_engine)
+
+# Search packages for the host system instead of packages for the target system
+# in case of cross compilation these macros should be defined by the toolchain file
+if(NOT COMMAND find_host_package)
+    macro(find_host_package)
+        find_package(${ARGN})
+    endmacro()
+endif()
+if(NOT COMMAND find_host_program)
+    macro(find_host_program)
+        find_program(${ARGN})
+    endmacro()
+endif()
+
+#
+# ie_cpack_set_library_dir()
+#
+# 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}/${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} 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()
+
+ie_cpack_set_library_dir()
+
+#
+# ie_cpack_add_component(NAME ...)
+#
+# Wraps original `cpack_add_component` and adds component to internal IE list
+#
+macro(ie_cpack_add_component NAME)
+    list(APPEND IE_CPACK_COMPONENTS_ALL ${NAME})
+    set(IE_CPACK_COMPONENTS_ALL "${IE_CPACK_COMPONENTS_ALL}" CACHE STRING "" FORCE)
+    cpack_add_component(${NAME} ${ARGN})
+endmacro()
+
+macro(ie_cpack)
+    set(CPACK_GENERATOR "TGZ")
+    if(WIN32)
+        set(CPACK_PACKAGE_NAME inference-engine_${CMAKE_BUILD_TYPE})
+        string(REPLACE "\\" "_" CPACK_PACKAGE_VERSION "${CI_BUILD_NUMBER}")
+    else()
+        set(CPACK_PACKAGE_NAME inference-engine)
+        string(REPLACE "/" "_" CPACK_PACKAGE_VERSION "${CI_BUILD_NUMBER}")
+    endif()
+    set(CPACK_INCLUDE_TOPLEVEL_DIRECTORY OFF)
+    set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
+    set(CPACK_PACKAGE_VENDOR "Intel")
+    set(CPACK_COMPONENTS_ALL ${ARGN})
+    set(CPACK_STRIP_FILES ON)
+
+    if(OS_FOLDER)
+        set(CPACK_SYSTEM_NAME "${OS_FOLDER}")
+    endif()
+
+    include(CPack)
+endmacro()
+
+# prepare temporary folder
+function(set_temp_directory temp_variable source_tree_dir)
+    if (DEFINED ENV{DL_SDK_TEMP} AND NOT $ENV{DL_SDK_TEMP} STREQUAL "")
+        message(STATUS "DL_SDK_TEMP environment is set : $ENV{DL_SDK_TEMP}")
+
+        if (WIN32)
+            string(REPLACE "\\" "\\\\" temp $ENV{DL_SDK_TEMP})
+        else()
+            set(temp $ENV{DL_SDK_TEMP})
+        endif()
+
+        if (ENABLE_ALTERNATIVE_TEMP)
+            set(ALTERNATIVE_PATH ${source_tree_dir}/temp)
+        endif()
+    else ()
+        set(temp ${source_tree_dir}/temp)
+    endif()
+
+    set("${temp_variable}" "${temp}" CACHE PATH "Path to temp directory")
+    if(ALTERNATIVE_PATH)
+        set(ALTERNATIVE_PATH "${ALTERNATIVE_PATH}" PARENT_SCOPE)
+    endif()
+endfunction()
+
+include(coverage/coverage)
+
+# 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()
+else()
+    set(BIN_FOLDER "bin/${ARCH_FOLDER}")
+endif()
+
+if("${CMAKE_BUILD_TYPE}" STREQUAL "")
+    debug_message(STATUS "CMAKE_BUILD_TYPE not defined, 'Release' will be used")
+    set(CMAKE_BUILD_TYPE "Release")
+endif()
+
+set(OUTPUT_ROOT ${OpenVINO_MAIN_SOURCE_DIR})
+
+# Enable postfixes for Debug/Release builds
+set(IE_DEBUG_POSTFIX_WIN "d")
+set(IE_RELEASE_POSTFIX_WIN "")
+set(IE_DEBUG_POSTFIX_LIN "")
+set(IE_RELEASE_POSTFIX_LIN "")
+set(IE_DEBUG_POSTFIX_MAC "d")
+set(IE_RELEASE_POSTFIX_MAC "")
+
+if(WIN32)
+    set(IE_DEBUG_POSTFIX ${IE_DEBUG_POSTFIX_WIN})
+    set(IE_RELEASE_POSTFIX ${IE_RELEASE_POSTFIX_WIN})
+elseif(APPLE)
+    set(IE_DEBUG_POSTFIX ${IE_DEBUG_POSTFIX_MAC})
+    set(IE_RELEASE_POSTFIX ${IE_RELEASE_POSTFIX_MAC})
+else()
+    set(IE_DEBUG_POSTFIX ${IE_DEBUG_POSTFIX_LIN})
+    set(IE_RELEASE_POSTFIX ${IE_RELEASE_POSTFIX_LIN})
+endif()
+
+set(CMAKE_DEBUG_POSTFIX ${IE_DEBUG_POSTFIX})
+set(CMAKE_RELEASE_POSTFIX ${IE_RELEASE_POSTFIX})
+
+if (WIN32)
+    # Support CMake multiconfiguration for Visual Studio build
+    set(IE_BUILD_POSTFIX $<$<CONFIG:Debug>:${IE_DEBUG_POSTFIX}>$<$<CONFIG:Release>:${IE_RELEASE_POSTFIX}>)
+else ()
+    if (${CMAKE_BUILD_TYPE} STREQUAL "Debug" )
+        set(IE_BUILD_POSTFIX ${IE_DEBUG_POSTFIX})
+    else()
+        set(IE_BUILD_POSTFIX ${IE_RELEASE_POSTFIX})
+    endif()
+endif()
+message(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
+
+add_definitions(-DIE_BUILD_POSTFIX=\"${IE_BUILD_POSTFIX}\")
+
+if(NOT UNIX)
+    if (WIN32)
+        # set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+        # set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
+    endif()
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
+    set(CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
+    set(CMAKE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
+else()
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE}/lib)
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE}/lib)
+    set(CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE})
+    set(CMAKE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE})
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE})
+endif()
+
+if(APPLE)
+    set(CMAKE_MACOSX_RPATH ON)
+endif(APPLE)
+
+# Use solution folders
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+include(sdl)
+include(os_flags NO_POLICY_SCOPE)
+include(sanitizer)
+
+function(set_ci_build_number)
+    set(OpenVINO_MAIN_SOURCE_DIR "${CMAKE_SOURCE_DIR}")
+    include(version)
+    set(CI_BUILD_NUMBER "${CI_BUILD_NUMBER}" PARENT_SCOPE)
+endfunction()
+set_ci_build_number()

cmake/download/dependency_solver.cmake

@@ -0,0 +1,195 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+include ("download")
+
+function (resolve_archive_dependency VAR COMPONENT ARCHIVE ARCHIVE_UNIFIED ARCHIVE_WIN ARCHIVE_LIN ARCHIVE_MAC ARCHIVE_ANDROID TARGET_PATH FOLDER ENVIRONMENT)
+
+  if (ENVIRONMENT AND (DEFINED ${ENVIRONMENT} OR DEFINED ENV{${ENVIRONMENT}}))
+    set(HAS_ENV "TRUE")
+  endif()
+
+  if (NOT DEFINED HAS_ENV)
+    if (ARCHIVE)
+      #TODO: check whether this is platform specific binary with same name per or it is in common folder
+      DownloadAndExtract(${COMPONENT} ${ARCHIVE} ${TARGET_PATH} result_path ${FOLDER})
+    else()
+      DownloadAndExtractPlatformSpecific(${COMPONENT} ${ARCHIVE_UNIFIED} ${ARCHIVE_WIN} ${ARCHIVE_LIN} ${ARCHIVE_MAC} ${ARCHIVE_ANDROID} ${TARGET_PATH} result_path  ${FOLDER})
+    endif()
+
+    set (${VAR} ${result_path} PARENT_SCOPE)
+  else()
+    if (DEFINED ${ENVIRONMENT})
+      set (${VAR} ${${ENVIRONMENT}} PARENT_SCOPE)
+    else ()
+      set (${VAR} $ENV{${ENVIRONMENT}} PARENT_SCOPE)
+    endif ()
+  endif()
+
+endfunction(resolve_archive_dependency)
+
+function(resolve_pull_request GITHUB_PULL_REQUEST TARGET_PATH)
+    get_filename_component(FILE_NAME ${GITHUB_PULL_REQUEST} NAME)
+    set (PATCH_URL "")
+    DownloadAndApply("${PATCH_URL}/${GITHUB_PULL_REQUEST}" "${IE_MAIN_SOURCE_DIR}/${TARGET_PATH}/${FILE_NAME}")
+endfunction(resolve_pull_request)
+
+function(extract_version_from_filename filename regex version)
+    string(REGEX MATCH ${regex} match ${filename})
+
+    if (CMAKE_MATCH_1)
+        set(${version} ${CMAKE_MATCH_1} PARENT_SCOPE)
+    else()
+        set(${version} ${filename} PARENT_SCOPE)
+    endif()
+endfunction(extract_version_from_filename)
+
+function(read_version archive regex version_var)
+    extract_version_from_filename(${archive} ${regex} version)
+    set(${version_var} "${version}" CACHE INTERNAL "" FORCE)
+    debug_message(STATUS "${version_var} = " ${version})
+endfunction(read_version)
+
+function (RESOLVE_DEPENDENCY NAME_OF_CMAKE_VAR)
+
+  list(REMOVE_AT ARGV 0)
+  set(SUPPORTED_ARGS FOLDER ARCHIVE ARCHIVE_UNIFIED ARCHIVE_WIN ARCHIVE_LIN ARCHIVE_MAC ARCHIVE_ANDROID TARGET_PATH ENVIRONMENT GITHUB_PULL_REQUEST VERSION_REGEX)
+
+
+  #unnecessary vars
+  foreach(arg ${ARGV})
+    #message("one_arg=" ${one_arg})
+    #message("arg=" ${arg})
+    #parse no arg vars
+    if (";${SUPPORTED_ARGS};" MATCHES ";${arg};")
+      if(DEFINED one_arg)
+        set(${one_arg} TRUE)
+      endif()
+      set (one_arg ${arg})
+    elseif(DEFINED one_arg)
+      set(${one_arg} ${arg})
+      unset(one_arg)
+    else()
+      message(FATAL_ERROR "invalid argument passed to resolve dependency: " ${arg})
+    endif()
+  endforeach(arg)
+
+  #if last token was bool
+  if(DEFINED one_arg)
+    set(${one_arg} TRUE)
+  endif()
+
+
+  if (NOT DEFINED ARCHIVE)
+    SET(ARCHIVE "OFF")
+  endif()
+
+  if (NOT DEFINED ARCHIVE_UNIFIED)
+    SET(ARCHIVE_UNIFIED "OFF")
+  endif()
+
+  if (NOT DEFINED ARCHIVE_WIN)
+    SET(ARCHIVE_WIN "OFF")
+  endif()
+
+  if (NOT DEFINED ARCHIVE_LIN)
+    SET(ARCHIVE_LIN "OFF")
+  endif()
+
+  if (NOT DEFINED ARCHIVE_MAC)
+    SET(ARCHIVE_MAC "OFF")
+  endif()
+
+  if (NOT DEFINED ARCHIVE_ANDROID)
+    SET(ARCHIVE_ANDROID "OFF")
+  endif()
+
+  if (NOT DEFINED ENVIRONMENT)
+    set (ENVIRONMENT "OFF")
+  endif()
+
+  if (NOT DEFINED FOLDER)
+    set (FOLDER FALSE)
+  endif()
+
+
+
+  #for each dependency type have to do separate things
+  if (ARCHIVE_WIN OR ARCHIVE_LIN OR ARCHIVE_MAC OR ARCHIVE_ANDROID OR ARCHIVE OR ARCHIVE_UNIFIED)
+    if (NOT DEFINED TARGET_PATH)
+      message(FATAL_ERROR "TARGET_PATH should be defined for every dependency")
+    endif()
+
+    resolve_archive_dependency(RESULT ${NAME_OF_CMAKE_VAR} ${ARCHIVE} ${ARCHIVE_UNIFIED} ${ARCHIVE_WIN} ${ARCHIVE_LIN} ${ARCHIVE_MAC} ${ARCHIVE_ANDROID} ${TARGET_PATH} ${FOLDER} ${ENVIRONMENT})
+    set(${NAME_OF_CMAKE_VAR} ${RESULT} PARENT_SCOPE)
+    if (VERSION_REGEX)
+        GetNameAndUrlToDownload(archive RELATIVE_URL ${ARCHIVE_UNIFIED} ${ARCHIVE_WIN} ${ARCHIVE_LIN} ${ARCHIVE_MAC} ${ARCHIVE_ANDROID})
+        if (archive)
+            read_version(${archive} ${VERSION_REGEX} "${NAME_OF_CMAKE_VAR}_VERSION")
+        endif()
+    endif()
+
+  elseif (DEFINED GITHUB_PULL_REQUEST)
+    resolve_pull_request(${GITHUB_PULL_REQUEST} ${TARGET_PATH})
+  else()
+    message(FATAL_ERROR "Dependency of unknowntype, SHOULD set one of ARCHIVE_WIN, ARCHIVE, ARCHIVE_LIN, ARCHIVE_MAC, ARCHIVE_ANDROID, GITHUB_PULL_REQUEST")
+  endif()
+
+endfunction(RESOLVE_DEPENDENCY)
+
+function (resolve_model_dependency network archive network_model_path)
+  RESOLVE_DEPENDENCY(${network_model_path}
+        ARCHIVE "models_archives/${archive}"
+        TARGET_PATH "${MODELS_PATH}/${network}")
+  string (REPLACE ${MODELS_PATH} "" relative_path ${${network_model_path}})
+  set(${network_model_path} ".${relative_path}" PARENT_SCOPE)
+endfunction()
+
+function(reset_deps_cache)
+    #
+    # Reset the dependencies cache if it was set by dependency solver
+    #
+    set(need_reset FALSE)
+
+    foreach(var_name IN LISTS ARGN)
+        if(DEFINED ${var_name})
+            if(${var_name} MATCHES ${TEMP})
+                set(need_reset TRUE)
+            endif()
+        endif()
+    endforeach()
+    foreach(var_name IN LISTS ARGN)
+        if(DEFINED ENV{${var_name}})
+            if($ENV{${var_name}} MATCHES ${TEMP})
+                set(need_reset TRUE)
+            endif()
+        endif()
+    endforeach()
+
+    if(need_reset)
+        foreach(var_name IN LISTS ARGN)
+            unset(${var_name} CACHE)
+        endforeach()
+        foreach(var_name IN LISTS ARGN)
+            unset(ENV{${var_name}})
+        endforeach()
+    endif()
+endfunction()
+
+function(update_deps_cache VAR_NAME INTERNAL_VALUE DOC_MSG)
+    #
+    # Update the variable value if it wasn't provided by the user
+    #
+
+    if(NOT DEFINED ${VAR_NAME} AND NOT DEFINED ENV{${VAR_NAME}})
+        # User didn't provide its own value, use INTERNAL_VALUE
+        set(${VAR_NAME} ${INTERNAL_VALUE} CACHE PATH ${DOC_MSG})
+    else()
+        # The variable was provided by the user, don't use INTERNAL_VALUE
+        if(NOT DEFINED ${VAR_NAME} AND DEFINED ENV{${VAR_NAME}})
+            # User provided the variable via environment, convert it to the CACHE variable
+            set(${VAR_NAME} $ENV{${VAR_NAME}} CACHE PATH ${DOC_MSG})
+        endif()
+    endif()
+endfunction()

cmake/download/download.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 

cmake/download/download_and_apply.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 

cmake/download/download_and_check.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 

cmake/download/download_and_extract.cmake

@@ -1,34 +1,29 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 
 include ("extract")
 include ("download_and_check")
 
-function (GetNameAndUrlToDownload name url archive_name_unified archive_name_win archive_name_lin archive_name_mac)
+function (GetNameAndUrlToDownload name url archive_name_unified archive_name_win archive_name_lin archive_name_mac archive_name_android)
   if (archive_name_unified)
     set (${url} "${archive_name_unified}" PARENT_SCOPE)
     set (${name} ${archive_name_unified} PARENT_SCOPE)
   else()
-    if (LINUX OR (APPLE AND NOT archive_name_mac))
-      if (NOT archive_name_lin)
-        return()
-      endif()  
+    if(archive_name_lin)
       set (PLATFORM_FOLDER linux)
       set (archive_name ${archive_name_lin})
-    elseif(APPLE)
-      if (NOT archive_name_mac)
-        return()
-      endif()  
+    elseif(archive_name_mac)
       set (PLATFORM_FOLDER mac)
       set (archive_name ${archive_name_mac})
-    else()
-      #if no dependency for target platfrom skip it
-      if (NOT archive_name_win)
-        return()
-      endif()
+    elseif(archive_name_android)
+      set (PLATFORM_FOLDER android)
+      set (archive_name ${archive_name_android})
+    elseif(archive_name_win)
       set (PLATFORM_FOLDER windows)
       set (archive_name ${archive_name_win})
+    else()
+      return()
     endif()
 
     set (${name} ${archive_name} PARENT_SCOPE)
@@ -37,17 +32,18 @@ function (GetNameAndUrlToDownload name url archive_name_unified archive_name_win
 endfunction(GetNameAndUrlToDownload)
 
 #download from paltform specific folder from share server
-function (DownloadAndExtractPlatformSpecific 
-  component 
-  archive_name_unified 
-  archive_name_win 
-  archive_name_lin 
-  archive_name_mac 
-  unpacked_path 
+function (DownloadAndExtractPlatformSpecific
+  component
+  archive_name_unified
+  archive_name_win
+  archive_name_lin
+  archive_name_mac
+  archive_name_android
+  unpacked_path
   result_path
   folder)
 
-  GetNameAndUrlToDownload(archive_name RELATIVE_URL ${archive_name_unified} ${archive_name_win} ${archive_name_lin} ${archive_name_mac} )
+  GetNameAndUrlToDownload(archive_name RELATIVE_URL ${archive_name_unified} ${archive_name_win} ${archive_name_lin} ${archive_name_mac} ${archive_name_android} )
   if (NOT archive_name OR NOT RELATIVE_URL)
     return()
   endif()
@@ -61,35 +57,35 @@ function (DownloadAndExtract component archive_name unpacked_path result_path fo
   set (RELATIVE_URL  "${archive_name}")
   set(fattal TRUE)
   CheckOrDownloadAndExtract(${component} ${RELATIVE_URL} ${archive_name} ${unpacked_path} result_path2 ${folder} ${fattal} result TRUE)
-  
+
   if (NOT ${result})
     DownloadAndExtractPlatformSpecific(${component} ${archive_name} ${archive_name} ${archive_name} ${unpacked_path} ${result_path2} ${folder})
-  endif()  
+  endif()
 
   set (${result_path} ${result_path2} PARENT_SCOPE)
 
 endfunction(DownloadAndExtract)
 
 
-function (DownloadAndExtractInternal URL archive_path  unpacked_path folder fattal result123)
+function (DownloadAndExtractInternal URL archive_path  unpacked_path folder fattal resultExt)
   set (status "ON")
   DownloadAndCheck(${URL} ${archive_path} ${fattal} result1)
   if ("${result1}" STREQUAL "ARCHIVE_DOWNLOAD_FAIL")
     #check alternative url as well
     set (status "OFF")
-    file(REMOVE_RECURSE "${archive_path}")    
+    file(REMOVE_RECURSE "${archive_path}")
   endif()
 
   if ("${result1}" STREQUAL "CHECKSUM_DOWNLOAD_FAIL" OR "${result1}" STREQUAL "HASH_MISMATCH")
     set(status FALSE)
-    file(REMOVE_RECURSE "${archive_path}")    
+    file(REMOVE_RECURSE "${archive_path}")
   endif()
 
   if("${status}" STREQUAL "ON")
     ExtractWithVersion(${URL} ${archive_path} ${unpacked_path} ${folder} result)
   endif()
-  
-  set (result123 ${status} PARENT_SCOPE)
+
+  set (${resultExt} ${status} PARENT_SCOPE)
 
 endfunction(DownloadAndExtractInternal)
 
@@ -98,36 +94,49 @@ function (ExtractWithVersion URL archive_path unpacked_path folder result)
   debug_message("ExtractWithVersion : ${archive_path} : ${unpacked_path}")
   extract(${archive_path} ${unpacked_path} ${folder} status)
   #dont need archive actually after unpacking
-  file(REMOVE_RECURSE "${archive_path}")  
+  file(REMOVE_RECURSE "${archive_path}")
   if (${status})
     set (version_file ${unpacked_path}/ie_dependency.info)
     file(WRITE ${version_file} ${URL})
   else()
     file(REMOVE_RECURSE "${unpacked_path}")
+    message(FATAL_ERROR "Failed to extract the archive from ${URL}, archive ${archive_path} to folder ${unpacked_path}")
   endif()
-  set (${result} ${status} PARENT_SCOPE)  
+  set (${result} ${status} PARENT_SCOPE)
 endfunction (ExtractWithVersion)
 
-function (DownloadOrExtractInternal URL archive_path unpacked_path folder fattal result123)
+function (DownloadOrExtractInternal URL archive_path unpacked_path folder fattal resultExt)
   debug_message("checking wether archive downloaded : ${archive_path}")
-
+  set (downloadStatus "NOTOK")
   if (NOT EXISTS ${archive_path})
     DownloadAndExtractInternal(${URL} ${archive_path} ${unpacked_path} ${folder} ${fattal} result)
+    if (${result})
+      set (downloadStatus "OK")
+    endif()
   else()
 
     if (ENABLE_UNSAFE_LOCATIONS)
       ExtractWithVersion(${URL} ${archive_path} ${unpacked_path} ${folder} result)
       if(NOT ${result})
         DownloadAndExtractInternal(${URL} ${archive_path} ${unpacked_path} ${folder} ${fattal} result)
+        if (${result})
+          set (downloadStatus "OK")
+        endif()
       endif()
     else()
       debug_message("archive found on FS : ${archive_path}, however we cannot check it's checksum and think that it is invalid")
       file(REMOVE_RECURSE "${archive_path}")
       DownloadAndExtractInternal(${URL} ${archive_path} ${unpacked_path} ${folder} ${fattal} result)
-    endif()  
+      if (${result})
+        set (downloadStatus "OK")
+      endif()
+    endif()
 
-  
-  endif()  
+  endif()
+
+  if (NOT ${downloadStatus} STREQUAL "OK")
+    message(FATAL_ERROR "Failed to download and extract the archive from ${URL}, archive ${archive_path} to folder ${unpacked_path}")
+  endif()
 
   if (NOT ${result})
     message(FATAL_ERROR "error: extract of '${archive_path}' failed")
@@ -137,7 +146,7 @@ endfunction(DownloadOrExtractInternal)
 
 file(REMOVE ${CMAKE_BINARY_DIR}/dependencies_64.txt)
 
-function (CheckOrDownloadAndExtract component RELATIVE_URL archive_name unpacked_path result_path folder fattal result123 use_alternatives)
+function (CheckOrDownloadAndExtract component RELATIVE_URL archive_name unpacked_path result_path folder fattal resultExt use_alternatives)
   set (archive_path ${TEMP}/download/${archive_name})
   set (status "ON")
   set (on_master FALSE)
@@ -145,7 +154,7 @@ function (CheckOrDownloadAndExtract component RELATIVE_URL archive_name unpacked
   if(DEFINED ENV{IE_PATH_TO_DEPS})
     set(URL "$ENV{IE_PATH_TO_DEPS}/${RELATIVE_URL}")
   else()
-    set(URL "https://download.01.org/opencv/2019/openvinotoolkit/R3/inference_engine/${RELATIVE_URL}")
+    set(URL "https://download.01.org/opencv/2020/openvinotoolkit/2020.3/inference_engine/${RELATIVE_URL}")
   endif()
 
   #no message on recursive calls
@@ -159,7 +168,7 @@ function (CheckOrDownloadAndExtract component RELATIVE_URL archive_name unpacked
 
   if (NOT EXISTS ${unpacked_path})
     DownloadOrExtractInternal(${URL} ${archive_path} ${unpacked_path} ${folder} ${fattal} status)
-  else(NOT EXISTS ${unpacked_path})  
+  else(NOT EXISTS ${unpacked_path})
     #path exists, so we would like to check what was unpacked version
     set (version_file ${unpacked_path}/ie_dependency.info)
 
@@ -176,7 +185,7 @@ function (CheckOrDownloadAndExtract component RELATIVE_URL archive_name unpacked
         "\trm -rf ${unpacked_path}\n"
         "and rerun cmake.\n"
         "If your dependency is fine, then execute:\n\techo ${URL} > ${unpacked_path}/ie_dependency.info\n")
-#     file(REMOVE_RECURSE "${unpacked_path}") 
+#     file(REMOVE_RECURSE "${unpacked_path}")
 #     DownloadOrExtractInternal(${URL} ${archive_path} ${unpacked_path} ${fattal} status)
     else()
       if (EXISTS ${version_file})
@@ -196,11 +205,11 @@ function (CheckOrDownloadAndExtract component RELATIVE_URL archive_name unpacked
         string(REPLACE ${TEMP} ${ALTERNATIVE_PATH} archive_path ${archive_path})
 
         debug_message("dependency different: use local path for fetching updated version: ${alternative_path}")
-        CheckOrDownloadAndExtract(${component} ${RELATIVE_URL} ${archive_name} ${unpacked_path} ${result_path} ${folder} ${fattal} ${result123} FALSE)
+        CheckOrDownloadAndExtract(${component} ${RELATIVE_URL} ${archive_name} ${unpacked_path} ${result_path} ${folder} ${fattal} ${resultExt} FALSE)
 
       else()
         debug_message("dependency updated: download it again")
-        file(REMOVE_RECURSE "${unpacked_path}") 
+        file(REMOVE_RECURSE "${unpacked_path}")
         DownloadOrExtractInternal(${URL} ${archive_path} ${unpacked_path} ${folder} ${fattal} status)
       endif()
     endif ()
@@ -208,11 +217,10 @@ function (CheckOrDownloadAndExtract component RELATIVE_URL archive_name unpacked
   endif()
 
   if (${use_alternatives} OR ${on_master})
-    set (${result123} "${status}" PARENT_SCOPE)
+    set (${resultExt} "${status}" PARENT_SCOPE)
     set (${result_path} ${unpacked_path} PARENT_SCOPE)
   endif()
 
-  
-  
-endfunction(CheckOrDownloadAndExtract)
 
+
+endfunction(CheckOrDownloadAndExtract)

cmake/download/extract.cmake

@@ -1,10 +1,9 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 
 function (extract archive_path unpacked_path folder result)
   # Slurped from a generated extract-TARGET.cmake file.
-  if (NOT EXISTS ${unpacked_path})
     get_filename_component(unpacked_dir ${unpacked_path} DIRECTORY)
 
     file(MAKE_DIRECTORY ${unpacked_path})
@@ -40,6 +39,5 @@ function (extract archive_path unpacked_path folder result)
     else()
       set(${result} 1 PARENT_SCOPE)
     endif()
-    
-  endif()
+
 endfunction (extract)

cmake/features.cmake

@@ -0,0 +1,40 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+include (target_flags)
+include (options)
+
+# these options are aimed to optimize build time on development system
+
+if(X86_64)
+    set(ENABLE_MKL_DNN_DEFAULT ON)
+else()
+    set(ENABLE_MKL_DNN_DEFAULT OFF)
+endif()
+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 "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 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_SANITIZER "enable checking memory errors via AddressSanitizer" OFF)
+
+ie_option (ENABLE_THREAD_SANITIZER "enable checking data races via ThreadSanitizer" OFF)
+
+ie_dependent_option (COVERAGE "enable code coverage" OFF "CMAKE_CXX_COMPILER_ID STREQUAL GNU" OFF)
+
+# Define CPU capabilities
+
+ie_dependent_option (ENABLE_SSE42 "Enable SSE4.2 optimizations" ON "X86_64 OR X86" OFF)
+
+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)

cmake/options.cmake

@@ -0,0 +1,27 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+# Usage: ie_option(<option_variable> "description" <initial value or boolean expression> [IF <condition>])
+
+include (CMakeDependentOption)
+include (version)
+
+macro (ie_option variable description value)
+    option(${variable} "${description}" ${value})
+    list(APPEND IE_OPTIONS ${variable})
+endmacro()
+
+macro (ie_dependent_option variable description def_value condition fallback_value)
+    cmake_dependent_option(${variable} "${description}" ${def_value} "${condition}" ${fallback_value})
+    list(APPEND IE_OPTIONS ${variable})
+endmacro()
+
+function (print_enabled_features)
+    message(STATUS "Inference Engine enabled features: ")
+    message(STATUS "")
+    message(STATUS "    CI_BUILD_NUMBER: ${CI_BUILD_NUMBER}")
+    foreach(_var ${IE_OPTIONS})
+        message(STATUS "    ${_var} = ${${_var}}")
+    endforeach()
+    message(STATUS "")
+endfunction()

cmake/os_flags.cmake

@@ -0,0 +1,291 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+#
+# Disables deprecated warnings generation
+# Defines ie_c_cxx_deprecated varaible which contains C / C++ compiler flags
+#
+macro(disable_deprecated_warnings)
+    if(WIN32)
+        if(CMAKE_CXX_COMPILER_ID MATCHES Intel)
+            set(ie_c_cxx_deprecated "/Qdiag-disable:1478,1786")
+        elseif(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+            set(ie_c_cxx_deprecated "/wd4996")
+        endif()
+    else()
+        if(CMAKE_CXX_COMPILER_ID STREQUAL Intel)
+            set(ie_c_cxx_deprecated "-diag-disable=1478,1786")
+        else()
+            set(ie_c_cxx_deprecated "-Wno-deprecated-declarations")
+        endif()
+    endif()
+
+    if(NOT ie_c_cxx_deprecated)
+        message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
+    endif()
+
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ie_c_cxx_deprecated}")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ie_c_cxx_deprecated}")
+endmacro()
+
+#
+# Don't threat deprecated warnings as errors
+# Defines ie_c_cxx_deprecated_no_errors varaible which contains C / C++ compiler flags
+#
+macro(ie_deprecated_no_errors)
+    if(WIN32)
+        if(CMAKE_CXX_COMPILER_ID MATCHES Intel)
+            set(ie_c_cxx_deprecated "/Qdiag-warning:1478,1786")
+        elseif(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+            set(ie_c_cxx_deprecated "/wd4996")
+        endif()
+    else()
+        if(CMAKE_CXX_COMPILER_ID MATCHES Intel)
+            set(ie_c_cxx_deprecated_no_errors "-diag-warning=1478,1786")
+        else()
+            set(ie_c_cxx_deprecated_no_errors "-Wno-error=deprecated-declarations")
+        endif()
+
+        if(NOT ie_c_cxx_deprecated_no_errors)
+            message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
+        endif()
+    endif()
+
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ie_c_cxx_deprecated_no_errors}")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ie_c_cxx_deprecated_no_errors}")
+endmacro()
+
+#
+# Provides SSE4.2 compilation flags depending on an OS and a compiler
+#
+function(ie_sse42_optimization_flags flags)
+    if(WIN32)
+        if(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+            # No such option for MSVC 2019
+        elseif(CMAKE_CXX_COMPILER_ID STREQUAL Intel)
+            set(${flags} "/arch:SSE4.2 /QxSSE4.2" PARENT_SCOPE)
+        else()
+            message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
+        endif()
+    else()
+        if(CMAKE_CXX_COMPILER_ID STREQUAL Intel)
+            set(${flags} "-msse4.2 -xSSE4.2" PARENT_SCOPE)
+        else()
+            set(${flags} "-msse4.2" PARENT_SCOPE)
+        endif()
+    endif()
+endfunction()
+
+#
+# Provides AVX2 compilation flags depending on an OS and a compiler
+#
+function(ie_avx2_optimization_flags flags)
+    if(WIN32)
+        if(CMAKE_CXX_COMPILER_ID STREQUAL Intel)
+            set(${flags} "/QxCORE-AVX2" PARENT_SCOPE)
+        elseif(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+            set(${flags} "/arch:AVX2" PARENT_SCOPE)
+        else()
+            message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
+        endif()
+    else()
+        if(CMAKE_CXX_COMPILER_ID STREQUAL Intel)
+            set(${flags} "-march=core-avx2 -xCORE-AVX2 -mtune=core-avx2" PARENT_SCOPE)
+        else()
+            set(${flags} "-mavx2 -mfma" PARENT_SCOPE)
+        endif()
+    endif()
+endfunction()
+
+#
+# Provides common AVX512 compilation flags for AVX512F instruction set support
+# depending on an OS and a compiler
+#
+function(ie_avx512_optimization_flags flags)
+    if(WIN32)
+        if(CMAKE_CXX_COMPILER_ID STREQUAL Intel)
+            set(${flags} "/QxCOMMON-AVX512" PARENT_SCOPE)
+        elseif(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+            set(${flags} "/arch:AVX512" PARENT_SCOPE)
+        else()
+            message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
+        endif()
+    else()
+        if(CMAKE_CXX_COMPILER_ID STREQUAL Intel)
+            set(${flags} "-xCOMMON-AVX512" PARENT_SCOPE)
+        endif()
+        if(CMAKE_CXX_COMPILER_ID STREQUAL GNU)
+            set(${flags} "-mavx512f -mfma" PARENT_SCOPE)
+        endif()
+    endif()
+endfunction()
+
+#
+# Enables Link Time Optimization compilation
+#
+macro(ie_enable_lto)
+    if(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(WIN32)
+        if(CMAKE_BUILD_TYPE STREQUAL Release)
+            # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /GL")
+            # set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /GL")
+            # set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LTCG:STATUS")
+            # set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /LTCG:STATUS")
+            # set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} /LTCG:STATUS")
+        endif()
+    endif()
+endmacro()
+
+#
+# Adds compiler flags to C / C++ sources
+#
+macro(ie_add_compiler_flags)
+    foreach(flag ${ARGN})
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}")
+    endforeach()
+endmacro()
+
+#
+# Compilation and linker flags
+#
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+
+# to allows to override CMAKE_CXX_STANDARD from command line
+if(NOT DEFINED CMAKE_CXX_STANDARD)
+    if(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+        set(CMAKE_CXX_STANDARD 14)
+    else()
+        set(CMAKE_CXX_STANDARD 11)
+    endif()
+    set(CMAKE_CXX_EXTENSIONS OFF)
+    set(CMAKE_CXX_STANDARD_REQUIRED ON)
+endif()
+
+if(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 MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsigned-char")
+endif()
+
+set(CMAKE_POLICY_DEFAULT_CMP0063 NEW)
+set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
+
+if(WIN32)
+    ie_add_compiler_flags(-D_CRT_SECURE_NO_WARNINGS -D_SCL_SECURE_NO_WARNINGS)
+    ie_add_compiler_flags(/EHsc) # no asynchronous structured exception handling
+    ie_add_compiler_flags(/Gy) # remove unreferenced functions: function level linking
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LARGEADDRESSAWARE")
+
+    if (TREAT_WARNING_AS_ERROR)
+        if(CMAKE_CXX_COMPILER_ID MATCHES Intel)
+            ie_add_compiler_flags(/WX)
+            ie_add_compiler_flags(/Qdiag-warning:47,1740,1786)
+        elseif (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+           # ie_add_compiler_flags(/WX) # Too many warnings
+        endif()
+    endif()
+
+    # Compiler specific flags
+
+    ie_add_compiler_flags(/bigobj)
+
+    # Disable noisy warnings
+
+    if(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+        # C4251 needs to have dll-interface to be used by clients of class
+        ie_add_compiler_flags(/wd4251)
+        # C4275 non dll-interface class used as base for dll-interface class
+        ie_add_compiler_flags(/wd4275)
+    endif()
+
+    if(CMAKE_CXX_COMPILER_ID MATCHES Intel)
+        # 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
+        # 2586 decorated name length exceeded, name was truncated
+        # 2651: attribute does not apply to any entity
+        # 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,2586,2651,3180,11075,15335)
+    endif()
+
+    # Debug information flags
+
+    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Z7")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Z7")
+
+    if(ENABLE_DEBUG_SYMBOLS)
+        ie_add_compiler_flags(/Z7)
+
+        set(DEBUG_SYMBOLS_LINKER_FLAGS "/DEBUG")
+        if (CMAKE_BUILD_TYPE STREQUAL "Release")
+            # Keep default /OPT values. See /DEBUG reference for details.
+            set(DEBUG_SYMBOLS_LINKER_FLAGS "${DEBUG_SYMBOLS_LINKER_FLAGS} /OPT:REF /OPT:ICF")
+        endif()
+
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${DEBUG_SYMBOLS_LINKER_FLAGS}")
+        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${DEBUG_SYMBOLS_LINKER_FLAGS}")
+        set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${DEBUG_SYMBOLS_LINKER_FLAGS}")
+    endif()
+else()
+    # TODO: enable for C sources as well
+    # ie_add_compiler_flags(-Werror)
+    if(TREAT_WARNING_AS_ERROR)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+    endif()
+
+    ie_add_compiler_flags(-ffunction-sections -fdata-sections)
+    ie_add_compiler_flags(-fdiagnostics-show-option)
+    ie_add_compiler_flags(-Wundef)
+
+    # Disable noisy warnings
+
+    if (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+        ie_add_compiler_flags(-Wswitch)
+    elseif(UNIX)
+        ie_add_compiler_flags(-Wuninitialized -Winit-self)
+        if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+            ie_add_compiler_flags(-Wno-error=switch)
+        else()
+            ie_add_compiler_flags(-Wmaybe-uninitialized)
+        endif()
+    endif()
+
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+        ie_add_compiler_flags(-diag-disable=remark)
+    endif()
+
+    # Linker flags
+
+    if(APPLE)
+        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-dead_strip")
+        set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,-dead_strip")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-dead_strip")
+    elseif(LINUX)
+        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--gc-sections -Wl,--exclude-libs,ALL")
+        set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--gc-sections -Wl,--exclude-libs,ALL")
+    endif()
+endif()

cmake/sanitizer.cmake

@@ -0,0 +1,36 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+include(CheckCXXCompilerFlag)
+
+if (ENABLE_SANITIZER)
+    set(SANITIZER_COMPILER_FLAGS "-g -fsanitize=address -fno-omit-frame-pointer")
+    CHECK_CXX_COMPILER_FLAG("-fsanitize-recover=address" SANITIZE_RECOVER_SUPPORTED)
+    if (SANITIZE_RECOVER_SUPPORTED)
+        set(SANITIZER_COMPILER_FLAGS "${SANITIZER_COMPILER_FLAGS} -fsanitize-recover=address")
+    endif()
+
+    set(SANITIZER_LINKER_FLAGS "-fsanitize=address")
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        set(SANITIZER_LINKER_FLAGS "${SANITIZER_LINKER_FLAGS} -fuse-ld=gold")
+    endif()
+
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SANITIZER_COMPILER_FLAGS}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SANITIZER_COMPILER_FLAGS}")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${SANITIZER_LINKER_FLAGS}")
+    set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${SANITIZER_LINKER_FLAGS}")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZER_LINKER_FLAGS}")
+endif()
+
+if (ENABLE_THREAD_SANITIZER)
+    set(SANITIZER_COMPILER_FLAGS "-g -fsanitize=thread")
+
+    set(SANITIZER_LINKER_FLAGS "-fsanitize=thread")
+
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SANITIZER_COMPILER_FLAGS}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SANITIZER_COMPILER_FLAGS}")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${SANITIZER_LINKER_FLAGS}")
+    set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${SANITIZER_LINKER_FLAGS}")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZER_LINKER_FLAGS}")
+endif()

cmake/sdl.cmake

@@ -0,0 +1,45 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+if (CMAKE_BUILD_TYPE STREQUAL "Release")
+    if(UNIX)
+        set(IE_C_CXX_FLAGS "${IE_C_CXX_FLAGS} -Wformat -Wformat-security")
+        if (NOT ENABLE_SANITIZER)
+            # ASan does not support fortification https://github.com/google/sanitizers/issues/247
+            set(IE_C_CXX_FLAGS "${IE_C_CXX_FLAGS} -D_FORTIFY_SOURCE=2")
+        endif()
+        if(NOT APPLE)
+            set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -pie")
+        endif()
+
+        if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+            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()
+                set(IE_C_CXX_FLAGS "${IE_C_CXX_FLAGS} -fstack-protector-strong")
+            endif()
+            if (NOT ENABLE_SANITIZER)
+                set(IE_C_CXX_FLAGS "${IE_C_CXX_FLAGS} -s")
+            endif()
+        elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+            set(IE_C_CXX_FLAGS "${IE_C_CXX_FLAGS} -fstack-protector-all")
+        elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
+            if (NOT ENABLE_SANITIZER)
+                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(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 MATCHES MSVC)
+        set(IE_C_CXX_FLAGS "${IE_C_CXX_FLAGS} /sdl")
+    endif()
+
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${IE_C_CXX_FLAGS}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${IE_C_CXX_FLAGS}")
+endif()

cmake/target_flags.cmake

@@ -0,0 +1,35 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+# Target system specific flags
+
+if(CMAKE_CL_64)
+  set(MSVC64 ON)
+endif()
+
+if(WIN32 AND CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+  execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpmachine
+                  OUTPUT_VARIABLE OPENVINO_GCC_TARGET_MACHINE
+                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  if(OPENVINO_GCC_TARGET_MACHINE MATCHES "amd64|x86_64|AMD64")
+    set(MINGW64 ON)
+  endif()
+endif()
+
+if(MSVC64 OR MINGW64)
+  set(X86_64 ON)
+elseif(MINGW OR (MSVC AND NOT CMAKE_CROSSCOMPILING))
+  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.*")
+  set(X86 ON)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(arm.*|ARM.*)")
+  set(ARM ON)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64.*|AARCH64.*)")
+  set(AARCH64 ON)
+endif()
+
+if(UNIX AND NOT APPLE)
+    set(LINUX ON)
+endif()

cmake/version.cmake

@@ -1,11 +1,11 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 
 function (branchName VAR)
     execute_process(
             COMMAND git rev-parse --abbrev-ref HEAD
-            WORKING_DIRECTORY ${IE_MAIN_SOURCE_DIR}
+            WORKING_DIRECTORY ${OpenVINO_MAIN_SOURCE_DIR}
             OUTPUT_VARIABLE GIT_BRANCH
             OUTPUT_STRIP_TRAILING_WHITESPACE)
     set (${VAR} ${GIT_BRANCH} PARENT_SCOPE)
@@ -14,7 +14,7 @@ endfunction()
 function (commitHash VAR)
     execute_process(
             COMMAND git rev-parse HEAD
-            WORKING_DIRECTORY ${IE_MAIN_SOURCE_DIR}
+            WORKING_DIRECTORY ${OpenVINO_MAIN_SOURCE_DIR}
             OUTPUT_VARIABLE GIT_COMMIT_HASH
             OUTPUT_STRIP_TRAILING_WHITESPACE)
     set (${VAR} ${GIT_COMMIT_HASH} PARENT_SCOPE)

cmake/whole_archive.cmake

@@ -0,0 +1,53 @@
+# Copyright (C) 2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+#[[
+function links static library without removing any symbol from it.
+
+ieTargetLinkWholeArchive(<target name> <lib1> [<lib2> ...])
+Example:
+ieTargetLinkWholeArchive("MyriadFunctionalTests" "CommonLib" "AnotherLib")
+
+#]]
+
+function(ieTargetLinkWholeArchive targetName)
+    set(libs)
+    foreach(staticLib ${ARGN})
+        if (MSVC)
+            # CMake does not support generator expression in LINK_FLAGS, so we workaround it a little bit:
+            # passing same static library as normal link (to get build deps working, and includes too), than using WHOLEARCHIVE option
+            # it's important here to not use slash '/' for option !
+            if (CMAKE_GENERATOR MATCHES "Visual Studio")
+                # MSBuild is unhappy when parsing double quotes in combination with WHOLEARCHIVE flag.
+                # remove quotes from path - so build path with spaces not supported, but it's better than nothing.
+                list(APPEND libs ${staticLib}
+                    "-WHOLEARCHIVE:$<TARGET_FILE:${staticLib}>"
+                    )
+                if (CMAKE_CURRENT_BINARY_DIR MATCHES " ")
+                    message(WARNING "Visual Studio CMake generator may cause problems if your build directory contains spaces. "
+                        "Remove spaces from path or select different generator.")
+                endif()
+            else()
+                list(APPEND libs ${staticLib}
+                    "-WHOLEARCHIVE:\"$<TARGET_FILE:${staticLib}>\""
+                    )
+            endif()
+        elseif(APPLE)
+            list(APPEND libs
+                "-Wl,-all_load"
+                ${staticLib}
+                "-Wl,-noall_load"
+                )
+        else()
+            list(APPEND libs
+                "-Wl,--whole-archive"
+                ${staticLib}
+                "-Wl,--no-whole-archive"
+                )
+        endif()
+    endforeach()
+    if (libs)
+        target_link_libraries(${targetName} PRIVATE ${libs})
+    endif()
+endfunction()

docs/CMakeLists.txt

@@ -0,0 +1,47 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+if(NOT ENABLE_DOCKER)
+    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()
+    add_subdirectory(template_extension)
+endif()
+
+# OpenVINO docs
+
+set(OPENVINO_DOCS_PATH "" CACHE PATH "Path to openvino-documentation local repository")
+set(args "")
+
+if(OPENVINO_DOCS_PATH)
+    set(args "${args} ovinodoc_path:${OPENVINO_DOCS_PATH}")
+endif()
+
+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}")
+
+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)
+
+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
+                      COMMENT "Open OpenVINO documentation"
+                      VERBATIM)
+endif()

docs/examples/CMakeLists.txt

@@ -0,0 +1,14 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+set(TARGET_NAME ie_docs_examples)
+
+file(GLOB SOURCES *.cpp)
+
+add_library(ie_docs_examples STATIC ${SOURCES})
+
+target_link_libraries(${TARGET_NAME} PRIVATE inference_engine_plugin_api)
+
+#add_cpplint_target(${TARGET_NAME}_cpplint FOR_TARGETS ${TARGET_NAME})
+#add_clang_format_target(clang_format_${TARGET_NAME} FOR_TARGETS ${TARGET_NAME})

docs/examples/example_async_infer_request.cpp

@@ -0,0 +1,68 @@
+// Copyright (C) 2018-2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <threading/ie_itask_executor.hpp>
+#include <cpp_interfaces/impl/ie_infer_async_request_thread_safe_default.hpp>
+#include <memory>
+
+using namespace InferenceEngine;
+
+class AcceleratorSyncRequest : public InferRequestInternal {
+public:
+	using Ptr = std::shared_ptr<AcceleratorSyncRequest>;
+
+	void Preprocess();
+	void WriteToDevice();
+	void RunOnDevice();
+	void ReadFromDevice();
+	void PostProcess();
+};
+
+// ! [async_infer_request:define_pipeline]
+// Inherits from AsyncInferRequestThreadSafeDefault
+class AcceleratorAsyncInferRequest : public AsyncInferRequestThreadSafeDefault {
+    // Store the pointer to the synchronous request and five executors
+    AcceleratorAsyncInferRequest(const AcceleratorSyncRequest::Ptr& syncRequest,
+                                 const ITaskExecutor::Ptr& preprocessExecutor,
+                                 const ITaskExecutor::Ptr& writeToDeviceExecutor,
+                                 const ITaskExecutor::Ptr& runOnDeviceExecutor,
+                                 const ITaskExecutor::Ptr& readFromDeviceExecutor,
+                                 const ITaskExecutor::Ptr& postProcessExecutor) :
+    AsyncInferRequestThreadSafeDefault(syncRequest, nullptr, nullptr),
+    _accSyncRequest{syncRequest},
+    _preprocessExecutor{preprocessExecutor},
+    _writeToDeviceExecutor{writeToDeviceExecutor},
+    _runOnDeviceExecutor{runOnDeviceExecutor},
+    _readFromDeviceExecutor{readFromDeviceExecutor},
+    _postProcessExecutor{postProcessExecutor}
+    {
+        // Five pipeline stages of synchronous infer request are run by different executors
+        _pipeline = {
+            { _preprocessExecutor , [this] {
+                _accSyncRequest->Preprocess();
+            }},
+            { _writeToDeviceExecutor , [this] {
+                _accSyncRequest->WriteToDevice();
+            }},
+            { _runOnDeviceExecutor , [this] {
+                _accSyncRequest->RunOnDevice();
+            }},
+            { _readFromDeviceExecutor , [this] {
+                _accSyncRequest->ReadFromDevice();
+            }},
+            { _postProcessExecutor , [this] {
+                _accSyncRequest->PostProcess();
+            }},
+        };
+    }
+
+    // As all stages use _accSyncRequest member we should wait for all stages tasks before the destructor destroy this member.
+    ~AcceleratorAsyncInferRequest() {
+        StopAndWait();
+    }
+
+    AcceleratorSyncRequest::Ptr _accSyncRequest;
+    ITaskExecutor::Ptr _preprocessExecutor, _writeToDeviceExecutor, _runOnDeviceExecutor, _readFromDeviceExecutor, _postProcessExecutor;
+};
+// ! [async_infer_request:define_pipeline]

docs/examples/example_itask_executor.cpp

@@ -0,0 +1,53 @@
+// Copyright (C) 2018-2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <threading/ie_cpu_streams_executor.hpp>
+
+#include <memory>
+#include <future>
+#include <iostream>
+
+void example1() {
+// ! [itask_executor:define_pipeline]
+    // std::promise is move only object so to satisfy copy callable constraint we use std::shared_ptr
+    auto promise = std::make_shared<std::promise<void>>();
+    // When the promise is created we can get std::future to wait the result
+    auto future = promise->get_future();
+    // Rather simple task
+    InferenceEngine::Task task = [] {std::cout << "Some Output" << std::endl; };
+    // Create an executor
+    InferenceEngine::ITaskExecutor::Ptr taskExecutor = std::make_shared<InferenceEngine::CPUStreamsExecutor>();
+    if (taskExecutor == nullptr) {
+        // ProcessError(e);
+        return;
+    }
+    // We capture the task and the promise. When the task is executed in the task executor context
+    // we munually call std::promise::set_value() method
+    taskExecutor->run([task, promise] {
+        std::exception_ptr currentException;
+        try {
+            task();
+        } catch(...) {
+            // If there is some exceptions store the pointer to current exception
+            currentException = std::current_exception();
+        }
+
+        if (nullptr == currentException) {
+            promise->set_value();  //  <-- If there is no problems just call std::promise::set_value()
+        } else {
+            promise->set_exception(currentException);    //  <-- If there is an exception forward it to std::future object
+        }
+    });
+    // To wait the task completion we call std::future::wait method
+    future.wait();  //  The current thread will be blocked here and wait when std::promise::set_value()
+                    //  or std::promise::set_exception() method will be called.
+
+    // If the future store the exception it will be rethrown in std::future::get method
+    try {
+        future.get();
+    } catch(std::exception& /*e*/) {
+        // ProcessError(e);
+    }
+// ! [itask_executor:define_pipeline]
+}

docs/template_extension/CMakeLists.txt

@@ -0,0 +1,18 @@
+# Copyright (C) 2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+# [cmake:extension]
+set(TARGET_NAME "template_extension")
+
+find_package(ngraph REQUIRED)
+find_package(InferenceEngine REQUIRED)
+
+file(GLOB_RECURSE SRC *.cpp)
+
+add_library(${TARGET_NAME} SHARED ${SRC})
+
+target_compile_definitions(${TARGET_NAME} PRIVATE IMPLEMENT_INFERENCE_EXTENSION_API)
+target_link_libraries(${TARGET_NAME} PRIVATE ${InferenceEngine_LIBRARIES}
+                                             ${NGRAPH_LIBRARIES})
+# [cmake:extension]

docs/template_extension/cpu_kernel.cpp

@@ -0,0 +1,124 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+#include "cpu_kernel.hpp"
+#include "op.hpp"
+#include <details/ie_exception.hpp>
+#include <ie_layouts.h>
+
+using namespace TemplateExtension;
+
+//! [cpu_implementation:ctor]
+OpImplementation::OpImplementation(const std::shared_ptr<ngraph::Node> &node) {
+    try {
+        auto castedNode = std::dynamic_pointer_cast<Operation>(node);
+        if (!castedNode)
+            THROW_IE_EXCEPTION << "Cannot create implementation for unknown operation!";
+        if (castedNode->inputs().size() != 1 || castedNode->outputs().size() != 1)
+            THROW_IE_EXCEPTION << "Cannot create implementation for operation with incorrect number of inputs or outputs!";
+        if (castedNode->get_input_partial_shape(0).is_dynamic() || castedNode->get_output_partial_shape(0).is_dynamic())
+            THROW_IE_EXCEPTION << "Cannot create implementation for op with dynamic shapes!";
+        if (castedNode->get_input_shape(0).size() != 4 || castedNode->get_output_shape(0).size() != 4)
+            THROW_IE_EXCEPTION << "Operation supports only 4d tensors for input and output.";
+        if (castedNode->get_input_element_type(0) != ngraph::element::f32 || castedNode->get_output_element_type(0) != ngraph::element::f32)
+            THROW_IE_EXCEPTION << "Operation supports only FP32 tensors.";
+        add = castedNode->getAddAttr();
+    } catch (InferenceEngine::details::InferenceEngineException& ex) {
+        error = ex.what();
+    }
+}
+//! [cpu_implementation:ctor]
+
+//! [cpu_implementation:getSupportedConfigurations]
+InferenceEngine::StatusCode OpImplementation::getSupportedConfigurations(std::vector<InferenceEngine::LayerConfig> &conf,
+                                                                         InferenceEngine::ResponseDesc *resp) noexcept {
+    auto createConfig = [](const InferenceEngine::SizeVector inShape, const InferenceEngine::SizeVector& outShape, bool planar) {
+        InferenceEngine::LayerConfig config;
+        config.dynBatchSupport = false;
+        InferenceEngine::DataConfig inData;
+        InferenceEngine::DataConfig outData;
+        InferenceEngine::SizeVector order = {0, 1, 2, 3};
+        // Allow any offset before data
+        size_t offset((std::numeric_limits<size_t>::max)());
+        if (planar) {
+            inData.desc = InferenceEngine::TensorDesc(InferenceEngine::Precision::FP32, inShape, {inShape, order, offset});
+            config.inConfs.push_back(inData);
+            outData.desc = InferenceEngine::TensorDesc(InferenceEngine::Precision::FP32, outShape, {outShape, order, offset});
+            config.outConfs.push_back(outData);
+        } else {
+            // Add blocked (nChw8c) format
+            auto div_up = [](const int a, const int b) -> int {
+                if (!b)
+                    return 0;
+                return (a + b - 1) / b;
+            };
+
+            order.push_back(1);
+            InferenceEngine::SizeVector inBlkDims = inShape;
+            inBlkDims[1] = div_up(inBlkDims[1], 8);
+            inBlkDims.push_back(8);
+            InferenceEngine::SizeVector outBlkDims = outShape;
+            outBlkDims[1] = div_up(outBlkDims[1], 8);
+            outBlkDims.push_back(8);
+            inData.desc = InferenceEngine::TensorDesc(InferenceEngine::Precision::FP32, inShape, {inBlkDims, order, offset});
+            config.inConfs.push_back(inData);
+            outData.desc = InferenceEngine::TensorDesc(InferenceEngine::Precision::FP32, outShape, {outBlkDims, order, offset});
+            config.outConfs.push_back(outData);
+        }
+        return config;
+    };
+    if (!error.empty()) {
+        if (resp) {
+            strncpy(resp->msg, error.c_str(), sizeof(resp->msg) - 1);
+            resp->msg[sizeof(resp->msg)-1] = 0;
+        }
+        return InferenceEngine::GENERAL_ERROR;
+    }
+    // Add planar format
+    conf.emplace_back(createConfig(inShape, outShape, true));
+    // Add blocked format nChw8c
+    conf.emplace_back(createConfig(inShape, outShape, false));
+    return InferenceEngine::OK;
+}
+//! [cpu_implementation:getSupportedConfigurations]
+
+//! [cpu_implementation:init]
+InferenceEngine::StatusCode OpImplementation::init(InferenceEngine::LayerConfig &config, InferenceEngine::ResponseDesc *resp) noexcept {
+    try {
+        if (config.inConfs.size() != 1 || config.outConfs.size() != 1) {
+            THROW_IE_EXCEPTION << "Operation cannot be initialized with incorrect number of inputs/outputs!";
+        }
+
+        if (config.inConfs[0].desc.getDims().size() != 4 || config.outConfs[0].desc.getDims().size() != 4) {
+            THROW_IE_EXCEPTION << "Operation can be initialized only with 4d input/output tensors!";
+        }
+
+        if (config.outConfs[0].desc.getPrecision() != InferenceEngine::Precision::FP32 ||
+                config.inConfs[0].desc.getPrecision() != InferenceEngine::Precision::FP32)  {
+            THROW_IE_EXCEPTION << "Operation supports only FP32 precisions!";
+        }
+    } catch (InferenceEngine::details::InferenceEngineException& ex) {
+        if (resp) {
+            strncpy(resp->msg, error.c_str(), sizeof(resp->msg) - 1);
+            resp->msg[sizeof(resp->msg)-1] = 0;
+        }
+        return InferenceEngine::GENERAL_ERROR;
+    }
+
+    return InferenceEngine::OK;
+}
+//! [cpu_implementation:init]
+
+//! [cpu_implementation:execute]
+InferenceEngine::StatusCode OpImplementation::execute(std::vector<InferenceEngine::Blob::Ptr> &inputs,
+                                                      std::vector<InferenceEngine::Blob::Ptr> &outputs,
+                                                      InferenceEngine::ResponseDesc *resp) noexcept {
+    const float* src_data = inputs[0]->cbuffer().as<const float *>() + inputs[0]->getTensorDesc().getBlockingDesc().getOffsetPadding();
+    float *dst_data = outputs[0]->buffer().as<float *>() + outputs[0]->getTensorDesc().getBlockingDesc().getOffsetPadding();
+
+    for (size_t i = 0; i < inputs[0]->size(); i++) {
+        dst_data[i] = src_data[i] + add;
+    }
+    return InferenceEngine::OK;
+}
+//! [cpu_implementation:execute]

docs/template_extension/cpu_kernel.hpp

@@ -0,0 +1,31 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <ie_iextension.h>
+#include <ngraph/ngraph.hpp>
+
+namespace TemplateExtension {
+
+//! [cpu_implementation:header]
+class OpImplementation : public InferenceEngine::ILayerExecImpl {
+public:
+    explicit OpImplementation(const std::shared_ptr<ngraph::Node>& node);
+    InferenceEngine::StatusCode getSupportedConfigurations(std::vector<InferenceEngine::LayerConfig> &conf,
+                                                           InferenceEngine::ResponseDesc *resp) noexcept override;
+    InferenceEngine::StatusCode init(InferenceEngine::LayerConfig &config,
+                                     InferenceEngine::ResponseDesc *resp) noexcept override;
+    InferenceEngine::StatusCode execute(std::vector<InferenceEngine::Blob::Ptr> &inputs,
+                                        std::vector<InferenceEngine::Blob::Ptr> &outputs,
+                                        InferenceEngine::ResponseDesc *resp) noexcept override;
+private:
+    int64_t add;
+    ngraph::Shape inShape;
+    ngraph::Shape outShape;
+    std::string error;
+};
+//! [cpu_implementation:header]
+
+}  // namespace TemplateExtension

docs/template_extension/extension.cpp

@@ -0,0 +1,73 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+#include "extension.hpp"
+#include "cpu_kernel.hpp"
+#include "op.hpp"
+#include <ngraph/factory.hpp>
+#include <ngraph/opsets/opset.hpp>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+using namespace TemplateExtension;
+
+//! [extension:GetVersion]
+void Extension::GetVersion(const InferenceEngine::Version *&versionInfo) const noexcept {
+    static InferenceEngine::Version ExtensionDescription = {
+        {1, 0},           // extension API version
+        "1.0",
+        "template_ext"    // extension description message
+    };
+
+    versionInfo = &ExtensionDescription;
+}
+//! [extension:GetVersion]
+
+//! [extension:getOpSets]
+std::map<std::string, ngraph::OpSet> Extension::getOpSets() {
+    std::map<std::string, ngraph::OpSet> opsets;
+    ngraph::OpSet opset;
+    opset.insert<Operation>();
+    opsets["custom_opset"] = opset;
+    return opsets;
+}
+//! [extension:getOpSets]
+
+//! [extension:getImplTypes]
+std::vector<std::string> Extension::getImplTypes(const std::shared_ptr<ngraph::Node> &node) {
+    if (std::dynamic_pointer_cast<Operation>(node)) {
+        return {"CPU"};
+    }
+    return {};
+}
+//! [extension:getImplTypes]
+
+//! [extension:getImplementation]
+InferenceEngine::ILayerImpl::Ptr Extension::getImplementation(const std::shared_ptr<ngraph::Node> &node, const std::string &implType) {
+    if (std::dynamic_pointer_cast<Operation>(node) && implType == "CPU") {
+        return std::make_shared<OpImplementation>(node);
+    }
+    return nullptr;
+}
+//! [extension:getImplementation]
+
+//! [extension:CreateExtension]
+// Exported function
+INFERENCE_EXTENSION_API(InferenceEngine::StatusCode) InferenceEngine::CreateExtension(InferenceEngine::IExtension *&ext,
+                                                                                      InferenceEngine::ResponseDesc *resp) noexcept {
+    try {
+        ext = new Extension();
+        return OK;
+    } catch (std::exception &ex) {
+        if (resp) {
+            std::string err = ((std::string) "Couldn't create extension: ") + ex.what();
+            err.copy(resp->msg, 255);
+        }
+        return InferenceEngine::GENERAL_ERROR;
+    }
+}
+//! [extension:CreateExtension]

docs/template_extension/extension.hpp

@@ -0,0 +1,31 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <ie_iextension.h>
+#include <ie_api.h>
+#include <ngraph/ngraph.hpp>
+#include <memory>
+#include <vector>
+#include <string>
+#include <map>
+
+//! [extension:header]
+namespace TemplateExtension {
+
+class Extension : public InferenceEngine::IExtension {
+public:
+    Extension() = default;
+    void GetVersion(const InferenceEngine::Version*& versionInfo) const noexcept override;
+    void Unload() noexcept override {}
+    void Release() noexcept override { delete this; }
+
+    std::map<std::string, ngraph::OpSet> getOpSets() override;
+    std::vector<std::string> getImplTypes(const std::shared_ptr<ngraph::Node>& node) override;
+    InferenceEngine::ILayerImpl::Ptr getImplementation(const std::shared_ptr<ngraph::Node>& node, const std::string& implType) override;
+};
+
+}  // namespace TemplateExtension
+//! [extension:header]

docs/template_extension/op.cpp

@@ -0,0 +1,38 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+#include "op.hpp"
+
+using namespace TemplateExtension;
+
+constexpr ngraph::NodeTypeInfo Operation::type_info;
+
+//! [op:ctor]
+Operation::Operation(const ngraph::Output<ngraph::Node> &arg, int64_t add) : Op({arg}), add(add) {
+    constructor_validate_and_infer_types();
+}
+//! [op:ctor]
+
+//! [op:validate]
+void Operation::validate_and_infer_types() {
+    // Operation doesn't change shapes end element type
+    set_output_type(0, get_input_element_type(0), get_input_partial_shape(0));
+}
+//! [op:validate]
+
+//! [op:copy]
+std::shared_ptr<ngraph::Node> Operation::copy_with_new_args(const ngraph::NodeVector &new_args) const {
+    if (new_args.size() != 1) {
+        throw ngraph::ngraph_error("Incorrect number of new arguments");
+    }
+
+    return std::make_shared<Operation>(new_args.at(0), add);
+}
+//! [op:copy]
+
+//! [op:visit_attributes]
+bool Operation::visit_attributes(ngraph::AttributeVisitor &visitor) {
+    visitor.on_attribute("add", add);
+    return true;
+}
+//! [op:visit_attributes]

docs/template_extension/op.hpp

@@ -0,0 +1,29 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <ngraph/ngraph.hpp>
+
+//! [op:header]
+namespace TemplateExtension {
+
+class Operation : public ngraph::op::Op {
+public:
+    static constexpr ngraph::NodeTypeInfo type_info{"Template", 0};
+    const ngraph::NodeTypeInfo& get_type_info() const override { return type_info;  }
+
+    Operation() = default;
+    Operation(const ngraph::Output<ngraph::Node>& arg, int64_t add);
+    void validate_and_infer_types() override;
+    std::shared_ptr<ngraph::Node> copy_with_new_args(const ngraph::NodeVector& new_args) const override;
+    bool visit_attributes(ngraph::AttributeVisitor& visitor) override;
+    int64_t getAddAttr() { return add; }
+
+private:
+    int64_t add;
+};
+//! [op:header]
+
+}  // namespace TemplateExtension

docs/template_plugin/CMakeLists.txt

@@ -0,0 +1,31 @@
+# Copyright (C) 2018 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+# [cmake:main]
+if (APPLE)
+    # due to https://cmake.org/cmake/help/v3.12/policy/CMP0068.html
+    cmake_minimum_required(VERSION 3.9 FATAL_ERROR)
+else()
+    cmake_minimum_required(VERSION 3.7.2 FATAL_ERROR)
+endif()
+
+project(InferenceEngineTemplatePlugin)
+
+set(IE_MAIN_TEMPLATE_PLUGIN_SOURCE_DIR ${InferenceEngineTemplatePlugin_SOURCE_DIR})
+
+find_package(InferenceEngineDeveloperPackage REQUIRED)
+
+add_subdirectory(src)
+
+if(ENABLE_TESTS)
+	include(CTest)
+	enable_testing()
+
+endif()
+# [cmake:main]
+
+# install
+
+# ATTENTION: uncomment to install component
+# ie_cpack(template)

docs/template_plugin/README.md

@@ -0,0 +1,18 @@
+# template-plugin
+
+Template Plugin for Inference Engine which demonstrates basics of how Inference Engine plugin can be built and implemented on top of Inference Engine Developer Package and Plugin API.
+
+## How to build
+
+```bash
+$ cd $DLDT_HOME
+$ mkdir $DLDT_HOME/build
+$ cd $DLDT_HOME/build
+$ cmake -DENABLE_TESTS=ON -DENABLE_BEH_TESTS=ON -DENABLE_FUNCTIONAL_TESTS=ON ..
+$ make -j8
+$ cd $TEMPLATE_PLUGIN_HOME
+$ mkdir $TEMPLATE_PLUGIN_HOME/build
+$ cd $TEMPLATE_PLUGIN_HOME/build
+$ cmake -DInferenceEngineDeveloperPackage_DIR=$DLDT_HOME/build ..
+$ make -j8
+```

docs/template_plugin/include/template/template_config.hpp

@@ -0,0 +1,59 @@
+// Copyright (C) 2018-2019 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header that defines advanced related properties for DLIA plugins.
+ * These properties should be used in SetConfig() and LoadNetwork() methods of plugins
+ *
+ * @file dlia_config.hpp
+ */
+
+#pragma once
+
+#include <string>
+#include "ie_plugin_config.hpp"
+
+namespace InferenceEngine {
+
+namespace TemplateMetrics {
+
+/**
+ * @def TEMPLATE_METRIC_VALUE(name)
+ * @brief Shortcut for defining Template metric values
+ */
+#define TEMPLATE_METRIC_VALUE(name) InferenceEngine::TemplateMetrics::name
+#define DECLARE_TEMPLATE_METRIC_VALUE(name) static constexpr auto name = #name
+
+// ! [public_header:metrics]
+/**
+ * @brief Defines whether current Template device instance supports hardware blocks for fast convolution computations.
+ */
+DECLARE_TEMPLATE_METRIC_VALUE(HARDWARE_CONVOLUTION);
+// ! [public_header:metrics]
+
+}  // namespace TemplateMetrics
+
+namespace TemplateConfigParams {
+
+/**
+ * @def TEMPLATE_CONFIG_KEY(name)
+ * @brief Shortcut for defining Template device configuration keys
+ */
+#define TEMPLATE_CONFIG_KEY(name) InferenceEngine::TemplateConfigParams::_CONFIG_KEY(TEMPLATE_##name)
+
+#define DECLARE_TEMPLATE_CONFIG_KEY(name) DECLARE_CONFIG_KEY(TEMPLATE_##name)
+#define DECLARE_TEMPLATE_CONFIG_VALUE(name) DECLARE_CONFIG_VALUE(TEMPLATE_##name)
+
+/**
+ * @brief The key to define the type of transformations for TEMPLATE inputs and outputs.
+ * TEMPLATE use custom data layout for input and output blobs. IE TEMPLATE Plugin provides custom
+ * optimized version of transformation functions that do not use OpenMP and much more faster
+ * than native TEMPLATE functions. Values: "NO" - optimized plugin transformations
+ * are used, "YES" - native TEMPLATE transformations are used.
+ */
+DECLARE_TEMPLATE_CONFIG_KEY(ANY_CONFIG_KEY);
+
+
+}  // namespace TemplateConfigParams
+}  // namespace InferenceEngine

docs/template_plugin/src/CMakeLists.txt

@@ -0,0 +1,43 @@
+# Copyright (C) 2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+# [cmake:plugin]
+set(TARGET_NAME "templatePlugin")
+
+if(ENABLE_LTO)
+    ie_enable_lto()
+endif()
+
+file(GLOB SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
+file(GLOB_RECURSE HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/*.hpp)
+
+# adds a shared library with plugin
+ie_add_plugin(NAME ${TARGET_NAME}
+              DEVICE_NAME "TEMPLATE"
+              SOURCES ${SOURCES} ${HEADERS}
+              SKIP_INSTALL # ATTENTION: uncomment to install component
+              VERSION_DEFINES_FOR template_plugin.cpp)
+
+target_include_directories(${TARGET_NAME} PRIVATE
+    "${CMAKE_CURRENT_SOURCE_DIR}"
+    "${IE_MAIN_TEMPLATE_PLUGIN_SOURCE_DIR}/include")
+
+target_link_libraries(${TARGET_NAME} PRIVATE IE::inference_engine IE::inference_engine_transformations ${NGRAPH_LIBRARIES} ${INTEL_ITT_LIBS})
+
+# ATTENTION: uncomment to register a plugin in the plugins.xml file
+# ie_register_plugins(MAIN_TARGET ${TARGET_NAME}
+                    # POSSIBLE_PLUGINS ${TARGET_NAME})
+# [cmake:plugin]
+
+# ATTENTION: uncomment to install component
+# install
+
+# set(component_name template)
+# ie_cpack_add_component(${component_name} REQUIRED)
+
+# install(TARGETS ${TARGET_NAME}
+#         RUNTIME DESTINATION ${IE_CPACK_RUNTIME_PATH}
+#         ARCHIVE DESTINATION ${IE_CPACK_ARCHIVE_PATH}
+#         LIBRARY DESTINATION ${IE_CPACK_LIBRARY_PATH}
+#         COMPONENT ${component_name})

docs/template_plugin/src/template_async_infer_request.cpp

@@ -0,0 +1,44 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <utility>
+
+#include <ie_profiling.hpp>
+
+#include "template_async_infer_request.hpp"
+#include "template_executable_network.hpp"
+
+using namespace TemplatePlugin;
+
+// ! [async_infer_request:ctor]
+TemplateAsyncInferRequest::TemplateAsyncInferRequest(
+    const TemplateInferRequest::Ptr&           inferRequest,
+    const InferenceEngine::ITaskExecutor::Ptr& cpuTaskExecutor,
+    const InferenceEngine::ITaskExecutor::Ptr& waitExecutor,
+    const InferenceEngine::ITaskExecutor::Ptr& callbackExecutor) :
+    AsyncInferRequestThreadSafeDefault(inferRequest, cpuTaskExecutor, callbackExecutor),
+    _inferRequest(inferRequest), _waitExecutor(waitExecutor) {
+    _pipeline = {
+        {cpuTaskExecutor, [this] {
+            IE_PROFILING_AUTO_SCOPE(PreprocessingAndStartPipeline)
+            _inferRequest->inferPreprocess();
+            _inferRequest->startPipeline();
+        }},
+        {_waitExecutor, [this] {
+            IE_PROFILING_AUTO_SCOPE(WaitPipeline)
+            _inferRequest->waitPipeline();
+        }},
+        {cpuTaskExecutor, [this] {
+            IE_PROFILING_AUTO_SCOPE(Postprocessing)
+            _inferRequest->inferPostprocess();
+        }}
+    };
+}
+// ! [async_infer_request:ctor]
+
+// ! [async_infer_request:dtor]
+TemplateAsyncInferRequest::~TemplateAsyncInferRequest() {
+    InferenceEngine::AsyncInferRequestThreadSafeDefault::StopAndWait();
+}
+// ! [async_infer_request:dtor]

docs/template_plugin/src/template_async_infer_request.hpp

@@ -0,0 +1,30 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+
+#pragma once
+
+#include <cpp_interfaces/impl/ie_infer_async_request_thread_safe_default.hpp>
+
+#include "template_infer_request.hpp"
+
+namespace TemplatePlugin {
+
+// ! [async_infer_request:header]
+class TemplateAsyncInferRequest : public InferenceEngine::AsyncInferRequestThreadSafeDefault {
+public:
+    TemplateAsyncInferRequest(const TemplateInferRequest::Ptr&           inferRequest,
+                              const InferenceEngine::ITaskExecutor::Ptr& taskExecutor,
+                              const InferenceEngine::ITaskExecutor::Ptr& waitExecutor,
+                              const InferenceEngine::ITaskExecutor::Ptr& callbackExecutor);
+
+    ~TemplateAsyncInferRequest() override;
+
+private:
+    TemplateInferRequest::Ptr           _inferRequest;
+    InferenceEngine::ITaskExecutor::Ptr _waitExecutor;
+};
+// ! [async_infer_request:header]
+
+}  // namespace TemplatePlugin

docs/template_plugin/src/template_config.cpp

@@ -0,0 +1,45 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+
+#include <string>
+#include <vector>
+#include <algorithm>
+
+#include <ie_util_internal.hpp>
+#include <ie_plugin_config.hpp>
+#include <file_utils.h>
+#include <cpp_interfaces/exception2status.hpp>
+
+#include "template_config.hpp"
+
+using namespace TemplatePlugin;
+
+Configuration::Configuration() { }
+
+Configuration::Configuration(const ConfigMap& config, const Configuration & defaultCfg, bool throwOnUnsupported) {
+    *this = defaultCfg;
+    for (auto&& c : config) {
+        const auto& key = c.first;
+        const auto& value = c.second;
+
+        if (CONFIG_KEY(DEVICE_ID) == key) {
+            deviceId = std::stoi(value);
+        } else if (CONFIG_KEY(PERF_COUNT) == key) {
+            perfCount = (CONFIG_VALUE(YES) == value);
+        } else if (throwOnUnsupported) {
+            THROW_IE_EXCEPTION << NOT_FOUND_str << ": " << key;
+        }
+    }
+}
+
+InferenceEngine::Parameter Configuration::Get(const std::string& name) const {
+    if (name == CONFIG_KEY(DEVICE_ID)) {
+        return {std::to_string(deviceId)};
+    } else if (name == CONFIG_KEY(PERF_COUNT)) {
+        return {perfCount};
+    } else {
+        THROW_IE_EXCEPTION << NOT_FOUND_str << ": " << name;
+    }
+}

docs/template_plugin/src/template_config.hpp

@@ -0,0 +1,40 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <vector>
+#include <string>
+#include <map>
+#include <unordered_map>
+
+#include <ie_parameter.hpp>
+
+namespace TemplatePlugin {
+
+template<typename T>
+using IOMap = std::unordered_map<std::string, T>;
+
+// ! [configuration:header]
+using ConfigMap = std::map<std::string, std::string>;
+
+struct Configuration {
+    Configuration();
+    Configuration(const Configuration&)             = default;
+    Configuration(Configuration&&)                  = default;
+    Configuration& operator=(const Configuration&)  = default;
+    Configuration& operator=(Configuration&&)       = default;
+
+    explicit Configuration(const ConfigMap& config, const Configuration & defaultCfg = {}, const bool throwOnUnsupported = true);
+
+    InferenceEngine::Parameter Get(const std::string& name) const;
+
+    // Plugin configuration parameters
+
+    int deviceId                = 0;
+    bool perfCount              = true;
+};
+// ! [configuration:header]
+
+}  //  namespace TemplatePlugin

docs/template_plugin/src/template_executable_network.cpp

@@ -0,0 +1,167 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <atomic>
+#include <set>
+#include <utility>
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <ie_metric_helpers.hpp>
+#include <ie_util_internal.hpp>
+#include <ie_plugin_config.hpp>
+#include <network_serializer.h>
+#include <threading/ie_executor_manager.hpp>
+#include <details/ie_cnn_network_tools.h>
+
+#include <ngraph/specialize_function.hpp>
+#include <ngraph/pass/manager.hpp>
+#include <ngraph/pass/constant_folding.hpp>
+
+#include <transformations/convert_divide.hpp>
+
+#include "template_plugin.hpp"
+#include "template_executable_network.hpp"
+
+using namespace TemplatePlugin;
+
+// ! [executable_network:ctor_cnnnetwork]
+TemplatePlugin::ExecutableNetwork::ExecutableNetwork(InferenceEngine::ICNNNetwork&  network,
+                                                     const Configuration&           cfg):
+    _name(network.getName()),
+    _cfg(cfg),
+    _waitExecutor(InferenceEngine::ExecutorManager::getInstance()->getExecutor("Template")) {
+    // TODO: if your plugin supports device ID (more that single instance of device can be on host machine)
+    // you should select proper device based on KEY_DEVICE_ID or automatic behavior
+    // In this case, _waitExecutor should also be created per device.
+
+    try {
+        if (std::shared_ptr<const ngraph::Function> ngraphFunction = network.getFunction()) {
+            CompileGraph(ngraphFunction);
+        } else {
+            THROW_IE_EXCEPTION << "TEMPLATE plugin can compile only IR v10 networks";
+        }
+    }
+    catch (const InferenceEngineException & e) {
+        throw e;
+    }
+    catch (const std::exception & e) {
+        THROW_IE_EXCEPTION << "Standard exception from compilation library: " << e.what();
+    }
+    catch (...) {
+        THROW_IE_EXCEPTION << "Generic exception is thrown";
+    }
+}
+// ! [executable_network:ctor_cnnnetwork]
+
+// ! [executable_network:ctor_import_stream]
+TemplatePlugin::ExecutableNetwork::ExecutableNetwork(std::istream &                 model,
+                                                     const Configuration&           cfg) :
+                  _cfg(cfg) {
+    // TODO: since Import network is not a mandatory functionality, this ctor can just be removed
+}
+// ! [executable_network:ctor_import_stream]
+
+// ! [executable_network:compile_graph]
+void TemplatePlugin::ExecutableNetwork::CompileGraph(const std::shared_ptr<const ngraph::Function> & ngraphFunction) {
+    // TODO: perform actual graph compilation taking `_cfg` into account
+
+    // 1.Copy ngraph::Function first to apply some transformations later in
+    // ExecutableNetwork::CompileGraph, which modify original ngraph::Function
+    const bool shareConsts = false, constFolding = false;
+    std::vector<::ngraph::element::Type> new_types;
+    std::vector<::ngraph::PartialShape> new_shapes;
+
+    for (const auto &parameter : ngraphFunction->get_parameters()) {
+        new_shapes.emplace_back(parameter->get_partial_shape());
+        new_types.emplace_back(parameter->get_element_type());
+    }
+
+    auto copyFunction = ngraph::specialize_function(std::const_pointer_cast<ngraph::Function>(ngraphFunction),
+        new_types, new_shapes, std::vector<void *>(new_types.size(), nullptr), constFolding, shareConsts);
+
+    // 2. Perform common and device-specific transformations
+    ngraph::pass::Manager passManager;
+    // Example: register standard ngraph transformation from ngraph::ngraph
+    passManager.register_pass<ngraph::pass::ConstantFolding>();
+    // Example: register inference engine optimization transformation for IE::inference_engine_transformations
+    passManager.register_pass<ngraph::pass::ConvertDivide>();
+    // Register any other transformations
+    // ..
+
+    // After `run_passes`, we have the transformed function, where operations match device operations,
+    // and we can create device hardware-dependent graph
+    passManager.run_passes(copyFunction);
+
+    // 3. Iterate over operations and create hardware-specific ngraph
+    for (const auto& op : copyFunction->get_ordered_ops()) {
+        // TODO: map ngraph `op` to device operation
+    }
+
+    // 4. Perform any other steps like allocation and filling device buffers, and so on
+}
+// ! [executable_network:compile_graph]
+
+// ! [executable_network:create_infer_request_impl]
+InferenceEngine::InferRequestInternal::Ptr TemplatePlugin::ExecutableNetwork::CreateInferRequestImpl(InferenceEngine::InputsDataMap networkInputs,
+                                                                                                     InferenceEngine::OutputsDataMap networkOutputs) {
+    return std::make_shared<TemplateInferRequest>(networkInputs, networkOutputs, std::static_pointer_cast<ExecutableNetwork>(shared_from_this()));
+}
+// ! [executable_network:create_infer_request_impl]
+
+// ! [executable_network:create_infer_request]
+void TemplatePlugin::ExecutableNetwork::CreateInferRequest(IInferRequest::Ptr& asyncRequest) {
+    auto internalRequest = CreateInferRequestImpl(_networkInputs, _networkOutputs);
+    auto asyncThreadSafeImpl = std::make_shared<TemplateAsyncInferRequest>(std::static_pointer_cast<TemplateInferRequest>(internalRequest),
+                                                                           _taskExecutor, _waitExecutor, _callbackExecutor);
+    asyncRequest.reset(new InferenceEngine::InferRequestBase<TemplateAsyncInferRequest>(asyncThreadSafeImpl),
+                       [](InferenceEngine::IInferRequest *p) { p->Release(); });
+    asyncThreadSafeImpl->SetPointerToPublicInterface(asyncRequest);
+}
+// ! [executable_network:create_infer_request]
+
+// ! [executable_network:get_config]
+void TemplatePlugin::ExecutableNetwork::GetConfig(const std::string &name, Parameter &result, ResponseDesc *resp) const {
+    // TODO: return more supported values for config keys
+    if (name == CONFIG_KEY(DEVICE_ID) ||
+        name == CONFIG_KEY(PERF_COUNT)) {
+        result = _cfg.Get(name);
+    } else {
+        THROW_IE_EXCEPTION << "Unsupported ExecutableNetwork config key: " << name;
+    }
+}
+// ! [executable_network:get_config]
+
+// ! [executable_network:get_metric]
+void TemplatePlugin::ExecutableNetwork::GetMetric(const std::string &name, InferenceEngine::Parameter &result, InferenceEngine::ResponseDesc *) const {
+    // TODO: return more supported values for metrics
+    if (METRIC_KEY(SUPPORTED_METRICS) == name) {
+        result = IE_SET_METRIC(SUPPORTED_METRICS, std::vector<std::string>{
+            METRIC_KEY(NETWORK_NAME),
+            METRIC_KEY(SUPPORTED_METRICS),
+            METRIC_KEY(SUPPORTED_CONFIG_KEYS),
+            METRIC_KEY(OPTIMAL_NUMBER_OF_INFER_REQUESTS)});
+    } else if (METRIC_KEY(SUPPORTED_CONFIG_KEYS) == name) {
+        result = IE_SET_METRIC(SUPPORTED_CONFIG_KEYS, std::vector<std::string>{
+            CONFIG_KEY(DEVICE_ID),
+            CONFIG_KEY(PERF_COUNT)});
+    } else if (METRIC_KEY(NETWORK_NAME) == name) {
+        result = IE_SET_METRIC(NETWORK_NAME, _name);
+    } else if (METRIC_KEY(OPTIMAL_NUMBER_OF_INFER_REQUESTS) == name) {
+        // TODO: fill with actual number
+        unsigned int value = 1;
+        result = IE_SET_METRIC(OPTIMAL_NUMBER_OF_INFER_REQUESTS, value);
+    } else {
+        THROW_IE_EXCEPTION << "Unsupported ExecutableNetwork metric: " << name;
+    }
+}
+// ! [executable_network:get_metric]
+
+// ! [executable_network:export_impl]
+void TemplatePlugin::ExecutableNetwork::ExportImpl(std::ostream& dlaModel) {
+    // TODO: Code which exports graph from std::ostream
+}
+// ! [executable_network:export_impl]

docs/template_plugin/src/template_executable_network.hpp

@@ -0,0 +1,68 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+
+#pragma once
+
+#include <utility>
+#include <tuple>
+#include <memory>
+#include <string>
+#include <vector>
+#include <map>
+#include <unordered_map>
+#include <list>
+
+#include <ie_common.h>
+#include <cpp_interfaces/impl/ie_executable_network_thread_safe_default.hpp>
+#include <cnn_network_impl.hpp>
+#include <threading/ie_itask_executor.hpp>
+
+#include <ngraph/function.hpp>
+
+#include "template_config.hpp"
+#include "template_infer_request.hpp"
+#include "template_async_infer_request.hpp"
+
+namespace TemplatePlugin {
+
+class Engine;
+
+/**
+ * @class ExecutableNetwork
+ * @brief Interface of executable network
+ */
+// ! [executable_network:header]
+class ExecutableNetwork : public InferenceEngine::ExecutableNetworkThreadSafeDefault {
+public:
+    ExecutableNetwork(InferenceEngine::ICNNNetwork&  network,
+                      const Configuration&           cfg);
+
+    ExecutableNetwork(std::istream &                 model,
+                      const Configuration&           cfg);
+
+    ~ExecutableNetwork() override = default;
+
+    // Methods from a base class ExecutableNetworkThreadSafeDefault
+
+    void ExportImpl(std::ostream& model) override;
+    InferenceEngine::InferRequestInternal::Ptr CreateInferRequestImpl(InferenceEngine::InputsDataMap networkInputs,
+                                                                      InferenceEngine::OutputsDataMap networkOutputs) override;
+    void CreateInferRequest(InferenceEngine::IInferRequest::Ptr &asyncRequest) override;
+    void GetMetric(const std::string &name, InferenceEngine::Parameter &result, InferenceEngine::ResponseDesc *resp) const override;
+    void GetConfig(const std::string &name, InferenceEngine::Parameter &result, InferenceEngine::ResponseDesc *resp) const override;
+
+    std::atomic<std::size_t>                    _requestId = {0};
+    std::string                                 _name;
+    Configuration                               _cfg;
+
+private:
+    void CompileGraph(const std::shared_ptr<const ngraph::Function> & ngraphFunction);
+
+    std::shared_ptr<Engine>                     _plugin;
+    InferenceEngine::ITaskExecutor::Ptr         _waitExecutor;
+};
+// ! [executable_network:header]
+
+}  // namespace TemplatePlugin

docs/template_plugin/src/template_infer_request.cpp

@@ -0,0 +1,224 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+
+#include <utility>
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <map>
+
+#include <ie_blob.h>
+#include <ie_plugin.hpp>
+#include <description_buffer.hpp>
+#include <debug.h>
+#include <ie_layouts.h>
+#include <threading/ie_executor_manager.hpp>
+#include <blob_transform.hpp>
+#include <ie_parallel.hpp>
+#include <ie_memcpy.h>
+#include <precision_utils.h>
+#include <template/template_config.hpp>
+
+#include "template_infer_request.hpp"
+#include "template_executable_network.hpp"
+#include "template_plugin.hpp"
+
+using namespace TemplatePlugin;
+
+using Time = std::chrono::high_resolution_clock;
+using ns = std::chrono::nanoseconds;
+using fsec = std::chrono::duration<float>;
+
+// ! [infer_request:ctor]
+TemplateInferRequest::TemplateInferRequest(const InferenceEngine::InputsDataMap&                     networkInputs,
+                                           const InferenceEngine::OutputsDataMap&                    networkOutputs,
+                                           const std::shared_ptr<TemplatePlugin::ExecutableNetwork>& executableNetwork) :
+    InferRequestInternal(networkInputs, networkOutputs),
+    _executableNetwork(executableNetwork) {
+    // TODO: allocate infer request device and host buffers if needed, fill actual list of profiling tasks
+
+    auto requestID = std::to_string(_executableNetwork->_requestId);
+    _executableNetwork->_requestId++;
+
+    std::string name = _executableNetwork->_name + "_Req" + requestID;
+    _profilingTask = { {
+        { ProfilingTask("Template" + std::to_string(_executableNetwork->_cfg.deviceId) + "_" + name + "_Preprocess") },
+        { ProfilingTask("Template" + std::to_string(_executableNetwork->_cfg.deviceId) + "_" + name + "_Postprocess") },
+        { ProfilingTask("Template" + std::to_string(_executableNetwork->_cfg.deviceId) + "_" + name + "_StartPipline") },
+        { ProfilingTask("Template" + std::to_string(_executableNetwork->_cfg.deviceId) + "_" + name + "_WaitPipline") },
+    } };
+
+    allocateDeviceBuffers();
+    allocateInputBlobs();
+    allocateOutputBlobs();
+}
+// ! [infer_request:ctor]
+
+// ! [infer_request:dtor]
+TemplateInferRequest::~TemplateInferRequest() {
+    _executableNetwork->_requestId--;
+}
+// ! [infer_request:dtor]
+
+void TemplateInferRequest::allocateDeviceBuffers() {
+    // TODO: allocate device buffers if Template device is a remote one
+}
+
+void TemplateInferRequest::allocateInputBlobs() {
+    for (auto &networkInput : _networkInputs) {
+        SizeVector dims = networkInput.second->getTensorDesc().getDims();
+        Precision precision = networkInput.second->getTensorDesc().getPrecision();
+        Layout input_layout = networkInput.second->getInputData()->getLayout();
+        Blob::Ptr inputBlob;
+        Blob::Ptr inputBlobNCHW;
+        switch (precision) {
+        case Precision::FP32 :
+            inputBlobNCHW = inputBlob = InferenceEngine::make_shared_blob<float>({ precision, dims, input_layout });
+            if (input_layout == Layout::NHWC) {
+                inputBlobNCHW = InferenceEngine::make_shared_blob<float>({ precision, dims, Layout::NCHW });
+            }
+            break;
+        case Precision::FP16 :
+        case Precision::I16 :
+            inputBlobNCHW = inputBlob = InferenceEngine::make_shared_blob<int16_t>({ precision, dims, input_layout });
+            if (input_layout == Layout::NHWC) {
+                inputBlobNCHW = InferenceEngine::make_shared_blob<int16_t>({ precision, dims, Layout::NCHW });
+            }
+            break;
+        case Precision::U8 :
+            inputBlobNCHW = inputBlob = InferenceEngine::make_shared_blob<uint8_t>({ precision, dims, input_layout });
+            if (input_layout == Layout::NHWC) {
+                inputBlobNCHW = InferenceEngine::make_shared_blob<uint8_t>({ precision, dims, Layout::NCHW });
+            }
+            break;
+        default:
+            THROW_IE_EXCEPTION << "Unsupported network precision: " << precision
+                << precision << "! Supported precisions are: FP32, FP16, I16, U8";
+        }
+        // allocate the input blob
+        inputBlob->allocate();
+        _inputs[networkInput.first] = inputBlob;
+        if (inputBlobNCHW != inputBlob) {
+            inputBlobNCHW->allocate();
+        }
+        _inputsNCHW[networkInput.first] = inputBlobNCHW;
+    }
+}
+
+void TemplateInferRequest::allocateOutputBlobs() {
+    for (auto &networkOutput : _networkOutputs) {
+        SizeVector dims = networkOutput.second->getTensorDesc().getDims();
+        Precision precision = networkOutput.second->getPrecision();
+        Blob::Ptr outputBlob;
+
+        // allocate the output blob
+        Blob::Ptr outputBlobNCHW;
+        switch (precision) {
+        case Precision::FP32 :
+            outputBlobNCHW = outputBlob = InferenceEngine::make_shared_blob<float>({ precision, dims, networkOutput.second->getLayout() });
+            if (networkOutput.second->getLayout() == Layout::NHWC) {
+                outputBlobNCHW = InferenceEngine::make_shared_blob<float>({ precision, dims,  Layout::NCHW });
+            }
+            break;
+        case Precision::FP16 :
+            outputBlobNCHW = outputBlob = InferenceEngine::make_shared_blob<int16_t>({ precision, dims, networkOutput.second->getLayout() });
+            if (networkOutput.second->getLayout() == Layout::NHWC) {
+                outputBlobNCHW = InferenceEngine::make_shared_blob<int16_t>({ precision, dims, Layout::NCHW });
+            }
+            break;
+        default:
+            THROW_IE_EXCEPTION << PARAMETER_MISMATCH_str << "Unsupported output precision: "
+                << precision << "! Supported precisions are: FP32, FP16";
+        }
+        // allocate the output blob
+        outputBlob->allocate();
+        _outputs[networkOutput.first] = outputBlob;
+        if (outputBlobNCHW != outputBlob) {
+            outputBlobNCHW->allocate();
+        }
+        _outputsNCHW[networkOutput.first] = outputBlobNCHW;
+    }
+
+    if (_networkOutputs.empty() || _networkInputs.empty()) {
+        THROW_IE_EXCEPTION << "Internal error: no information about network's output/input";
+    }
+}
+
+// ! [infer_request:infer_impl]
+void TemplateInferRequest::InferImpl() {
+    // TODO: fill with actual list of pipeline stages, which are executed syncronously for sync infer requests
+    inferPreprocess();
+    startPipeline();
+    waitPipeline();
+    inferPostprocess();
+}
+// ! [infer_request:infer_impl]
+
+// ! [infer_request:infer_preprocess]
+void TemplateInferRequest::inferPreprocess() {
+    auto prev = Time::now();
+
+    // execute input pre-processing.
+    InferRequestInternal::execDataPreprocessing(_inputs);
+
+    for (auto &input : InferRequestInternal::_inputs) {
+        auto& src = input.second;
+        auto& dst = _inputsNCHW[input.first];
+        if (src != dst) {
+            if (src->getTensorDesc().getPrecision() == dst->getTensorDesc().getPrecision()
+                && src->getTensorDesc().getDims() == dst->getTensorDesc().getDims()
+                && src->getTensorDesc().getLayout() == dst->getTensorDesc().getLayout()) {
+                _inputsNCHW[input.first] = input.second;
+            } else {  // Convert Layout to NCHW
+                InferenceEngine::blob_copy(src, dst);
+            }
+        }
+    }
+
+    // TODO: Preprocessing on inputs if needed: work _inputsNCHW
+
+    _inputPreprocessTime = static_cast<double>(std::chrono::duration_cast<ns>(Time::now() - prev).count());
+}
+// ! [infer_request:infer_preprocess]
+
+void TemplateInferRequest::startPipeline() {
+    IE_PROFILING_AUTO_SCOPE_TASK(_profilingTask[StartPipeline])
+    // TODO: Start pipeline and fill _inputTransferTime, _executeTime, _outputTransferTime
+}
+
+void TemplateInferRequest::waitPipeline() {
+    IE_PROFILING_AUTO_SCOPE_TASK(_profilingTask[WaitPipeline])
+    auto prev = Time::now();
+    // TODO: Wait pipeline using driver API or other synronizations methods
+    _inputPreprocessTime = static_cast<double>(std::chrono::duration_cast<ns>(Time::now() - prev).count());
+}
+
+void TemplateInferRequest::inferPostprocess() {
+    IE_PROFILING_AUTO_SCOPE_TASK(_profilingTask[Postprocess])
+    auto prev = Time::now();
+    // TODO: perform post-processing and convert to NHWC layout
+    _outputPostProcessTime = static_cast<double>(std::chrono::duration_cast<ns>(Time::now() - prev).count());
+}
+
+// ! [infer_request:get_performance_counts]
+void TemplateInferRequest::GetPerformanceCounts(std::map<std::string, InferenceEngineProfileInfo> &perfMap) const {
+    InferenceEngineProfileInfo info;
+    info.execution_index = 0;
+    info.status = InferenceEngineProfileInfo::EXECUTED;
+    info.cpu_uSec = info.realTime_uSec = _inputPreprocessTime / 1000;
+    perfMap["1. input preprocessing"] = info;
+    info.cpu_uSec = 0;
+    info.realTime_uSec = _inputTransferTime / 1000;
+    perfMap["2. input transfer to a device"] = info;
+    info.cpu_uSec = 0;
+    info.realTime_uSec = _executeTime / 1000;
+    perfMap["3. execution time"] = info;
+    info.cpu_uSec = 0;
+    info.realTime_uSec = _outputTransferTime / 1000;
+    perfMap["4. output transfer from a device"] = info;
+    info.cpu_uSec = info.realTime_uSec = _outputPostProcessTime / 1000;
+    perfMap["5. output postprocessing"] = info;
+}
+// ! [infer_request:get_performance_counts]

docs/template_plugin/src/template_infer_request.hpp

@@ -0,0 +1,74 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+#include <memory>
+#include <unordered_map>
+
+#include <ie_common.h>
+#include <ie_profiling.hpp>
+#include <cpp_interfaces/impl/ie_infer_request_internal.hpp>
+#include <cpp_interfaces/impl/ie_executable_network_internal.hpp>
+#include <threading/ie_itask_executor.hpp>
+
+#include "template_config.hpp"
+
+namespace TemplatePlugin {
+
+class ExecutableNetwork;
+
+// ! [infer_request:header]
+class TemplateInferRequest : public InferenceEngine::InferRequestInternal {
+public:
+    typedef std::shared_ptr<TemplateInferRequest> Ptr;
+
+    TemplateInferRequest(const InferenceEngine::InputsDataMap&     networkInputs,
+                         const InferenceEngine::OutputsDataMap&    networkOutputs,
+                         const std::shared_ptr<ExecutableNetwork>& executableNetwork);
+    ~TemplateInferRequest() override;
+
+    void InferImpl() override;
+    void GetPerformanceCounts(std::map<std::string, InferenceEngine::InferenceEngineProfileInfo>& perfMap) const override;
+
+    // pipeline methods-stages which are used in async infer request implementation and assigned to particular executor
+    void inferPreprocess();
+    void startPipeline();
+    void waitPipeline();
+    void inferPostprocess();
+
+    std::shared_ptr<ExecutableNetwork>                      _executableNetwork;
+
+private:
+    void allocateDeviceBuffers();
+    void allocateInputBlobs();
+    void allocateOutputBlobs();
+
+    enum {
+        Preprocess,
+        Postprocess,
+        StartPipeline,
+        WaitPipeline,
+        numOfStages
+    };
+
+    std::array<InferenceEngine::ProfilingTask, numOfStages> _profilingTask;
+
+    InferenceEngine::BlobMap                                _inputsNCHW;
+    InferenceEngine::BlobMap                                _outputsNCHW;
+
+    // for performance counts
+    double                                                  _inputPreprocessTime   = 0.0;
+    double                                                  _inputTransferTime     = 0.0;
+    double                                                  _executeTime           = 0.0;
+    double                                                  _outputTransferTime    = 0.0;
+    double                                                  _outputPostProcessTime = 0.0;
+};
+// ! [infer_request:header]
+
+}  // namespace TemplatePlugin

docs/template_plugin/src/template_plugin.cpp

@@ -0,0 +1,194 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+
+#include <utility>
+#include <memory>
+#include <vector>
+#include <sstream>
+#include <regex>
+#include <string>
+#include <map>
+
+#include <ie_metric_helpers.hpp>
+#include <details/ie_cnn_network_tools.h>
+#include <ie_plugin_config.hpp>
+#include <ie_util_internal.hpp>
+#include <inference_engine.hpp>
+#include <file_utils.h>
+#include <cpp_interfaces/base/ie_plugin_base.hpp>
+#include <cpp_interfaces/interface/ie_internal_plugin_config.hpp>
+#include <threading/ie_executor_manager.hpp>
+#include <graph_tools.hpp>
+#include <ie_input_info.hpp>
+#include <ie_layouts.h>
+#include <hetero/hetero_plugin_config.hpp>
+#include <template/template_config.hpp>
+
+#include "template_plugin.hpp"
+#include "template_executable_network.hpp"
+#include "template_infer_request.hpp"
+
+using namespace TemplatePlugin;
+
+// ! [plugin:ctor]
+Plugin::Plugin() {
+    // TODO: fill with actual device name
+    _pluginName = "TEMPLATE";
+}
+// ! [plugin:ctor]
+
+// ! [plugin:load_exe_network_impl]
+InferenceEngine::ExecutableNetworkInternal::Ptr Plugin::LoadExeNetworkImpl(const InferenceEngine::ICore * core,
+    const InferenceEngine::ICNNNetwork & network,
+    const ConfigMap &config) {
+    auto cfg = Configuration{ config, _cfg };
+    InferenceEngine::InputsDataMap networkInputs;
+    InferenceEngine::OutputsDataMap networkOutputs;
+
+    network.getInputsInfo(networkInputs);
+    network.getOutputsInfo(networkOutputs);
+
+    // TODO: check with precisions supported by Template device
+
+    for (auto networkOutput : networkOutputs) {
+        auto output_precision = networkOutput.second->getPrecision();
+
+        if (output_precision != Precision::FP32 &&
+            output_precision != Precision::FP16) {
+            THROW_IE_EXCEPTION << "Template device supports only FP16 and FP32 output precision.";
+        }
+    }
+
+    for (auto networkInput : networkInputs) {
+        auto input_precision = networkInput.second->getTensorDesc().getPrecision();
+
+        if (input_precision != InferenceEngine::Precision::FP32 &&
+            input_precision != InferenceEngine::Precision::FP16 &&
+            input_precision != InferenceEngine::Precision::I16 &&
+            input_precision != InferenceEngine::Precision::U8) {
+            THROW_IE_EXCEPTION << "Input image format " << input_precision << " is not supported yet.\n"
+                       << "Supported formats are: FP32, FP16, I16 and U8.";
+        }
+    }
+
+    auto clonedNetwork = cloneNet(network);
+    ConstTransformer transformator(clonedNetwork.get());
+    transformator.fullTrim();
+
+    return std::make_shared<ExecutableNetwork>(*clonedNetwork, cfg);
+}
+// ! [plugin:load_exe_network_impl]
+
+// ! [plugin:import_network_impl]
+InferenceEngine::ExecutableNetwork Plugin::ImportNetworkImpl(std::istream& model, const std::map<std::string, std::string>& config) {
+    // TODO: Import network from stream is not mandatory functionality;
+    // Can just throw an exception and remove the code below
+    Configuration exportedCfg;
+
+    // some code below which reads exportedCfg from `model` stream
+    // ..
+
+    auto cfg = Configuration(config, exportedCfg);
+
+    IExecutableNetwork::Ptr executableNetwork;
+    auto exec_network_impl = std::make_shared<ExecutableNetwork>(model, cfg);
+    executableNetwork.reset(new ExecutableNetworkBase<ExecutableNetworkInternal>(exec_network_impl),
+                            [](InferenceEngine::details::IRelease *p) {p->Release(); });
+
+    return InferenceEngine::ExecutableNetwork{ executableNetwork };
+}
+// ! [plugin:import_network_impl]
+
+// ! [plugin:query_network]
+void Plugin::QueryNetwork(const ICNNNetwork &network, const ConfigMap& config, QueryNetworkResult &res) const {
+    Configuration cfg{config, _cfg, false};
+    res.rc = StatusCode::OK;
+
+    if (std::shared_ptr<const ngraph::Function> ngraphFunction = network.getFunction()) {
+        auto ops = ngraphFunction->get_ordered_ops();
+        for (auto&& op : ops) {
+            // TODO: investigate if an op is actually supported by Template device
+            bool supported = true;
+            if (supported) {
+                res.supportedLayersMap.insert({ op->get_friendly_name(), GetName() });
+            }
+        }
+    } else {
+        THROW_IE_EXCEPTION << "TEMPLATE plugin can query only IR v10 networks";
+    }
+}
+// ! [plugin:query_network]
+
+// ! [plugin:add_extension]
+void Plugin::AddExtension(InferenceEngine::IExtensionPtr /*extension*/) {
+    // TODO: add extensions if plugin supports extensions
+}
+// ! [plugin:add_extension]
+
+// ! [plugin:set_config]
+void Plugin::SetConfig(const ConfigMap &config) {
+    _cfg = Configuration{config, _cfg};
+}
+// ! [plugin:set_config]
+
+// ! [plugin:get_config]
+InferenceEngine::Parameter Plugin::GetConfig(const std::string& name, const std::map<std::string, InferenceEngine::Parameter> & /*options*/) const {
+    return _cfg.Get(name);
+}
+// ! [plugin:get_config]
+
+// ! [plugin:get_metric]
+InferenceEngine::Parameter Plugin::GetMetric(const std::string& name, const std::map<std::string, InferenceEngine::Parameter> & options) const {
+    if (METRIC_KEY(SUPPORTED_METRICS) == name) {
+        std::vector<std::string> supportedMetrics = {
+            METRIC_KEY(AVAILABLE_DEVICES),
+            METRIC_KEY(SUPPORTED_METRICS),
+            METRIC_KEY(SUPPORTED_CONFIG_KEYS),
+            METRIC_KEY(FULL_DEVICE_NAME),
+            METRIC_KEY(OPTIMIZATION_CAPABILITIES),
+            METRIC_KEY(RANGE_FOR_ASYNC_INFER_REQUESTS) };
+        IE_SET_METRIC_RETURN(SUPPORTED_METRICS, supportedMetrics);
+    } else if (METRIC_KEY(SUPPORTED_CONFIG_KEYS) == name) {
+        std::vector<std::string> confiKeys = {
+            CONFIG_KEY(DEVICE_ID),
+            CONFIG_KEY(PERF_COUNT) };
+        IE_SET_METRIC_RETURN(SUPPORTED_CONFIG_KEYS, confiKeys);
+    } else if (METRIC_KEY(AVAILABLE_DEVICES) == name) {
+        // TODO: fill list of available devices
+        std::vector<std::string> availableDevices = { "" };
+        IE_SET_METRIC_RETURN(AVAILABLE_DEVICES, availableDevices);
+    } else if (METRIC_KEY(FULL_DEVICE_NAME) == name) {
+        std::string name = "Template Device Full Name";
+        IE_SET_METRIC_RETURN(FULL_DEVICE_NAME, name);
+    } else if (METRIC_KEY(OPTIMIZATION_CAPABILITIES) == name) {
+        // TODO: fill actual list of supported capabilities: e.g. Template device supports only FP32
+        std::vector<std::string> capabilities = { METRIC_VALUE(FP32), TEMPLATE_METRIC_VALUE(HARDWARE_CONVOLUTION) };
+        IE_SET_METRIC_RETURN(OPTIMIZATION_CAPABILITIES, capabilities);
+    } else if (METRIC_KEY(RANGE_FOR_ASYNC_INFER_REQUESTS) == name) {
+        // TODO: fill with actual values
+        using uint = unsigned int;
+        IE_SET_METRIC_RETURN(RANGE_FOR_ASYNC_INFER_REQUESTS, std::make_tuple(uint{1}, uint{1}, uint{1}));
+    } else  {
+        THROW_IE_EXCEPTION << "Unsupported device metric: " << name;
+    }
+}
+// ! [plugin:get_metric]
+
+IE_SUPPRESS_DEPRECATED_START
+
+// ! [plugin:create_plugin_engine]
+INFERENCE_PLUGIN_API(StatusCode) CreatePluginEngine(IInferencePlugin *&plugin, ResponseDesc *resp) noexcept {
+    try {
+        plugin = make_ie_compatible_plugin({2, 1, CI_BUILD_NUMBER, "templatePlugin"},
+                                           std::make_shared<Plugin>());
+        return OK;
+    }
+    catch (std::exception &ex) {
+        return DescriptionBuffer(GENERAL_ERROR, resp) << ex.what();
+    }
+}
+// ! [plugin:create_plugin_engine]
+
+IE_SUPPRESS_DEPRECATED_END

docs/template_plugin/src/template_plugin.hpp

@@ -0,0 +1,48 @@
+// Copyright (C) 2020 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <inference_engine.hpp>
+#include <description_buffer.hpp>
+#include <cpp_interfaces/impl/ie_plugin_internal.hpp>
+#include <ie_error.hpp>
+
+#include <memory>
+#include <string>
+#include <map>
+#include <unordered_map>
+#include <vector>
+
+#include "template_executable_network.hpp"
+#include "template_config.hpp"
+
+//! [plugin:header]
+namespace TemplatePlugin {
+
+class Plugin : public InferenceEngine::InferencePluginInternal {
+public:
+    using Ptr = std::shared_ptr<Plugin>;
+
+    Plugin();
+    ~Plugin() override = default;
+
+    void SetConfig(const std::map<std::string, std::string> &config) override;
+    void QueryNetwork(const InferenceEngine::ICNNNetwork &network,
+                      const std::map<std::string, std::string>& config,
+                      InferenceEngine::QueryNetworkResult &res) const override;
+    InferenceEngine::ExecutableNetworkInternal::Ptr
+    LoadExeNetworkImpl(const InferenceEngine::ICore * core, const InferenceEngine::ICNNNetwork &network,
+                       const std::map<std::string, std::string> &config) override;
+    void AddExtension(InferenceEngine::IExtensionPtr extension) override;
+    InferenceEngine::Parameter GetConfig(const std::string& name, const std::map<std::string, InferenceEngine::Parameter> & options) const override;
+    InferenceEngine::Parameter GetMetric(const std::string& name, const std::map<std::string, InferenceEngine::Parameter> & options) const override;
+    InferenceEngine::ExecutableNetwork ImportNetworkImpl(std::istream& model, const std::map<std::string, std::string>& config) override;
+
+private:
+    Configuration                    _cfg;
+};
+
+}  // namespace TemplatePlugin
+//! [plugin:header]

get-started-linux.md

@@ -1,43 +1,59 @@
 # Get Started with OpenVINO™ Deep Learning Deployment Toolkit (DLDT) on Linux*
 
-This guide provides you with the information that will help you to start using the DLDT on Linux*. With this guide you will learn how to:
+This guide provides you with the information that will help you to start using 
+the OpenVINO on Linux\*. With this guide, you will learn how to:
 
 1. [Configure the Model Optimizer](#configure-the-model-optimizer)
-2. [Prepare a model for sample inference:](#prepare-a-model-for-sample-inference)
+2. [Prepare a model for sample inference](#prepare-a-model-for-sample-inference)
    1. [Download a pre-trained model](#download-a-trained-model)
    2. [Convert the model to an Intermediate Representation (IR) with the Model Optimizer](#convert-the-model-to-an-intermediate-representation-with-the-model-optimizer)
 3. [Run the Image Classification Sample Application with the model](#run-the-image-classification-sample-application)
 
 ## Prerequisites
-1. This guide assumes that you have already cloned the `dldt` repo and successfully built the Inference Engine and Samples using the [build instructions](inference-engine/README.md). 
-2. The original structure of the repository directories is kept unchanged.
+1. This guide assumes that you have already cloned the `openvino` repo and 
+   successfully built the Inference Engine and Samples using the 
+   [build instructions](inference-engine/README.md). 
+2. The original structure of the repository directories remains unchanged.
 
-> **NOTE**: Below, the directory to which the `dldt` repository is cloned is referred to as `<DLDT_DIR>`.  
+> **NOTE**: Below, the directory to which the `openvino` repository is cloned is 
+referred to as `<OPENVINO_DIR>`.  
 
 ## Configure the Model Optimizer
 
-The Model Optimizer is a Python\*-based command line tool for importing trained models from popular deep learning frameworks such as Caffe\*, TensorFlow\*, Apache MXNet\*, ONNX\* and Kaldi\*.
+The Model Optimizer is a Python\*-based command line tool for importing trained 
+models from popular deep learning frameworks such as Caffe\*, TensorFlow\*, 
+Apache MXNet\*, ONNX\* and Kaldi\*.
 
-You cannot perform inference on your trained model without running the model through the Model Optimizer. When you run a pre-trained model through the Model Optimizer, your output is an Intermediate Representation (IR) of the network. The Intermediate Representation is a pair of files that describe the whole model:
+You cannot perform inference on your trained model without having first run the 
+model through the Model Optimizer. When you run a pre-trained model through the 
+Model Optimizer, it outputs an *Intermediate Representation*, or *(IR)* of 
+the network, a pair of files that describes the whole model:
 
 - `.xml`: Describes the network topology
 - `.bin`: Contains the weights and biases binary data
 
-For more information about the Model Optimizer, refer to the [Model Optimizer Developer Guide](https://docs.openvinotoolkit.org/latest/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html). 
+For more information about the Model Optimizer, refer to the 
+[Model Optimizer Developer Guide]. 
 
 ### Model Optimizer Configuration Steps
 
-You can choose to either configure all supported frameworks at once **OR** configure one framework at a time. Choose the option that best suits your needs. If you see error messages, make sure you installed all dependencies.
+You can choose to either configure all supported frameworks at once **OR** 
+configure one framework at a time. Choose the option that best suits your needs. 
+If you see error messages, check for any missing dependencies.
 
-> **NOTE**: Since the TensorFlow framework is not officially supported on CentOS*, the Model Optimizer for TensorFlow can't be configured and ran on those systems.  
+> **NOTE**: The TensorFlow\* framework is not officially supported on CentOS\*, 
+  so the Model Optimizer for TensorFlow cannot be configured on, or run with 
+  CentOS.  
 
-> **IMPORTANT**: The Internet access is required to execute the following steps successfully. If you have access to the Internet through the proxy server only, please make sure that it is configured in your OS environment.
+> **IMPORTANT**: Internet access is required to execute the following steps 
+  successfully. If you access the Internet via proxy server only, please make 
+  sure that it is configured in your OS environment as well.
 
 **Option 1: Configure all supported frameworks at the same time**
 
 1.  Go to the Model Optimizer prerequisites directory:
 ```sh
-cd <DLDT_DIR>/model_optimizer/install_prerequisites
+cd <OPENVINO_DIR>/model_optimizer/install_prerequisites
 ```
 2.  Run the script to configure the Model Optimizer for Caffe,
     TensorFlow, MXNet, Kaldi\*, and ONNX:
@@ -47,11 +63,12 @@ sudo ./install_prerequisites.sh
 
 **Option 2: Configure each framework separately**
 
-Configure individual frameworks separately **ONLY** if you did not select **Option 1** above.
+Configure individual frameworks separately **ONLY** if you did not select 
+**Option 1** above.
 
 1.  Go to the Model Optimizer prerequisites directory:
 ```sh
-cd <DLDT_DIR>/model_optimizer/install_prerequisites
+cd <OPENVINO_DIR>/model_optimizer/install_prerequisites
 ```
 2.  Run the script for your model framework. You can run more than one script:
 
@@ -79,25 +96,45 @@ cd <DLDT_DIR>/model_optimizer/install_prerequisites
    ```sh
    sudo ./install_prerequisites_kaldi.sh
    ```
-The Model Optimizer is configured for one or more frameworks. Continue to the next session to download and prepare a model for running a sample inference.
+The Model Optimizer is configured for one or more frameworks. Continue to the 
+next session to download and prepare a model for running a sample inference.
 
 ## Prepare a Model for Sample Inference
 
-This paragraph contains the steps to get the pre-trained model for sample inference and to prepare the model's optimized Intermediate Representation that Inference Engine uses.
+This section describes how to get a pre-trained model for sample inference
+and how to prepare the optimized Intermediate Representation (IR) that 
+Inference Inference Engine uses.
+
 
 ### Download a Trained Model
 
-To run the Image Classification Sample you'll need a pre-trained model to run the inference on. This guide will use the public SqueezeNet 1.1 Caffe* model. You can find and download this model manually or use the OpenVINO™ [Model Downloader](https://github.com/opencv/open_model_zoo/tree/master/tools/downloader). 
+To run the Image Classification Sample, you need a pre-trained model to run 
+the inference on. This guide uses the public SqueezeNet 1.1 Caffe\* model. 
+You can find and download this model manually or use the OpenVINO™ 
+[Model Downloader]. 
 
-With the Model Downloader, you can download other popular public deep learning topologies and the [OpenVINO™ pre-trained models](https://github.com/opencv/open_model_zoo/tree/master/models/intel) prepared for running inference for a wide list of inference scenarios: object detection, object recognition, object re-identification, human pose estimation, action recognition and others.
+With the Model Downloader, you can download other popular public deep learning 
+topologies and [OpenVINO™ pre-trained models], which are already prepared for 
+running inference upon a wide list of inference scenarios: 
 
-To download the SqueezeNet 1.1 Caffe* model to a models folder with the Model Downloader:
-1. Install the [prerequisites](https://github.com/opencv/open_model_zoo/tree/master/tools/downloader#prerequisites).
-2. Run the `downloader.py` with specifying the topology name and a `<models_dir>` path. For example to download the model to the `~/public_models` directory:
+* object detection, 
+* object recognition, 
+* object re-identification, 
+* human pose estimation, 
+* action recognition, and others.
+
+To download the SqueezeNet 1.1 Caffe* model to a `models` folder (referred to 
+as `<models_dir>` below) with the Model Downloader:
+
+1. Install the [prerequisites].
+2. Run the `downloader.py` script, specifying the topology name and the path 
+   to your `<models_dir>`. For example, to download the model to a directory 
+   named `~/public_models`, run:
    ```sh
    ./downloader.py --name squeezenet1.1 --output_dir ~/public_models
    ```
-   When the model files are successfully downloaded the output similar to the following is printed:
+   When the model files are successfully downloaded, output similar to the 
+   following is printed:
    ```sh
    ###############|| Downloading topologies ||###############
 
@@ -117,59 +154,74 @@ To download the SqueezeNet 1.1 Caffe* model to a models folder with the Model Do
 
 1. Create a `<ir_dir>` directory that will contains the Intermediate Representation (IR) of the model. 
 
-2. Inference Engine can perform inference on a [list of supported devices](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_supported_plugins_Supported_Devices.html) using specific device plugins. Different plugins support models of [different precision formats](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_supported_plugins_Supported_Devices.html#supported_model_formats), such as FP32, FP16, INT8. To prepare an IR to run inference on a particular hardware, run the Model Optimizer with the appropriate `--data_type` options:
+2. Inference Engine can perform inference on a [list of supported devices] 
+   using specific device plugins. Different plugins support models of 
+   [different precision formats], such as `FP32`, `FP16`, `INT8`. To prepare an 
+   IR to run inference on particular hardware, run the Model Optimizer with the 
+   appropriate `--data_type` options:
 
    **For CPU (FP32):**
    ```sh  
-   python3 <DLDT_DIR>/model_optimizer/mo.py --input_model <models_dir>/classification/squeezenet/1.1/caffe/squeezenet1.1.caffemodel --data_type FP32 --output_dir <ir_dir>
+   python3 <OPENVINO_DIR>/model_optimizer/mo.py --input_model <models_dir>/classification/squeezenet/1.1/caffe/squeezenet1.1.caffemodel --data_type FP32 --output_dir <ir_dir>
    ```
 
    **For GPU and MYRIAD (FP16):**
    ```sh  
-   python3 <DLDT_DIR>/model_optimizer/mo.py --input_model <models_dir>/classification/squeezenet/1.1/caffe/squeezenet1.1.caffemodel --data_type FP16 --output_dir <ir_dir>
+   python3 <OPENVINO_DIR>/model_optimizer/mo.py --input_model <models_dir>/classification/squeezenet/1.1/caffe/squeezenet1.1.caffemodel --data_type FP16 --output_dir <ir_dir>
    ``` 
    After the Model Optimizer script is completed, the produced IR files (`squeezenet1.1.xml`, `squeezenet1.1.bin`) are in the specified `<ir_dir>` directory.
 
-3. Copy the `squeezenet1.1.labels` file from the `<DLDT_DIR>/inference-engine/samples/sample_data/` to the model IR directory. This file contains the classes that ImageNet uses so that the inference results show text instead of classification numbers:
-   ```sh
-   cp <DLDT_DIR>/inference-engine/samples/sample_data/squeezenet1.1.labels <ir_dir>
+3. Copy the `squeezenet1.1.labels` file from the `<OPENVINO_DIR>/scripts/demo/` 
+   folder to the model IR directory. This file contains the classes that ImageNet 
+   uses so that the inference results show text instead of classification numbers:
+   ```sh   
+   cp <OPENVINO_DIR>/scripts/demo/squeezenet1.1.labels <ir_dir>
    ```
 
 Now you are ready to run the Image Classification Sample Application.
 
 ## Run the Image Classification Sample Application
 
-The Inference Engine sample applications are automatically compiled when you built the Inference Engine using the [build instructions](inference-engine/README.md). The binary files are located in the `<DLDT_DIR>/inference-engine/bin/intel64/Release` directory.
+The Inference Engine sample applications are automatically compiled when you 
+built the Inference Engine using the [build instructions](inference-engine/README.md). 
+The binary files are located in the `<OPENVINO_DIR>/inference-engine/bin/intel64/Release` 
+directory.
 
-Follow the steps below to run the Image Classification sample application on the prepared IR and with an input image: 
+To run the Image Classification sample application with an input image on the prepared IR: 
 
 1. Go to the samples build directory:
    ```sh
-   cd <DLDT_DIR>/inference-engine/bin/intel64/Release
-   ```
-2. Run the sample executable with specifying the `car.png` file from the `<DLDT_DIR>/inference-engine/samples/sample_data/` directory as an input image, the IR of your model and a plugin for a hardware device to perform inference on:
+   cd <OPENVINO_DIR>/inference-engine/bin/intel64/Release
+   
+2. Run the sample executable with specifying the `car.png` file from the 
+   `<OPENVINO_DIR>/scripts/demo/` directory as an input 
+   image, the IR of your model and a plugin for a hardware device to perform 
+   inference on:
 
    **For CPU:**
    ```sh
-   ./classification_sample -i <DLDT_DIR>/inference-engine/samples/sample_data/car.png -m <ir_dir>/squeezenet1.1.xml -d CPU
+   ./classification_sample -i <OPENVINO_DIR>/scripts/demo/car.png -m <ir_dir>/squeezenet1.1.xml -d CPU
    ```
 
    **For GPU:**
    ```sh
-   ./classification_sample -i <DLDT_DIR>/inference-engine/samples/sample_data/car.png -m <ir_dir>/squeezenet1.1.xml -d GPU
+   ./classification_sample -i <OPENVINO_DIR>/scripts/demo/car.png -m <ir_dir>/squeezenet1.1.xml -d GPU
    ```
    
    **For MYRIAD:** 
-   >**NOTE**: Running inference on VPU devices (Intel® Movidius™ Neural Compute Stick or Intel® Neural Compute Stick 2) with the MYRIAD plugin requires performing [additional hardware configuration steps](inference-engine/README.md#optional-additional-installation-steps-for-the-intel-movidius-neural-compute-stick-and-neural-compute-stick-2).
-   ```sh
-   ./classification_sample -i <DLDT_DIR>/inference-engine/samples/sample_data/car.png -m <ir_dir>/squeezenet1.1.xml -d MYRIAD
+
+   >**NOTE**: Running inference on VPU devices (Intel® Movidius™ Neural Compute 
+   Stick or Intel® Neural Compute Stick 2) with the MYRIAD plugin requires 
+   performing [additional hardware configuration steps](inference-engine/README.md#optional-additional-installation-steps-for-the-intel-movidius-neural-compute-stick-and-neural-compute-stick-2).
+   ```sh   
+   ./classification_sample -i <OPENVINO_DIR>/scripts/demo/car.png -m <ir_dir>/squeezenet1.1.xml -d MYRIAD
    ```
 
 When the Sample Application completes, you will have the label and confidence for the top-10 categories printed on the screen. Below is a sample output with inference results on CPU:    
 ```sh
 Top 10 results:
 
-Image /home/user/dldt/inference-engine/samples/sample_data/car.png
+Image /home/user/openvino/scripts/demo/car.png
 
 classid probability label
 ------- ----------- -----
@@ -199,5 +251,12 @@ Throughput: 375.3339402 FPS
 * [Inference Engine build instructions](inference-engine/README.md)
 * [Introduction to Intel® 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)
+* [Model Optimizer Developer Guide]
 * [Inference Engine Samples Overview](https://docs.openvinotoolkit.org/latest/_docs_IE_DG_Samples_Overview.html). 
+
+[Model Optimizer Developer Guide]:https://docs.openvinotoolkit.org/latest/_docs_MO_DG_Deep_Learning_Model_Optimizer_DevGuide.html
+[Model Downloader]:https://github.com/opencv/open_model_zoo/tree/master/tools/downloader
+[OpenVINO™ pre-trained models]:https://github.com/opencv/open_model_zoo/tree/master/models/intel
+[prerequisites]:https://github.com/opencv/open_model_zoo/tree/master/tools/downloader#prerequisites 
+[list of supported devices]:https://docs.openvinotoolkit.org/latest/_docs_IE_DG_supported_plugins_Supported_Devices.html
+[different precision formats]:https://docs.openvinotoolkit.org/latest/_docs_IE_DG_supported_plugins_Supported_Devices.html#supported_model_formats

inference-engine/CMakeLists.txt

@@ -1,57 +1,79 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
-
-if (APPLE)
-    # due to https://cmake.org/cmake/help/v3.12/policy/CMP0068.html
-    cmake_minimum_required(VERSION 3.9 FATAL_ERROR)
-else()
-    cmake_minimum_required(VERSION 3.5 FATAL_ERROR)
-endif()
-
 project(InferenceEngine)
 
-set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
-set(IE_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(CMAKE_MODULE_PATH "${IE_MAIN_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
 
-include(CTest)
-include(features)
+include(features_ie)
 
 # include developer package
-include(developer_package)
+include(developer_package_ie)
 
 # These options are shared with 3rdparty plugins
 # by means of developer package
-include(check_features)
+include(check_features_ie)
 
 # resolving dependencies for the project
 include(dependencies)
 
-message (STATUS "PROJECT ............................... " ${PROJECT_NAME})
-message (STATUS "CMAKE_BINARY_DIR ...................... " ${CMAKE_BINARY_DIR})
-message (STATUS "IE_MAIN_SOURCE_DIR .................... " ${IE_MAIN_SOURCE_DIR})
-message (STATUS "CMAKE_GENERATOR ....................... " ${CMAKE_GENERATOR})
-message (STATUS "CMAKE_C_COMPILER_ID ................... " ${CMAKE_C_COMPILER_ID})
-message (STATUS "CMAKE_BUILD_TYPE ...................... " ${CMAKE_BUILD_TYPE})
 
-# remove file with exported developer targets to force its regeneration
-file(REMOVE "${CMAKE_BINARY_DIR}/targets_developer.cmake")
+# Fuzz tests also building without ENABLE_FUZZING
+include(fuzzing)
+
+if (ENABLE_FUZZING)
+    enable_fuzzing()
+endif()
+
+find_package(ngraph QUIET)
+if(NOT ngraph_FOUND)
+    set(ngraph_DIR ${CMAKE_BINARY_DIR}/ngraph)
+endif()
+find_package(ngraph REQUIRED)
+
+find_package(Threads REQUIRED)
+
+unset(IEDeveloperPackageTargets CACHE)
+function(ie_developer_export_targets)
+    set(IEDeveloperPackageTargets "${IEDeveloperPackageTargets};${ARGV}")
+
+    # to allow exporting of aliased targets with the original names
+    foreach(target_name ${IEDeveloperPackageTargets})
+        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 IEDeveloperPackageTargets ${target_name})
+                list(APPEND IEDeveloperPackageTargets ${original_name})
+            endif()
+        endif()
+    endforeach()
+
+    list(REMOVE_DUPLICATES IEDeveloperPackageTargets)
+    set(IEDeveloperPackageTargets "${IEDeveloperPackageTargets}" CACHE INTERNAL
+        "Paths to extra Inference Engine plugins" FORCE)
+endfunction()
+
+function(ie_developer_export)
+    export(TARGETS ${IEDeveloperPackageTargets} NAMESPACE IE::
+            APPEND FILE "${CMAKE_BINARY_DIR}/targets_developer.cmake")
+
+    # Custom target to build only Inference Engine Developer Package targets
+    add_custom_target(ie_dev_targets ALL DEPENDS ${IEDeveloperPackageTargets})
+endfunction()
+
+add_subdirectory(thirdparty)
 
 add_subdirectory(src)
 
 if(ENABLE_TESTS)
+    add_subdirectory(tests_deprecated)
     add_subdirectory(tests)
 endif()
 
-add_subdirectory(thirdparty)
-
 add_subdirectory(tools)
 
-if (ENABLE_SAMPLES)
-    # hint for find_package(InferenceEngine in the samples folder)
-    set(InferenceEngine_DIR "${CMAKE_BINARY_DIR}")
-endif()
-
 # gflags and format_reader targets are kept inside of samples directory and
 # they must be built even if samples build is disabled (required for tests and tools).
 add_subdirectory(samples)
@@ -65,4 +87,123 @@ if (ENABLE_PYTHON)
     add_subdirectory(ie_bridges/python)
 endif()
 
+if (ENABLE_C)
+    add_subdirectory(ie_bridges/c)
+endif()
+
 add_cpplint_report_target()
+
+#
+# Install
+#
+
+# install C++ samples
+
+ie_cpack_add_component(cpp_samples REQUIRED DEPENDS core)
+
+if(UNIX)
+    install(DIRECTORY samples/
+            DESTINATION ${IE_CPACK_IE_DIR}/samples/cpp
+            COMPONENT cpp_samples
+            USE_SOURCE_PERMISSIONS
+            PATTERN *.bat EXCLUDE
+            PATTERN speech_libs_and_demos EXCLUDE)
+elseif(WIN32)
+    install(DIRECTORY samples/
+            DESTINATION ${IE_CPACK_IE_DIR}/samples/cpp
+            COMPONENT cpp_samples
+            USE_SOURCE_PERMISSIONS
+            PATTERN *.sh EXCLUDE
+            PATTERN speech_libs_and_demos EXCLUDE)
+endif()
+
+# install C samples
+
+ie_cpack_add_component(c_samples REQUIRED DEPENDS core)
+
+if(UNIX)
+    install(PROGRAMS samples/build_samples.sh
+            DESTINATION ${IE_CPACK_IE_DIR}/samples/c
+            COMPONENT c_samples)
+elseif(WIN32)
+    install(PROGRAMS samples/build_samples_msvc.bat
+            DESTINATION ${IE_CPACK_IE_DIR}/samples/c
+            COMPONENT c_samples)
+endif()
+
+install(DIRECTORY ie_bridges/c/samples/
+        DESTINATION ${IE_CPACK_IE_DIR}/samples/c
+        COMPONENT c_samples
+        PATTERN ie_bridges/c/samples/CMakeLists.txt EXCLUDE)
+
+install(FILES samples/CMakeLists.txt
+        DESTINATION ${IE_CPACK_IE_DIR}/samples/c
+        COMPONENT c_samples)
+
+# install Python samples
+
+if(ENABLE_PYTHON)
+    ie_cpack_add_component(python_samples REQUIRED DEPENDS core)
+
+    install(DIRECTORY ${ie_python_api_SOURCE_DIR}/sample/
+            DESTINATION ${IE_CPACK_IE_DIR}/samples/python
+            COMPONENT python_samples)
+endif()
+
+#
+# Developer package
+#
+
+ie_developer_export_targets(format_reader)
+ie_developer_export_targets(${NGRAPH_LIBRARIES})
+
+ie_developer_export()
+
+configure_file(
+    "${IE_MAIN_SOURCE_DIR}/cmake/developer_package_config.cmake.in"
+    "${CMAKE_BINARY_DIR}/InferenceEngineDeveloperPackageConfig.cmake"
+    @ONLY)
+
+configure_file(
+    "${IE_MAIN_SOURCE_DIR}/cmake/share/InferenceEngineConfig-version.cmake.in"
+    "${CMAKE_BINARY_DIR}/InferenceEngineDeveloperPackageConfig-version.cmake"
+    COPYONLY)
+
+#
+# Coverage
+#
+
+if(COVERAGE)
+    include(coverage_ie)
+endif()
+
+#
+# Add plugins
+#
+
+function(register_extra_plugins)
+    set(InferenceEngineDeveloperPackage_DIR "${CMAKE_CURRENT_BINARY_DIR}/build-plugins")
+    set(iedevconfig_file "${InferenceEngineDeveloperPackage_DIR}/InferenceEngineDeveloperPackageConfig.cmake")
+    file(REMOVE "${iedevconfig_file}")
+
+    file(WRITE "${iedevconfig_file}" "\# !! AUTOGENERATED: DON'T EDIT !!\n\n")
+    file(APPEND "${iedevconfig_file}" "ie_deprecated_no_errors()\n")
+
+    foreach(target IN LISTS IEDeveloperPackageTargets)
+        if(target)
+            file(APPEND "${iedevconfig_file}" "add_library(IE::${target} ALIAS ${target})\n")
+        endif()
+    endforeach()
+
+    # automatically import plugins from the 'plugins' folder
+    file(GLOB local_extra_plugins "plugins/*")
+    list(APPEND local_extra_plugins "${OpenVINO_MAIN_SOURCE_DIR}/docs/template_plugin")
+
+    foreach(plugin_path IN LISTS IE_EXTRA_PLUGINS local_extra_plugins)
+        get_filename_component(plugin_dir "${plugin_path}" NAME)
+        message(STATUS "Register ${plugin_dir} to be built in build-plugins/${plugin_dir}")
+        add_subdirectory("${plugin_path}" "build-plugins/${plugin_dir}")
+    endforeach()
+endfunction()
+
+register_extra_plugins()

inference-engine/README.md

@@ -1,492 +0,0 @@
-# Build 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)
-- [Use Custom OpenCV Builds for Inference Engine](#use-custom-opencv-builds-for-inference-engine)
-- [Adding Inference Engine to your project](#adding-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)
-  - [For Windows](#for-windows-1)
-- [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™](https://software.intel.com/en-us/openvino-toolkit).
-
-## Build on Linux* Systems
-
-The software was validated on:
-- 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\*](https://cmake.org/download/) 3.5 or higher
-- GCC\* 4.8 or higher to build the Inference Engine
-- Python 2.7 or higher for Inference Engine Python API wrapper
-- (Optional) [Install Intel® Graphics Compute Runtime for OpenCL™ Driver package 19.04.12237](https://github.com/intel/compute-runtime/releases/tag/19.04.12237).
-
-### Build Steps
-1. Clone submodules:
-    ```sh
-    cd dldt/inference-engine
-    git submodule init
-    git submodule update --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.04.12237](https://github.com/intel/compute-runtime/releases/tag/19.04.12237) 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:
-
-- Internal JIT GEMM implementation is used by default.
-
-- To switch to OpenBLAS\* implementation, use the `GEMM=OPENBLAS` option and `BLAS_INCLUDE_DIRS` and `BLAS_LIBRARIES` CMake options to specify path to the OpenBLAS headers and library. For example use 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 [MKL-DNN repository](https://github.com/intel/mkl-dnn/releases/download/v0.19/mklml_lnx_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: 
-  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:
-     ```sh
-     -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 off/on the CPU and GPU plugins, use the `cmake` options `-DENABLE_MKL_DNN=ON/OFF` and `-DENABLE_CLDNN=ON/OFF` respectively. 
-  
-## 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 `inference-engine` directory of the cloned `dldt` repository:
-
-  ```bash
-  cd dldt/inference-engine
-  ```
-
-3. Initialize submodules:
-
-  ```bash
-  git submodule init
-  git submodule update --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\* 16.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 \
-      cmake \
-      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
-  ```
-
-  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/dldt:/dldt ie_cross_armhf /bin/bash
-  ```
-
-6. While in the container:
-
-    1. Go to the `inference-engine` directory of the cloned `dldt` repository:
-
-      ```bash
-      cd dldt/inference-engine
-      ```
-
-    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 `dldt/inference-engine/bin/armv7l/` directory and the OpenCV* installation in the `dldt/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 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 Python API wrapper, install `libpython3-dev:armhf` and `python3-pip` packages using `apt-get`, then install `numpy` and `cython` python modules using `pip3` command and add the following cmake 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
-```
-
-## 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\*](https://cmake.org/download/) 3.5 or higher
-- [OpenBLAS\*](https://sourceforge.net/projects/openblas/files/v0.2.14/OpenBLAS-v0.2.14-Win64-int64.zip/download) and [mingw64\* runtime dependencies](https://sourceforge.net/projects/openblas/files/v0.2.14/mingw64_dll.zip/download).
-- [Intel® C++ Compiler](https://software.intel.com/en-us/intel-parallel-studio-xe) 18.0 to build the Inference Engine on Windows.
-- (Optional) [Intel® Graphics Driver for Windows* [25.20] driver package](https://downloadcenter.intel.com/download/28646/Intel-Graphics-Windows-10-DCH-Drivers?product=80939).
-- Python 3.4 or higher for Inference Engine Python API wrapper
-
-### Build Steps
-1. Clone submodules:
-    ```sh
-    git submodule init
-    git submodule update --recursive
-    ```
-2. Download and install [Intel® C++ Compiler](https://software.intel.com/en-us/intel-parallel-studio-xe) 18.0
-3. Install OpenBLAS:
-    1. Download [OpenBLAS\*](https://sourceforge.net/projects/openblas/files/v0.2.14/OpenBLAS-v0.2.14-Win64-int64.zip/download)
-    2. Unzip the downloaded package to a directory on your machine. In this document, this directory is referred to as `<OPENBLAS_DIR>`.
-4. 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* [25.20] driver package](https://downloadcenter.intel.com/download/28646/Intel-Graphics-Windows-10-DCH-Drivers?product=80939) 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.    
-5. Create build directory:
-    ```sh
-    mkdir build
-    ```
-6. In the `build` directory, run `cmake` to fetch project dependencies and generate a Visual Studio solution:
-```sh
-cd build
-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" ..
-```
-
-7. Build generated solution in Visual Studio 2017 or run `cmake --build . --config Release` to build from the command line.
-
-8. Before running the samples, add paths to 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 `<dldt_repo>/inference-engine/temp/tbb/lib` folder, OpenCV binaries - to the `<dldt_repo>/inference-engine/temp/opencv_4.1.0/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. Prebuilt OpenBLAS\* package can be downloaded [here](https://sourceforge.net/projects/openblas/files/v0.2.14/OpenBLAS-v0.2.14-Win64-int64.zip/download). mingw64* runtime dependencies can be downloaded [here](https://sourceforge.net/projects/openblas/files/v0.2.14/mingw64_dll.zip/download).
-- 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 [MKL-DNN repository](https://github.com/intel/mkl-dnn/releases/download/v0.19/mklml_win_2019.0.5.20190502.zip).
-
-- 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"
-   ```
-
-### 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 dldt 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\*](https://cmake.org/download/) 3.5 or higher
-- Clang\* compiler from Xcode\* 10.1
-- Python\* 3.4 or higher for the Inference Engine Python API wrapper
-
-### Build Steps
-1. Clone submodules:
-    ```sh
-    cd dldt/inference-engine
-    git submodule init
-    git submodule update --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 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
-```
-
-## Use Custom OpenCV Builds for Inference Engine
-
-> **NOTE**: The recommended and tested version of OpenCV is 4.1. The minimum supported version is 3.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/2019/openvinotoolkit](https://download.01.org/opencv/2019/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.
-
-## Adding Inference Engine to your project
-
-For CMake projects, set the `InferenceEngine_DIR` environment variable:
-
-```sh
-export InferenceEngine_DIR=/path/to/dldt/inference-engine/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](https://software.intel.com/en-us/neural-compute-stick/get-started)
-
-### For Linux, Raspbian\* Stretch OS
-
-1. Add the current Linux user to the `users` group:
-```sh
-sudo usermod -a -G users "$(whoami)"
-```
-Log out and log in for it to take effect.
-
-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
-```
-
-### For Windows
-
-For Intel® Movidius™ Neural Compute Stick and Intel® Neural Compute Stick 2, install the Movidius™ VSC driver:
-1. Go to the `<DLDT_ROOT_DIR>/inference-engine/thirdparty/movidius/MovidiusDriver` directory, where the `DLDT_ROOT_DIR` is the directory to which the DLDT repository was cloned. 
-2. Right click on the `Movidius_VSC_Device.inf` file and choose **Install** from the pop up menu.
-
-You have installed the driver for your Intel® Movidius™ Neural Compute Stick or Intel® Neural Compute Stick 2.
-
-## Next Steps
-
-Congratulations, you have built the Inference Engine. To get started with the OpenVINO™ DLDT, proceed to the Get Started guides:
-
-* [Get Started with Deep Learning Deployment Toolkit on Linux*](../get-started-linux.md)
-
-## 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.

inference-engine/cmake/FindITT.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 

inference-engine/cmake/FindlibGNA.cmake

@@ -1,20 +1,20 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 
 # module to locate GNA libraries
 
 if (WIN32)
-    set(GNA_PLATFORM_DIR win64)
+    set(GNA_PLATFORM_DIR win64 CACHE STRING "" FORCE)
 elseif (UNIX)
-    set(GNA_PLATFORM_DIR linux)
+    set(GNA_PLATFORM_DIR linux CACHE STRING "" FORCE)
 else ()
     message(FATAL_ERROR "GNA not supported on this platform, only linux, and windows")
 endif ()
 
 set(libGNA_FOUND TRUE)
 
-set(GNA_KERNEL_LIB_NAME gna)
+set(GNA_KERNEL_LIB_NAME gna CACHE STRING "" FORCE)
 set(GNA_LIBS_LIST
         "libGNA::API"
         "libGNA::KERNEL")
@@ -22,20 +22,20 @@ set(GNA_LIBS_LIST
 if (GNA_LIBRARY_VERSION STREQUAL "GNA1")
     # use old version of GNA Library from gna_20181120
     if (WIN32)
-        set(GNA_LIB_DIR x64)
+        set(GNA_LIB_DIR x64 CACHE STRING "" FORCE)
     else ()
         list(APPEND GNA_LIBS_LIST
                 "libGNA::OLD_API_LIB")
-        set(GNA_LIB_DIR lib)
-        set(GNA_KERNEL_LIB_NAME gna_kernel)
+        set(GNA_LIB_DIR lib CACHE STRING "" FORCE)
+        set(GNA_KERNEL_LIB_NAME gna_kernel CACHE STRING "" FORCE)
     endif()
-    set(libGNA_INCLUDE_DIRS "${GNA}/${GNA_PLATFORM_DIR}/include")
+    set(libGNA_INCLUDE_DIRS "${GNA}/${GNA_PLATFORM_DIR}/include" CACHE STRING "" FORCE)
 else()
     # use current version of GNA library
-    set(GNA_LIB_DIR x64)
-    set(libGNA_INCLUDE_DIRS "${GNA}/include")
+    set(GNA_LIB_DIR x64 CACHE STRING "" FORCE)
+    set(libGNA_INCLUDE_DIRS "${GNA}/include" CACHE STRING "" FORCE)
 endif()
-set(libGNA_LIBRARIES_BASE_PATH ${GNA}/${GNA_PLATFORM_DIR}/${GNA_LIB_DIR})
+set(libGNA_LIBRARIES_BASE_PATH ${GNA}/${GNA_PLATFORM_DIR}/${GNA_LIB_DIR} CACHE STRING "" FORCE)
 
 add_library(libGNA::KERNEL SHARED IMPORTED)
 find_library(GNA_KERNEL_LIBRARY

inference-engine/cmake/add_ie_target.cmake

@@ -0,0 +1,156 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+#[[
+function to create CMake target and setup its options in a declarative style.
+Example:
+addIeTarget(
+   NAME core_lib
+   ADD_CPPLINT
+   DEVELOPER_PACKAGE
+   TYPE SHARED
+   ROOT ${CMAKE_CURRENT_SOURCE_DIR}
+   ADDITIONAL_SOURCE_DIRS
+        /some/additional/sources
+   EXCLUDED_SOURCE_DIRS
+        ${CMAKE_CURRENT_SOURCE_DIR}/unnecessary_sources/
+   INCLUDES
+        ${SDL_INCLUDES}
+        /some/specific/path
+   LINK_LIBRARIES
+        ie::important_plugin
+   EXPORT_DEPENDENCIES
+        dependency_lib_to_export
+   DEPENDENCIES
+        dependencies
+   OBJECT_FILES
+        object libraries
+)
+#]]
+function(addIeTarget)
+    set(options
+        ADD_CPPLINT                   # Enables code style checks for the target
+        DEVELOPER_PACKAGE             # Enables exporting of the target through the developer package
+        )
+    set(oneValueRequiredArgs
+        TYPE # type of target, SHARED|STATIC|EXECUTABLE. SHARED and STATIC correspond to add_library, EXECUTABLE to add_executable
+        NAME # name of target
+        ROOT # root directory to be used for recursive search of source files
+        )
+    set(oneValueOptionalArgs
+        )
+    set(multiValueArgs
+        INCLUDES                      # Extra include directories
+        LINK_LIBRARIES                # Link libraries (in form of target name or file name)
+        DEPENDENCIES                  # compile order dependencies (no link implied)
+        DEFINES                       # extra preprocessor definitions
+        ADDITIONAL_SOURCE_DIRS        # list of directories which will be used to recursive search of source files in addition to ROOT
+        OBJECT_FILES                  # list of object files to be additionally built into the target
+        EXCLUDED_SOURCE_DIRS          # list of directories excluded from the global recursive search of source files
+        LINK_LIBRARIES_WHOLE_ARCHIVE  # list of static libraries to link, each object file should be used and not discarded
+        LINK_FLAGS                    # list of extra commands to linker
+        EXPORT_DEPENDENCIES           # list of the dependencies to be exported with the target through the developer package
+        )
+    cmake_parse_arguments(ARG "${options}" "${oneValueRequiredArgs};${oneValueOptionalArgs}" "${multiValueArgs}" ${ARGN} )
+
+    # sanity checks
+    foreach(argName ${oneValueRequiredArgs})
+        if (NOT ARG_${argName})
+            message(SEND_ERROR "Argument '${argName}' is required.")
+        endif()
+    endforeach()
+    if (ARG_UNPARSED_ARGUMENTS)
+        message(SEND_ERROR "Unexpected parameters have passed to function: ${ARG_UNPARSED_ARGUMENTS}")
+    endif()
+
+    # adding files to target
+    set(includeSearch)
+    set(sourceSearch)
+    foreach(directory ${ARG_ROOT} ${ARG_ADDITIONAL_SOURCE_DIRS})
+        list(APPEND includeSearch ${directory}/*.h ${directory}/*.hpp)
+        list(APPEND sourceSearch  ${directory}/*.cpp)
+    endforeach()
+
+    file(GLOB_RECURSE includes ${includeSearch})
+    file(GLOB_RECURSE sources  ${sourceSearch})
+
+    # remove unnecessary directories
+    if (ARG_EXCLUDED_SOURCE_DIRS)
+        list(FILTER includes EXCLUDE REGEX "${ARG_EXCLUDED_SOURCE_DIRS}/*")
+        list(FILTER sources EXCLUDE REGEX "${ARG_EXCLUDED_SOURCE_DIRS}/*")
+    endif()
+
+    source_group("include" FILES ${includes})
+    source_group("src"     FILES ${sources})
+
+    set(all_sources)
+    list(APPEND all_sources ${sources} ${includes} ${ARG_OBJECT_FILES})
+
+    # defining a target
+    if (ARG_TYPE STREQUAL EXECUTABLE)
+        add_executable(${ARG_NAME} ${all_sources})
+    elseif(ARG_TYPE STREQUAL STATIC OR ARG_TYPE STREQUAL SHARED)
+        add_library(${ARG_NAME} ${type} ${all_sources})
+    else()
+        message(SEND_ERROR "Invalid target type ${ARG_TYPE} specified for target name ${ARG_NAME}")
+    endif()
+
+    ieTargetLinkWholeArchive(${ARG_NAME} ${ARG_LINK_LIBRARIES_WHOLE_ARCHIVE})
+
+    if (ARG_DEFINES)
+        target_compile_definitions(${ARG_NAME} PRIVATE ${ARG_DEFINES})
+    endif()
+    if (ARG_INCLUDES)
+        target_include_directories(${ARG_NAME} PRIVATE ${ARG_INCLUDES})
+    endif()
+    if (ARG_LINK_LIBRARIES)
+        target_link_libraries(${ARG_NAME} PRIVATE ${ARG_LINK_LIBRARIES})
+    endif()
+    if (ARG_DEPENDENCIES)
+        add_dependencies(${ARG_NAME} ${ARG_DEPENDENCIES})
+    endif()
+    if (ARG_LINK_FLAGS)
+        get_target_property(oldLinkFlags ${ARG_NAME} LINK_FLAGS)
+        string(REPLACE ";" " " ARG_LINK_FLAGS "${ARG_LINK_FLAGS}")
+        set_target_properties(${ARG_NAME} PROPERTIES LINK_FLAGS "${oldLinkFlags} ${ARG_LINK_FLAGS}")
+    endif()
+    if (ARG_ADD_CPPLINT)
+        # code style
+        add_cpplint_target(${ARG_NAME}_cpplint FOR_TARGETS ${ARG_NAME})
+        add_clang_format_target(${ARG_NAME}_clang_format FOR_TARGETS ${ARG_NAME})
+    endif()
+    if (ARG_DEVELOPER_PACKAGE)
+        # developer package
+        ie_developer_export_targets(${ARG_NAME})
+        if (ARG_EXPORT_DEPENDENCIES)
+            ie_developer_export_targets(${ARG_NAME} ${ARG_EXPORT_DEPENDENCIES})
+        endif()
+    endif()
+endfunction()
+
+#[[
+Wrapper function over addIeTarget, that also adds a test with the same name.
+You could use
+addIeTargetTest( ... LABELS labelOne labelTwo )
+also to provide labels for that test.
+Important: you MUST pass LABELS as last argument, otherwise it will consume any parameters that come after.
+#]]
+function(addIeTargetTest)
+    set(options
+        )
+    set(oneValueRequiredArgs
+        NAME
+        )
+    set(oneValueOptionalArgs
+        )
+    set(multiValueArgs
+        LABELS
+        )
+    cmake_parse_arguments(ARG "${options}" "${oneValueRequiredArgs};${oneValueOptionalArgs}" "${multiValueArgs}" ${ARGN} )
+
+    addIeTarget(TYPE EXECUTABLE NAME ${ARG_NAME} ${ARG_UNPARSED_ARGUMENTS})
+
+    add_test(NAME ${ARG_NAME} COMMAND ${ARG_NAME})
+    set_property(TEST ${ARG_NAME} PROPERTY LABELS ${ARG_LABELS})
+endfunction()

inference-engine/cmake/arm.toolchain.cmake

@@ -1,14 +0,0 @@
-# Copyright (C) 2018-2019 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_PROCESSOR armv7l)
-
-set(CMAKE_C_COMPILER arm-linux-gnueabihf-gcc)
-set(CMAKE_CXX_COMPILER arm-linux-gnueabihf-g++)
-
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

inference-engine/cmake/arm64.toolchain.cmake

@@ -1,14 +0,0 @@
-# Copyright (C) 2018-2019 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_PROCESSOR aarch64)
-
-set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)
-set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)
-
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

inference-engine/cmake/check_features.cmake

@@ -1,129 +0,0 @@
-# Copyright (C) 2018-2019 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-#64 bits platform
-if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
-    message(STATUS "Detected 64 bit architecture")
-    SET(ARCH_64 ON)
-    SET(ARCH_32 OFF)
-else()
-    message(STATUS "Detected 32 bit architecture")
-    SET(ARCH_64 OFF)
-    SET(ARCH_32 ON)
-endif()
-
-if (NOT ARCH_64)
-    if (UNIX OR APPLE)
-        SET(ENABLE_CLDNN OFF)
-    endif()
-    SET(ENABLE_MKL_DNN OFF)
-endif()
-
-#apple specific
-if (APPLE)
-    set(ENABLE_GNA OFF)
-    set(ENABLE_CLDNN OFF)
-endif()
-
-
-#minGW specific - under wine no support for downloading file and applying them using git
-if (WIN32)
-    if (MINGW)
-        SET(ENABLE_CLDNN OFF) # dont have mingw dll for linking
-        set(ENABLE_SAMPLES OFF)
-    endif()
-endif()
-
-if (NOT ENABLE_MKL_DNN)
-    set(ENABLE_MKL OFF)
-endif()
-
-if (NOT ENABLE_VPU)
-    set(ENABLE_MYRIAD OFF)
-endif()
-
-#next section set defines to be accesible in c++/c code for certain feature
-if (ENABLE_PROFILING_RAW)
-    add_definitions(-DENABLE_PROFILING_RAW=1)
-endif()
-
-if (ENABLE_CLDNN)
-    add_definitions(-DENABLE_CLDNN=1)
-endif()
-
-if (ENABLE_MYRIAD)
-    add_definitions(-DENABLE_MYRIAD=1)
-endif()
-
-if (ENABLE_MYRIAD_NO_BOOT AND ENABLE_MYRIAD )
-    add_definitions(-DENABLE_MYRIAD_NO_BOOT=1)
-endif()
-
-if (ENABLE_MKL_DNN)
-    add_definitions(-DENABLE_MKL_DNN=1)
-endif()
-
-if (ENABLE_GNA)
-    add_definitions(-DENABLE_GNA)
-
-    set (DEFAULT_GNA_LIB GNA1_1401)
-
-    # "GNA library version: GNA1|GNA1_1401|GNA2" - default is 1401
-    if (NOT GNA_LIBRARY_VERSION STREQUAL "GNA1"
-            AND NOT GNA_LIBRARY_VERSION STREQUAL "GNA1_1401"
-            AND NOT GNA_LIBRARY_VERSION STREQUAL "GNA2")
-        set (GNA_LIBRARY_VERSION ${DEFAULT_GNA_LIB})
-        message(STATUS "GNA_LIBRARY_VERSION not set. Can be GNA1, GNA1_1401 or GNA2. Default is ${GNA_LIBRARY_VERSION}")
-    endif()
-
-    if (GNA_LIBRARY_VERSION STREQUAL "GNA2")
-        message(WARNING "GNA2 is not currently supported. Fallback to ${DEFAULT_GNA_LIB}")
-        set(GNA_LIBRARY_VERSION ${DEFAULT_GNA_LIB})
-    endif()
-
-    if (UNIX AND NOT APPLE AND CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.4)
-        message(WARNING "${GNA_LIBRARY_VERSION} no supported on GCC version ${CMAKE_CXX_COMPILER_VERSION}. Fallback to GNA1")
-        set(GNA_LIBRARY_VERSION GNA1)
-    endif()
-
-    set(GNA_LIBRARY_VERSION "${GNA_LIBRARY_VERSION}" CACHE STRING "GNAVersion" FORCE)
-    list (APPEND IE_OPTIONS GNA_LIBRARY_VERSION)
-endif()
-
-if (ENABLE_SAMPLES)
-    set (ENABLE_SAMPLES_CORE ON)
-endif()
-
-#models dependend tests
-
-if (DEVELOPMENT_PLUGIN_MODE)
-    message (STATUS "Enabled development plugin mode")
-
-    set (ENABLE_MKL_DNN OFF)
-    set (ENABLE_TESTS OFF)
-
-    message (STATUS "Initialising submodules")
-    execute_process (COMMAND git submodule update --init ${IE_MAIN_SOURCE_DIR}/thirdparty/pugixml
-                     RESULT_VARIABLE git_res)
-
-    if (NOT ${git_res})
-        message (STATUS "Initialising submodules - done")
-    endif()
-endif()
-
-if (NOT ENABLE_TESTS)
-    set(ENABLE_GNA_MODELS OFF)
-endif ()
-
-if (VERBOSE_BUILD)
-    set(CMAKE_VERBOSE_MAKEFILE  ON)
-endif()
-
-
-if(ENABLE_DUMP)
-    add_definitions(-DDEBUG_DUMP)
-endif()
-
-
-print_enabled_features()

inference-engine/cmake/check_features_ie.cmake

@@ -0,0 +1,39 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+#next section set defines to be accesible in c++/c code for certain feature
+if (ENABLE_PROFILING_RAW)
+    add_definitions(-DENABLE_PROFILING_RAW=1)
+endif()
+
+if (ENABLE_MYRIAD)
+    add_definitions(-DENABLE_MYRIAD=1)
+endif()
+
+if (ENABLE_MYRIAD_NO_BOOT AND ENABLE_MYRIAD )
+    add_definitions(-DENABLE_MYRIAD_NO_BOOT=1)
+endif()
+
+if (ENABLE_CLDNN)
+    add_definitions(-DENABLE_CLDNN=1)
+endif()
+
+if (ENABLE_MKL_DNN)
+    add_definitions(-DENABLE_MKL_DNN=1)
+endif()
+
+if (ENABLE_GNA)
+    add_definitions(-DENABLE_GNA)
+
+    if (UNIX AND NOT APPLE AND CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.4)
+        message(WARNING "${GNA_LIBRARY_VERSION} is not supported on GCC version ${CMAKE_CXX_COMPILER_VERSION}. Fallback to GNA1")
+        set(GNA_LIBRARY_VERSION GNA1)
+    endif()
+endif()
+
+if (ENABLE_SPEECH_DEMO)
+    add_definitions(-DENABLE_SPEECH_DEMO)
+endif()
+
+print_enabled_features()

inference-engine/cmake/clang_format.cmake

@@ -0,0 +1,124 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+if (ENABLE_CLANG_FORMAT)
+    set(CLANG_FORMAT_FILENAME clang-format-9 clang-format)
+    find_program(CLANG_FORMAT NAMES ${CLANG_FORMAT_FILENAME} PATHS ENV PATH)
+    if (CLANG_FORMAT)
+        execute_process(COMMAND ${CLANG_FORMAT} ${CMAKE_CURRENT_SOURCE_DIR} ARGS --version OUTPUT_VARIABLE CLANG_VERSION)
+        if (NOT CLANG_VERSION OR CLANG_VERSION STREQUAL "")
+            message(WARNING "Supported clang-format version is 9!")
+            set(ENABLE_CLANG_FORMAT OFF)
+        else()
+            string(REGEX REPLACE "[^0-9]+([0-9]+)\\..*" "\\1" CLANG_FORMAT_MAJOR_VERSION ${CLANG_VERSION})
+            if (NOT ${CLANG_FORMAT_MAJOR_VERSION} EQUAL "9")
+                message(WARNING "Supported clang-format version is 9!")
+                set(ENABLE_CLANG_FORMAT OFF)
+            endif()
+        endif()
+    endif()
+endif()
+
+if(ENABLE_CLANG_FORMAT)
+    add_custom_target(clang_format_check_all)
+    add_custom_target(clang_format_fix_all)
+    set(CLANG_FORMAT_ALL_OUTPUT_FILES "" CACHE INTERNAL "All clang-format output files")
+endif()
+
+function(add_clang_format_target TARGET_NAME)
+    if(NOT ENABLE_CLANG_FORMAT)
+        return()
+    endif()
+
+    set(options ALL)
+    set(oneValueArgs "")
+    set(multiValueArgs "FOR_TARGETS" "FOR_SOURCES" "EXCLUDE_PATTERNS")
+    cmake_parse_arguments(CLANG_FORMAT "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(CLANG_FORMAT_ALL)
+        set(all ALL)
+    endif()
+
+    foreach(target IN LISTS CLANG_FORMAT_FOR_TARGETS)
+        get_target_property(target_sources "${target}" SOURCES)
+        list(APPEND CLANG_FORMAT_FOR_SOURCES ${target_sources})
+    endforeach()
+    list(REMOVE_DUPLICATES CLANG_FORMAT_FOR_SOURCES)
+
+    set(all_output_files "")
+    foreach(source_file IN LISTS CLANG_FORMAT_FOR_SOURCES)
+        set(exclude FALSE)
+        foreach(pattern IN LISTS CLANG_FORMAT_EXCLUDE_PATTERNS)
+            if(source_file MATCHES "${pattern}")
+                set(exclude ON)
+                break()
+            endif()
+        endforeach()
+
+        if(exclude)
+            continue()
+        endif()
+
+        # ignore object libraries
+        if(NOT EXISTS "${source_file}")
+            continue()
+        endif()
+
+        file(RELATIVE_PATH source_file_relative "${CMAKE_CURRENT_SOURCE_DIR}" "${source_file}")
+        set(output_file "${CMAKE_CURRENT_BINARY_DIR}/clang_format/${source_file_relative}.clang")
+        string(REPLACE ".." "__" output_file "${output_file}")
+        get_filename_component(output_dir "${output_file}" DIRECTORY)
+        file(MAKE_DIRECTORY "${output_dir}")
+
+        add_custom_command(
+            OUTPUT
+            "${output_file}"
+            COMMAND
+            "${CMAKE_COMMAND}"
+            -D "CLANG_FORMAT=${CLANG_FORMAT}"
+            -D "INPUT_FILE=${source_file}"
+            -D "OUTPUT_FILE=${output_file}"
+            -P "${IE_MAIN_SOURCE_DIR}/cmake/clang_format_check.cmake"
+            DEPENDS
+            "${source_file}"
+            "${IE_MAIN_SOURCE_DIR}/cmake/clang_format_check.cmake"
+            COMMENT
+            "[clang-format] ${source_file}"
+            VERBATIM)
+
+        list(APPEND all_output_files "${output_file}")
+    endforeach()
+
+    set(CLANG_FORMAT_ALL_OUTPUT_FILES
+        ${CLANG_FORMAT_ALL_OUTPUT_FILES} ${all_output_files}
+        CACHE INTERNAL
+        "All clang-format output files")
+
+    add_custom_target(${TARGET_NAME}
+        ${all}
+        DEPENDS ${all_output_files}
+        COMMENT "[clang-format] ${TARGET_NAME}")
+
+    add_custom_target(${TARGET_NAME}_fix
+        COMMAND
+        "${CMAKE_COMMAND}"
+        -D "CLANG_FORMAT=${CLANG_FORMAT}"
+        -D "INPUT_FILES=${CLANG_FORMAT_FOR_SOURCES}"
+        -D "EXCLUDE_PATTERNS=${CLANG_FORMAT_EXCLUDE_PATTERNS}"
+        -P "${IE_MAIN_SOURCE_DIR}/cmake/clang_format_fix.cmake"
+        DEPENDS
+        "${CLANG_FORMAT_FOR_SOURCES}"
+        "${IE_MAIN_SOURCE_DIR}/cmake/clang_format_fix.cmake"
+        COMMENT
+        "[clang-format] ${TARGET_NAME}_fix"
+        VERBATIM)
+
+    # if(CLANG_FORMAT_FOR_TARGETS)
+    #     foreach(target IN LISTS CLANG_FORMAT_FOR_TARGETS)
+    #         add_dependencies(${target} ${TARGET_NAME})
+    #     endforeach()
+    # endif()
+
+    add_dependencies(clang_format_check_all ${TARGET_NAME})
+    add_dependencies(clang_format_fix_all ${TARGET_NAME}_fix)
+endfunction()

inference-engine/cmake/clang_format_check.cmake

@@ -0,0 +1,18 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+file(REMOVE "${OUTPUT_FILE}")
+
+execute_process(COMMAND ${CLANG_FORMAT} -style=file -output-replacements-xml ${INPUT_FILE}
+    OUTPUT_VARIABLE STYLE_CHECK_RESULT
+    )
+# Display the cpplint output to console (to parse it form IDE)
+message("${output}")
+file(WRITE "${OUTPUT_FILE}" "${STYLE_CHECK_RESULT}")
+
+if(NOT SKIP_RETURN_CODE)
+    if("${STYLE_CHECK_RESULT}" MATCHES ".*<replacement .*")
+        message(FATAL_ERROR "[clang-format] Code style check failed for : ${INPUT_FILE}")
+    endif()
+endif()

inference-engine/cmake/clang_format_fix.cmake

@@ -0,0 +1,24 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+function(style_apply_file INPUT_FILE)
+    execute_process(COMMAND ${CLANG_FORMAT} -style=file -i ${INPUT_FILE}
+        OUTPUT_VARIABLE STYLE_CHECK_RESULT)
+endfunction()
+
+foreach(source_file IN LISTS INPUT_FILES)
+    set(exclude FALSE)
+    foreach(pattern IN LISTS EXCLUDE_PATTERNS)
+        if(source_file MATCHES "${pattern}")
+            set(exclude ON)
+            break()
+        endif()
+    endforeach()
+
+    if(exclude)
+        continue()
+    endif()
+
+    style_apply_file(${source_file})
+endforeach()

inference-engine/cmake/config.cmake.in

@@ -1,15 +1,34 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 
 if(DEFINED IE_MAIN_SOURCE_DIR AND TARGET inference_engine)
-    set(InferenceEngine_INCLUDE_DIRS ${IE_MAIN_SOURCE_DIR}/include)
-    set(InferenceEngine_LIBRARIES inference_engine)
+    set(InferenceEngine_LIBRARIES inference_engine_legacy inference_engine
+                                  inference_engine_c_api inference_engine_nn_builder)
 else()
     include("${CMAKE_CURRENT_LIST_DIR}/targets.cmake")
     if(NOT WIN32)
         set_target_properties(IE::inference_engine PROPERTIES INTERFACE_COMPILE_OPTIONS "-Wno-error=deprecated-declarations")
     endif()
+
+    file(TO_CMAKE_PATH "${CMAKE_CURRENT_LIST_DIR}" cache_path)
+    set (ie_options THREADING)
+    load_cache("${cache_path}" READ_WITH_PREFIX "" ${ie_options})
+    message(STATUS "The following CMake options are exported from the Inference Engine build")
+    message("")
+    foreach(option IN LISTS ie_options)
+        message("    ${option}: ${${option}}")
+    endforeach()
+    message("")
+
+    # inherit TBB from main IE project if enabled
+    if (THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO")
+        load_cache("${cache_path}" READ_WITH_PREFIX "" TBB_DIR;ENABLE_TBB_RELEASE_ONLY)
+        set(TBB_FIND_RELEASE_ONLY ${ENABLE_TBB_RELEASE_ONLY})
+        find_package(TBB)
+    endif()
+
     get_target_property(InferenceEngine_INCLUDE_DIRS IE::inference_engine INTERFACE_INCLUDE_DIRECTORIES)
-    set(InferenceEngine_LIBRARIES IE::inference_engine)
+    set(InferenceEngine_LIBRARIES IE::inference_engine_legacy IE::inference_engine
+                                  IE::inference_engine_c_api IE::inference_engine_nn_builder)
 endif()

inference-engine/cmake/coverage_ie.cmake

@@ -0,0 +1,73 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+set(DLDT_COVERAGE_GCDA_DATA_DIRECTORY "${CMAKE_BINARY_DIR}/inference-engine/src")
+set(DLDT_COVERAGE_BASE_DIRECTORY "${IE_MAIN_SOURCE_DIR}/src")
+
+ie_coverage_clean(REPOSITORY "dldt"
+                  DIRECTORY "${DLDT_COVERAGE_GCDA_DATA_DIRECTORY}")
+ie_coverage_capture(INFO_FILE "dldt"
+                    BASE_DIRECTORY "${DLDT_COVERAGE_BASE_DIRECTORY}"
+                    DIRECTORY "${DLDT_COVERAGE_GCDA_DATA_DIRECTORY}")
+
+# Generate reports
+
+ie_coverage_extract(INPUT "dldt" OUTPUT "inference_engine_with_builders"
+                    PATTERNS "${DLDT_COVERAGE_BASE_DIRECTORY}/inference_engine/*"
+                             "${DLDT_COVERAGE_BASE_DIRECTORY}/plugin_api/*")
+ie_coverage_remove(INPUT "inference_engine_with_builders" OUTPUT "inference_engine"
+                   PATTERNS "${DLDT_COVERAGE_BASE_DIRECTORY}/inference_engine/builders/*")
+ie_coverage_genhtml(INFO_FILE "inference_engine"
+                    PREFIX "${DLDT_COVERAGE_BASE_DIRECTORY}")
+
+ie_coverage_extract(INPUT "dldt" OUTPUT "inference_engine_legacy"
+                    PATTERNS "${DLDT_COVERAGE_BASE_DIRECTORY}/legacy_api/*")
+ie_coverage_genhtml(INFO_FILE "inference_engine_legacy"
+                    PREFIX "${DLDT_COVERAGE_BASE_DIRECTORY}")
+
+ie_coverage_extract(INPUT "dldt" OUTPUT "hetero_plugin"
+                    PATTERNS "${DLDT_COVERAGE_BASE_DIRECTORY}/hetero_plugin/*")
+ie_coverage_genhtml(INFO_FILE "hetero_plugin"
+                    PREFIX "${DLDT_COVERAGE_BASE_DIRECTORY}")
+
+ie_coverage_extract(INPUT "dldt" OUTPUT "multi_device"
+                    PATTERNS "${DLDT_COVERAGE_BASE_DIRECTORY}/multi_device/*")
+ie_coverage_genhtml(INFO_FILE "multi_device"
+                    PREFIX "${DLDT_COVERAGE_BASE_DIRECTORY}")
+
+ie_coverage_extract(INPUT "dldt" OUTPUT "preprocessing"
+                    PATTERNS "${DLDT_COVERAGE_BASE_DIRECTORY}/preprocessing/*")
+ie_coverage_genhtml(INFO_FILE "preprocessing"
+                    PREFIX "${DLDT_COVERAGE_BASE_DIRECTORY}")
+
+ie_coverage_extract(INPUT "dldt" OUTPUT "inference_engine_transformations"
+                    PATTERNS "${DLDT_COVERAGE_BASE_DIRECTORY}/inference_engine_transformations/*")
+ie_coverage_genhtml(INFO_FILE "inference_engine_transformations"
+                    PREFIX "${DLDT_COVERAGE_BASE_DIRECTORY}")
+
+ie_coverage_extract(INPUT "dldt" OUTPUT "low_precision_transformations"
+                    PATTERNS "${DLDT_COVERAGE_BASE_DIRECTORY}/low_precision_transformations/*")
+ie_coverage_genhtml(INFO_FILE "low_precision_transformations"
+                    PREFIX "${DLDT_COVERAGE_BASE_DIRECTORY}")
+
+if(ENABLE_MKL_DNN)
+    ie_coverage_extract(INPUT "dldt" OUTPUT "mkldnn_plugin"
+                        PATTERNS "${DLDT_COVERAGE_BASE_DIRECTORY}/mkldnn_plugin/*")
+    ie_coverage_genhtml(INFO_FILE "mkldnn_plugin"
+                        PREFIX "${DLDT_COVERAGE_BASE_DIRECTORY}")
+endif()
+
+if(ENABLE_CLDNN)
+    ie_coverage_extract(INPUT "dldt" OUTPUT "cldnn_engine"
+                        PATTERNS "${DLDT_COVERAGE_BASE_DIRECTORY}/cldnn_engine/*")
+    ie_coverage_genhtml(INFO_FILE "cldnn_engine"
+                        PREFIX "${DLDT_COVERAGE_BASE_DIRECTORY}")
+endif()
+
+if(ENABLE_GNA)
+    ie_coverage_extract(INPUT "dldt" OUTPUT "gna_plugin"
+                        PATTERNS "${DLDT_COVERAGE_BASE_DIRECTORY}/gna_plugin/*")
+    ie_coverage_genhtml(INFO_FILE "gna_plugin"
+                        PREFIX "${DLDT_COVERAGE_BASE_DIRECTORY}")
+endif()

inference-engine/cmake/cppcheck.cmake

@@ -1,28 +0,0 @@
-# Copyright (C) 2019 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-if(ENABLE_CPPCHECK)
-    find_program(CPPCHECK_EXECUTABLE cppcheck)
-
-    if(NOT CPPCHECK_EXECUTABLE)
-        message(WARNING "cppcheck was not found : disable static analysis")
-        set(ENABLE_CPPCHECK OFF)
-    endif()
-endif()
-
-function(add_cppcheck)
-    if(NOT ENABLE_CPPCHECK)
-        return()
-    endif()
-
-    set_property(
-        TARGET ${ARGN}
-        PROPERTY CXX_CPPCHECK
-            ${CPPCHECK_EXECUTABLE}
-            "--suppress=*:*/temp/*"
-            "--suppress=*:*/thirdparty/*"
-            "--error-exitcode=1"
-            "--template={file}:{line}: error: [cppcheck:{severity}] {message}"
-            "--quiet")
-endfunction()

inference-engine/cmake/cpplint.cmake

@@ -1,12 +1,12 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 
 if(ENABLE_CPPLINT)
-    find_package(PythonInterp 2.7 EXACT)
+    find_host_package(PythonInterp)
 
-    if(NOT PYTHONINTERP_FOUND OR NOT PYTHON_VERSION_MAJOR EQUAL 2)
-        message(WARNING "Python 2.7 was not found (required for cpplint check)")
+    if(NOT PYTHONINTERP_FOUND)
+        message(WARNING "Python interpreter was not found (required for cpplint check)")
         set(ENABLE_CPPLINT OFF)
     endif()
 endif()
@@ -23,7 +23,7 @@ function(add_cpplint_target TARGET_NAME)
 
     set(options "")
     set(oneValueArgs "")
-    set(multiValueArgs "FOR_TARGETS" "FOR_SOURCES" "EXCLUDE_PATTERNS")
+    set(multiValueArgs FOR_TARGETS FOR_SOURCES EXCLUDE_PATTERNS CUSTOM_FILTERS)
     cmake_parse_arguments(CPPLINT "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
     foreach(target IN LISTS CPPLINT_FOR_TARGETS)
@@ -32,12 +32,17 @@ function(add_cpplint_target TARGET_NAME)
     endforeach()
     list(REMOVE_DUPLICATES CPPLINT_FOR_SOURCES)
 
+    set(custom_filter "")
+    foreach(filter IN LISTS CPPLINT_CUSTOM_FILTERS)
+        string(CONCAT custom_filter "${custom_filter}" "," "${filter}")
+    endforeach()
+
     set(all_output_files "")
     foreach(source_file IN LISTS CPPLINT_FOR_SOURCES)
         set(exclude FALSE)
         foreach(pattern IN LISTS CPPLINT_EXCLUDE_PATTERNS)
             if(source_file MATCHES "${pattern}")
-                set(exclude TRUE)
+                set(exclude ON)
                 break()
             endif()
         endforeach()
@@ -46,6 +51,11 @@ function(add_cpplint_target TARGET_NAME)
             continue()
         endif()
 
+        # ignore object libraries
+        if(NOT EXISTS "${source_file}")
+            continue()
+        endif()
+
         file(RELATIVE_PATH source_file_relative "${CMAKE_CURRENT_SOURCE_DIR}" "${source_file}")
         set(output_file "${CMAKE_CURRENT_BINARY_DIR}/cpplint/${source_file_relative}.cpplint")
         string(REPLACE ".." "__" output_file "${output_file}")
@@ -57,12 +67,12 @@ function(add_cpplint_target TARGET_NAME)
                 "${output_file}"
             COMMAND
                 "${CMAKE_COMMAND}"
-                -D "PYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}"
                 -D "CPPLINT_SCRIPT=${IE_MAIN_SOURCE_DIR}/scripts/cpplint.py"
                 -D "INPUT_FILE=${source_file}"
                 -D "OUTPUT_FILE=${output_file}"
                 -D "WORKING_DIRECTORY=${CMAKE_CURRENT_SOURCE_DIR}"
                 -D "SKIP_RETURN_CODE=${ENABLE_CPPLINT_REPORT}"
+                -D "CUSTOM_FILTER=${custom_filter}"
                 -P "${IE_MAIN_SOURCE_DIR}/cmake/cpplint_run.cmake"
             DEPENDS
                 "${source_file}"

inference-engine/cmake/cpplint_html.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 

inference-engine/cmake/cpplint_merge.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 

inference-engine/cmake/cpplint_run.cmake

@@ -1,36 +1,55 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 
 file(REMOVE "${OUTPUT_FILE}")
 
+set(DEFAULT_FILTER "
+    -build/header_guard,\
+    -build/include,\
+    -build/include_order,\
+    -build/include_subdir,\
+    -build/include_what_you_use,\
+    -build/namespaces,\
+    -build/c++11,\
+    -whitespace/indent,\
+    -whitespace/comments,\
+    -whitespace/ending_newline,\
+    -runtime/references,\
+    -runtime/int,\
+    -runtime/explicit,\
+    -readability/todo,\
+    -readability/fn_size,\
+")
+set(FILTER "${DEFAULT_FILTER}${CUSTOM_FILTER}")
+
 execute_process(
     COMMAND
-        "${PYTHON_EXECUTABLE}"
+        python3
         "${CPPLINT_SCRIPT}"
         "--linelength=160"
         "--counting=detailed"
-        "--filter=-readability/fn_size"
+        "--quiet"
+        "--filter=${FILTER}"
         "${INPUT_FILE}"
     WORKING_DIRECTORY "${WORKING_DIRECTORY}"
     RESULT_VARIABLE result
     OUTPUT_VARIABLE output
     ERROR_VARIABLE output)
 
-# Display the cpplint output to console (to parse it form IDE)
-message("${output}")
-
 # Store cpplint output to file (replace problematic symbols)
-string(REPLACE "\"" "&quot\;" output "${output}")
-string(REPLACE "<" "&lt\;" output "${output}")
-string(REPLACE ">" "&gt\;" output "${output}")
-string(REPLACE "'" "&apos\;" output "${output}")
-string(REPLACE "&" "&amp\;" output "${output}")
-file(WRITE "${OUTPUT_FILE}" "${output}")
+string(REPLACE "\"" "&quot\;" formatted_output "${output}")
+string(REPLACE "<" "&lt\;" formatted_output "${formatted_output}")
+string(REPLACE ">" "&gt\;" formatted_output "${formatted_output}")
+string(REPLACE "'" "&apos\;" formatted_output "${formatted_output}")
+string(REPLACE "&" "&amp\;" formatted_output "${formatted_output}")
+file(WRITE "${OUTPUT_FILE}" "${formatted_output}")
 
 if(NOT SKIP_RETURN_CODE)
     # Pass through the cpplint return code
     if(NOT result EQUAL 0)
+        # Display the cpplint output to console (to parse it form IDE)
+        message("${output}")
         message(FATAL_ERROR "[cpplint] Code style check failed for : ${INPUT_FILE}")
     endif()
 endif()

inference-engine/cmake/cpplint_to_cppcheck_xml.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 

inference-engine/cmake/dependencies.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 
@@ -7,7 +7,9 @@ cmake_policy(SET CMP0054 NEW)
 #we have number of dependencies stored on ftp
 include(dependency_solver)
 
-set_temp_directory(TEMP "${IE_MAIN_SOURCE_DIR}")
+if (CMAKE_CROSSCOMPILING)
+    set(CMAKE_STAGING_PREFIX "${TEMP}")
+endif()
 
 include(ExternalProject)
 
@@ -16,6 +18,8 @@ if(COMMAND get_linux_name)
     get_linux_name(LINUX_OS_NAME)
 endif()
 
+include(CMakeParseArguments)
+
 if (ENABLE_MYRIAD)
     include(vpu_dependencies)
 endif()
@@ -44,129 +48,180 @@ endif ()
 
 ## Intel OMP package
 if (THREADING STREQUAL "OMP")
-    if (WIN32)
+    reset_deps_cache(OMP)
+    if (WIN32 AND X86_64)
         RESOLVE_DEPENDENCY(OMP
                 ARCHIVE_WIN "iomp.zip"
                 TARGET_PATH "${TEMP}/omp"
                 ENVIRONMENT "OMP"
                 VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*")
-    elseif(LINUX)
+    elseif(LINUX AND X86_64)
         RESOLVE_DEPENDENCY(OMP
                 ARCHIVE_LIN "iomp.tgz"
                 TARGET_PATH "${TEMP}/omp"
                 ENVIRONMENT "OMP"
                 VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*")
-    else(APPLE)
+    elseif(APPLE AND X86_64)
         RESOLVE_DEPENDENCY(OMP
                 ARCHIVE_MAC "iomp_20190130_mac.tgz"
                 TARGET_PATH "${TEMP}/omp"
                 ENVIRONMENT "OMP"
                 VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*")
+    else()
+        message(FATAL_ERROR "Intel OMP is not available on current platform")
     endif()
+    update_deps_cache(OMP "${OMP}" "Path to OMP root folder")
     log_rpath_from_dir(OMP "${OMP}/lib")
     debug_message(STATUS "intel_omp=" ${OMP})
 endif ()
 
 ## TBB package
 if (THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO")
-    if (WIN32)
-        #TODO: add target_path to be platform specific as well, to avoid following if
-        RESOLVE_DEPENDENCY(TBB
-                ARCHIVE_WIN "tbb2019_20181010_win.zip" #TODO: windows zip archive created incorrectly using old name for folder
-                TARGET_PATH "${TEMP}/tbb"
-                ENVIRONMENT "TBBROOT"
-                VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*")
-    elseif(LINUX)
-        RESOLVE_DEPENDENCY(TBB
-                ARCHIVE_LIN "tbb2019_20181010_lin.tgz"
-                TARGET_PATH "${TEMP}/tbb"
-                ENVIRONMENT "TBBROOT")
-    else(APPLE)
-        RESOLVE_DEPENDENCY(TBB
-                ARCHIVE_MAC "tbb2019_20190414_v1_mac.tgz"
-                TARGET_PATH "${TEMP}/tbb"
-                ENVIRONMENT "TBBROOT"
-                VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*")
+    reset_deps_cache(TBBROOT TBB_DIR)
+
+    if(NOT DEFINED TBB_DIR AND NOT DEFINED ENV{TBB_DIR})
+        if (WIN32 AND X86_64)
+            #TODO: add target_path to be platform specific as well, to avoid following if
+            RESOLVE_DEPENDENCY(TBB
+                    ARCHIVE_WIN "tbb2020_20200415_win.zip"
+                    TARGET_PATH "${TEMP}/tbb"
+                    ENVIRONMENT "TBBROOT"
+                    VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*")
+        elseif(ANDROID)  # Should be before LINUX due LINUX is detected as well
+            RESOLVE_DEPENDENCY(TBB
+                    ARCHIVE_ANDROID "tbb2020_20200404_android.tgz"
+                    TARGET_PATH "${TEMP}/tbb"
+                    ENVIRONMENT "TBBROOT"
+                    VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*")
+        elseif(LINUX AND X86_64)
+            RESOLVE_DEPENDENCY(TBB
+                    ARCHIVE_LIN "tbb2020_20200415_lin_strip.tgz"
+                    TARGET_PATH "${TEMP}/tbb"
+                    ENVIRONMENT "TBBROOT")
+        elseif(APPLE AND X86_64)
+            RESOLVE_DEPENDENCY(TBB
+                    ARCHIVE_MAC "tbb2020_20200404_mac.tgz"
+                    TARGET_PATH "${TEMP}/tbb"
+                    ENVIRONMENT "TBBROOT"
+                    VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*")
+        else()
+            message(FATAL_ERROR "TBB is not available on current platform")
+        endif()
+    else()
+        if(DEFINED TBB_DIR)
+            get_filename_component(TBB ${TBB_DIR} DIRECTORY)
+        else()
+            get_filename_component(TBB $ENV{TBB_DIR} DIRECTORY)
+        endif()
     endif()
-    log_rpath_from_dir(TBB "${TBB}/lib")
+
+    update_deps_cache(TBBROOT "${TBB}" "Path to TBB root folder")
+    update_deps_cache(TBB_DIR "${TBBROOT}/cmake" "Path to TBB package folder")
+
+    if (WIN32)
+        log_rpath_from_dir(TBB "${TBB_DIR}/../bin")
+    else ()
+        log_rpath_from_dir(TBB "${TBB_DIR}/../lib")
+    endif ()
     debug_message(STATUS "tbb=" ${TBB})
 endif ()
 
 if (ENABLE_OPENCV)
-    set(OPENCV_VERSION "4.1.2")
-    set(OPENCV_BUILD "624")
-    set(OPENCV_SUFFIX "")
-    if (WIN32)
+    reset_deps_cache(OpenCV_DIR)
+
+    set(OPENCV_VERSION "4.3.0")
+    set(OPENCV_BUILD "060")
+    if (WIN32 AND X86_64)
         RESOLVE_DEPENDENCY(OPENCV
-                ARCHIVE_WIN "opencv_${OPENCV_VERSION}-${OPENCV_BUILD}.zip"
-                TARGET_PATH "${TEMP}/opencv_${OPENCV_VERSION}"
+                ARCHIVE_WIN "opencv_${OPENCV_VERSION}-${OPENCV_BUILD}.txz"
+                TARGET_PATH "${TEMP}/opencv_${OPENCV_VERSION}/opencv"
                 ENVIRONMENT "OpenCV_DIR"
                 VERSION_REGEX ".*_([0-9]+.[0-9]+.[0-9]+).*")
-        log_rpath_from_dir(OPENCV "\\opencv_${OPENCV_VERSION}\\bin")
-    elseif(APPLE)
+    elseif(APPLE AND X86_64)
         RESOLVE_DEPENDENCY(OPENCV
-                ARCHIVE_MAC "opencv_${OPENCV_VERSION}-${OPENCV_BUILD}_osx.tar.xz"
-                TARGET_PATH "${TEMP}/opencv_${OPENCV_VERSION}_osx"
+                ARCHIVE_MAC "opencv_${OPENCV_VERSION}-${OPENCV_BUILD}_osx.txz"
+                TARGET_PATH "${TEMP}/opencv_${OPENCV_VERSION}_osx/opencv"
                 ENVIRONMENT "OpenCV_DIR"
                 VERSION_REGEX ".*_([0-9]+.[0-9]+.[0-9]+).*")
-        log_rpath_from_dir(OPENCV "opencv_${OPENCV_VERSION}_osx/lib")
     elseif(LINUX)
         if (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "armv7l")
             set(OPENCV_SUFFIX "debian9arm")
+        elseif (${LINUX_OS_NAME} STREQUAL "CentOS 7" OR CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.9")
+            set(OPENCV_SUFFIX "centos7")
         elseif (${LINUX_OS_NAME} STREQUAL "Ubuntu 16.04")
             set(OPENCV_SUFFIX "ubuntu16")
         elseif (${LINUX_OS_NAME} STREQUAL "Ubuntu 18.04")
             set(OPENCV_SUFFIX "ubuntu18")
-        elseif (${LINUX_OS_NAME} STREQUAL "CentOS 7")
-            set(OPENCV_SUFFIX "centos7")
+        else()
+            message(FATAL_ERROR "OpenCV is not available on current platform")
         endif()
-    endif()
-
-    if (OPENCV_SUFFIX)
         RESOLVE_DEPENDENCY(OPENCV
-                ARCHIVE_LIN "opencv_${OPENCV_VERSION}-${OPENCV_BUILD}_${OPENCV_SUFFIX}.tar.xz"
-                TARGET_PATH "${TEMP}/opencv_${OPENCV_VERSION}_${OPENCV_SUFFIX}"
+                ARCHIVE_LIN "opencv_${OPENCV_VERSION}-${OPENCV_BUILD}_${OPENCV_SUFFIX}.txz"
+                TARGET_PATH "${TEMP}/opencv_${OPENCV_VERSION}_${OPENCV_SUFFIX}/opencv"
                 ENVIRONMENT "OpenCV_DIR"
                 VERSION_REGEX ".*_([0-9]+.[0-9]+.[0-9]+).*")
-        log_rpath_from_dir(OPENCV "opencv_${OPENCV_VERSION}_${OPENCV_SUFFIX}/lib")
+    endif()
+
+    if(ANDROID)
+        set(ocv_cmake_path "${OPENCV}/sdk/native/jni/")
+    else()
+        set(ocv_cmake_path "${OPENCV}/cmake")
+    endif()
+
+    update_deps_cache(OpenCV_DIR "${ocv_cmake_path}" "Path to OpenCV package folder")
+
+    if(WIN32)
+        log_rpath_from_dir(OPENCV "${OpenCV_DIR}/../bin")
+    elseif(ANDROID)
+        log_rpath_from_dir(OPENCV "${OpenCV_DIR}/../../../lib")
+    else()
+        log_rpath_from_dir(OPENCV "${OpenCV_DIR}/../lib")
     endif()
     debug_message(STATUS "opencv=" ${OPENCV})
-    # OpenCV_DIR should point to cmake folder within the specified OpenCV binary package.
-    # It's required to successsfully find OpenCV libs using find_package(OpenCV ...) command.
-    # So, the cached OpenCV_DIR variable should be update if custom value wasn't previously set here.
-    if (NOT DEFINED ENV{OpenCV_DIR})
-        set(OpenCV_DIR "${OPENCV}/cmake" CACHE PATH "Path to OpenCV in temp directory")
-    endif()
 endif()
 
 include(ie_parallel)
 
 if (ENABLE_GNA)
+    reset_deps_cache(
+            GNA
+            GNA_PLATFORM_DIR
+            GNA_KERNEL_LIB_NAME
+            GNA_LIBS_LIST
+            GNA_LIB_DIR
+            libGNA_INCLUDE_DIRS
+            libGNA_LIBRARIES_BASE_PATH)
     if (GNA_LIBRARY_VERSION STREQUAL "GNA1")
         RESOLVE_DEPENDENCY(GNA
                 ARCHIVE_UNIFIED "gna_20181120.zip"
                 TARGET_PATH "${TEMP}/gna")
-    elseif(GNA_LIBRARY_VERSION STREQUAL "GNA1_1401")
-        set(GNA_VERSION "01.00.00.1401")
+    else()
+        if(GNA_LIBRARY_VERSION STREQUAL "GNA1_1401")
+            set(GNA_VERSION "01.00.00.1401")
+        endif()
+        if(GNA_LIBRARY_VERSION STREQUAL "GNA2")
+            set(GNA_VERSION "02.00.00.0654")
+        endif()
         RESOLVE_DEPENDENCY(GNA
                 ARCHIVE_UNIFIED "GNA_${GNA_VERSION}.zip"
                 TARGET_PATH "${TEMP}/gna_${GNA_VERSION}"
                 VERSION_REGEX ".*_([0-9]+.[0-9]+.[0-9]+.[0-9]+).*")
     endif()
+    update_deps_cache(GNA "${GNA}" "Path to GNA root folder")
     debug_message(STATUS "gna=" ${GNA})
 endif()
 
 configure_file(
-        "${PROJECT_SOURCE_DIR}/cmake/share/InferenceEngineConfig.cmake.in"
+        "${IE_MAIN_SOURCE_DIR}/cmake/share/InferenceEngineConfig.cmake.in"
         "${CMAKE_BINARY_DIR}/share/InferenceEngineConfig.cmake"
         @ONLY)
 
 configure_file(
-        "${PROJECT_SOURCE_DIR}/cmake/share/InferenceEngineConfig-version.cmake.in"
+        "${IE_MAIN_SOURCE_DIR}/cmake/share/InferenceEngineConfig-version.cmake.in"
         "${CMAKE_BINARY_DIR}/share/InferenceEngineConfig-version.cmake"
         COPYONLY)
 
 configure_file(
-        "${PROJECT_SOURCE_DIR}/cmake/ie_parallel.cmake"
+        "${IE_MAIN_SOURCE_DIR}/cmake/ie_parallel.cmake"
         "${CMAKE_BINARY_DIR}/share/ie_parallel.cmake"
         COPYONLY)

inference-engine/cmake/dependency_solver.cmake

@@ -1,131 +0,0 @@
-# Copyright (C) 2018-2019 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-include ("download")
-
-function (resolve_archive_dependency VAR COMPONENT ARCHIVE ARCHIVE_UNIFIED ARCHIVE_WIN ARCHIVE_LIN ARCHIVE_MAC TARGET_PATH FOLDER ENVIRONMENT)
-
-  if (ENVIRONMENT AND (DEFINED ENV{${ENVIRONMENT}}))
-    set(HAS_ENV "TRUE")
-  endif()
-
-  if (NOT DEFINED HAS_ENV)
-    if (ARCHIVE)
-      #TODO: check whether this is platform specific binary with same name per or it is in common folder
-      DownloadAndExtract(${COMPONENT} ${ARCHIVE} ${TARGET_PATH} result_path ${FOLDER})
-    else()
-      DownloadAndExtractPlatformSpecific(${COMPONENT} ${ARCHIVE_UNIFIED} ${ARCHIVE_WIN} ${ARCHIVE_LIN} ${ARCHIVE_MAC} ${TARGET_PATH} result_path  ${FOLDER})
-    endif()
-
-    set (${VAR} ${result_path} PARENT_SCOPE)
-  else()
-    set (${VAR} $ENV{${ENVIRONMENT}} PARENT_SCOPE)
-  endif()
-
-endfunction(resolve_archive_dependency)
-
-function(resolve_pull_request GITHUB_PULL_REQUEST TARGET_PATH)
-    get_filename_component(FILE_NAME ${GITHUB_PULL_REQUEST} NAME)
-    set (PATCH_URL "")
-    DownloadAndApply("${PATCH_URL}/${GITHUB_PULL_REQUEST}" "${IE_MAIN_SOURCE_DIR}/${TARGET_PATH}/${FILE_NAME}")
-endfunction(resolve_pull_request)
-
-function(extract_version_from_filename filename regex version)
-    string(REGEX MATCH ${regex} match ${filename})
-
-    if (CMAKE_MATCH_1)
-        set(${version} ${CMAKE_MATCH_1} PARENT_SCOPE)
-    else()
-        set(${version} ${filename} PARENT_SCOPE)
-    endif()
-endfunction(extract_version_from_filename)
-
-function(read_version archive regex version_var)
-    extract_version_from_filename(${archive} ${regex} version)
-    set(${version_var} "${version}" CACHE INTERNAL "" FORCE)
-    debug_message(STATUS "${version_var} = " ${version})
-endfunction(read_version)
-
-function (RESOLVE_DEPENDENCY NAME_OF_CMAKE_VAR)
-
-  list(REMOVE_AT ARGV 0)
-  set(SUPPORTED_ARGS FOLDER ARCHIVE ARCHIVE_UNIFIED ARCHIVE_WIN ARCHIVE_LIN ARCHIVE_MAC TARGET_PATH ENVIRONMENT GITHUB_PULL_REQUEST VERSION_REGEX)
-
-
-  #unnecessary vars
-  foreach(arg ${ARGV})
-    #message("one_arg=" ${one_arg})
-    #message("arg=" ${arg})
-    #parse no arg vars
-    if (";${SUPPORTED_ARGS};" MATCHES ";${arg};")
-      if(DEFINED one_arg)
-        set(${one_arg} TRUE)
-      endif()
-      set (one_arg ${arg})
-    elseif(DEFINED one_arg)
-      set(${one_arg} ${arg})
-      unset(one_arg)
-    else()
-      message(FATAL_ERROR "invalid argument passed to resolve dependency: " ${arg})
-    endif()
-  endforeach(arg)
-
-  #if last token was bool
-  if(DEFINED one_arg)
-    set(${one_arg} TRUE)
-  endif()
-
-
-  if (NOT DEFINED ARCHIVE)
-    SET(ARCHIVE "OFF")
-  endif()
-
-  if (NOT DEFINED ARCHIVE_UNIFIED)
-    SET(ARCHIVE_UNIFIED "OFF")
-  endif()
-
-  if (NOT DEFINED ARCHIVE_WIN)
-    SET(ARCHIVE_WIN "OFF")
-  endif()
-
-  if (NOT DEFINED ARCHIVE_LIN)
-    SET(ARCHIVE_LIN "OFF")
-  endif()
-
-  if (NOT DEFINED ARCHIVE_MAC)
-    SET(ARCHIVE_MAC "OFF")
-  endif()
-
-  if (NOT DEFINED ENVIRONMENT)
-    set (ENVIRONMENT "OFF")
-  endif()
-
-  if (NOT DEFINED FOLDER)
-    set (FOLDER FALSE)
-  endif()
-
-
-
-  #for each dependency type have to do separate things
-  if (ARCHIVE_WIN OR ARCHIVE_LIN OR ARCHIVE_MAC OR ARCHIVE OR ARCHIVE_UNIFIED)
-    if (NOT DEFINED TARGET_PATH)
-      message(FATAL_ERROR "TARGET_PATH should be defined for every dependency")
-    endif()
-
-    resolve_archive_dependency(RESULT ${NAME_OF_CMAKE_VAR} ${ARCHIVE} ${ARCHIVE_UNIFIED} ${ARCHIVE_WIN} ${ARCHIVE_LIN} ${ARCHIVE_MAC} ${TARGET_PATH} ${FOLDER} ${ENVIRONMENT})
-    set(${NAME_OF_CMAKE_VAR} ${RESULT} PARENT_SCOPE)
-    if (VERSION_REGEX)
-        GetNameAndUrlToDownload(archive RELATIVE_URL ${ARCHIVE_UNIFIED} ${ARCHIVE_WIN} ${ARCHIVE_LIN} ${ARCHIVE_MAC})
-        if (archive)
-            read_version(${archive} ${VERSION_REGEX} "${NAME_OF_CMAKE_VAR}_VERSION")
-        endif()
-    endif()
-
-  elseif (DEFINED GITHUB_PULL_REQUEST)
-    resolve_pull_request(${GITHUB_PULL_REQUEST} ${TARGET_PATH})
-  else()
-    message(FATAL_ERROR "Dependency of unknowntype, SHOULD set one of ARCHIVE_WIN, ARCHIVE, ARCHIVE_LIN, ARCHIVE_MAC, GITHUB_PULL_REQUEST")
-  endif()
-
-endfunction(RESOLVE_DEPENDENCY)

inference-engine/cmake/developer_package.cmake

@@ -1,159 +0,0 @@
-# Copyright (C) 2018 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-# printing debug messages
-include(debug)
-
-if (UNIX AND NOT APPLE)
-    set(LINUX ON)
-endif()
-
-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()
-else()
-    set(BIN_FOLDER "bin/${ARCH_FOLDER}")
-endif()
-
-if("${CMAKE_BUILD_TYPE}" STREQUAL "")
-    debug_message(STATUS "CMAKE_BUILD_TYPE not defined, 'Release' will be used")
-    set(CMAKE_BUILD_TYPE "Release")
-endif()
-
-if(COVERAGE)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage -O0")
-endif()
-
-if(UNIX)
-    SET(LIB_DL ${CMAKE_DL_LIBS})
-endif()
-
-set(OUTPUT_ROOT ${IE_MAIN_SOURCE_DIR})
-
-# Enable postfixes for Debug/Release builds
-set(IE_DEBUG_POSTFIX_WIN "d")
-set(IE_RELEASE_POSTFIX_WIN "")
-set(IE_DEBUG_POSTFIX_LIN "")
-set(IE_RELEASE_POSTFIX_LIN "")
-set(IE_DEBUG_POSTFIX_MAC "d")
-set(IE_RELEASE_POSTFIX_MAC "")
-
-if(WIN32)
-    set(IE_DEBUG_POSTFIX ${IE_DEBUG_POSTFIX_WIN})
-    set(IE_RELEASE_POSTFIX ${IE_RELEASE_POSTFIX_WIN})
-elseif(APPLE)
-    set(IE_DEBUG_POSTFIX ${IE_DEBUG_POSTFIX_MAC})
-    set(IE_RELEASE_POSTFIX ${IE_RELEASE_POSTFIX_MAC})
-else()
-    set(IE_DEBUG_POSTFIX ${IE_DEBUG_POSTFIX_LIN})
-    set(IE_RELEASE_POSTFIX ${IE_RELEASE_POSTFIX_LIN})
-endif()
-
-set(CMAKE_DEBUG_POSTFIX ${IE_DEBUG_POSTFIX})
-set(CMAKE_RELEASE_POSTFIX ${IE_RELEASE_POSTFIX})
-
-if (WIN32)
-    # Support CMake multiconfiguration for Visual Studio build
-    set(IE_BUILD_POSTFIX $<$<CONFIG:Debug>:${IE_DEBUG_POSTFIX}>$<$<CONFIG:Release>:${IE_RELEASE_POSTFIX}>)
-else ()
-    if (${CMAKE_BUILD_TYPE} STREQUAL "Debug" )
-        set(IE_BUILD_POSTFIX ${IE_DEBUG_POSTFIX})
-    else()
-        set(IE_BUILD_POSTFIX ${IE_RELEASE_POSTFIX})
-    endif()
-endif()
-message(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
-
-add_definitions(-DIE_BUILD_POSTFIX=\"${IE_BUILD_POSTFIX}\")
-
-if(NOT UNIX)
-    if (WIN32)
-        # set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
-        # set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
-    endif()
-    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
-    set(CMAKE_LIBRARY_PATH ${OUTPUT_ROOT}/${BIN_FOLDER})
-    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
-    set(CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
-    set(CMAKE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
-    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
-    set(LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
-    set(LIBRARY_OUTPUT_PATH ${LIBRARY_OUTPUT_DIRECTORY}) # compatibility issue: linux uses LIBRARY_OUTPUT_PATH, windows uses LIBRARY_OUTPUT_DIRECTORY
-else()
-    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE}/lib)
-    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE}/lib)
-    set(CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE})
-    set(CMAKE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE})
-    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE})
-    set(LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE}/lib)
-    set(LIBRARY_OUTPUT_PATH ${LIBRARY_OUTPUT_DIRECTORY}/lib)
-endif()
-
-if(APPLE)
-	set(CMAKE_MACOSX_RPATH 1)
-endif(APPLE)
-
-# rpath fully disabled
-if (NOT ENABLE_PLUGIN_RPATH)
-    set(CMAKE_SKIP_RPATH TRUE)
-endif()
-
-# prepare temporary folder
-function(set_temp_directory temp_variable source_tree_dir)
-    if (DEFINED ENV{${DL_SDK_TEMP}} AND NOT $ENV{${DL_SDK_TEMP}} STREQUAL "")
-        if (WIN32)
-            string(REPLACE "\\" "\\\\" temp $ENV{${DL_SDK_TEMP}})
-        else(WIN32)
-            set(temp $ENV{${DL_SDK_TEMP}})
-        endif(WIN32)
-
-        if (ENABLE_ALTERNATIVE_TEMP)
-            set(ALTERNATIVE_PATH ${source_tree_dir}/temp)
-        endif()
-    else ()
-        message(STATUS "DL_SDK_TEMP envionment not set")
-        set(temp ${source_tree_dir}/temp)
-    endif()
-
-    set("${temp_variable}" "${temp}" PARENT_SCOPE)
-    if(ALTERNATIVE_PATH)
-        set(ALTERNATIVE_PATH "${ALTERNATIVE_PATH}" PARENT_SCOPE)
-    endif()
-endfunction()
-
-# Use solution folders
-set_property(GLOBAL PROPERTY USE_FOLDERS ON)
-
-set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-
-include(os_flags)
-include(sdl)
-include(sanitizer)
-include(cpplint)
-include(cppcheck)
-
-function(set_ci_build_number)
-    set(IE_MAIN_SOURCE_DIR "${CMAKE_SOURCE_DIR}")
-    include(version)
-    set(CI_BUILD_NUMBER "${CI_BUILD_NUMBER}" PARENT_SCOPE)
-endfunction()
-set_ci_build_number()
-
-if(ENABLE_PROFILING_ITT)
-    find_package(ITT REQUIRED)
-endif()
-
-include(plugins/plugins)

inference-engine/cmake/developer_package_config.cmake.in

@@ -1,33 +1,15 @@
-# Copyright (C) 2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 
-set(IE_MAIN_SOURCE_DIR "@CMAKE_SOURCE_DIR@")
+set(OpenVINO_MAIN_SOURCE_DIR "@OpenVINO_SOURCE_DIR@")
+set(IE_MAIN_SOURCE_DIR "@InferenceEngine_SOURCE_DIR@")
+
 file(TO_CMAKE_PATH "${CMAKE_CURRENT_LIST_DIR}" cache_path)
 
-# inherit OpenCV from main IE project
-load_cache("${cache_path}" READ_WITH_PREFIX "" OpenCV_DIR)
-find_package(OpenCV COMPONENTS imgcodecs)
-
-# Targets
-
-include("${CMAKE_CURRENT_LIST_DIR}/targets_developer.cmake")
-
-# add additional interface include directories needed for plugin development
-if(NOT TARGET IE::inference_engine)
-	message(FATAL_ERROR "The target IE::inference_engine does not exist")
-endif()
-
-set(ie_plugin_headers "${IE_MAIN_SOURCE_DIR}/src/inference_engine")
-set_property(TARGET IE::inference_engine APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES "${ie_plugin_headers}")
-set_property(TARGET IE::inference_engine PROPERTY IMPORTED_GLOBAL TRUE)
-
-get_target_property(InferenceEngine_INCLUDE_DIRS IE::inference_engine INTERFACE_INCLUDE_DIRECTORIES)
-set(InferenceEngine_LIBRARIES IE::inference_engine)
-
 # Variables to export in plugin's projects
 
-set(ie_options "@IE_OPTIONS@;CMAKE_BUILD_TYPE")
+set(ie_options "@IE_OPTIONS@;CMAKE_BUILD_TYPE;CMAKE_SKIP_RPATH")
 
 load_cache("${cache_path}" READ_WITH_PREFIX "" ${ie_options})
 
@@ -38,11 +20,41 @@ foreach(option IN LISTS ie_options)
 endforeach()
 message("")
 
+set(gflags_DIR "@gflags_BINARY_DIR@")
+
+# Targets
+
+include("${CMAKE_CURRENT_LIST_DIR}/targets_developer.cmake")
+# to allow too create ALIAS for IE::inference_engine in 3rd-party projects
+set_property(TARGET IE::inference_engine PROPERTY IMPORTED_GLOBAL TRUE)
+
+get_target_property(InferenceEngine_INCLUDE_DIRS IE::inference_engine INTERFACE_INCLUDE_DIRECTORIES)
+set(InferenceEngine_LIBRARIES IE::inference_engine_legacy IE::inference_engine IE::inference_engine_nn_builder)
+
 #
 # Common cmake includes
 #
 
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake;${IE_MAIN_SOURCE_DIR}/cmake")
+list(APPEND CMAKE_MODULE_PATH "${OpenVINO_MAIN_SOURCE_DIR}/cmake")
+list(APPEND CMAKE_MODULE_PATH "${IE_MAIN_SOURCE_DIR}/cmake")
 
 # generic stuff from developer package
-include(developer_package)
+include(developer_package NO_POLICY_SCOPE)
+include(developer_package_ie)
+
+# Don't threat deprecated API warnings as errors in 3rd party apps
+ie_deprecated_no_errors()
+
+# inherit OpenCV from main IE project if enabled
+if (ENABLE_OPENCV)
+    load_cache("${cache_path}" READ_WITH_PREFIX "" OpenCV_DIR)
+    find_package(OpenCV)
+endif()
+
+# inherit TBB from main IE project if enabled
+if (THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO")
+    load_cache("${cache_path}" READ_WITH_PREFIX "" TBB_DIR)
+    find_package(TBB)
+endif()
+
+find_package(Threads REQUIRED)

inference-engine/cmake/developer_package_ie.cmake

@@ -0,0 +1,15 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+include(cpplint)
+include(clang_format)
+
+if(ENABLE_PROFILING_ITT)
+    find_package(ITT REQUIRED)
+endif()
+
+set(TBB_FIND_RELEASE_ONLY ${ENABLE_TBB_RELEASE_ONLY})
+
+include(plugins/plugins)
+include(add_ie_target)

inference-engine/cmake/features.cmake

@@ -1,130 +0,0 @@
-# Copyright (C) 2018-2019 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-include (options)
-
-#these options are aimed to optimize build time on development system
-
-#backed targets
-ie_option (ENABLE_GNA "GNA support for inference engine" ON)
-ie_option (ENABLE_ROCKHOPER "use Rockhopper decoder for converting / output scores" ON)
-
-ie_option (ENABLE_MKL_DNN "MKL-DNN plugin for inference engine" ON)
-
-ie_option (ENABLE_CLDNN "clDnn based plugin for inference engine" ON)
-
-ie_option (ENABLE_CLDNN_TESTS "Enable clDNN unit tests" OFF)
-
-ie_option (ENABLE_CLDNN_BUILD "build clDnn from sources" OFF)
-
-ie_option (ENABLE_PROFILING_ITT "ITT tracing of IE and plugins internals" ON)
-
-ie_option (ENABLE_PROFILING_RAW "Raw counters profiling (just values, no start/stop time or timeline)" OFF)
-
-# "MKL-DNN library might use MKL-ML or OpenBLAS for gemm tasks: MKL|OPENBLAS|JIT"
-if (NOT GEMM STREQUAL "MKL"
-        AND NOT GEMM STREQUAL "OPENBLAS"
-        AND NOT GEMM STREQUAL "JIT")
-    set (GEMM "JIT")
-    message(STATUS "GEMM should be set to MKL, OPENBLAS or JIT. Default option is " ${GEMM})
-endif()
-set(GEMM "${GEMM}" CACHE STRING "Gemm implementation" FORCE)
-list (APPEND IE_OPTIONS GEMM)
-
-# "MKL-DNN library based on OMP or TBB or Sequential implementation: TBB|OMP|SEQ"
-if (NOT THREADING STREQUAL "TBB"
-        AND NOT THREADING STREQUAL "TBB_AUTO"
-        AND NOT THREADING STREQUAL "OMP"
-        AND NOT THREADING STREQUAL "SEQ")
-    set (THREADING "TBB")
-    message(STATUS "THREADING should be set to TBB, TBB_AUTO, OMP or SEQ. Default option is " ${THREADING})
-endif()
-set(THREADING "${THREADING}" CACHE STRING "Threading" FORCE)
-list (APPEND IE_OPTIONS THREADING)
-
-ie_option (ENABLE_VPU "vpu targeted plugins for inference engine" ON)
-
-ie_option (ENABLE_MYRIAD "myriad targeted plugin for inference engine" ON)
-
-ie_option (ENABLE_MYRIAD_NO_BOOT "myriad plugin will skip device boot" OFF)
-
-ie_option (ENABLE_TESTS "unit and functional tests" OFF)
-
-ie_option (ENABLE_GAPI_TESTS "tests for GAPI kernels" OFF)
-
-ie_option (GAPI_TEST_PERF "if GAPI unit tests should examine performance" OFF)
-
-ie_option (ENABLE_MYRIAD_MVNC_TESTS "functional and behavior tests for mvnc api" OFF)
-
-ie_option (ENABLE_SAMPLES "console samples are part of inference engine package" ON)
-
-ie_option (ENABLE_SAMPLES_CORE "console samples core library" ON)
-
-ie_option (ENABLE_SANITIZER "enable checking memory errors via AddressSanitizer" OFF)
-
-ie_option (ENABLE_FUZZING "instrument build for fuzzing" OFF)
-
-ie_option (COVERAGE "enable code coverage" OFF)
-
-ie_option (ENABLE_STRESS_UNIT_TESTS "stress unit tests" OFF)
-
-ie_option (VERBOSE_BUILD "shows extra information about build" OFF)
-
-ie_option (ENABLE_UNSAFE_LOCATIONS "skip check for MD5 for dependency" OFF)
-
-ie_option (ENABLE_ALTERNATIVE_TEMP "in case of dependency conflict, to avoid modification in master, use local copy of dependency" ON)
-
-ie_option (ENABLE_SEGMENTATION_TESTS "segmentation tests" ON)
-
-ie_option (ENABLE_OBJECT_DETECTION_TESTS "object detection tests" ON)
-
-ie_option (ENABLE_OPENCV "enables OpenCV" ON)
-
-ie_option (OS_FOLDER "create OS dedicated folder in output" OFF)
-
-ie_option (ENABLE_PLUGIN_RPATH "enables rpath information to be present in plugins binary, and in corresponding test_applications" ON)
-
-ie_option (ENABLE_AFFINITY_GENERATOR "enables affinity generator build" OFF)
-
-ie_option (ENABLE_DEBUG_SYMBOLS "generates symbols for debugging" OFF)
-
-ie_option (ENABLE_PYTHON "enables ie python bridge build" OFF)
-
-ie_option (DEVELOPMENT_PLUGIN_MODE "Disabled build of all plugins" OFF)
-
-ie_option (TREAT_WARNING_AS_ERROR "Treat build warnings as errors" ON)
-
-ie_option (ENABLE_CPP_CCT "enables C++ version of Cross Check Tool" OFF)
-
-ie_option (ENABLE_UNICODE_PATH_SUPPORT "Enable loading models from Unicode paths" ON)
-
-ie_option (ENABLE_LTO "Enable Link Time Optimization" OFF)
-
-# FIXME: there are compiler failures with LTO and Cross-Compile toolchains. Disabling for now, but
-#        this must be addressed in a proper way
-if(CMAKE_CROSSCOMPILING OR NOT (UNIX AND NOT APPLE))
-    set(ENABLE_LTO OFF)
-endif()
-
-if (UNIX AND NOT APPLE AND CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.3)
-    set(ENABLE_UNICODE_PATH_SUPPORT OFF)
-endif()
-
-if (UNIX AND NOT APPLE)
-    ie_option(ENABLE_CPPLINT "Enable cpplint checks during the build" OFF)
-    ie_option(ENABLE_CPPLINT_REPORT "Build cpplint report instead of failing the build" OFF)
-else()
-    set(ENABLE_CPPLINT OFF)
-endif()
-
-if (UNIX AND NOT APPLE)
-    ie_option(ENABLE_CPPCHECK "Enable cppcheck during the build" OFF)
-else()
-    set(ENABLE_CPPCHECK OFF)
-endif()
-
-#environment variables used
-
-#name of environment variable stored path to temp directory"
-set (DL_SDK_TEMP  "DL_SDK_TEMP")

inference-engine/cmake/features_ie.cmake

@@ -0,0 +1,114 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+include (target_flags)
+include (options)
+
+#these options are aimed to optimize build time on development system
+
+ie_dependent_option (ENABLE_GNA "GNA support for inference engine" ON "NOT APPLE;NOT ANDROID;X86 OR X86_64" OFF)
+
+ie_dependent_option (ENABLE_CLDNN_TESTS "Enable clDNN unit tests" OFF "ENABLE_CLDNN" OFF)
+
+ie_dependent_option (ENABLE_PROFILING_ITT "ITT tracing of IE and plugins internals" ON "NOT CMAKE_CROSSCOMPILING" OFF)
+
+# "MKL-DNN library might use MKL-ML or OpenBLAS for gemm tasks: MKL|OPENBLAS|JIT"
+if (ENABLE_MKL_DNN)
+    if(AARCH64)
+        set(GEMM_DEFAULT "OPENBLAS")
+    else()
+        set(GEMM_DEFAULT "JIT")
+    endif()
+    set(GEMM "${GEMM_DEFAULT}" CACHE STRING "GEMM implementation")
+    set_property(CACHE GEMM PROPERTY STRINGS "MKL" "OPENBLAS" "JIT")
+    list (APPEND IE_OPTIONS GEMM)
+    if (NOT GEMM STREQUAL "MKL" AND
+        NOT GEMM STREQUAL "OPENBLAS" AND
+        NOT GEMM STREQUAL "JIT")
+        message(FATAL_ERROR "GEMM should be set to MKL, OPENBLAS or JIT. Default option is ${GEMM_DEFAULT}")
+    endif()
+endif()
+
+# "MKL-DNN library based on OMP or TBB or Sequential implementation: TBB|OMP|SEQ"
+if(ARM)
+    set(THREADING_DEFAULT "SEQ")
+else()
+    set(THREADING_DEFAULT "TBB")
+endif()
+set(THREADING "${THREADING_DEFAULT}" CACHE STRING "Threading")
+set_property(CACHE THREADING PROPERTY STRINGS "TBB" "TBB_AUTO" "OMP" "SEQ")
+list (APPEND IE_OPTIONS THREADING)
+if (NOT THREADING STREQUAL "TBB" AND
+    NOT THREADING STREQUAL "TBB_AUTO" AND
+    NOT THREADING STREQUAL "OMP" AND
+    NOT THREADING STREQUAL "SEQ")
+    message(FATAL_ERROR "THREADING should be set to TBB, TBB_AUTO, OMP or SEQ. Default option is ${THREADING_DEFAULT}")
+endif()
+
+if (ENABLE_GNA)
+    if (UNIX AND NOT APPLE AND CMAKE_COMPILER_IS_GNUCC AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.4)
+        set (DEFAULT_GNA_LIB GNA1)
+    else()
+        set (DEFAULT_GNA_LIB GNA1_1401)
+    endif()
+    set(GNA_LIBRARY_VERSION "${DEFAULT_GNA_LIB}" CACHE STRING "GNAVersion")
+    set_property(CACHE GNA_LIBRARY_VERSION PROPERTY STRINGS "GNA1" "GNA1_1401" "GNA2")
+    list (APPEND IE_OPTIONS GNA_LIBRARY_VERSION)
+    if (NOT GNA_LIBRARY_VERSION STREQUAL "GNA1" AND
+        NOT GNA_LIBRARY_VERSION STREQUAL "GNA1_1401" AND
+        NOT GNA_LIBRARY_VERSION STREQUAL "GNA2")
+        message(FATAL_ERROR "GNA_LIBRARY_VERSION should be set to GNA1, GNA1_1401 or GNA2. Default option is ${DEFAULT_GNA_LIB}")
+    endif()
+endif()
+
+ie_option (ENABLE_IR_READER "Compile with IR readers / parsers" ON)
+
+ie_option (ENABLE_VPU "vpu targeted plugins for inference engine" ON)
+
+ie_dependent_option (ENABLE_MYRIAD "myriad targeted plugin for inference engine" ON "ENABLE_VPU" OFF)
+
+ie_dependent_option (ENABLE_MYRIAD_NO_BOOT "myriad plugin will skip device boot" OFF "ENABLE_MYRIAD" OFF)
+
+ie_option (ENABLE_TESTS "unit, behavior and functional tests" OFF)
+
+ie_dependent_option (ENABLE_GAPI_TESTS "tests for GAPI kernels" OFF "ENABLE_TESTS" OFF)
+
+ie_dependent_option (GAPI_TEST_PERF "if GAPI unit tests should examine performance" OFF "ENABLE_GAPI_TESTS" OFF)
+
+ie_dependent_option (ENABLE_MYRIAD_MVNC_TESTS "functional and behavior tests for mvnc api" OFF "ENABLE_TESTS;ENABLE_MYRIAD" OFF)
+
+ie_dependent_option (ENABLE_SAMPLES "console samples are part of inference engine package" ON "NOT MINGW" OFF)
+
+ie_dependent_option (ENABLE_BEH_TESTS "tests oriented to check inference engine API corecteness" ON "ENABLE_TESTS" OFF)
+
+ie_dependent_option (ENABLE_FUNCTIONAL_TESTS "functional tests" ON "ENABLE_TESTS;ENABLE_IR_READER" OFF)
+
+ie_dependent_option (ENABLE_SAMPLES "console samples are part of inference engine package" ON "NOT MINGW" OFF)
+
+ie_option (ENABLE_FUZZING "instrument build for fuzzing" OFF)
+
+ie_option (VERBOSE_BUILD "shows extra information about build" OFF)
+
+ie_option (ENABLE_UNSAFE_LOCATIONS "skip check for MD5 for dependency" OFF)
+
+ie_option (ENABLE_ALTERNATIVE_TEMP "in case of dependency conflict, to avoid modification in master, use local copy of dependency" ON)
+
+ie_option (ENABLE_OPENCV "enables OpenCV" ON)
+
+ie_option (ENABLE_DEBUG_SYMBOLS "generates symbols for debugging" OFF)
+
+ie_option (ENABLE_PYTHON "enables ie python bridge build" OFF)
+
+ie_option (ENABLE_CPP_CCT "enables C++ version of Cross Check Tool" OFF)
+
+ie_option (ENABLE_C "enables ie c bridge build" ON)
+
+ie_dependent_option(ENABLE_CPPLINT "Enable cpplint checks during the build" OFF "OFF;UNIX;NOT APPLE;NOT ANDROID" OFF)
+ie_dependent_option(ENABLE_CPPLINT_REPORT "Build cpplint report instead of failing the build" OFF "ENABLE_CPPLINT" OFF)
+
+ie_option(ENABLE_CLANG_FORMAT "Enable clang-format checks during the build" OFF)
+
+set(IE_EXTRA_PLUGINS "" CACHE STRING "Extra paths for plugins to include into DLDT build tree")
+
+ie_dependent_option(ENABLE_TBB_RELEASE_ONLY "Only Release TBB libraries are linked to the Inference Engine binaries" ON "THREADING MATCHES TBB;LINUX" OFF)

inference-engine/cmake/fuzzing.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 

inference-engine/cmake/ie_parallel.cmake

@@ -1,82 +1,61 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 
 function(set_ie_threading_interface_for TARGET_NAME)
+    get_target_property(target_type ${TARGET_NAME} TYPE)
+    if(target_type STREQUAL "INTERFACE_LIBRARY")
+        set(LINK_TYPE "INTERFACE")
+    else()
+        set(LINK_TYPE "PUBLIC")
+    endif()
+
+    function(ie_target_link_libraries TARGET_NAME LINK_TYPE)
+        if(CMAKE_VERSION VERSION_LESS "3.12.0")
+            if(NOT target_type STREQUAL "OBJECT_LIBRARY")
+                target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${ARGN})
+            else()
+                # Object library may not link to anything.
+                # To add interface include directories and compile options explicitly.
+                foreach(ITEM IN LISTS ARGN)
+                    if(TARGET ${ITEM})
+                        get_target_property(compile_options ${ITEM} INTERFACE_COMPILE_OPTIONS)
+                        if (compile_options)
+                            target_compile_options(${TARGET_NAME} ${LINK_TYPE} ${compile_options})
+                        endif()
+                        get_target_property(compile_definitions ${ITEM} INTERFACE_COMPILE_DEFINITIONS)
+                        if (compile_options)
+                            target_compile_definitions(${TARGET_NAME} ${LINK_TYPE} ${compile_definitions})
+                        endif()
+                    endif()
+                endforeach()
+            endif()
+        else()
+            target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${ARGN})
+        endif()
+
+        # include directories as SYSTEM
+        foreach(library IN LISTS ARGN)
+            if(TARGET ${library})
+                get_target_property(include_directories ${library} INTERFACE_INCLUDE_DIRECTORIES)
+                if(include_directories)
+                    target_include_directories(${TARGET_NAME} SYSTEM BEFORE ${LINK_TYPE} ${include_directories})
+                endif()
+            endif()
+        endforeach()
+    endfunction()
+
     set(IE_THREAD_DEFINE "IE_THREAD_SEQ")
 
     if (THREADING STREQUAL "TBB" OR THREADING STREQUAL "TBB_AUTO")
-        if (DEFINED ENV{TBBROOT})
-            # Check TBB package in case if custom TBBROOT path configured
-            find_package(TBB QUIET PATHS "$ENV{TBBROOT}/cmake")
-            if (TBB_FOUND)
-                set(IE_THREAD_DEFINE "IE_THREAD_TBB")
-                if (WIN32)
-                    target_link_libraries(${TARGET_NAME} PUBLIC "-nodefaultlib:vcomp")
-                endif ()
-                target_link_libraries(${TARGET_NAME} PUBLIC ${TBB_IMPORTED_TARGETS})
-            else ()
-                # TBB was not found by the configured TBBROOT path, SEQ method will be used
-                ext_message(WARNING "TBB not found by the configured TBBROOT path $ENV{TBBROOT}")
-            endif ()
-        else()
-            if (NOT (IE_MAIN_SOURCE_DIR))
-                set(incl_path ${IE_EXTERNAL_DIR}/tbb/include)
-                if (WIN32)
-                    set(lib_rel_path ${IE_LIB_REL_DIR})
-                    set(lib_dbg_path ${IE_LIB_DBG_DIR})
-                else ()
-                    set(lib_rel_path ${IE_EXTERNAL_DIR}/tbb/lib)
-                    set(lib_dbg_path ${lib_rel_path})
-                endif ()
-            else ()
-                set(incl_path ${TBB}/include)
-                set(lib_rel_path ${TBB}/lib)
-                set(lib_dbg_path ${lib_rel_path})
-            endif ()
-
-            if (NOT TBB_INCLUDE_DIRS OR NOT TBB_LIBRARIES_RELEASE)
-                find_path(TBB_INCLUDE_DIRS tbb/tbb.h ${incl_path} NO_DEFAULT_PATH)
-                find_library(TBB_LIBRARIES_RELEASE tbb ${lib_rel_path} NO_DEFAULT_PATH)
-                ext_message(STATUS "TBB include: ${TBB_INCLUDE_DIRS}")
-                ext_message(STATUS "TBB Release lib: ${TBB_LIBRARIES_RELEASE}")
-                if (NOT LINUX)
-                    find_library(TBB_LIBRARIES_DEBUG tbb_debug ${lib_dbg_path} NO_DEFAULT_PATH)
-                    if (TBB_LIBRARIES_DEBUG)
-                        ext_message(STATUS "TBB Debug lib: ${TBB_LIBRARIES_DEBUG}")
-                    else ()
-                        ext_message(WARNING "TBB Debug binaries are missed.")
-                    endif ()
-                endif ()
-            endif ()
-
-            if (NOT TBB_INCLUDE_DIRS OR NOT TBB_LIBRARIES_RELEASE)
-                ext_message(WARNING "TBB not found. TBB support will be disabled. ${IE_THREAD_DEFINE} is defined")
-            else ()
-                set(IE_THREAD_DEFINE "IE_THREAD_TBB")
-
-                target_include_directories(${TARGET_NAME} PUBLIC ${TBB_INCLUDE_DIRS})
-                if (WIN32)
-                    target_link_libraries(${TARGET_NAME} PUBLIC "-nodefaultlib:vcomp")
-                endif ()
-
-                # Debug binaries are optional.
-                if (TBB_LIBRARIES_DEBUG AND NOT LINUX)
-                    if (WIN32)
-                        target_link_libraries(${TARGET_NAME} PUBLIC "$<$<CONFIG:DEBUG>:${TBB_LIBRARIES_DEBUG}>;$<$<NOT:$<CONFIG:DEBUG>>:${TBB_LIBRARIES_RELEASE}>")
-                    else ()
-                        if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-                            target_link_libraries(${TARGET_NAME} PUBLIC ${TBB_LIBRARIES_DEBUG})
-                        else()
-                            target_link_libraries(${TARGET_NAME} PUBLIC ${TBB_LIBRARIES_RELEASE})
-                        endif ()
-                    endif ()
-                else ()
-                    # Link Release library to all configurations.
-                    target_link_libraries(${TARGET_NAME} PUBLIC ${TBB_LIBRARIES_RELEASE})
-                endif ()
-            endif ()
-        endif()
+        find_package(TBB COMPONENTS tbb tbbmalloc)
+        if (TBB_FOUND)
+            set(IE_THREAD_DEFINE "IE_THREAD_TBB")
+            ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${TBB_IMPORTED_TARGETS})
+        else ()
+            ext_message(WARNING "TBB was not found by the configured TBB_DIR path. \
+                                 SEQ method will be used for ${TARGET_NAME}")
+        endif ()
     elseif (THREADING STREQUAL "OMP")
         if (WIN32)
             set(omp_lib_name libiomp5md)
@@ -116,36 +95,36 @@ function(set_ie_threading_interface_for TARGET_NAME)
             set(IE_THREAD_DEFINE "IE_THREAD_OMP")
 
             if (WIN32)
-                target_compile_options(${TARGET_NAME} PUBLIC ${OpenMP_CXX_FLAGS} /openmp)
-                target_compile_options(${TARGET_NAME} PUBLIC ${OpenMP_CXX_FLAGS} /Qopenmp)
-                target_link_libraries(${TARGET_NAME} PUBLIC "-nodefaultlib:vcomp")
+                target_compile_options(${TARGET_NAME} ${LINK_TYPE} ${OpenMP_CXX_FLAGS} /openmp)
+                target_compile_options(${TARGET_NAME} ${LINK_TYPE} ${OpenMP_CXX_FLAGS} /Qopenmp)
+                ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} "-nodefaultlib:vcomp")
             else()
-                target_compile_options(${TARGET_NAME} PUBLIC ${OpenMP_CXX_FLAGS} -fopenmp)
+                target_compile_options(${TARGET_NAME} ${LINK_TYPE} ${OpenMP_CXX_FLAGS} -fopenmp)
             endif ()
 
             # Debug binaries are optional.
             if (OMP_LIBRARIES_DEBUG AND NOT LINUX)
                 if (WIN32)
-                    target_link_libraries(${TARGET_NAME} PUBLIC "$<$<CONFIG:DEBUG>:${OMP_LIBRARIES_DEBUG}>;$<$<NOT:$<CONFIG:DEBUG>>:${OMP_LIBRARIES_RELEASE}>")
+                    ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} "$<$<CONFIG:DEBUG>:${OMP_LIBRARIES_DEBUG}>;$<$<NOT:$<CONFIG:DEBUG>>:${OMP_LIBRARIES_RELEASE}>")
                 else()
                     if ("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
-                        target_link_libraries(${TARGET_NAME} PUBLIC ${OMP_LIBRARIES_DEBUG})
+                        ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${OMP_LIBRARIES_DEBUG})
                     else()
-                        target_link_libraries(${TARGET_NAME} PUBLIC ${OMP_LIBRARIES_RELEASE})
+                        ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${OMP_LIBRARIES_RELEASE})
                     endif ()
                 endif ()
             else ()
                 # Link Release library to all configurations.
-                target_link_libraries(${TARGET_NAME} PUBLIC ${OMP_LIBRARIES_RELEASE})
+                ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${OMP_LIBRARIES_RELEASE})
             endif ()
         endif ()
 
     endif ()
 
-    target_compile_definitions(${TARGET_NAME} PUBLIC -DIE_THREAD=${IE_THREAD_DEFINE})
+    target_compile_definitions(${TARGET_NAME} ${LINK_TYPE} -DIE_THREAD=${IE_THREAD_DEFINE})
 
     if (NOT THREADING STREQUAL "SEQ")
         find_package(Threads REQUIRED)
-        target_link_libraries(${TARGET_NAME} PUBLIC ${CMAKE_THREAD_LIBS_INIT})
+        ie_target_link_libraries(${TARGET_NAME} ${LINK_TYPE} ${CMAKE_THREAD_LIBS_INIT})
     endif()
 endfunction(set_ie_threading_interface_for)

inference-engine/cmake/linux_name.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 

inference-engine/cmake/options.cmake

@@ -1,27 +0,0 @@
-# Copyright (C) 2018-2019 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-# Usage: ie_option(<option_variable> "description" <initial value or boolean expression> [IF <condition>])
-
-function (ie_option variable description value)
-	list(FIND IE_OPTIONS "${variable}" result)
-
-	if(${result} EQUAL -1)
-	    option(${variable} "${description}" ${value})
-	    list (APPEND IE_OPTIONS "${variable}")
-
-	    set (IE_OPTIONS "${IE_OPTIONS}" PARENT_SCOPE)
-	endif()
-endfunction()
-
-include(version)
-
-function (print_enabled_features)
-	message(STATUS "Inference Engine enabled features: ")
-    message("")
-    message("    CI_BUILD_NUMBER: ${CI_BUILD_NUMBER}")
-    foreach(_var ${IE_OPTIONS})
-        message("    ${_var} = ${${_var}}")
-    endforeach()
-    message("")
-endfunction()

inference-engine/cmake/os_flags.cmake

@@ -1,77 +0,0 @@
-# Copyright (C) 2018-2019 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-macro(disable_deprecated_warnings)
-    if(WIN32)
-        if(CMAKE_CXX_COMPILER_ID MATCHES Intel)
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Qdiag-warning:1478")
-        elseif(CMAKE_CXX_COMPILER_ID STREQUAL MSVC)
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4996") # disable warning on deprecated API
-        endif()
-    else()
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations")
-    endif()
-endmacro()
-
-if (WIN32)
-    set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS _CRT_SECURE_NO_WARNINGS)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_SCL_SECURE_NO_WARNINGS")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc") #no asynchronous structured exception handling
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LARGEADDRESSAWARE")
-
-    if (TREAT_WARNING_AS_ERROR)
-        if(CMAKE_CXX_COMPILER_ID MATCHES Intel)
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /WX")
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Qdiag-warning:2586,177,3180,1740,1786,47,161")
-        elseif (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
-#            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /WX") # Too many warnings
-        endif()
-    endif()
-
-    set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Z7")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Z7")
-
-    if(ENABLE_DEBUG_SYMBOLS)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Z7")
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Z7")
-
-        set(DEBUG_SYMBOLS_LINKER_FLAGS "/DEBUG")
-        if (CMAKE_BUILD_TYPE STREQUAL "Release")
-            # Keep default /OPT values. See /DEBUG reference for details.
-            set(DEBUG_SYMBOLS_LINKER_FLAGS "${DEBUG_SYMBOLS_LINKER_FLAGS} /OPT:REF /OPT:ICF")
-        endif()
-
-        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${DEBUG_SYMBOLS_LINKER_FLAGS}")
-        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${DEBUG_SYMBOLS_LINKER_FLAGS}")
-        set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${DEBUG_SYMBOLS_LINKER_FLAGS}")
-    endif()
-else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Werror=return-type ")
-    if (APPLE)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=unused-command-line-argument")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-function")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-variable")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-private-field")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-reorder")       
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wswitch")    
-    elseif(UNIX)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wuninitialized -Winit-self")
-        if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-switch")
-        else()
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wmaybe-uninitialized")
-        endif()
-    endif()
-
-    if(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -diag-disable=remark")
-    endif()
-
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility-inlines-hidden")
-
-    if(LINUX)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffunction-sections -fdata-sections")
-        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--gc-sections -Wl,--exclude-libs,ALL")
-    endif()
-endif()

inference-engine/cmake/plugins/create_plugin_file.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 

inference-engine/cmake/plugins/plugins.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 
@@ -21,13 +21,15 @@ endif()
 # ie_add_plugin(NAME <targetName>
 #               DEVICE_NAME <deviceName>
 #               SOURCES <sources>
+#               OBJECT_LIBRARIES <object_libs>
 #               VERSION_DEFINES_FOR <source>
+#               SKIP_INSTALL
 #               )
 #
 function(ie_add_plugin)
-    set(options)
+    set(options SKIP_INSTALL)
     set(oneValueArgs NAME DEVICE_NAME VERSION_DEFINES_FOR)
-    set(multiValueArgs SOURCES)
+    set(multiValueArgs SOURCES OBJECT_LIBRARIES CPPLINT_FILTERS)
     cmake_parse_arguments(IE_PLUGIN "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
     if(NOT IE_PLUGIN_NAME)
@@ -44,14 +46,31 @@ function(ie_add_plugin)
         addVersionDefines(${IE_PLUGIN_VERSION_DEFINES_FOR} CI_BUILD_NUMBER)
     endif()
 
-    add_library(${IE_PLUGIN_NAME} SHARED ${IE_PLUGIN_SOURCES})
+    set(input_files ${IE_PLUGIN_SOURCES})
+    foreach(obj_lib IN LISTS IE_PLUGIN_OBJECT_LIBRARIES)
+        list(APPEND input_files $<TARGET_OBJECTS:${obj_lib}>)
+        add_cpplint_target(${obj_lib}_cpplint FOR_TARGETS ${obj_lib})
+    endforeach()
+
+    add_library(${IE_PLUGIN_NAME} SHARED ${input_files})
     target_compile_definitions(${IE_PLUGIN_NAME} PRIVATE IMPLEMENT_INFERENCE_ENGINE_PLUGIN)
 
+    if(TARGET IE::inference_engine_plugin_api)
+        target_link_libraries(${IE_PLUGIN_NAME} PRIVATE IE::inference_engine_plugin_api)
+    else()
+        target_link_libraries(${IE_PLUGIN_NAME} PRIVATE inference_engine_plugin_api)
+    endif()
+
     if(WIN32)
         set_target_properties(${IE_PLUGIN_NAME} PROPERTIES COMPILE_PDB_NAME ${TARGET_NAME})
     endif()
 
-    add_cpplint_target(${IE_PLUGIN_NAME}_cpplint FOR_TARGETS ${IE_PLUGIN_NAME})
+    set(custom_filter "")
+    foreach(filter IN LISTS IE_PLUGIN_CPPLINT_FILTERS)
+        string(CONCAT custom_filter "${custom_filter}" "," "${filter}")
+    endforeach()
+
+    add_cpplint_target(${IE_PLUGIN_NAME}_cpplint FOR_TARGETS ${IE_PLUGIN_NAME} CUSTOM_FILTERS ${custom_filter})
 
     # append plugin to the list to register
 
@@ -60,6 +79,21 @@ function(ie_add_plugin)
     set(PLUGIN_FILES "${PLUGIN_FILES}" CACHE INTERNAL "" FORCE)
 
     add_dependencies(ie_plugins ${IE_PLUGIN_NAME})
+    if(TARGET inference_engine_preproc)
+        add_dependencies(${IE_PLUGIN_NAME} inference_engine_preproc)
+    endif()
+
+    # install rules
+
+    if(NOT IE_PLUGIN_SKIP_INSTALL)
+        string(TOLOWER "${IE_PLUGIN_DEVICE_NAME}" install_component)
+        ie_cpack_add_component(${install_component} REQUIRED DEPENDS core)
+
+        install(TARGETS ${IE_PLUGIN_NAME}
+            RUNTIME DESTINATION ${IE_CPACK_RUNTIME_PATH} COMPONENT ${install_component}
+            ARCHIVE DESTINATION ${IE_CPACK_ARCHIVE_PATH} COMPONENT ${install_component}
+            LIBRARY DESTINATION ${IE_CPACK_LIBRARY_PATH} COMPONENT ${install_component})
+    endif()
 endfunction()
 
 #

inference-engine/cmake/plugins/register_plugin_cmake.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 

inference-engine/cmake/plugins/unregister_plugin_cmake.cmake

@@ -1,4 +1,4 @@
-# Copyright (C) 2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 

inference-engine/cmake/sanitizer.cmake

@@ -1,23 +0,0 @@
-# Copyright (C) 2018-2019 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-include(CheckCXXCompilerFlag)
-
-if (ENABLE_SANITIZER)
-    set(SANITIZER_COMPILER_FLAGS "-fsanitize=address")
-    CHECK_CXX_COMPILER_FLAG("-fsanitize-recover=address" SANITIZE_RECOVER_SUPPORTED)
-    if (SANITIZE_RECOVER_SUPPORTED)
-        set(SANITIZER_COMPILER_FLAGS "${SANITIZER_COMPILER_FLAGS} -fsanitize-recover=address")
-    endif()
-
-    set(SANITIZER_LINKER_FLAGS "-fsanitize=address")
-    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-        set(SANITIZER_LINKER_FLAGS "${SANITIZER_LINKER_FLAGS} -fuse-ld=gold")
-    endif()
-
-    set(CMAKE_CC_FLAGS "${CMAKE_CC_FLAGS} ${SANITIZER_COMPILER_FLAGS}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SANITIZER_COMPILER_FLAGS}")
-    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${SANITIZER_LINKER_FLAGS}")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZER_LINKER_FLAGS}")
-endif()

inference-engine/cmake/sdl.cmake

@@ -1,42 +0,0 @@
-# Copyright (C) 2018-2019 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-if (UNIX OR APPLE AND CMAKE_BUILD_TYPE STREQUAL "Release")
-    set(CMAKE_CCXX_FLAGS "${CMAKE_CCXX_FLAGS} -fPIE -fPIC -Wformat -Wformat-security")
-    # TODO: double check it it's OK
-    if(CMAKE_CXX_COMPILER_ID MATCHES Intel)
-        string(REPLACE "-fPIE" "" CMAKE_CCXX_FLAGS "${CMAKE_CCXX_FLAGS}")
-    endif()
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2")
-    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2")
-    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pie")
-    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -z noexecstack -z relro -z now")
-        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -z noexecstack -z relro -z now")
-        if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9)
-            set(CMAKE_CCXX_FLAGS "${CMAKE_CCXX_FLAGS} -fstack-protector-all")
-        else()
-            set(CMAKE_CCXX_FLAGS "${CMAKE_CCXX_FLAGS} -fstack-protector-strong")
-        endif()
-        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -s -fvisibility=hidden")
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -s -fvisibility=hidden")
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-        set(CMAKE_CCXX_FLAGS "${CMAKE_CCXX_FLAGS} -fstack-protector-all")
-        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -fvisibility=hidden")
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fvisibility=hidden")
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector-strong")
-        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -z noexecstack -z relro -z now")
-        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -z noexecstack -z relro -z now")
-        set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -Wl,--strip-all -fvisibility=hidden")
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Wl,--strip-all -fvisibility=hidden")
-    endif()
-
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_CCXX_FLAGS}")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CCXX_FLAGS}")
-elseif (WIN32)
-    if (CMAKE_CXX_COMPILER_ID STREQUAL MSVC)
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MP /sdl")
-    endif()
-endif()

inference-engine/cmake/share/InferenceEngineConfig-version.cmake.in

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 

inference-engine/cmake/share/InferenceEngineConfig.cmake.in

@@ -1,4 +1,4 @@
-# Copyright (C) 2018-2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 #
@@ -15,7 +15,10 @@
 #
 # and the following imported targets:
 #
-#   IE::inference_engine    - The Inference Engine library
+#   IE::inference_engine            - The Inference Engine library
+#   IE::inference_engine_legacy     - The Inference Engine library with legacy API for IR v7 and older.
+#   IE::inference_engine_c_api      - The Inference Engine C API library
+#   IE::inference_engine_nn_builder - The Inference Engine NN Builder library
 #
 
 macro(ext_message TRACE_LEVEL)
@@ -36,7 +39,8 @@ set(InferenceEngine_FOUND FALSE)
 if(TARGET IE::inference_engine)
     set(InferenceEngine_FOUND TRUE)
     get_target_property(InferenceEngine_INCLUDE_DIRS IE::inference_engine INTERFACE_INCLUDE_DIRECTORIES)
-    set(InferenceEngine_LIBRARIES IE::inference_engine)
+    set(InferenceEngine_LIBRARIES IE::inference_engine_legacy IE::inference_engine
+                                  IE::inference_engine_c_api IE::inference_engine_nn_builder)
 else()
     if (WIN32)
         set(_ARCH intel64)
@@ -73,7 +77,6 @@ else()
     endif()
 
     find_path(IE_INCLUDE_DIR inference_engine.hpp "${IE_ROOT_DIR}/include" NO_DEFAULT_PATH)
-    find_path(IE_SRC_DIR extension "${IE_ROOT_DIR}/src" NO_DEFAULT_PATH)
 
     set(IE_LIB_DIR "${IE_ROOT_DIR}/lib/${_ARCH}")
     set(IE_LIB_REL_DIR "${IE_LIB_DIR}/Release")
@@ -83,73 +86,90 @@ else()
 
     if(WIN32)
         find_library(IE_RELEASE_LIBRARY inference_engine@IE_RELEASE_POSTFIX_WIN@ "${IE_LIB_REL_DIR}" NO_DEFAULT_PATH)
+        find_library(IE_LEGACY_RELEASE_LIBRARY inference_engine_legacy@IE_RELEASE_POSTFIX_WIN@ "${IE_LIB_REL_DIR}" NO_DEFAULT_PATH)
+        find_library(IE_C_API_RELEASE_LIBRARY inference_engine_c_api@IE_RELEASE_POSTFIX_WIN@ "${IE_LIB_REL_DIR}" NO_DEFAULT_PATH)
+        find_library(IE_NN_BUILDER_RELEASE_LIBRARY inference_engine_nn_builder@IE_RELEASE_POSTFIX_WIN@ "${IE_LIB_REL_DIR}" NO_DEFAULT_PATH)
     elseif(APPLE)
         find_library(IE_RELEASE_LIBRARY inference_engine@IE_RELEASE_POSTFIX_MAC@ "${IE_LIB_DIR}" NO_DEFAULT_PATH)
+        find_library(IE_LEGACY_RELEASE_LIBRARY inference_engine_legacy@IE_RELEASE_POSTFIX_MAC@ "${IE_LIB_DIR}" NO_DEFAULT_PATH)
+        find_library(IE_C_API_RELEASE_LIBRARY inference_engine_c_api@IE_RELEASE_POSTFIX_MAC@ "${IE_LIB_DIR}" NO_DEFAULT_PATH)
+        find_library(IE_NN_BUILDER_RELEASE_LIBRARY inference_engine_nn_builder@IE_RELEASE_POSTFIX_MAC@ "${IE_LIB_DIR}" NO_DEFAULT_PATH)
     else()
         find_library(IE_RELEASE_LIBRARY inference_engine@IE_RELEASE_POSTFIX_LIN@ "${IE_LIB_DIR}" NO_DEFAULT_PATH)
+        find_library(IE_LEGACY_RELEASE_LIBRARY inference_engine_legacy@IE_RELEASE_POSTFIX_LIN@ "${IE_LIB_DIR}" NO_DEFAULT_PATH)
+        find_library(IE_C_API_RELEASE_LIBRARY inference_engine_c_api@IE_RELEASE_POSTFIX_LIN@ "${IE_LIB_DIR}" NO_DEFAULT_PATH)
+        find_library(IE_NN_BUILDER_RELEASE_LIBRARY inference_engine_nn_builder@IE_RELEASE_POSTFIX_LIN@ "${IE_LIB_DIR}" NO_DEFAULT_PATH)
     endif()
 
     find_package_handle_standard_args(  InferenceEngine
                                         FOUND_VAR INFERENCEENGINE_FOUND
-                                        REQUIRED_VARS IE_RELEASE_LIBRARY IE_INCLUDE_DIR
+                                        REQUIRED_VARS IE_RELEASE_LIBRARY IE_LEGACY_RELEASE_LIBRARY IE_C_API_RELEASE_LIBRARY IE_NN_BUILDER_RELEASE_LIBRARY IE_INCLUDE_DIR
                                         FAIL_MESSAGE "Some of mandatory Inference Engine components are not found. Please consult InferenceEgnineConfig.cmake module's help page.")
 
     if(INFERENCEENGINE_FOUND)
         # to keep this line for successful execution in CMake 2.8
         set(InferenceEngine_FOUND TRUE)
 
-        add_library(IE::inference_engine SHARED IMPORTED GLOBAL)
+        foreach(ie_library_suffix "" "_legacy" "_c_api" "_nn_builder")
+            string(TOUPPER "${ie_library_suffix}" ie_library_usuffix)
+            add_library(IE::inference_engine${ie_library_suffix} SHARED IMPORTED GLOBAL)
 
-        if (WIN32)
-            set_target_properties(IE::inference_engine PROPERTIES
-                    IMPORTED_CONFIGURATIONS RELEASE
-                    IMPORTED_IMPLIB_RELEASE    "${IE_RELEASE_LIBRARY}"
-                    MAP_IMPORTED_CONFIG_RELEASE Release
-                    MAP_IMPORTED_CONFIG_RELWITHDEBINFO Release
-                    INTERFACE_INCLUDE_DIRECTORIES "${IE_INCLUDE_DIR}")
+            if (WIN32)
+                set_target_properties(IE::inference_engine${ie_library_suffix} PROPERTIES
+                        IMPORTED_CONFIGURATIONS RELEASE
+                        IMPORTED_IMPLIB_RELEASE    "${IE${ie_library_usuffix}_RELEASE_LIBRARY}"
+                        MAP_IMPORTED_CONFIG_RELEASE Release
+                        MAP_IMPORTED_CONFIG_RELWITHDEBINFO Release
+                        INTERFACE_INCLUDE_DIRECTORIES "${IE_INCLUDE_DIR}")
 
-            # Debug binaries are optional
-            find_library(IE_DEBUG_LIBRARY inference_engine@IE_DEBUG_POSTFIX_WIN@ "${IE_LIB_DBG_DIR}" NO_DEFAULT_PATH)
-            if (IE_DEBUG_LIBRARY)
-                set_property(TARGET IE::inference_engine APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
-                set_target_properties(IE::inference_engine PROPERTIES
-                        IMPORTED_IMPLIB_DEBUG "${IE_DEBUG_LIBRARY}"
-                        MAP_IMPORTED_CONFIG_DEBUG Debug)
+                # Debug binaries are optional
+                find_library(IE${ie_library_usuffix}_DEBUG_LIBRARY inference_engine${ie_library_suffix}@IE_DEBUG_POSTFIX_WIN@
+                    "${IE_LIB_DBG_DIR}" NO_DEFAULT_PATH)
+                if (IE${ie_library_usuffix}_DEBUG_LIBRARY)
+                    set_property(TARGET IE::inference_engine${ie_library_suffix} APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+                    set_target_properties(IE::inference_engine${ie_library_suffix} PROPERTIES
+                            IMPORTED_IMPLIB_DEBUG "${IE${ie_library_usuffix}_DEBUG_LIBRARY}"
+                            MAP_IMPORTED_CONFIG_DEBUG Debug)
+                else()
+                    ext_message(WARNING "Inference Engine DEBUG binaries are missed.")
+                endif()
+            elseif (APPLE)
+                set_target_properties(IE::inference_engine${ie_library_suffix} PROPERTIES
+                        IMPORTED_LOCATION_RELEASE "${IE${ie_library_usuffix}_RELEASE_LIBRARY}"
+                        INTERFACE_INCLUDE_DIRECTORIES "${IE_INCLUDE_DIR}"
+                        INTERFACE_COMPILE_OPTIONS "-Wno-error=deprecated-declarations")
+
+                # Debug binaries are optional
+                find_library(IE${ie_library_usuffix}_DEBUG_LIBRARY inference_engine${ie_library_suffix}@IE_DEBUG_POSTFIX_MAC@ "${IE_LIB_DIR}" NO_DEFAULT_PATH)
+                if (IE${ie_library_usuffix}_DEBUG_LIBRARY)
+                    set_target_properties(IE::inference_engine${ie_library_suffix} PROPERTIES
+                            IMPORTED_LOCATION_DEBUG "${IE${ie_library_usuffix}_DEBUG_LIBRARY}")
+                else()
+                    ext_message(WARNING "Inference Engine DEBUG binaries are missed")
+                endif()
+
+                target_link_libraries(IE::inference_engine${ie_library_suffix} INTERFACE ${CMAKE_DL_LIBS})
             else()
-                ext_message(WARNING "Inference Engine DEBUG binaries are missed.")
+                # Only Release binaries are distributed for Linux systems
+                set_target_properties(IE::inference_engine${ie_library_suffix} PROPERTIES
+                        IMPORTED_LOCATION "${IE${ie_library_usuffix}_RELEASE_LIBRARY}"
+                        INTERFACE_INCLUDE_DIRECTORIES "${IE_INCLUDE_DIR}")
+                if(CMAKE_CXX_COMPILER_ID MATCHES Intel)
+                    set_target_properties(IE::inference_engine${ie_library_suffix} PROPERTIES
+                            INTERFACE_COMPILE_OPTIONS "-diag-warning=1786")
+                else()
+                    set_target_properties(IE::inference_engine${ie_library_suffix} PROPERTIES
+                            INTERFACE_COMPILE_OPTIONS "-Wno-error=deprecated-declarations")
+                endif()
+                target_link_libraries(IE::inference_engine${ie_library_suffix} INTERFACE ${CMAKE_DL_LIBS})
             endif()
-        elseif (APPLE)
-            set_target_properties(IE::inference_engine PROPERTIES
-                    IMPORTED_LOCATION_RELEASE "${IE_RELEASE_LIBRARY}"
-                    INTERFACE_INCLUDE_DIRECTORIES "${IE_INCLUDE_DIR}"
-                    INTERFACE_COMPILE_OPTIONS "-Wno-error=deprecated-declarations")
-
-            # Debug binaries are optional
-            find_library(IE_DEBUG_LIBRARY inference_engine@IE_DEBUG_POSTFIX_MAC@ "${IE_LIB_DIR}" NO_DEFAULT_PATH)
-            if (IE_DEBUG_LIBRARY)
-                set_target_properties(IE::inference_engine PROPERTIES
-                        IMPORTED_LOCATION_DEBUG "${IE_DEBUG_LIBRARY}")
-            else()
-                ext_message(WARNING "Inference Engine DEBUG binaries are missed")
-            endif()
-
-            target_link_libraries(IE::inference_engine INTERFACE ${CMAKE_DL_LIBS})
-        else()
-            # Only Release binaries are distributed for Linux systems
-            set_target_properties(IE::inference_engine PROPERTIES
-                    IMPORTED_LOCATION "${IE_RELEASE_LIBRARY}"
-                    INTERFACE_INCLUDE_DIRECTORIES "${IE_INCLUDE_DIR}"
-                    INTERFACE_COMPILE_OPTIONS "-Wno-error=deprecated-declarations")
-            target_link_libraries(IE::inference_engine INTERFACE ${CMAKE_DL_LIBS})
-        endif()
+        endforeach()
 
         set(InferenceEngine_INCLUDE_DIRS ${IE_INCLUDE_DIR})
-        set(InferenceEngine_LIBRARIES IE::inference_engine)
+        set(InferenceEngine_LIBRARIES IE::inference_engine_legacy IE::inference_engine
+                                      IE::inference_engine_c_api IE::inference_engine_nn_builder)
 
         set(IE_EXTERNAL_DIR "${IE_ROOT_DIR}/external")
         include("${IE_ROOT_DIR}/share/ie_parallel.cmake")
-
-        add_subdirectory(${IE_SRC_DIR}/extension EXCLUDE_FROM_ALL ie_cpu_extension)
-        add_library(IE::ie_cpu_extension ALIAS ie_cpu_extension)
     endif()
 endif()

inference-engine/cmake/vpu_dependencies.cmake

@@ -1,45 +1,59 @@
-# Copyright (C) 2019 Intel Corporation
+# Copyright (C) 2018-2020 Intel Corporation
 # SPDX-License-Identifier: Apache-2.0
 #
 
-set(VPU_SUPPORTED_SOC ma2450 ma2x8x mv0262)
+if(CMAKE_VERSION VERSION_GREATER 3.9.6)
+    include_guard(GLOBAL)
+else()
+    if(__CURRENT_FILE_VAR__)
+      return()
+    endif()
+    set(__CURRENT_FILE_VAR__ TRUE)
+endif()
+
+include(dependency_solver)
+
+set(VPU_SUPPORTED_FIRMWARES usb-ma2450 usb-ma2x8x pcie-ma248x)
 
 #
-# Default firmware packages
+# Default packages
 #
 
-RESOLVE_DEPENDENCY(VPU_FIRMWARE_MA2450
-    ARCHIVE_UNIFIED firmware_ma2450_759W.zip
-    TARGET_PATH "${TEMP}/vpu/firmware/ma2450"
-    ENVIRONMENT "VPU_FIRMWARE_MA2450"
-    FOLDER)
-debug_message(STATUS "ma2450=" ${VPU_FIRMWARE_MA2450})
-
-RESOLVE_DEPENDENCY(VPU_FIRMWARE_MV0262
-    ARCHIVE_UNIFIED firmware_mv0262_mdk_R9.8.zip
-    TARGET_PATH "${TEMP}/vpu/firmware/mv0262"
-    ENVIRONMENT "VPU_FIRMWARE_MV0262"
-    FOLDER)
-debug_message(STATUS "mv0262=" ${VPU_FIRMWARE_MV0262})
-
-RESOLVE_DEPENDENCY(VPU_FIRMWARE_MA2X8X
-    ARCHIVE_UNIFIED firmware_ma2x8x_mdk_R9.8.zip
-    TARGET_PATH "${TEMP}/vpu/firmware/ma2x8x"
-    ENVIRONMENT "VPU_FIRMWARE_MA2X8X"
-    FOLDER)
-debug_message(STATUS "ma2x8x=" ${VPU_FIRMWARE_MA2X8X})
+set(FIRMWARE_PACKAGE_VERSION 1119)
 
 #
 # CMake variables to override default firmware files
 #
 
-foreach(soc IN LISTS VPU_SUPPORTED_SOC)
-    string(TOUPPER "${soc}" soc_upper)
-    set(var_name VPU_FIRMWARE_${soc_upper}_FILE)
+foreach(firmware_name IN LISTS VPU_SUPPORTED_FIRMWARES)
+    string(TOUPPER "${firmware_name}" firmware_name_upper)
 
-    find_file(${var_name} MvNCAPI-${soc}.mvcmd "${VPU_FIRMWARE_${soc_upper}}/mvnc")
-    if(NOT ${var_name})
-        message(FATAL_ERROR "[VPU] Missing ${soc} firmware")
+    set(firmware_name_full ${firmware_name}.mvcmd)
+    # Handle PCIe elf firmware for Windows
+    if (WIN32 AND "${firmware_name}" STREQUAL "pcie-ma248x")
+        set(firmware_name_full ${firmware_name}.elf)
+    endif ()
+
+    reset_deps_cache(VPU_FIRMWARE_${firmware_name_upper}_FILE)
+
+    RESOLVE_DEPENDENCY(VPU_FIRMWARE_${firmware_name_upper}
+        ARCHIVE_UNIFIED firmware_${firmware_name}_${FIRMWARE_PACKAGE_VERSION}.zip
+        TARGET_PATH "${TEMP}/vpu/firmware/${firmware_name}"
+        ENVIRONMENT "VPU_FIRMWARE_${firmware_name_upper}_FILE"
+        FOLDER)
+    debug_message(STATUS "${firmware_name}=" ${VPU_FIRMWARE_${firmware_name_upper}})
+
+    update_deps_cache(
+        VPU_FIRMWARE_${firmware_name_upper}_FILE
+        "${VPU_FIRMWARE_${firmware_name_upper}}/mvnc/${firmware_name_full}"
+        "[VPU] ${firmware_name_full} firmware")
+
+    find_file(
+        VPU_FIRMWARE_${firmware_name_upper}_FILE
+        NAMES ${firmware_name_full}
+        NO_CMAKE_FIND_ROOT_PATH)
+    if(NOT VPU_FIRMWARE_${firmware_name_upper}_FILE)
+        message(FATAL_ERROR "[VPU] Missing ${firmware_name_full} firmware")
     endif()
 endforeach()
 
@@ -47,13 +61,18 @@ endforeach()
 # `vpu_copy_firmware` CMake target
 #
 
-foreach(soc IN LISTS VPU_SUPPORTED_SOC)
-    string(TOUPPER "${soc}" soc_upper)
-    set(var_name VPU_FIRMWARE_${soc_upper}_FILE)
+foreach(firmware_name IN LISTS VPU_SUPPORTED_FIRMWARES)
+    string(TOUPPER "${firmware_name}" firmware_name_upper)
+    set(var_name VPU_FIRMWARE_${firmware_name_upper}_FILE)
+
+    set(firmware_out_file "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${firmware_name}.mvcmd")
+
+    # Handle PCIe elf firmware for Windows
+    if (WIN32 AND "${firmware_name}" STREQUAL "pcie-ma248x")
+        set(firmware_out_file "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${firmware_name}.elf")
+    endif ()
 
-    set(firmware_out_file "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/MvNCAPI-${soc}.mvcmd")
     list(APPEND all_firmware_files ${firmware_out_file})
-
     add_custom_command(
         OUTPUT ${firmware_out_file}
         COMMAND
@@ -61,8 +80,28 @@ foreach(soc IN LISTS VPU_SUPPORTED_SOC)
         MAIN_DEPENDENCY ${${var_name}}
         COMMENT "[VPU] Copy ${${var_name}} to ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}"
         VERBATIM)
+
+    install(FILES ${${var_name}}
+        DESTINATION ${IE_CPACK_RUNTIME_PATH}
+        COMPONENT myriad)
 endforeach()
 
 add_custom_target(vpu_copy_firmware
     DEPENDS ${all_firmware_files}
     COMMENT "[VPU] Copy firmware files")
+
+#
+# libusb
+#
+
+if(ANDROID)
+    RESOLVE_DEPENDENCY(LIBUSB
+        ARCHIVE_ANDROID "libusb_39409_android.tgz"
+        TARGET_PATH "${TEMP}/vpu/libusb")
+    debug_message(STATUS "LIBUSB=" ${LIBUSB})
+
+    set(LIBUSB_INCLUDE_DIR "${LIBUSB}/include")
+    set(LIBUSB_LIBRARY "${LIBUSB}/libs/${ANDROID_ABI}/libusb1.0.so")
+
+    log_rpath_from_dir(LIBUSB "${LIBUSB}/libs/${ANDROID_ABI}")
+endif()

inference-engine/ie_bridges/c/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+project(InferenceEngine_C_API)
+
+add_subdirectory(src)
+
+if(ENABLE_SAMPLES)
+    add_subdirectory(samples)
+endif()

inference-engine/ie_bridges/c/docs/api_overview.md

@@ -0,0 +1,798 @@
+# Overview of Inference Engine C* API
+
+> **NOTE**: It is a preview version of the Inference Engine C* API for evaluation purpose only.
+> Module structure and API itself may be changed in future releases.
+
+This API provides a simplified interface for Inference Engine functionality that allows to:
+
+- handle the models
+- load and configure Inference Engine plugins based on device names
+- perform inference in synchronous and asynchronous modes with arbitrary number of infer requests (the number of infer requests may be limited by target device capabilities)
+
+## Supported OSes
+
+Currently the Inference Engine C* API is supported on Ubuntu* 16.04, Microsoft Windows* 10 and CentOS* 7.3 OSes.
+Supported Python* versions:
+
+- On Ubuntu 16.04: 2.7, 3.5, 3.6
+- On Windows 10: 3.5, 3.6
+- On CentOS 7.3: 3.4, 3.5, 3.6
+
+## Setting Up the Environment
+
+To configure the environment for the Inference Engine C* API, run:
+
+- On Ubuntu 16.04: `source <INSTALL_DIR>/bin/setupvars.sh .`
+- On Windows 10: XXXX
+
+The script automatically detects latest installed C* version and configures required environment if the version is supported.
+If you want to use certain version of C*, set the environment variable XXXXX
+after running the environment configuration script.
+
+## Struct
+
+```
+typedef struct ie_core_version {
+
+​    size_t major;
+
+​    size_t minor;
+
+​    const char *build_number;
+
+​    const char *description;
+
+}ie_core_version_t;
+```
+
+```
+typedef struct ie_config {
+
+​    char *name;
+
+​    char *value;
+
+}ie_config_t;
+```
+
+```
+typedef struct ie_param {
+
+​    union { //To be continue, to collect metric and config parameters
+
+​    };
+
+}ie_param_t;
+```
+
+```
+typedef struct ie_param_config {
+
+​    char *name;
+
+​    ie_param_t *param;
+
+}ie_param_config_t;
+```
+
+```
+typedef struct desc {
+
+​    char msg[256];
+
+}desc_t;
+```
+
+```
+typedef struct dimensions {
+
+​    size_t dims[8];
+
+}dimensions_t;
+```
+
+```
+struct tensor_desc {
+
+​    layout_t layout;
+
+​    dimensions_t dims;
+
+​    precision_e precision;
+
+};
+
+
+```
+
+```
+typedef void (*completeCallBackFunc)(ie_infer_request_t *infer_request, int *status);
+```
+
+```
+enum precision_e{
+
+​    UNSPECIFIED = 255, /**< Unspecified value. Used by default */
+
+​    MIXED = 0,  /**< Mixed value. Can be received from network. No applicable for tensors */
+
+​    FP32 = 10,  /**< 32bit floating point value */
+
+​    FP16 = 11,  /**< 16bit floating point value */
+
+​    Q78 = 20,   /**< 16bit specific signed fixed point precision */
+
+​    I16 = 30,   /**< 16bit signed integer value */
+
+​    U8 = 40,    /**< 8bit unsigned integer value */
+
+​    I8 = 50,    /**< 8bit signed integer value */
+
+​    U16 = 60,   /**< 16bit unsigned integer value */
+
+​    I32 = 70,   /**< 32bit signed integer value */
+
+​    I64 = 72,   /**< 64bit signed integer value */
+
+​    U64 = 73,   /**< 64bit unsigned integer value */
+
+​    BIN = 71,   /**< 1bit integer value */
+
+​    CUSTOM = 80 /**< custom precision has it's own name and size of elements */
+
+};
+```
+
+```
+enum layout_t {
+
+​    ANY = 0,	// "any" layout
+
+​    // I/O data layouts
+
+​    NCHW = 1,
+
+​    NHWC = 2,
+
+​    NCDHW = 3,
+
+​    NDHWC = 4,
+
+​    // weight layouts
+
+​    OIHW = 64,
+
+​    // Scalar
+
+​    SCALAR = 95,
+
+​    // bias layouts
+
+​    C = 96,
+
+​    // Single image layout (for mean image)
+
+​    CHW = 128,
+
+​    // 2D
+
+​    HW = 192,
+
+​    NC = 193,
+
+​    CN = 194,
+
+
+​    BLOCKED = 200,
+
+};
+```
+
+```
+enum colorformat_e {
+
+​    RAW = 0u,    ///< Plain blob (default), no extra color processing required
+
+​    RGB,         ///< RGB color format
+
+​    BGR,         ///< BGR color format, default in DLDT
+
+​    RGBX,        ///< RGBX color format with X ignored during inference
+
+​    BGRX,        ///< BGRX color format with X ignored during inference
+
+​    NV12,        ///< NV12 color format represented as compound Y+UV blob
+
+};
+```
+
+```
+enum resize_alg_e {
+
+​    NO_RESIZE = 0,
+
+​    RESIZE_BILINEAR,
+
+​    RESIZE_AREA
+
+};
+```
+
+```
+struct roi_e {
+
+​    size_t id;     // ID of a roi
+
+​    size_t posX;   // W upper left coordinate of roi
+
+​    size_t posY;   // H upper left coordinate of roi
+
+​    size_t sizeX;  // W size of roi
+
+​    size_t sizeY;  // H size of roi
+
+};
+```
+
+```
+enum IEStatusCode {
+
+​    OK = 0,
+
+​    GENERAL_ERROR = -1,
+
+​    NOT_IMPLEMENTED = -2,
+
+​    NETWORK_NOT_LOADED = -3,
+
+​    PARAMETER_MISMATCH = -4,
+
+​    NOT_FOUND = -5,
+
+​    OUT_OF_BOUNDS = -6,
+
+​    /*
+
+​     \* @brief exception not of std::exception derived type was thrown
+
+​     */
+
+​    UNEXPECTED = -7,
+
+​    REQUEST_BUSY = -8,
+
+​    RESULT_NOT_READY = -9,
+
+​    NOT_ALLOCATED = -10,
+
+​    INFER_NOT_STARTED = -11,
+
+​    NETWORK_NOT_READ = -12
+
+};
+```
+
+
+
+- `const char *ie_c_api_version(void)`
+
+  - Description: Returns number of version that is exported.
+
+  - Parameters: None.
+
+  - Return value: Version number of the API.
+
+  - Usage example:
+
+    ```
+    const char *ver_num=ie_c_api_version();
+    ```
+
+## IECore
+
+This strcut represents an Inference Engine entity and allows you to manipulate with plugins using unified interfaces.
+
+### Create
+
+- `IEStatusCode ie_core_create(char *xml_config_file, ie_core_t *core_result)`
+
+  > Note: create an ie_core_t instance with default configuration when xml_config_file=null.
+
+  - Parameters:
+
+    - `xml_config_file`- A full path to`.xml` file containing plugins configuration. If the parameter is not specified, the default configuration is handled automatically.
+    - `core_result` - A pointer to the newly created `ie_core_t`.
+
+  - Return value: Status code of the operation: OK(0) for success.
+
+  - Usage examples:
+
+    Create an `ie_core_t` t instance with a custom configuration location sepcified:
+
+    ```
+    char *xml_config_file="/localdisk/plugins/my_custom_cfg.xml";
+    ie_core_t ie;
+    IEStatusCode status = ie_core_create(xml_config_file,ie);
+    ```
+
+    .`xml` file has the following structure:
+
+    ```
+    <ie>
+    	<plugins>
+    		<plugin name="" location="" optional="yes/no">
+    			<extensions>
+    				<extension location=""/>
+    			</extensions>
+                <properties>
+                	<property key="" value=""/>
+                </properties>
+             </plugin>
+        </plugins>
+    </ie>
+    ```
+
+
+### <a name="iecore-methods"></a>Methods
+
+- `IEStatusCode ie_core_get_versions(ie_core_t *core, char *device_name, ie_core_version_t *version_result)`
+
+  - Description: Returns a `ie_core_version_t` with versions of the plugin specified.
+
+  - Parameters:
+
+    - `core` -A pointer to `ie_core_t` instance.
+    - `device_name` - Name of the the registered plugin.
+  - `version_result` - Dictionary mapping a plugin name .
+
+  - Return value: Status  of the operation: OK(0) for success.
+
+  - Usage example:
+
+    ```
+    char *xml_config_file="/localdisk/plugins/my_custom_cfg.xml";
+  char *device_name="CPU";
+    ie_core_t *ie;
+  ie_core_version_t *version;
+    IEStatusCode status= ie_core_create(xml_config_file, ie);
+    IEStatusCode status2=ie_core_get_versions(ie,device_name, version);
+    print("description:%s, major:%d, minor:%d, build_number:%s.\n",version-		  >description, version->major, version->minor, version->build_number);
+    ```
+
+- `IEStatusCode ie_core_load_network(ie_core_t *core, ie_network_t *network, const char *device_name,  ie_config_t config, ie_executable_network_t *exec_network_result)`
+
+  - Description: Loads a network that was read from the Intermediate Representation (IR) to the plugin with specified device name and creates an `ie_executable_network_t` instance of the `ie_network_t` struct.
+    You can create as many networks as you need and use them simultaneously (up to the limitation of the hardware resources).
+
+  - Parameters:
+
+    - `core` - A pointer to `ie_core_t` instance.
+    - `network` - A pointer to `ie_network_t` instance.
+    - `device_name` - A device name of a target plugin.
+    - `config` - A dictionary of plugin configuration keys and their values.
+    - `exec_network_result` - A pointer to the newly loaded network.
+
+  - Return value: Status code of the operation: OK(0) for success.
+
+  - Usage example:
+
+    ```
+
+    ```
+
+- `IEStatusCode ie_core_set_config(ie_core_t *core, ie_config_t *ie_core_config, const char *device_name)`
+
+  - Description: Sets a configuration for a plugin.
+  - Parameters:
+    - `core`- A pointer to `ie_core_t` instance.
+    - `ie_core_config` - A dictionary of configuration parameters as keys and their values.
+    - `device_name` - A device name of a target plugin.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_core_register_plugin(ie_core_t *core, const char *plugin_name, const char *device_name )`
+
+  - Description: Registers a new device and a plugin which implement this device inside Inference Engine.
+  - Parameters:
+    - `core`- A pointer to `ie_core_t` instance.
+    - `plugin_name` - A name of a plugin. Depending on a platform, plugin_name is wrapped with a shared library suffix and a prefix to identify a full name of the library.
+    - `device_name` - A target device name for the plugin. If not specified, the method registers.
+      a plugin with the default name.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_core_register_plugins(ie_core_t *core, const char *xml_config_file)`
+
+  - Description: Registers plugins specified in an `.xml` configuration file
+  - Parameters:
+    - `core` - A pointer to `ie_core_t` instance.
+    - `xml_config_file` -  A full path to `.xml` file containing plugins configuration.
+  - Return value: Status code of the operation: 0 for success.
+
+- `IEStatusCode ie_core_unregister_plugin(ie_core_t *core, const char *device_name)`
+
+  - Description: Unregisters a plugin with a specified device name
+  - Parameters:
+    - `core` -  A pointer `ie_core_t` instance.
+    - `device_name` -  A device name of the plugin to unregister.
+
+  - Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_core_add_extension(ie_core_t *core, const char *extension_path, const char *device_name)`
+
+  - Description:  Loads extension library to the plugin with a specified device name.
+  - Parameters:
+    - `core` - A pointer `ie_core_t` instance.
+    - `extension_path` -  Path to the extensions library file to load to a plugin.
+    - `device_name` -  A device name of a plugin to load the extensions to.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_core_get_metric(ie_core_t *core, const char *device_name, const char *metric_name, ie_param_t *param_result)`
+
+  - Description: Gets a general runtime metric for dedicated hardware. Enables to request common device properties, which are `ie_executable_network_t` agnostic, such as device name, temperature, and other devices-specific values.
+  - Parameters:
+    - `core` - A pointer `ie_core_t` instance.
+    - `device_name` - A name of a device to get a metric value.
+    - `metric_name` - A metric name to request.
+    - `param_result` - A metric value corresponding to a metric key.
+  -  Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_core_get_config(ie_core_t *core, const char *device_name, const char *config_name, ie_param_t *param_result)`
+
+  - Description:  Gets a configuration dedicated to device behavior. The method targets to extract information which can be set via SetConfig method.
+
+  - Parameters:
+    - `core` - A pointer `ie_core_t` instance.
+    - `device_name` - A name of a device to get a metric value.
+    - `config_name` - A configuration value corresponding to a configuration key.
+    - `param_result` - A metric value corresponding to a metric key.
+
+  - Return value: Status code of the operation: OK(0) for success.
+
+
+
+## IENetwork
+
+This struct contains the information about the network model read from IR and allows you to manipulate with some model parameters such as layers affinity and output layers.
+
+### Methods
+
+- `IEStatusCode ie_network_read(char *xml, char *weights_file, ie_network_t *network_result)`
+  - Description: Reads the model from the `.xml` and `.bin` files of the IR.
+  - Parameters:
+    - `xml_file` -  `.xml` file's path of the IR.
+    - `weights_file` - `.bin` file's path of the IR.
+    - `network_result` - A pointer to the newly created network.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_free(ie_network_t *network)`
+  - Description: When network is loaded into the Inference Engine, it is not required anymore and should be released.
+  - Parameters:
+    - `network` - The pointer to the instance of the `ie_network_t` to free.
+  - Return value: Status code of the operation: OK(0) for success.
+-  `IEStatusCode ie_network_get_input_numbers(ie_network_t *network, size_t *size_result)`
+  - Description: Gets number of inputs for the `IENetwork` instance.
+  - Parameters:
+    - `network` - The instance of the `ie_network_t` to get size of input information for this instance.
+    - `size_result` - A number of the instance's input information.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_get_input_name(ie_network_t *network, size_t number, char *name_result)`
+  - Description: Gets name corresponding to the "number".
+  - Parameters:
+    - `network` - The instance of the `ie_network_t` to get input information.
+    - `number` - An id of input  information .
+    - `name_result` - Input name corresponding to the "number".
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_get_output_numbers(ie_network_t *network, size_t size_result)`
+  - Description: Gets number of output for the `ie_network_t` instance.
+  - Parameters:
+    - `network` - The instance of the `ie_network_t` to get size of output information for this instance.
+    - `size_result` - A number of the instance's output information.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_get_output_name(ie_network_t *network, size_t number, char *name_result)`
+  - Description: Gets output name corresponding to the "number".
+  - Parameters:
+    - `network` - The instance of the `ie_network_t` to get out information of nth layer for this instance.
+    - `number` - An id of output  information.
+    - `name_result` - A output name corresponding to the "number".
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_get_input_precision(ie_network_t *network, char *input_name, precision_e *prec_result)`
+  - Description: Gets a precision of the input data named "input_name".
+  - Parameters:
+    - `network` - A pointer to ie_network_t instance.
+    - `input_name` - Name of input data.
+    - `prec_result` - A pointer to the precision used for input blob creation.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_set_input_precision(ie_network_t *network, char *input_name, precision_e p)`
+  - Description: Changes the precision of the input data named "input_name".
+  - Parameters:
+    - `network` - A pointer to `ie_network_t` instance.
+    - `input_name` - Name of input data.
+    - `p` - A new precision of the input data to set (eg. precision_e.FP16).
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_get_input_layout(ie_network_t *network, char *input_name, layout_t *layout_result)`
+  - Description: Gets a layout of the input data named "input_name".
+  - Parameters:
+    - `network` - A pointer to `ie_network_t` instance.
+    - `input_name` - Name of input data.
+    - `layout_result` - A pointer to the layout used for input blob creation.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_set_input_layout(ie_network_t *network, char *input_name, layout_t l)`
+  - Description: Changes the layout of the input data named "input_name". This function should be called before loading the network to the plugin
+  - Parameters:
+    - `network` - A pointer to `ie_network_t` instance.
+    - `input_name` -  Name of input data.
+    - `layout` - Network layer layout (eg. layout_t.NCHW).
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_get_input_dims(ie_network_t *network, char *input_name, dimensions_t *dims_result)`
+  - Description: Gets dimensions/shape of the input data with reversed order.
+  - Parameters:
+    - `network` - A pointer to `ie_network_t` instance.
+    - `input_name` - Name of input data.
+    - `dims_result` - A pointer to the dimensions used for input blob creation.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_get_input_resize_algorithm(ie_network_t *network, char *input_name, resize_alg_e *resize_alg_result)`
+  - Description: Gets pre-configured resize algorithm.
+  - Parameters:
+    - `network` - A pointer to `ie_network_t` instance.
+    - `input_name` - Name of input data.
+    - `resize_alg_result` - The pointer to the resize algorithm used for input blob creation.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_set_input_resize_algorithm(ie_network_t *network, char *input_name, resize_alg_e resize_algo)`
+  - Description: Sets resize algorithm to be used during pre-processing
+  - Parameters:
+    - `network` - A pointer to `ie_network_t` instance.
+    - `input_name` - Name of input data.
+    - `resize_algo` - Resize algorithm.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_get_color_format(ie_network_t *network, char *input_name, colorformat_e *colformat_result)`
+  - Description: Gets color format of the input data named "input_name".
+  - Parameters:
+    - `network` - A pointer to `ie_network_t` instance.
+    - `input` - Name of input data.
+    - `colformat_result` - Input color format of the input data named "input_name".
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_set_color_format(ie_network_t *network, char *input_name, colorformat_e color_format)`
+  - Description: Changes the color format of the input data named "input_name".
+  - Parameters:
+    - `network` - A pointer to `ie_network_t` instance.
+    - `input_name` - Name of input data.
+    - `color_format` - Color format of the input data .
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_get_output_precision(ie_network_t *network, char *output_name, precision_e *prec_result)`
+  - Description: Get output precision of the output data named "output_name".
+  - Parameters:
+    - `network` - A pointer `ie_network_t` instance.
+    - `output_name` - Name of output date.
+    - `precision_e` - Output precision of the output data named "output_name".
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_set_output_precision(ie_network_t *network, char *output_name, precision_e p)`
+  - Description: Sets a precision type of the output date named "output_name".
+  - Parameters:
+    - `network` - A pointer to `ie_network_t` instance.
+    - `outputName` - Name of output data.
+    - `p` - Precision of the output data (eg. precision_e.FP16).
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_get_output_layout(ie_network_t *network, char *output_name, layout_t *layout_result)`
+  - Description: Get output layout of the output date named "output_name" in the network.
+  - Parameters:
+    - `network` - A pointer to `ie_network_t` instance.
+    - `output_name` - Name of output data.
+    - `layout_result` - Layout value of the output data named "output_name".
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_set_output_layout(ie_network_t *network, char *output_name, c l)`
+  - Description: Sets the layout value for output data named "output_name".
+  - Parameters:
+    - `network` - A pointer to `ie_network_t` instance.
+    - `output_name` - Name of output data.
+    - `l` - Layout value to set (eg. output_name.NCHW).
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_network_get_output_dims(ie_network_t *network, char *output_name, dimensions_t *dims_result)`
+  - Description: Get output dimension of output data named "output_name" in the network.
+  - Parameters:
+    - `network` - A pointer to `ie_network_t` instance.
+    - `output_name` - Name of output data.
+    - `dims_result` - Dimensions value of the output data named "output_name".
+  - Return value: Status code of the operation: OK(0) for success.
+
+## ExecutableNetwork
+
+This struct represents a network instance loaded to plugin and ready for inference.
+
+### Methods
+
+- `IEStatusCode ie_exec_network_create_infer_request(ie_executable_network_t *ie_exec_network, desc_t *desc, ie_infer_request_t **req)`
+
+  - Description:  Creates an inference request instance used to infer the network. The created request has allocated input and output blobs (that can be changed later).
+  - Parameters:
+    - `ie_exec_network` - A pointer to `ie_executable_network_t` instance.
+    - `desc` - A pointer to a `desc_t` instance.
+    - `req`  - A pointer to the newly created `ie_infer_request_t` instance.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_exec_network_get_metric(ie_executable_network_t *ie_exec_network, const char *metric_name, ie_param_t *param_result)`
+
+  - Description: - Gets general runtime metric for an executable network. It can be network name, actual device ID on which executable network is running or all other properties which cannot be changed dynamically.
+  - Parameters:
+    - `ie_exec_network`: A pointer to `ie_executable_network_t` instance.
+    - `metric_name` - A metric name to request.
+    - `param_result` - A metric value corresponding to a metric key.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_exec_network_set_config(ie_executable_network_t *ie_exec_network, ie_param_config_t *param_config, desc_t *desc)`
+
+  - Description: Sets a configuration for current executable network.
+  - Parameters:
+    - `ie_exec_network`: A pointer to `ie_executable_network_t` instance.
+    - `config`:  An  config for current executable network.
+  - Return value: Status code of the operation: OK(0) for success.
+- `IEStatusCode ie_exec_network_get_config(ie_executable_network_t *ie_exec_network, const char *metric_config, ie_param_t *param_result)`
+
+  - Description: - Gets configuration for current executable network. The method is responsible to extract information
+    - which affects executable network execution
+  - Parameters:
+    - `ie_exec_network` - A pointer to `ie_executable_network_t` instance.
+    - `metric_config` - A configuration parameter name to request.
+    - `param_result` - A configuration value corresponding to a configuration key.
+  - Return value: Status code of the operation: OK(0) for success.
+
+
+
+
+## InferRequest
+
+This struct provides an interface to infer requests of `ExecutableNetwork` and serves to handle infer requests execution and to set and get output data.
+
+### Methods
+
+- `IEStatusCode *ie_infer_request_get_blob(ie_infer_request_t *infer_request, const char *name, ie_blob_t **blob_result)`
+
+  - Description: Get a Blob corresponding to blob name.
+  - Parameters:
+    - `infer_request` - A pointer to `ie_infer_request_t` instance
+    - `name` - Blob name.
+    -  `blob_result` - A pointer to the blob corresponding to the blob name.
+  - Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_infer_request_set_blob(ie_infer_request_t *infer_request, ie_blob_t *blob)`
+
+  - Description: Sets the blob in a inference request.
+  - Parameters:
+    - `infer_request`: A pointer to `ie_infer_request_t` instance.
+    - `blob ` -   A pointer to `ie_blob_t` instance.
+  - Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_infer_request_infer(ie_infer_request_t *infer_request)`
+
+  - Description:  Starts synchronous inference of the infer request and fill outputs array
+  - Parameters:
+    - `infer_request`: A pointer to `ie_infer_request_t` instance.
+  - Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_infer_request_infer_async(ie_infer_request_t *infer_request)`
+
+  -  Description: Starts asynchronous inference of the infer request and fill outputs array.
+  - Parameters:
+    - `infer_request` - A pointer to `ie_infer_request_t` instance.
+  - Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_infer_set_completion_callback(ie_infer_request_t *infer_request,completeCallBackFunc callback)`
+
+  - Description: Sets a callback function that will be called on success or failure of asynchronous request.
+  - Parameters:
+    - `infer_request` - A pointer to a `ie_infer_request_t` instance.
+    - `callback` -  A function to be called.
+  - Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_infer_request_wait(ie_infer_request_t *infer_request, int64_t timeout)`
+
+  - Description:  Waits for the result to become available. Blocks until specified timeout elapses or the result becomes available, whichever comes first.
+
+    NOTE:** There are special values of the timeout parameter:
+
+    - 0 - Immediately returns the inference status. It does not block or interrupt execution.
+      ind statuses meaning.
+    - -1 - Waits until inference result becomes available (default value).
+
+  - Parameters:
+
+    - `infer_request` -A pointer to a `ie_infer_request_t` instance.
+    - `timeout` - Time to wait in milliseconds or special (0, -1) cases described above. If not specified, `timeout` value is set to -1 by default.
+
+  - Return value:  Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_infer_request_set_batch(ie_infer_request_t *infer_request, const size_t size)`
+
+  - Description:  Sets new batch size for certain infer request when dynamic batching is enabled in executable network that created this request.
+
+    NOTE:** Support of dynamic batch size depends on the target plugin.
+
+  - Parameters:
+
+    - `infer_request` -A pointer to a `ie_infer_request_t` instance.
+    - `size` - New batch size to be used by all the following inference calls for this request.
+
+  - Return value: Status code of the operation: OK(0) for success.
+
+## Blob
+
+### Methods
+
+/*The structure of the blobs has complex structure, below functions represent creation of memory blobs from the scratch or on top of existing memory These functions return handle to the blob to be used in other ie_* functions*/
+
+- `IEStatusCode make_memory_blob(const tensor_desc *tensorDesc, ie_blob_t *blob_result)`
+  - Description: Creates a `ie_blob_t` instance with the specified dimensions and layout but does not allocate the memory. Use the allocate() method to allocate memory. `tensor_desc` Defines the layout and dims of the blob.
+  - Parameters:
+    - `tensorDesc` - Defines the layout and dims of the blob.
+    - `blob_result` - A pointer to an empty ie_blob_t instance.
+  -  Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode make_memory_blob_from_preallocated_memory(const tensor_desc *tensorDesc, void *ptr, size_t size = 0, ie_blob_t *blob_result)`
+  - Description: The constructor creates a `ie_blob_t` instance with the specified dimensions and layout on the pre-allocated memory. The allocate() call is not required.
+  - Parameters:
+    - `tensorDesc` - Tensor description for Blob creation.
+    - `ptr` - A pointer to the pre-allocated memory.
+    - `size` -Length of the pre-allocated array. If not set, size is assumed equal to the dot product of dims.
+    - `blob_result` - A pointer to the newly created  ie_blob_t instance.
+  -  Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode make_memory_blob_with_roi(const ie_blob_t **inputBlob, const roi_e *roi, ie_blob_t *blob_result)`
+  - Description:  Creates a blob describing given roi instance based on the given blob with pre-allocated memory.
+  - Parameters:
+    - `inputBlob` - Original blob with pre-allocated memory.
+    - `roi` - A roi object inside of the original blob.
+    - `blob_result` - A  pointer to the newly created blob.
+  -  Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_blob_size(ie_blob_t *blob, int *size_result)`
+  - Description: Gets the total number of elements, which is a product of all the dimensions.
+  - Parameters:
+    - `blob` -  A  pointer to the blob.
+    - `size_result` - The total number of elements.
+  -  Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_blob_byte_size(ie_blob_t *blob, int *bsize_result)`
+  - Description: Gets the size of the current Blob in bytes.
+  - Parameters:
+    - `blob` -  A  pointer to the blob.
+    - `bsize_result` - The size of the current Blob in bytes.
+  -  Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_blob_allocate(ie_blob_t *blob)`
+  - Description:  Allocates memory for blob.
+  - Parameters:
+    - `blob` - A pointer to an empty blob.
+  - Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_blob_deallocate(ie_blob_t *blob)`
+  - Description:  Releases previously allocated data.
+  - Parameters:
+    - `blob` - A  pointer to the blob.
+  - Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_blob_buffer(ie_blob_t *blob, void *buffer)`
+  - Description: Gets access to the allocated memory .
+  - Parameters:
+    - `blob` - A  pointer to the blob.
+    - `buffer` - A pointer  to the coped date from the given pointer to the blob.
+  -  Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_blob_cbuffer(ie_blob_t *blob, const void *cbuffer)`
+  - Description:   Gets read-only access to the allocated memory.
+  - Parameters:
+    - `blob` - A  pointer to the blob.
+    - `cbuffer` - A pointer  to the coped date from the given pointer to the blob and the date is read-only.
+  -  Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_blob_get_dims(ie_blob_t *blob, dimensions_t *dims_result)`
+  - Description: Gets dimensions of blob instance's tensor.
+  - Parameters:
+    - `blob` - A  pointer to the blob.
+    - `dims_result` - A pointer to the dimensions of blob instance's tensor.
+  -  Return value:  Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_blob_get_layout(ie_blob_t *blob, layout_t *layout_result)`
+  - Description: Gets layout of blob instance's tensor.
+  - Parameters:
+    - `blob` - A  pointer to the blob.
+    - `layout_result` -  A pointer to the layout of blob instance's tensor.
+  -  Return value: Status code of the operation: OK(0) for success.
+
+- `IEStatusCode ie_blob_get_precision(ie_blob_t *blob, precision_e *prec_result)`
+  - Description: Gets precision of blob instance's tensor.
+  - Parameters:
+    - `blob` - A  pointer to the blob.
+    - `prec_result` - A pointer to the precision of blob instance's tensor.
+  - Return value: Status code of the operation: OK(0) for success.

inference-engine/ie_bridges/c/samples/CMakeLists.txt

@@ -0,0 +1,5 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+include("${InferenceEngine_SOURCE_DIR}/samples/CMakeLists.txt")

inference-engine/ie_bridges/c/samples/common/CMakeLists.txt

@@ -0,0 +1,29 @@
+# Copyright (C) 2018-2020 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+project(OpenCV_C_Wraper)
+set(TARGET_NAME opencv_c_wraper)
+
+#set(CMAKE_SHARED_LINKER_FLAGS "-Wl,--exclude-libs,ALL")
+file(GLOB SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
+file(GLOB HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/*.h)
+
+# create library
+add_library(${TARGET_NAME} SHARED ${HEADERS} ${SOURCES})
+
+# Find OpenCV components if exist
+find_package(OpenCV COMPONENTS imgcodecs videoio  QUIET)
+if(NOT OpenCV_FOUND)
+    message(WARNING "OPENCV is disabled or not found, " ${TARGET_NAME} " is built without OPENCV support")
+else()
+    add_definitions(-DUSE_OPENCV)
+endif()
+
+target_link_libraries(${TARGET_NAME} PUBLIC ${OpenCV_LIBRARIES})
+
+target_include_directories(${TARGET_NAME} PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}")
+
+if(COMMAND add_cpplint_target)
+	add_cpplint_target(${TARGET_NAME}_cpplint FOR_TARGETS ${TARGET_NAME})
+endif()