Relocatable developer package (#20327)

* Merge Linux CC + static build + clang compiler

* Improvements

* Removed ie prefixes from cmake scripts

* Fixes for NPU

* Initial relocatable OpenVINO Developer package

* Improvements

* Try to fix

* improvements

* Export a lot of headers

* Removed NVIDIA pipeline; make it to be a job

* Fixes

* Fixes 2

* Try ilya-lavrenov repo

* Clean-up

* More imrpovements

* Even more improvements

* Override export, install

* Override export, install

* Disable pythonwheel generation for relocatable OV dev package

* Fixed issues with versions

* Fixed android build

* Fixed android build

* Fixed NPU build

* Update src/bindings/python/CMakeLists.txt

.github/workflows/build_doc.yml

@@ -17,8 +17,8 @@ jobs:
       - name: Clone OpenVINO
         uses: actions/checkout@v4
         with:
-          submodules: true
+          submodules: 'true'
-          lfs: true
+          lfs: 'true'
 
       - name: Install apt-get dependencies
         uses: awalsh128/cache-apt-pkgs-action@v1.3.0

.github/workflows/linux.yml

@@ -50,6 +50,7 @@ jobs:
       OPENVINO_CONTRIB_REPO: /__w/openvino/openvino/openvino_contrib
       INSTALL_DIR: /__w/openvino/openvino/openvino_install
       INSTALL_TEST_DIR: /__w/openvino/openvino/tests_install
+      DEVELOPER_PACKAGE_DIR: /__w/openvino/openvino/developer_package_install
       BUILD_DIR: /__w/openvino/openvino/openvino_build
       CCACHE_DIR: /mount/caches/ccache/ubuntu20_x86_64_Release
       CCACHE_TEMPDIR: /__w/openvino/openvino/ccache_temp
@@ -74,6 +75,7 @@ jobs:
           repository: 'openvinotoolkit/openvino_contrib'
           path: ${{ env.OPENVINO_CONTRIB_REPO }}
           submodules: 'true'
+          ref: 'master'
 
       #
       # Dependencies
@@ -150,6 +152,7 @@ jobs:
         run: |
           cmake -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} -P ${BUILD_DIR}/cmake_install.cmake
           cmake -DCMAKE_INSTALL_PREFIX=${INSTALL_TEST_DIR} -DCOMPONENT=tests -P ${BUILD_DIR}/cmake_install.cmake
+          cmake -DCMAKE_INSTALL_PREFIX=${DEVELOPER_PACKAGE_DIR} -DCOMPONENT=developer_package -P ${BUILD_DIR}/cmake_install.cmake
           cmake -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR} -DCOMPONENT=python_wheels -P ${BUILD_DIR}/cmake_install.cmake
 
       - name: Pack Artifacts
@@ -164,6 +167,10 @@ jobs:
             tar -czvf ${BUILD_DIR}/openvino_package.tar.gz *
           popd
 
+          pushd ${DEVELOPER_PACKAGE_DIR}
+            tar -czvf ${BUILD_DIR}/openvino_developer_package.tar.gz *
+          popd
+
           pushd ${INSTALL_TEST_DIR}
             tar -czvf ${BUILD_DIR}/openvino_tests.tar.gz *
           popd
@@ -203,6 +210,14 @@ jobs:
           path: ${{ env.BUILD_DIR }}/openvino_package.tar.gz
           if-no-files-found: 'error'
 
+      - name: Upload openvino developer package
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: openvino_developer_package
+          path: ${{ env.BUILD_DIR }}/openvino_developer_package.tar.gz
+          if-no-files-found: 'error'
+
       - name: Upload openvino debian packages
         if: ${{ always() }}
         uses: actions/upload-artifact@v3
@@ -493,7 +508,6 @@ jobs:
       ONNX_RUNTIME_BUILD_DIR: /__w/openvino/openvino/onnxruntime/build
 
     steps:
-
       - name: Fetch install_build_dependencies.sh
         uses: actions/checkout@v4
         with:
@@ -501,6 +515,7 @@ jobs:
             install_build_dependencies.sh
           sparse-checkout-cone-mode: false
           path: ${{ env.OPENVINO_REPO }}
+          ref: 'master'
 
       - name: Install git
         run: |
@@ -1292,3 +1307,122 @@ jobs:
           path: |
             ${{ env.INSTALL_TEST_DIR }}/TEST*.html
           if-no-files-found: 'error'
+
+  NVIDIA_Plugin:
+    name: NVIDIA plugin
+    needs: Build
+    defaults:
+      run:
+        shell: bash
+    runs-on: aks-linux-16-cores
+    container:
+      image: openvinogithubactions.azurecr.io/dockerhub/nvidia/cuda:11.8.0-runtime-ubuntu20.04
+      volumes:
+        - /mount/caches:/mount/caches
+    env:
+      CMAKE_BUILD_TYPE: 'Release'
+      CMAKE_GENERATOR: 'Ninja Multi-Config'
+      CMAKE_CUDA_COMPILER_LAUNCHER: ccache
+      CMAKE_CXX_COMPILER_LAUNCHER: ccache
+      CMAKE_C_COMPILER_LAUNCHER: ccache
+      INSTALL_DIR: /__w/openvino/openvino/install
+      OPENVINO_DEVELOPER_PACKAGE: /__w/openvino/openvino/install/developer_package
+      OPENVINO_REPO: /__w/openvino/openvino/openvino
+      OPENVINO_CONTRIB_REPO: /__w/openvino/openvino/openvino_contrib
+      NVIDIA_BUILD_DIR: /__w/openvino/openvino/nvidia_plugin_build
+      DEBIAN_FRONTEND: 'noninteractive'
+      CCACHE_DIR: /mount/caches/ccache/ubuntu20_x86_64_Release
+      CCACHE_TEMPDIR: /__w/openvino/openvino/ccache_temp
+      CCACHE_MAXSIZE: 50G
+
+    steps:
+      - name: Install Prerequisites
+        run: apt update && apt install -y git ca-certificates
+
+      - name: Download OpenVINO package
+        uses: actions/download-artifact@v3
+        with:
+          name: openvino_package
+          path: ${{ env.INSTALL_DIR }}
+
+      - name: Download OpenVINO Developer package
+        uses: actions/download-artifact@v3
+        with:
+          name: openvino_developer_package
+          path: ${{ env.INSTALL_DIR }}
+
+      - name: Extract OpenVINO packages
+        run: |
+          pushd ${INSTALL_DIR}
+            tar -xzf openvino_package.tar.gz -C ${INSTALL_DIR}
+          popd
+
+          pushd ${INSTALL_DIR}
+            tar -xzf openvino_developer_package.tar.gz -C ${INSTALL_DIR}
+          popd
+
+      # TODO: replace with sparse checkout below
+      - name: Clone OpenVINO
+        uses: actions/checkout@v4
+        with:
+          path: ${{ env.OPENVINO_REPO }}
+
+      - name: Fetch install_build_dependencies.sh
+        if: ${{ 'false' }}
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: |
+            install_build_dependencies.sh
+          sparse-checkout-cone-mode: false
+          path: ${{ env.OPENVINO_REPO }}
+
+      - name: Clone OpenVINO Contrib
+        uses: actions/checkout@v4
+        with:
+          repository: 'openvinotoolkit/openvino_contrib'
+          path: ${{ env.OPENVINO_CONTRIB_REPO }}
+          ref: 'master'
+
+      #
+      # Dependencies
+      #
+
+      - name: Install build dependencies
+        run: |
+          ${OPENVINO_REPO}/install_build_dependencies.sh
+          apt -y --no-install-recommends install software-properties-common
+
+      - name: Install CUDA
+        run: |
+          wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/cuda-ubuntu2004.pin
+          mv cuda-ubuntu2004.pin /etc/apt/preferences.d/cuda-repository-pin-600
+
+          apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/3bf863cc.pub
+          add-apt-repository "deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/ /"
+          apt update
+          apt install -y \
+            libcudnn8=8.9.4.*-1+cuda11.8 \
+            libcudnn8-dev=8.9.4.*-1+cuda11.8 \
+            libcudnn8-samples=8.9.4.*-1+cuda11.8 \
+            cuda-runtime-11-8 \
+            cuda-11-8 \
+            libcutensor1=1.6.1.5-1 \
+            libcutensor-dev=1.6.1.5-1 \
+            cuda-drivers=520.61.05-1
+
+      #
+      # Build
+      #
+
+      - name: Cmake & Build - NVIDIA Plugin
+        run: |
+          source ${INSTALL_DIR}/setupvars.sh
+          cmake \
+            -DOpenVINODeveloperPackage_DIR=${OPENVINO_DEVELOPER_PACKAGE}/cmake \
+            -DCMAKE_COMPILE_WARNING_AS_ERROR=OFF \
+            -S ${OPENVINO_CONTRIB_REPO}/modules/nvidia_plugin \
+            -B ${NVIDIA_BUILD_DIR}
+          cmake --build ${NVIDIA_BUILD_DIR} --parallel --config ${{ env.CMAKE_BUILD_TYPE }} --verbose -- ov_nvidia_func_tests ov_nvidia_unit_tests
+
+      - name: Show ccache stats
+        run: ccache --show-stats

.github/workflows/linux_conditional_compilation.yml

@@ -73,6 +73,7 @@ jobs:
           repository: 'openvinotoolkit/testdata'
           path: ${{ env.MODELS_PATH }}
           lfs: 'true'
+          ref: 'master'
 
       #
       # Dependencies
@@ -230,6 +231,7 @@ jobs:
           repository: 'openvinotoolkit/testdata'
           path: ${{ env.MODELS_PATH }}
           lfs: 'true'
+          ref: 'master'
 
       - name: Download selective build statistics package
         uses: actions/download-artifact@v3

.github/workflows/linux_cuda.yml

@@ -1,143 +0,0 @@
-name: Linux NVIDIA Plugin (Ubuntu 20.04)
-on:
-  workflow_dispatch:
-  pull_request:
-    paths-ignore:
-      - '**/docs/**'
-      - 'docs/**'
-      - '**/**.md'
-      - '**.md'
-      - '**/layer_tests_summary/**'
-      - '**/conformance/**'
-  push:
-    paths-ignore:
-      - '**/docs/**'
-      - 'docs/**'
-      - '**/**.md'
-      - '**.md'
-      - '**/layer_tests_summary/**'
-      - '**/conformance/**'
-    branches:
-      - master
-
-concurrency:
-  # github.ref is not unique in post-commit
-  group: ${{ github.event_name == 'push' && github.run_id || github.ref }}-linux-nvidia
-  cancel-in-progress: true
-
-jobs:
-  Build:
-    defaults:
-      run:
-        shell: bash
-    runs-on: aks-linux-16-cores
-    container:
-      image: openvinogithubactions.azurecr.io/dockerhub/nvidia/cuda:11.8.0-runtime-ubuntu20.04
-      volumes:
-        - /mount/caches:/mount/caches
-    env:
-      CMAKE_BUILD_TYPE: 'Release'
-      CMAKE_GENERATOR: 'Ninja Multi-Config'
-      CMAKE_CUDA_COMPILER_LAUNCHER: ccache
-      CMAKE_CXX_COMPILER_LAUNCHER: ccache
-      CMAKE_C_COMPILER_LAUNCHER: ccache
-      OPENVINO_REPO: /__w/openvino/openvino/openvino
-      OPENVINO_CONTRIB_REPO: /__w/openvino/openvino/openvino_contrib
-      OV_BUILD_DIR: /__w/openvino/openvino/openvino_build
-      NVIDIA_BUILD_DIR: /__w/openvino/openvino/nvidia_plugin_build
-      DEBIAN_FRONTEND: 'noninteractive'
-      CCACHE_DIR: /mount/caches/ccache/ubuntu20_x86_64_Release
-      CCACHE_TEMPDIR: /__w/openvino/openvino/ccache_temp
-      CCACHE_MAXSIZE: 50G
-    steps:
-
-      - name: Install Prerequisites
-        run: |
-          apt update
-          apt install -y git curl git git-lfs unzip wget
-
-      - name: Clone OpenVINO
-        uses: actions/checkout@v4
-        with:
-          path: ${{ env.OPENVINO_REPO }}
-          submodules: 'true'
-
-      - name: Clone OpenVINO Contrib
-        uses: actions/checkout@v4
-        with:
-          repository: 'openvinotoolkit/openvino_contrib'
-          path: ${{ env.OPENVINO_CONTRIB_REPO }}
-          ref: 'master'
-
-      #
-      # Dependencies
-      #
-
-      - name: Install build dependencies
-        run: |
-          ${OPENVINO_REPO}/install_build_dependencies.sh
-          
-          apt -y --no-install-recommends install unzip wget software-properties-common
-
-      - name: Install CUDA
-        run: |
-         wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/cuda-ubuntu2004.pin 
-         mv cuda-ubuntu2004.pin /etc/apt/preferences.d/cuda-repository-pin-600
-         
-         apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/3bf863cc.pub
-         add-apt-repository "deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/ /"
-         apt update
-         apt install -y \
-            libcudnn8=8.9.4.*-1+cuda11.8 \
-            libcudnn8-dev=8.9.4.*-1+cuda11.8 \
-            libcudnn8-samples=8.9.4.*-1+cuda11.8 \
-            cuda-runtime-11-8 \
-            cuda-11-8 \
-            libcutensor1=1.6.1.5-1 \
-            libcutensor-dev=1.6.1.5-1 \
-            cuda-drivers=520.61.05-1
-
-      #
-      # Build
-      #
-
-      - name: CMake configure
-        run: |
-          cmake \
-            -G "${{ env.CMAKE_GENERATOR }}" \
-            -DENABLE_CPPLINT=OFF \
-            -DENABLE_NCC_STYLE=OFF \
-            -DENABLE_SYSTEM_PUGIXML=ON \
-            -DENABLE_SYSTEM_OPENCL=ON \
-            -DENABLE_STRICT_DEPENDENCIES=OFF \
-            -DCMAKE_BUILD_TYPE=${{ env.CMAKE_BUILD_TYPE }} \
-            -DENABLE_INTEL_CPU=OFF \
-            -DENABLE_INTEL_GPU=OFF \
-            -DENABLE_INTEL_GNA=OFF \
-            -DENABLE_OV_TF_FRONTEND=OFF \
-            -DENABLE_OV_TF_LITE_FRONTEND=OFF \
-            -DENABLE_OV_PADDLE_FRONTEND=OFF \
-            -DENABLE_OV_PYTORCH_FRONTEND=OFF \
-            -DENABLE_OV_ONNX_FRONTEND=OFF \
-            -DENABLE_PYTHON=OFF \
-            -DENABLE_TESTS=ON \
-            -DCPACK_GENERATOR=TGZ \
-            -DCMAKE_COMPILE_WARNING_AS_ERROR=ON \
-            -S ${OPENVINO_REPO} \
-            -B ${OV_BUILD_DIR}
-
-      - name: Build - OpenVINO
-        run: |
-          cmake --build ${OV_BUILD_DIR} --parallel --config ${{ env.CMAKE_BUILD_TYPE }} --verbose --target ov_dev_targets
-
-      - name: Cmake & Build - NVIDIA Plugin
-        run: |
-          cmake \
-            -DOpenVINODeveloperPackage_DIR=${OV_BUILD_DIR} \
-            -DCMAKE_COMPILE_WARNING_AS_ERROR=OFF \
-            -S ${OPENVINO_CONTRIB_REPO}/modules/nvidia_plugin \
-            -B ${NVIDIA_BUILD_DIR}
-          cmake --build ${NVIDIA_BUILD_DIR} --parallel --config ${{ env.CMAKE_BUILD_TYPE }} --verbose -- ov_nvidia_func_tests ov_nvidia_unit_tests
-
-      - name: Show ccache stats
-        run: ccache --show-stats

.github/workflows/windows.yml

@@ -56,6 +56,7 @@ jobs:
         with:
           repository: 'openvinotoolkit/openvino_contrib'
           path: 'openvino_contrib'
+          ref: 'master'
 
       #
       # Dependencies

.github/workflows/windows_conditional_compilation.yml

@@ -67,6 +67,7 @@ jobs:
           repository: 'openvinotoolkit/testdata'
           path: 'testdata'
           lfs: 'true'
+          ref: 'master'
 
       #
       # Dependencies

CMakeLists.txt

@@ -81,54 +81,55 @@ file(REMOVE "${CMAKE_BINARY_DIR}/ngraphTargets.cmake")
 file(REMOVE "${CMAKE_BINARY_DIR}/InferenceEngineTargets.cmake")
 file(REMOVE "${CMAKE_BINARY_DIR}/OpenVINOTargets.cmake")
 
-# remove exported developer targets to force its regeneration
+# remove exported developer targets files to force its regeneration
-macro(ov_clean_dev_targets)
+macro(ov_clean_developer_package_targets)
-    foreach(component IN LISTS openvino_export_components)
+    file(REMOVE "${CMAKE_BINARY_DIR}/inference_engine_developer_package_targets.cmake")
-        file(REMOVE "${CMAKE_BINARY_DIR}/${component}_dev_targets.cmake")
+    file(REMOVE "${CMAKE_BINARY_DIR}/openvino_developer_package_targets.cmake")
-        file(REMOVE "${CMAKE_BINARY_DIR}/ov_${component}_dev_targets.cmake")
+    unset(_OPENVINO_DEVELOPER_PACKAGE_TARGETS CACHE)
-        unset(${component} CACHE)
-    endforeach()
-    unset(openvino_export_components CACHE)
     unset(openvino_installed_targets CACHE)
 endmacro()
-ov_clean_dev_targets()
+ov_clean_developer_package_targets()
+
+function(ov_developer_package_export_targets)
+    cmake_parse_arguments(EXPORT "" "TARGET;INSTALL_DESTIONATION" "INSTALL_INCLUDE_DIRECTORIES" ${ARGN})
+
+    # to allow exporting of aliased targets with the original names
+    if(TARGET "${EXPORT_TARGET}")
+        get_target_property(original_name ${EXPORT_TARGET} ALIASED_TARGET)
+        if(TARGET "${original_name}")
+            # replace target with its original name
+            set(EXPORT_TARGET ${original_name})
+        endif()
+        list(APPEND _OPENVINO_DEVELOPER_PACKAGE_TARGETS ${EXPORT_TARGET})
+
+        if(EXPORT_INSTALL_INCLUDE_DIRECTORIES)
+            if(NOT EXPORT_INSTALL_DESTIONATION)
+                set(EXPORT_INSTALL_DESTIONATION "developer_package/include/${EXPORT_TARGET}")
+            endif()
+
+            target_include_directories(${EXPORT_TARGET} INTERFACE "$<INSTALL_INTERFACE:${EXPORT_INSTALL_DESTIONATION}>")
+
+            foreach(install_dir IN LISTS EXPORT_INSTALL_INCLUDE_DIRECTORIES)
+                install(DIRECTORY "${install_dir}"
+                        DESTINATION "${EXPORT_INSTALL_DESTIONATION}"
+                        COMPONENT developer_package EXCLUDE_FROM_ALL)
+            endforeach()
+        endif()
+    else()
+        message(FATAL_ERROR "Internal error: ${target_name} does not represent a cmake target")
+    endif()
+
+    list(REMOVE_DUPLICATES _OPENVINO_DEVELOPER_PACKAGE_TARGETS)
+    set(_OPENVINO_DEVELOPER_PACKAGE_TARGETS "${_OPENVINO_DEVELOPER_PACKAGE_TARGETS}" CACHE INTERNAL
+        "A list of OpenVINO Developer Package exported targets" FORCE)
+endfunction()
 
 #
 # Build
 #
 
-function(openvino_developer_export_targets)
-    cmake_parse_arguments(EXPORT "" "COMPONENT" "TARGETS" ${ARGN})
-
-    if(EXPORT_UNPARSED_ARGUMENTS)
-        message(FATAL_ERROR "openvino_developer_export_targets has unparsed arguments: ${EXPORT_UNPARSED_ARGUMENTS}")
-    endif()
-
-    set(${EXPORT_COMPONENT} "${${EXPORT_COMPONENT}};${EXPORT_TARGETS}")
-
-    # to allow exporting of aliased targets with the original names
-    foreach(target_name IN LISTS ${EXPORT_COMPONENT})
-        if(TARGET "${target_name}")
-            get_target_property(original_name ${target_name} ALIASED_TARGET)
-            if(TARGET "${original_name}")
-                list(REMOVE_ITEM ${EXPORT_COMPONENT} ${target_name})
-                list(APPEND ${EXPORT_COMPONENT} ${original_name})
-            endif()
-        endif()
-    endforeach()
-
-    list(REMOVE_DUPLICATES ${EXPORT_COMPONENT})
-    set(${EXPORT_COMPONENT} "${${EXPORT_COMPONENT}}" CACHE INTERNAL
-        "A list of OpenVINO ${EXPORT_COMPONENT} exported targets" FORCE)
-
-    list(APPEND openvino_export_components ${EXPORT_COMPONENT})
-    list(REMOVE_DUPLICATES openvino_export_components)
-    set(openvino_export_components "${openvino_export_components}" CACHE INTERNAL
-        "A list of OpenVINO exported components" FORCE)
-endfunction()
-
-# add target with processed tests model zoo
 if(ENABLE_TESTS)
+    # add target with processed tests model zoo
     include(cmake/test_model_zoo.cmake)
 endif()
 

cmake/dependencies.cmake

@@ -5,7 +5,7 @@
 cmake_policy(SET CMP0054 NEW)
 
 # TODO: fix it, outside of source dir MO cannot find TBB dependency
-set_temp_directory(TEMP "${CMAKE_SOURCE_DIR}")
+ov_set_temp_directory(TEMP "${CMAKE_SOURCE_DIR}")
 
 ## Intel OMP package
 if(THREADING STREQUAL "OMP")
@@ -71,12 +71,16 @@ function(ov_download_tbb)
 
     if(NOT DEFINED ENV{TBBROOT} AND (DEFINED ENV{TBB_DIR} OR DEFINED TBB_DIR))
         if(DEFINED ENV{TBB_DIR})
-            set(TEMP_ROOT $ENV{TBB_DIR})
+            set(TBB_DIR "$ENV{TBB_DIR}")
-        elseif (DEFINED TBB_DIR)
-            set(TEMP_ROOT ${TBB_DIR})
         endif()
+        set(TEMP_ROOT "${TBB_DIR}")
         while(NOT EXISTS "${TEMP_ROOT}/include")
-            get_filename_component(TEMP_ROOT ${TEMP_ROOT} PATH)
+            get_filename_component(TEMP_ROOT_PARENT ${TEMP_ROOT} PATH)
+            if(TEMP_ROOT_PARENT STREQUAL TEMP_ROOT)
+                # to prevent recursion
+                message(FATAL_ERROR "${TBB_DIR} does not contain 'include' folder. Please, unset TBB_DIR")
+            endif()
+            set(TEMP_ROOT "${TEMP_ROOT_PARENT}")
         endwhile()
         set(TBBROOT ${TEMP_ROOT})
     endif()

cmake/developer_package/OpenVINODeveloperScriptsConfig.cmake

@@ -27,11 +27,12 @@ endmacro()
 set(OLD_CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH})
 set(CMAKE_MODULE_PATH "${OpenVINODeveloperScripts_DIR}")
 
-function(set_ci_build_number)
+function(ov_set_ci_build_number)
-    set(repo_root "${CMAKE_SOURCE_DIR}")
     include(version)
-    foreach(var CI_BUILD_NUMBER OpenVINO_VERSION OpenVINO_SOVERSION OpenVINO_VERSION_SUFFIX OpenVINO_VERSION_BUILD
+    ov_parse_ci_build_number("${CMAKE_SOURCE_DIR}")
-                OpenVINO_VERSION_MAJOR OpenVINO_VERSION_MINOR OpenVINO_VERSION_PATCH)
+
+    foreach(var CI_BUILD_NUMBER OpenVINO_VERSION OpenVINO_SOVERSION OpenVINO_VERSION_SUFFIX
+                OpenVINO_VERSION_MAJOR OpenVINO_VERSION_MINOR OpenVINO_VERSION_PATCH OpenVINO_VERSION_BUILD)
         if(NOT DEFINED ${var})
             message(FATAL_ERROR "${var} version component is not defined")
         endif()
@@ -44,7 +45,7 @@ ov_set_if_not_defined(Python3_FIND_STRATEGY LOCATION)
 
 include(features)
 
-set_ci_build_number()
+ov_set_ci_build_number()
 
 #
 # Detect target
@@ -139,10 +140,13 @@ endif()
 
 # allow to override default OUTPUT_ROOT root
 if(NOT DEFINED OUTPUT_ROOT)
-    if(NOT DEFINED OpenVINO_SOURCE_DIR)
+    if(DEFINED OpenVINO_SOURCE_DIR)
-        message(FATAL_ERROR "OpenVINO_SOURCE_DIR is not defined")
+        # For BW compatiblity, when extra modules are built separately
+        # but still write its artifacts to OpenVINO source directory
+        set(OUTPUT_ROOT ${OpenVINO_SOURCE_DIR})
+    else()
+        set(OUTPUT_ROOT ${CMAKE_SOURCE_DIR})
     endif()
-    set(OUTPUT_ROOT ${OpenVINO_SOURCE_DIR})
 endif()
 
 # Enable postfixes for Debug/Release builds

cmake/developer_package/add_target_helpers.cmake

@@ -9,7 +9,6 @@ ov_add_target(
    NAME core_lib
    ADD_CPPLINT
    ADD_CLANG_FORMAT
-   DEVELOPER_PACKAGE <component>
    TYPE <SHARED / STATIC / EXECUTABLE>
    ROOT ${CMAKE_CURRENT_SOURCE_DIR}
    ADDITIONAL_SOURCE_DIRS
@@ -44,9 +43,6 @@ function(ov_add_target)
         NAME # name of target
         ROOT # root directory to be used for recursive search of source files
         )
-    set(oneValueOptionalArgs
-        DEVELOPER_PACKAGE             # Enables exporting of the target through the developer package
-        )
     set(multiValueArgs
         INCLUDES                      # Extra include directories
         LINK_LIBRARIES                # Link libraries (in form of target name or file name)
@@ -58,7 +54,7 @@ function(ov_add_target)
         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
         )
-    cmake_parse_arguments(ARG "${options}" "${oneValueRequiredArgs};${oneValueOptionalArgs}" "${multiValueArgs}" ${ARGN} )
+    cmake_parse_arguments(ARG "${options}" "${oneValueRequiredArgs}" "${multiValueArgs}" ${ARGN} )
 
     # sanity checks
     foreach(argName IN LISTS oneValueRequiredArgs)
@@ -128,11 +124,6 @@ function(ov_add_target)
         # code style
         ov_add_clang_format_target(${ARG_NAME}_clang FOR_TARGETS ${ARG_NAME})
     endif()
-    if (ARG_DEVELOPER_PACKAGE)
-        # developer package
-        openvino_developer_export_targets(COMPONENT ${ARG_DEVELOPER_PACKAGE}
-                                          TARGETS ${ARG_NAME})
-    endif()
     if(WIN32)
         # Provide default compile pdb name equal to target name
         set_target_properties(${ARG_NAME} PROPERTIES COMPILE_PDB_NAME ${ARG_NAME})

cmake/developer_package/compile_flags/os_flags.cmake

@@ -329,15 +329,15 @@ endif()
 
 file(RELATIVE_PATH OV_RELATIVE_BIN_PATH ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_SOURCE_DIR})
 
-if(${CMAKE_VERSION} VERSION_LESS "3.20")
+if(CMAKE_VERSION VERSION_LESS 3.20)
-    file(TO_NATIVE_PATH ${OpenVINO_SOURCE_DIR} OV_NATIVE_PROJECT_ROOT_DIR)
+    file(TO_NATIVE_PATH ${CMAKE_SOURCE_DIR} OV_NATIVE_PROJECT_ROOT_DIR)
     file(TO_NATIVE_PATH ${OV_RELATIVE_BIN_PATH} NATIVE_OV_RELATIVE_BIN_PATH)
 else()
-    cmake_path(NATIVE_PATH OpenVINO_SOURCE_DIR OV_NATIVE_PROJECT_ROOT_DIR)
+    cmake_path(NATIVE_PATH CMAKE_SOURCE_DIR OV_NATIVE_PROJECT_ROOT_DIR)
     cmake_path(NATIVE_PATH OV_RELATIVE_BIN_PATH NATIVE_OV_RELATIVE_BIN_PATH)
 endif()
 
-file(RELATIVE_PATH OV_NATIVE_PARENT_PROJECT_ROOT_DIR "${OpenVINO_SOURCE_DIR}/.." ${OpenVINO_SOURCE_DIR})
+file(RELATIVE_PATH OV_NATIVE_PARENT_PROJECT_ROOT_DIR "${CMAKE_SOURCE_DIR}/.." ${CMAKE_SOURCE_DIR})
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     #
@@ -392,7 +392,7 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     if(NOT DEFINED ENV{GITHUB_ACTIONS})
         add_compile_options(
             "$<$<COMPILE_LANGUAGE:CXX>:/d1trimfile:${OV_NATIVE_PROJECT_ROOT_DIR}\\>"
-            "$<$<COMPILE_LANGUAGE:CXX>:/d1trimfile:${OpenVINO_SOURCE_DIR}/>")
+            "$<$<COMPILE_LANGUAGE:CXX>:/d1trimfile:${CMAKE_SOURCE_DIR}/>")
     endif()
 
     #

cmake/developer_package/options.cmake

@@ -43,7 +43,7 @@ macro(ov_option_enum variable description value)
 endmacro()
 
 function (ov_print_enabled_features)
-    if(NOT COMMAND set_ci_build_number)
+    if(NOT COMMAND ov_set_ci_build_number)
         message(FATAL_ERROR "CI_BUILD_NUMBER is not set yet")
     endif()
 

cmake/developer_package/packaging/nsis.cmake

@@ -5,6 +5,8 @@
 macro(ov_nsis_specific_settings)
     # installation directory
     set(CPACK_PACKAGE_INSTALL_DIRECTORY "Intel")
+    # License to be embedded in the installer
+    set(CPACK_RESOURCE_FILE_LICENSE "${OpenVINO_SOURCE_DIR}/LICENSE")
 
     # TODO: provide icons
     # set(CPACK_NSIS_MUI_ICON "")

cmake/developer_package/packaging/packaging.cmake

@@ -193,8 +193,6 @@ macro(ov_cpack)
     set(CPACK_PACKAGE_CONTACT "OpenVINO Developers <openvino@intel.com>")
     set(CPACK_VERBATIM_VARIABLES ON)
     set(CPACK_COMPONENTS_ALL ${ARGN})
-    # TODO: set proper license file for Windows installer
-    set(CPACK_RESOURCE_FILE_LICENSE "${OpenVINO_SOURCE_DIR}/LICENSE")
 
     # default permissions for directories creation
     set(CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS

cmake/developer_package/version.cmake

@@ -4,50 +4,51 @@
 
 find_package(Git QUIET)
 
-function (branchName VAR)
+function(ov_branch_name VAR REPO_ROOT)
-    if(NOT DEFINED repo_root)
-        message(FATAL_ERROR "repo_root is not defined")
-    endif()
     if(GIT_FOUND)
         execute_process(
                 COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD
-                WORKING_DIRECTORY ${repo_root}
+                WORKING_DIRECTORY ${REPO_ROOT}
                 OUTPUT_VARIABLE GIT_BRANCH
                 OUTPUT_STRIP_TRAILING_WHITESPACE)
         set (${VAR} ${GIT_BRANCH} PARENT_SCOPE)
     endif()
 endfunction()
 
-function (commitHash VAR)
+function(ov_commit_hash VAR REPO_ROOT)
-    if(NOT DEFINED repo_root)
-        message(FATAL_ERROR "repo_root is not defined")
-    endif()
     if(GIT_FOUND)
         execute_process(
                 COMMAND ${GIT_EXECUTABLE} rev-parse --short=11 HEAD
-                WORKING_DIRECTORY ${repo_root}
+                WORKING_DIRECTORY ${REPO_ROOT}
                 OUTPUT_VARIABLE GIT_COMMIT_HASH
                 OUTPUT_STRIP_TRAILING_WHITESPACE)
         set (${VAR} ${GIT_COMMIT_HASH} PARENT_SCOPE)
     endif()
 endfunction()
 
-function (commitNumber VAR)
+function(ov_commit_number VAR REPO_ROOT)
-    if(NOT DEFINED repo_root)
-        message(FATAL_ERROR "repo_root is not defined")
-    endif()
     if(GIT_FOUND)
         execute_process(
                 COMMAND ${GIT_EXECUTABLE} rev-list --count --first-parent HEAD
-                WORKING_DIRECTORY ${repo_root}
+                WORKING_DIRECTORY ${REPO_ROOT}
                 OUTPUT_VARIABLE GIT_COMMIT_NUMBER
                 OUTPUT_STRIP_TRAILING_WHITESPACE)
         set (${VAR} ${GIT_COMMIT_NUMBER} PARENT_SCOPE)
+    else()
+        # set zeros since git is not available
+        set (${VAR} "000" PARENT_SCOPE)
     endif()
 endfunction()
 
-macro(ov_parse_ci_build_number)
+macro(ov_parse_ci_build_number repo_root)
-    set(OpenVINO_VERSION_BUILD 000)
+    # provides OpenVINO version
+    # 1. If CI_BUILD_NUMBER is defined, parses this information
+    # 2. Otherwise, either:
+    #  - parses openvino/core/version.hpp
+    #  - takes from OpenVINOConfig-version.cmake in case of relocatable Developer package
+    if (DEFINED ENV{CI_BUILD_NUMBER})
+        set(CI_BUILD_NUMBER $ENV{CI_BUILD_NUMBER})
+    endif()
 
     if(CI_BUILD_NUMBER MATCHES "^([0-9]+)\.([0-9]+)\.([0-9]+)\-([0-9]+)\-.*")
         set(OpenVINO_VERSION_MAJOR ${CMAKE_MATCH_1})
@@ -63,12 +64,9 @@ macro(ov_parse_ci_build_number)
         message(FATAL_ERROR "Failed to parse CI_BUILD_NUMBER which is ${CI_BUILD_NUMBER}")
     endif()
 
-    if(NOT DEFINED repo_root)
+    function(ov_compare_version_with_headers)
-        message(FATAL_ERROR "repo_root is not defined")
-    endif()
-
-    macro(ov_get_hpp_version)
         if(NOT DEFINED OpenVINO_SOURCE_DIR)
+            # if we are not in OpenVINO source tree, let's ignore this comparison
             return()
         endif()
 
@@ -101,30 +99,29 @@ macro(ov_parse_ci_build_number)
             endif()
         endforeach()
 
-        # detect commit number
+        foreach(var OpenVINO_VERSION_MAJOR OpenVINO_VERSION_MINOR OpenVINO_VERSION_PATCH)
-        commitNumber(OpenVINO_VERSION_BUILD_HPP)
-        if(OpenVINO_VERSION_BUILD STREQUAL "000" AND DEFINED OpenVINO_VERSION_BUILD_HPP)
-            set(OpenVINO_VERSION_BUILD "${OpenVINO_VERSION_BUILD_HPP}")
-        else()
-            set(OpenVINO_VERSION_BUILD_HPP "${OpenVINO_VERSION_BUILD}")
-        endif()
-
-        set(ov_hpp_version_is_found ON)
-    endmacro()
-
-    # detect OpenVINO version via openvino/core/version.hpp and ie_version.hpp
-    ov_get_hpp_version()
-
-    if(ov_hpp_version_is_found)
-        foreach(var OpenVINO_VERSION_MAJOR OpenVINO_VERSION_MINOR OpenVINO_VERSION_PATCH OpenVINO_VERSION_BUILD)
             if(DEFINED ${var} AND NOT ${var} EQUAL ${var}_HPP)
                 message(FATAL_ERROR "${var} parsed from CI_BUILD_NUMBER (${${var}}) \
                     and from openvino/core/version.hpp (${${var}_HPP}) are different")
             else()
                 # CI_BUILD_NUMBER is not defined well, take info from openvino/core/version.hpp as a baseline
-                set(${var} ${${var}_HPP})
+                set(${var} ${${var}_HPP} PARENT_SCOPE)
             endif()
         endforeach()
+    endfunction()
+
+    # detect OpenVINO version via openvino/core/version.hpp and ie_version.hpp
+    ov_compare_version_with_headers()
+
+    # detect commit number
+    ov_commit_number(OpenVINO_VERSION_BUILD_FROM_GIT "${repo_root}")
+
+    if(OpenVINO_VERSION_BUILD AND NOT OpenVINO_VERSION_BUILD STREQUAL OpenVINO_VERSION_BUILD_FROM_GIT)
+        # TODO: replace with FATAL_ERROR once NPU version will be discussed
+        message(WARNING "OpenVINO_VERSION_BUILD parsed from CI_BUILD_NUMBER (${OpenVINO_VERSION_BUILD}) \
+            and determined by git (${OpenVINO_VERSION_BUILD_FROM_GIT}) are different")
+    else()
+        set(OpenVINO_VERSION_BUILD "${OpenVINO_VERSION_BUILD_FROM_GIT}")
     endif()
 
     set(OpenVINO_SOVERSION "${OpenVINO_VERSION_MAJOR}${OpenVINO_VERSION_MINOR}${OpenVINO_VERSION_PATCH}")
@@ -140,8 +137,8 @@ macro(ov_parse_ci_build_number)
     if(NOT the_whole_version_is_defined_by_ci)
         # create CI_BUILD_NUMBER
 
-        branchName(GIT_BRANCH)
+        ov_branch_name(GIT_BRANCH "${repo_root}")
-        commitHash(GIT_COMMIT_HASH)
+        ov_commit_hash(GIT_COMMIT_HASH "${repo_root}")
 
         if(NOT GIT_BRANCH STREQUAL "master")
             set(GIT_BRANCH_POSTFIX "-${GIT_BRANCH}")
@@ -157,14 +154,6 @@ macro(ov_parse_ci_build_number)
     endif()
 endmacro()
 
-# provides OpenVINO version
-# 1. If CI_BUILD_NUMBER is defined, parses this information
-# 2. Otherwise, parses openvino/core/version.hpp
-if (DEFINED ENV{CI_BUILD_NUMBER})
-    set(CI_BUILD_NUMBER $ENV{CI_BUILD_NUMBER})
-endif()
-ov_parse_ci_build_number()
-
 macro (addVersionDefines FILE)
     message(WARNING "'addVersionDefines' is deprecated. Please, use 'ov_add_version_defines'")
 

cmake/extra_modules.cmake

@@ -9,13 +9,10 @@ function(ie_generate_dev_package_config)
         set(OpenCV_FOUND OFF)
     endif()
 
-    foreach(component IN LISTS openvino_export_components)
+    # export all targets with prefix and use them during extra modules build
-        # export all targets with prefix and use them during extra modules build
+    export(TARGETS ${_OPENVINO_DEVELOPER_PACKAGE_TARGETS} NAMESPACE IE::
-        export(TARGETS ${${component}} NAMESPACE IE::
+           APPEND FILE "${CMAKE_BINARY_DIR}/inference_engine_developer_package_targets.cmake")
-               APPEND FILE "${CMAKE_BINARY_DIR}/${component}_dev_targets.cmake")
+    add_custom_target(ie_dev_targets DEPENDS ${_OPENVINO_DEVELOPER_PACKAGE_TARGETS})
-        list(APPEND all_dev_targets ${${component}})
-    endforeach()
-    add_custom_target(ie_dev_targets DEPENDS ${all_dev_targets})
 
     set(PATH_VARS "OpenVINO_SOURCE_DIR")
     if(ENABLE_SAMPLES OR ENABLE_TESTS)
@@ -44,20 +41,20 @@ function(ov_generate_dev_package_config)
         set(OpenCV_FOUND OFF)
     endif()
 
-    foreach(component IN LISTS openvino_export_components)
+    # create a helper target to build all developer package targets
-        # filter out targets which are installed by OpenVINOConfig.cmake static build case
+    add_custom_target(ov_dev_targets DEPENDS ${_OPENVINO_DEVELOPER_PACKAGE_TARGETS})
-        set(exported_targets)
+
-        foreach(target IN LISTS ${component})
+    # filter out targets which are installed by OpenVINOConfig.cmake static build case
-            if(NOT target IN_LIST openvino_installed_targets)
+    if(openvino_installed_targets)
-                list(APPEND exported_targets ${target})
+        list(REMOVE_ITEM _OPENVINO_DEVELOPER_PACKAGE_TARGETS ${openvino_installed_targets})
-            endif()
+    endif()
-        endforeach()
+    # export all developer targets with prefix and use them during extra modules build
-        # export all developer targets with prefix and use them during extra modules build
+    export(TARGETS ${_OPENVINO_DEVELOPER_PACKAGE_TARGETS} NAMESPACE openvino::
-        export(TARGETS ${exported_targets} NAMESPACE openvino::
+           APPEND FILE "${CMAKE_BINARY_DIR}/openvino_developer_package_targets.cmake")
-               APPEND FILE "${CMAKE_BINARY_DIR}/ov_${component}_dev_targets.cmake")
+
-        list(APPEND all_dev_targets ${${component}})
+    #
-    endforeach()
+    # OpenVINODeveloperPackageConfig.cmake for build tree
-    add_custom_target(ov_dev_targets DEPENDS ${all_dev_targets})
+    #
 
     set(PATH_VARS "OpenVINO_SOURCE_DIR")
     if(ENABLE_SAMPLES OR ENABLE_TESTS)
@@ -77,38 +74,91 @@ function(ov_generate_dev_package_config)
     configure_file("${OpenVINO_SOURCE_DIR}/cmake/templates/OpenVINOConfig-version.cmake.in"
                    "${CMAKE_BINARY_DIR}/OpenVINODeveloperPackageConfig-version.cmake" 
                    @ONLY)
+
+    #
+    # OpenVINODeveloperPackageConfig.cmake for installation tree
+    #
+
+    set(DEV_PACKAGE_ROOT_DIR developer_package)
+    set(DEV_PACKAGE_CMAKE_DIR ${DEV_PACKAGE_ROOT_DIR}/cmake)
+    set(DEVELOPER_PACKAGE_COMPONENT developer_package)
+    set(DEVELOPER_PACKAGE_EXPORT_SET OpenVINODeveloperTargets)
+
+    # create and install main developer package config files
+    configure_package_config_file("${OpenVINO_SOURCE_DIR}/cmake/templates/OpenVINODeveloperPackageConfigRelocatable.cmake.in"
+                                  "${OpenVINO_BINARY_DIR}/share/OpenVINODeveloperPackageConfig.cmake"
+                                  INSTALL_DESTINATION ${DEV_PACKAGE_CMAKE_DIR}
+                                  NO_CHECK_REQUIRED_COMPONENTS_MACRO)
+
+    configure_file("${OpenVINO_SOURCE_DIR}/cmake/templates/OpenVINOConfig-version.cmake.in"
+                   "${OpenVINO_BINARY_DIR}/share/OpenVINODeveloperPackageConfig-version.cmake" 
+                   @ONLY)
+
+    install(FILES "${OpenVINO_BINARY_DIR}/share/OpenVINODeveloperPackageConfig.cmake"
+                  "${OpenVINO_BINARY_DIR}/share/OpenVINODeveloperPackageConfig-version.cmake"
+            DESTINATION ${DEV_PACKAGE_CMAKE_DIR}
+            COMPONENT ${DEVELOPER_PACKAGE_COMPONENT}
+            EXCLUDE_FROM_ALL)
+
+    # Install whole 'cmake/developer_package' folder
+    install(DIRECTORY "${OpenVINODeveloperScripts_DIR}/"
+            DESTINATION "${DEV_PACKAGE_CMAKE_DIR}"
+            COMPONENT ${DEVELOPER_PACKAGE_COMPONENT}
+            EXCLUDE_FROM_ALL)
+
+    # Install CMakeLists.txt to read cache variables from
+    install(FILES "${OpenVINO_BINARY_DIR}/CMakeCache.txt"
+            DESTINATION ${DEV_PACKAGE_CMAKE_DIR}
+            COMPONENT ${DEVELOPER_PACKAGE_COMPONENT}
+            EXCLUDE_FROM_ALL)
+
+    # install developer package targets
+    install(TARGETS ${_OPENVINO_DEVELOPER_PACKAGE_TARGETS} EXPORT ${DEVELOPER_PACKAGE_EXPORT_SET}
+            RUNTIME DESTINATION ${DEV_PACKAGE_ROOT_DIR}/bin COMPONENT ${DEVELOPER_PACKAGE_COMPONENT} EXCLUDE_FROM_ALL
+            ARCHIVE DESTINATION ${DEV_PACKAGE_ROOT_DIR}/lib COMPONENT ${DEVELOPER_PACKAGE_COMPONENT} EXCLUDE_FROM_ALL
+            LIBRARY DESTINATION ${DEV_PACKAGE_ROOT_DIR}/lib COMPONENT ${DEVELOPER_PACKAGE_COMPONENT} EXCLUDE_FROM_ALL)
+
+    install(EXPORT ${DEVELOPER_PACKAGE_EXPORT_SET}
+            FILE OpenVINODeveloperPackageTargets.cmake
+            NAMESPACE openvino::
+            DESTINATION ${DEV_PACKAGE_ROOT_DIR}/cmake
+            COMPONENT ${DEVELOPER_PACKAGE_COMPONENT}
+            EXCLUDE_FROM_ALL)
+
+    # Note: that OpenCV and gflags are explicitly not installed to simplify relocatable
+    # OpenVINO Developer package maintainance. OpenVINO_SOURCE_DIR is also unvailable, because
+    # relocatable developer package can be used on a different machine where OpenVINO repo is not available
 endfunction()
 
 #
 # Add extra modules
 #
 
-function(register_extra_modules)
+function(_ov_register_extra_modules)
     set(InferenceEngineDeveloperPackage_DIR "${CMAKE_CURRENT_BINARY_DIR}/build-modules")
     set(OpenVINODeveloperPackage_DIR "${CMAKE_BINARY_DIR}/build-modules")
     set(OpenVINO_DIR "${CMAKE_BINARY_DIR}")
 
-    function(generate_fake_dev_package NS)
+    function(_ov_generate_fake_developer_package NS)
         if(NS STREQUAL "openvino")
             set(devconfig_file "${OpenVINODeveloperPackage_DIR}/OpenVINODeveloperPackageConfig.cmake")
         else()
             set(devconfig_file "${InferenceEngineDeveloperPackage_DIR}/InferenceEngineDeveloperPackageConfig.cmake")
         endif()
-        file(REMOVE "${devconfig_file}")
 
+        file(REMOVE "${devconfig_file}")
         file(WRITE "${devconfig_file}" "\# !! AUTOGENERATED: DON'T EDIT !!\n\n")
 
-        foreach(targets_list IN LISTS ${openvino_export_components})
+        foreach(exported_target IN LISTS _OPENVINO_DEVELOPER_PACKAGE_TARGETS)
-            foreach(target IN LISTS targets_list)
+            file(APPEND "${devconfig_file}" "if(NOT TARGET ${NS}::${exported_target})
-                file(APPEND "${devconfig_file}" "if(NOT TARGET ${NS}::${target})
+    add_library(${NS}::${exported_target} ALIAS ${exported_target})
-    add_library(${NS}::${target} ALIAS ${target})
 endif()\n")
-            endforeach()
         endforeach()
     endfunction()
 
-    generate_fake_dev_package("openvino")
+    _ov_generate_fake_developer_package("openvino")
-    generate_fake_dev_package("IE")
+    # TODO: remove with API 1.0 removal
+    _ov_generate_fake_developer_package("IE")
 
     # detect where OPENVINO_EXTRA_MODULES contains folders with CMakeLists.txt
     # other folders are supposed to have sub-folders with CMakeLists.txt
@@ -155,21 +205,18 @@ endfunction()
 # Extra modules support
 #
 
-# this InferenceEngineDeveloperPackageConfig.cmake is not used
+# this OpenVINODeveloperPackageConfig.cmake is not used during extra modules build
-# during extra modules build since it's generated after modules
+# since it's generated after modules are configured
-# are configured
 ie_generate_dev_package_config()
 ov_generate_dev_package_config()
 
 # extra modules must be registered after inference_engine library
 # and all other OpenVINO Core libraries are creared
-# because 'register_extra_modules' creates fake InferenceEngineDeveloperPackageConfig.cmake
+# because '_ov_register_extra_modules' creates fake InferenceEngineDeveloperPackageConfig.cmake
 # with all imported developer targets
-register_extra_modules()
+_ov_register_extra_modules()
 
-# for static libraries case we need to generate final ov_plugins.hpp
+# we need to generate final ov_plugins.hpp with all the information about plugins
-# with all the information about plugins
 ov_generate_plugins_hpp()
-
+# we need to generate final ov_frontends.hpp with all the information about frontends
-# used for static build
 ov_generate_frontends_hpp()

cmake/templates/InferenceEngineDeveloperPackageConfig.cmake.in

@@ -88,9 +88,7 @@ endif()
 
 _ov_find_tbb()
 
-foreach(component @openvino_export_components@)
+include("${CMAKE_CURRENT_LIST_DIR}/inference_engine_developer_package_targets.cmake")
-    include("${CMAKE_CURRENT_LIST_DIR}/${component}_dev_targets.cmake")
-endforeach()
 
 if(TARGET IE::ov_core_dev AND NOT TARGET openvino::core::dev)
     add_library(openvino::core::dev INTERFACE IMPORTED)

cmake/templates/OpenVINODeveloperPackageConfig.cmake.in

@@ -77,13 +77,7 @@ find_dependency(OpenVINO
 _ov_find_tbb()
 _ov_find_pugixml()
 
-foreach(component @openvino_export_components@)
+include("${CMAKE_CURRENT_LIST_DIR}/openvino_developer_package_targets.cmake")
-    # TODO: remove legacy targets from some tests
-    # string(FIND "${component}" "_legacy" index)
-    # if (index EQUAL -1)
-    include("${CMAKE_CURRENT_LIST_DIR}/ov_${component}_dev_targets.cmake")
-    # endif()
-endforeach()
 
 # inherit OpenCV from main OpenVINO project if enabled
 if("@OpenCV_FOUND@")

cmake/templates/OpenVINODeveloperPackageConfigRelocatable.cmake.in

@@ -0,0 +1,76 @@
+# Copyright (C) 2018-2023 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+
+# Variables to export in plugin's projects
+
+set(ov_options "@OV_OPTIONS@")
+list(APPEND ov_options CMAKE_CXX_COMPILER_LAUNCHER CMAKE_C_COMPILER_LAUNCHER
+                       CMAKE_CXX_LINKER_LAUNCHER CMAKE_C_LINKER_LAUNCHER
+                       CMAKE_INSTALL_PREFIX CPACK_GENERATOR)
+
+if(APPLE)
+    list(APPEND ov_options CMAKE_OSX_ARCHITECTURES CMAKE_OSX_DEPLOYMENT_TARGET)
+endif()
+
+get_property(_OV_GENERATOR_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if(_OV_GENERATOR_MULTI_CONFIG)
+    list(APPEND ov_options CMAKE_CONFIGURATION_TYPES)
+    if(CMAKE_GENERATOR MATCHES "^Ninja Multi-Config$")
+        list(APPEND ov_options CMAKE_DEFAULT_BUILD_TYPE)
+    endif()
+else()
+    list(APPEND ov_options CMAKE_BUILD_TYPE)
+endif()
+unset(_OV_GENERATOR_MULTI_CONFIG)
+
+file(TO_CMAKE_PATH "${CMAKE_CURRENT_LIST_DIR}" cache_path)
+
+message(STATUS "The following CMake options are exported from OpenVINO Developer package")
+message(" ")
+foreach(option IN LISTS ov_options)
+    if(NOT DEFINED "${option}")
+        load_cache("${cache_path}" READ_WITH_PREFIX "" ${option})
+    endif()
+    message("    ${option}: ${${option}}")
+endforeach()
+message(" ")
+
+# Restore TBB installation directory (requires for proper LC_RPATH on macOS with SIP)
+load_cache("${cache_path}" READ_WITH_PREFIX "" TBB_INSTALL_DIR)
+
+# activate generation of plugins.xml
+set(ENABLE_PLUGINS_XML ON)
+
+# Disable warning as error for private components
+set(CMAKE_COMPILE_WARNING_AS_ERROR OFF)
+
+#
+# Content
+#
+
+# OpenVINO_DIR is supposed to be set as an environment variable
+find_dependency(OpenVINO)
+
+find_dependency(OpenVINODeveloperScripts
+                PATHS "${CMAKE_CURRENT_LIST_DIR}"
+                NO_CMAKE_FIND_ROOT_PATH
+                NO_DEFAULT_PATH)
+
+_ov_find_tbb()
+_ov_find_pugixml()
+
+include("${CMAKE_CURRENT_LIST_DIR}/OpenVINODeveloperPackageTargets.cmake")
+#
+# Extra Compile Flags
+#
+
+# don't fail on strict compilation options in 3rd party modules
+ov_dev_package_no_errors()
+
+# Don't threat deprecated API warnings as errors in 3rd party apps
+ov_deprecated_no_errors()

samples/CMakeLists.txt

@@ -5,7 +5,8 @@
 add_subdirectory(cpp)
 add_subdirectory(c)
 
-openvino_developer_export_targets(COMPONENT samples TARGETS format_reader ie_samples_utils)
+ov_developer_package_export_targets(TARGET format_reader)
+ov_developer_package_export_targets(TARGET ie_samples_utils)
 
 #
 # Install

samples/cpp/common/format_reader/CMakeLists.txt

@@ -30,7 +30,7 @@ else()
     target_compile_definitions(${TARGET_NAME} PRIVATE USE_OPENCV)
 endif()
 
-target_include_directories(${TARGET_NAME} PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include"
+target_include_directories(${TARGET_NAME} PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
                                           PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src")
 
 set_target_properties(${TARGET_NAME} PROPERTIES FOLDER cpp_samples)

samples/cpp/common/utils/CMakeLists.txt

@@ -11,7 +11,7 @@ add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
 set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "src")
 
 target_include_directories(${TARGET_NAME}
-    PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
+    PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>")
 
 find_package(OpenVINO REQUIRED COMPONENTS Runtime)
 

src/bindings/c/src/CMakeLists.txt

@@ -46,6 +46,7 @@ export(TARGETS ${TARGET_NAME} NAMESPACE openvino::
        APPEND FILE "${CMAKE_BINARY_DIR}/OpenVINOTargets.cmake")
 
 # install
+
 ov_cpack_add_component(${OV_CPACK_COMP_CORE_C} HIDDEN)
 ov_cpack_add_component(${OV_CPACK_COMP_CORE_C_DEV} HIDDEN)
 

src/bindings/python/CMakeLists.txt

@@ -20,7 +20,18 @@ project(OpenVINOPython DESCRIPTION "OpenVINO Runtime Python bindings")
 if(NOT DEFINED OpenVINO_SOURCE_DIR)
     find_package(OpenVINODeveloperPackage REQUIRED
                  PATHS "${InferenceEngineDeveloperPackage_DIR}")
+
+    # we assume that OpenVINODeveloperPackage is generated in OpenVINO build tree
     set(OpenVINO_BINARY_DIR "${OpenVINODeveloperPackage_DIR}")
+    # but this can be invalid for cases of OpenVINODeveloperPackage relocatable installation
+    # so, we need to disable wheen generation for this case
+    if(NOT EXISTS "${OpenVINO_BINARY_DIR}/cmake_install.cmake")
+        set(OpenVINODeveloperPackage_RELOCATABLE ON)
+    endif()
+endif()
+
+if(NOT DEFINED OpenVINODeveloperPackage_RELOCATABLE)
+    set(OpenVINODeveloperPackage_RELOCATABLE OFF)
 endif()
 
 #
@@ -141,11 +152,10 @@ function(ov_check_init_files_alignment init_files)
     endforeach()
 endfunction()
 
-set(INIT_FILES_RUNTIME
+set(INIT_FILES_RUNTIME "${OpenVINOPython_SOURCE_DIR}/src/openvino/__init__.py"
-"${OpenVINOPython_SOURCE_DIR}/src/openvino/__init__.py"
+                       "${OpenVINOPython_SOURCE_DIR}/src/compatibility/openvino/__init__.py"
-"${OpenVINOPython_SOURCE_DIR}/src/compatibility/openvino/__init__.py"
+                       "${OpenVINOPython_SOURCE_DIR}/../../../tools/ovc/openvino/__init__.py"
-"${OpenVINO_SOURCE_DIR}/tools/ovc/openvino/__init__.py"
+                       "${OpenVINOPython_SOURCE_DIR}/../../../tools/benchmark_tool/openvino/__init__.py")
-"${OpenVINO_SOURCE_DIR}/tools/benchmark_tool/openvino/__init__.py")
 
 ov_check_init_files_alignment("${INIT_FILES_RUNTIME}")
 
@@ -193,7 +203,7 @@ endif()
 
 # this option should not be a part of OpenVINODeveloperPackage
 # since wheels can be built only together with main OV build
-ov_dependent_option(ENABLE_WHEEL "Build wheel packages for PyPI" ${ENABLE_WHEEL_DEFAULT} "ENABLE_PYTHON" OFF)
+ov_dependent_option(ENABLE_WHEEL "Build wheel packages for PyPI" ${ENABLE_WHEEL_DEFAULT} "ENABLE_PYTHON;NOT OpenVINODeveloperPackage_RELOCATABLE" OFF)
 
 if(NOT ENABLE_PYTHON)
     if(CMAKE_SOURCE_DIR STREQUAL OpenVINOPython_SOURCE_DIR)
@@ -309,15 +319,15 @@ macro(ov_define_setup_py_dependencies)
         "${CMAKE_CURRENT_SOURCE_DIR}/wheel/setup.py"
         "${OpenVINOPython_SOURCE_DIR}/requirements.txt"
         "${OpenVINOPython_SOURCE_DIR}/wheel/readme.txt"
-        "${OpenVINO_SOURCE_DIR}/LICENSE"
+        "${OpenVINOPython_SOURCE_DIR}/../../../LICENSE"
-        "${OpenVINO_SOURCE_DIR}/licensing/onednn_third-party-programs.txt"
+        "${OpenVINOPython_SOURCE_DIR}/../../../licensing/onednn_third-party-programs.txt"
-        "${OpenVINO_SOURCE_DIR}/licensing/runtime-third-party-programs.txt"
+        "${OpenVINOPython_SOURCE_DIR}/../../../licensing/runtime-third-party-programs.txt"
-        "${OpenVINO_SOURCE_DIR}/licensing/tbb_third-party-programs.txt"
+        "${OpenVINOPython_SOURCE_DIR}/../../../licensing/tbb_third-party-programs.txt"
-        "${OpenVINO_SOURCE_DIR}/docs/install_guides/pypi-openvino-rt.md")
+        "${OpenVINOPython_SOURCE_DIR}/../../../docs/install_guides/pypi-openvino-rt.md")
 
     if(wheel_pre_release)
         list(APPEND ov_setup_py_deps
-            "${OpenVINO_SOURCE_DIR}/docs/install_guides/pre-release-note.md")
+            "${OpenVINOPython_SOURCE_DIR}/../../../docs/install_guides/pre-release-note.md")
     endif()
 endmacro()
 
@@ -394,8 +404,9 @@ if(ENABLE_TESTS)
 endif()
 
 if(OpenVINODeveloperPackage_FOUND)
+    # TODO: understand whether it's required
     # provides a callback function to describe each component in repo
-    include("${OpenVINO_SOURCE_DIR}/cmake/packaging/packaging.cmake")
+    include("${OpenVINOPython_SOURCE_DIR}/../../../cmake/packaging/packaging.cmake")
 
     ov_cpack(${OV_CPACK_COMPONENTS_ALL})
 endif()

src/bindings/python/src/compatibility/pyngraph/CMakeLists.txt

@@ -7,27 +7,25 @@ cmake_minimum_required (VERSION 3.13)
 project (pyngraph)
 
 if(NOT DEFINED OpenVINO_SOURCE_DIR)
+    find_package(OpenVINO REQUIRED)
     find_package(OpenVINODeveloperPackage QUIET
                  PATHS "${InferenceEngineDeveloperPackage_DIR}")
-    find_package(OpenVINO REQUIRED)
 endif()
 
 # Python3_VERSION_MAJOR and Python3_VERSION_MINOR are defined in FindPython3
 set(pyversion python${Python3_VERSION_MAJOR}.${Python3_VERSION_MINOR})
 
-if(OpenVINO_SOURCE_DIR)
+if(OV_GENERATOR_MULTI_CONFIG)
-    if(OV_GENERATOR_MULTI_CONFIG)
+    set(PYTHON_BRIDGE_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/$<CONFIG>/python/)
-        set(PYTHON_BRIDGE_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/$<CONFIG>/python/)
+else()
-    else()
+    set(PYTHON_BRIDGE_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/python/)
-        set(PYTHON_BRIDGE_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/python/)
-    endif()
-
-    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
-    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
-    set(CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
-    set(CMAKE_PDB_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
 endif()
 
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
+set(CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
+set(CMAKE_PDB_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
+
 # compile options
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
@@ -54,43 +52,39 @@ file(GLOB_RECURSE SOURCES *.cpp)
 
 pybind11_add_module(_${PROJECT_NAME} MODULE NO_EXTRAS ${SOURCES})
 
-target_include_directories(_${PROJECT_NAME} PRIVATE "../" "${OpenVINO_SOURCE_DIR}/src/common/transformations/include")
+target_include_directories(_${PROJECT_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/../")
 
-target_link_libraries(_${PROJECT_NAME} PRIVATE openvino::runtime)
+target_link_libraries(_${PROJECT_NAME} PRIVATE openvino::runtime openvino::core::dev)
 
 set_target_properties(_${PROJECT_NAME} PROPERTIES INTERPROCEDURAL_OPTIMIZATION_RELEASE ${ENABLE_LTO})
 
 # perform copy
-if(OpenVINO_SOURCE_DIR)
+add_custom_command(TARGET _${PROJECT_NAME}
-    add_custom_command(TARGET _${PROJECT_NAME}
+    POST_BUILD
-        POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/../ngraph ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/ngraph
-        COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/../ngraph ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/ngraph
+)
-    )
-endif()
 
 ov_set_apple_rpath(_${PROJECT_NAME} ${OV_CPACK_PYTHONDIR} ${OV_CPACK_RUNTIMEDIR})
 
 # Install
 
-if(OpenVINO_SOURCE_DIR OR OpenVINODeveloperPackage_FOUND)
+ov_python_minimal_api(_${PROJECT_NAME})
-    ov_python_minimal_api(_${PROJECT_NAME})
+ov_add_clang_format_target(_${PROJECT_NAME}_clang FOR_TARGETS _${PROJECT_NAME})
-    ov_add_clang_format_target(_${PROJECT_NAME}_clang FOR_TARGETS _${PROJECT_NAME})
 
-    ov_cpack_add_component(${OV_CPACK_COMP_PYTHON_OPENVINO}_${pyversion} HIDDEN)
+ov_cpack_add_component(${OV_CPACK_COMP_PYTHON_OPENVINO}_${pyversion} HIDDEN)
 
-    install(TARGETS _${PROJECT_NAME}
+install(TARGETS _${PROJECT_NAME}
-            DESTINATION ${OV_CPACK_PYTHONDIR}
+        DESTINATION ${OV_CPACK_PYTHONDIR}
-            COMPONENT ${OV_CPACK_COMP_PYTHON_OPENVINO}_${pyversion}
+        COMPONENT ${OV_CPACK_COMP_PYTHON_OPENVINO}_${pyversion}
-            ${OV_CPACK_COMP_PYTHON_OPENVINO_EXCLUDE_ALL})
+        ${OV_CPACK_COMP_PYTHON_OPENVINO_EXCLUDE_ALL})
 
-    install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/../ngraph
+install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/../ngraph
-            DESTINATION ${OV_CPACK_PYTHONDIR}
+        DESTINATION ${OV_CPACK_PYTHONDIR}
-            COMPONENT ${OV_CPACK_COMP_PYTHON_OPENVINO}_${pyversion}
+        COMPONENT ${OV_CPACK_COMP_PYTHON_OPENVINO}_${pyversion}
-            ${OV_CPACK_COMP_PYTHON_OPENVINO_EXCLUDE_ALL}
+        ${OV_CPACK_COMP_PYTHON_OPENVINO_EXCLUDE_ALL}
-            USE_SOURCE_PERMISSIONS)
+        USE_SOURCE_PERMISSIONS)
 
-    install(DIRECTORY ${OpenVINOPython_SOURCE_DIR}/tests_compatibility
+install(DIRECTORY ${OpenVINOPython_SOURCE_DIR}/tests_compatibility
-            DESTINATION tests/${PROJECT_NAME}
+        DESTINATION tests/${PROJECT_NAME}
-            COMPONENT tests
+        COMPONENT tests
-            EXCLUDE_FROM_ALL)
+        EXCLUDE_FROM_ALL)
-endif()

src/bindings/python/src/pyopenvino/CMakeLists.txt

@@ -10,19 +10,17 @@ endif()
 # Python3_VERSION_MAJOR and Python3_VERSION_MINOR are defined by FindPython3
 set(pyversion python${Python3_VERSION_MAJOR}.${Python3_VERSION_MINOR})
 
-if(OpenVINO_SOURCE_DIR)
+if(OV_GENERATOR_MULTI_CONFIG)
-    if(OV_GENERATOR_MULTI_CONFIG)
+    set(PYTHON_BRIDGE_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/$<CONFIG>/python/openvino)
-        set(PYTHON_BRIDGE_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/$<CONFIG>/python/openvino)
+else()
-    else()
+    set(PYTHON_BRIDGE_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/python/openvino)
-        set(PYTHON_BRIDGE_OUTPUT_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/python/openvino)
-    endif()
-
-    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
-    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
-    set(CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
-    set(CMAKE_PDB_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
 endif()
 
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
+set(CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
+set(CMAKE_PDB_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
+
 # compile options
 
 if(OV_COMPILER_IS_APPLECLANG)
@@ -64,15 +62,8 @@ list(FILTER SOURCES EXCLUDE REGEX ".*(frontend/(onnx|tensorflow|paddle|pytorch))
 
 pybind11_add_module(${PROJECT_NAME} MODULE NO_EXTRAS ${SOURCES})
 
-if(TARGET offline_transformations)
-    set(OFFLINE_TRANSFORMATIONS_LIB offline_transformations)
-else()
-    set(OFFLINE_TRANSFORMATIONS_LIB openvino::offline_transformations)
-endif()
-
 target_include_directories(${PROJECT_NAME} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/..")
-target_link_libraries(${PROJECT_NAME} PRIVATE
+target_link_libraries(${PROJECT_NAME} PRIVATE openvino::core::dev openvino::runtime openvino::offline_transformations)
-    openvino::core::dev openvino::runtime ${OFFLINE_TRANSFORMATIONS_LIB})
 set_target_properties(${PROJECT_NAME} PROPERTIES
     INTERPROCEDURAL_OPTIMIZATION_RELEASE ${ENABLE_LTO}
     OUTPUT_NAME "_pyopenvino")
@@ -96,58 +87,56 @@ if(OV_GENERATOR_MULTI_CONFIG)
 endif()
 
 # perform copy
-if(OpenVINO_SOURCE_DIR)
+add_custom_command(TARGET ${PROJECT_NAME}
-    add_custom_command(TARGET ${PROJECT_NAME}
+        POST_BUILD
-            POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_directory ${OpenVINOPython_SOURCE_DIR}/src/openvino ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
-            COMMAND ${CMAKE_COMMAND} -E copy_directory ${OpenVINOPython_SOURCE_DIR}/src/openvino ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
+        COMMAND ${CMAKE_COMMAND} -E copy ${OpenVINOPython_SOURCE_DIR}/requirements.txt ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/../requirements.txt
-            COMMAND ${CMAKE_COMMAND} -E copy ${OpenVINOPython_SOURCE_DIR}/requirements.txt ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/../requirements.txt
+        )
-            )
-endif()
 
-if(OpenVINO_SOURCE_DIR OR OpenVINODeveloperPackage_FOUND)
+ov_python_minimal_api(${PROJECT_NAME})
-    ov_python_minimal_api(${PROJECT_NAME})
+ov_add_clang_format_target(${PROJECT_NAME}_clang FOR_TARGETS ${PROJECT_NAME})
-    ov_add_clang_format_target(${PROJECT_NAME}_clang FOR_TARGETS ${PROJECT_NAME})
 
-    ov_cpack_add_component(${OV_CPACK_COMP_PYTHON_OPENVINO}_${pyversion}
+# install steps
-                           HIDDEN)
 
-    install(DIRECTORY ${OpenVINOPython_SOURCE_DIR}/src/openvino
+ov_cpack_add_component(${OV_CPACK_COMP_PYTHON_OPENVINO}_${pyversion}
-            DESTINATION ${OV_CPACK_PYTHONDIR}
+                        HIDDEN)
-            COMPONENT ${OV_CPACK_COMP_PYTHON_OPENVINO}_${pyversion}
-            ${OV_CPACK_COMP_PYTHON_OPENVINO_EXCLUDE_ALL}
-            USE_SOURCE_PERMISSIONS
-            PATTERN "test_utils" EXCLUDE
-            PATTERN "torchvision/requirements.txt" EXCLUDE)
 
-    install(TARGETS ${PROJECT_NAME}
+install(DIRECTORY ${OpenVINOPython_SOURCE_DIR}/src/openvino
-            DESTINATION ${OV_CPACK_PYTHONDIR}/openvino
+        DESTINATION ${OV_CPACK_PYTHONDIR}
-            COMPONENT ${OV_CPACK_COMP_PYTHON_OPENVINO}_${pyversion}
+        COMPONENT ${OV_CPACK_COMP_PYTHON_OPENVINO}_${pyversion}
-            ${OV_CPACK_COMP_PYTHON_OPENVINO_EXCLUDE_ALL})
+        ${OV_CPACK_COMP_PYTHON_OPENVINO_EXCLUDE_ALL}
+        USE_SOURCE_PERMISSIONS
+        PATTERN "test_utils" EXCLUDE
+        PATTERN "torchvision/requirements.txt" EXCLUDE)
 
-    ov_set_apple_rpath(${PROJECT_NAME} ${OV_CPACK_PYTHONDIR}/openvino
+install(TARGETS ${PROJECT_NAME}
-        # path to OpenVINO C++ libraries
+        DESTINATION ${OV_CPACK_PYTHONDIR}/openvino
-        ${OV_CPACK_RUNTIMEDIR}
+        COMPONENT ${OV_CPACK_COMP_PYTHON_OPENVINO}_${pyversion}
-        # pyopenvino also depends on TBB because of:
+        ${OV_CPACK_COMP_PYTHON_OPENVINO_EXCLUDE_ALL})
-        # pyopenvino => openvino::offline_transformations => TBB optimized openvino::reference
-        ${TBB_LIB_INSTALL_DIR})
 
-    ov_cpack_add_component(${OV_CPACK_COMP_OPENVINO_REQ_FILES} HIDDEN)
+ov_set_apple_rpath(${PROJECT_NAME} ${OV_CPACK_PYTHONDIR}/openvino
+    # path to OpenVINO C++ libraries
+    ${OV_CPACK_RUNTIMEDIR}
+    # pyopenvino also depends on TBB because of:
+    # pyopenvino => openvino::offline_transformations => TBB optimized openvino::reference
+    ${TBB_LIB_INSTALL_DIR})
 
-    install(FILES ${OpenVINOPython_SOURCE_DIR}/requirements.txt
+ov_cpack_add_component(${OV_CPACK_COMP_OPENVINO_REQ_FILES} HIDDEN)
-            DESTINATION ${OV_CPACK_PYTHONDIR}
-            COMPONENT ${OV_CPACK_COMP_OPENVINO_REQ_FILES}
-            ${OV_CPACK_COMP_OPENVINO_REQ_FILES_EXCLUDE_ALL})
-    
-    install(FILES ${OpenVINOPython_SOURCE_DIR}/src/openvino/preprocess/torchvision/requirements.txt
-            DESTINATION ${OV_CPACK_PYTHONDIR}/openvino/preprocess/torchvision
-            COMPONENT ${OV_CPACK_COMP_OPENVINO_REQ_FILES}
-            ${OV_CPACK_COMP_OPENVINO_REQ_FILES_EXCLUDE_ALL})
 
-    install(DIRECTORY ${OpenVINOPython_SOURCE_DIR}/tests
+install(FILES ${OpenVINOPython_SOURCE_DIR}/requirements.txt
-            DESTINATION tests/${PROJECT_NAME}
+        DESTINATION ${OV_CPACK_PYTHONDIR}
-            COMPONENT tests
+        COMPONENT ${OV_CPACK_COMP_OPENVINO_REQ_FILES}
-            EXCLUDE_FROM_ALL)
+        ${OV_CPACK_COMP_OPENVINO_REQ_FILES_EXCLUDE_ALL})
-endif()
+
+install(FILES ${OpenVINOPython_SOURCE_DIR}/src/openvino/preprocess/torchvision/requirements.txt
+        DESTINATION ${OV_CPACK_PYTHONDIR}/openvino/preprocess/torchvision
+        COMPONENT ${OV_CPACK_COMP_OPENVINO_REQ_FILES}
+        ${OV_CPACK_COMP_OPENVINO_REQ_FILES_EXCLUDE_ALL})
+
+install(DIRECTORY ${OpenVINOPython_SOURCE_DIR}/tests
+        DESTINATION tests/${PROJECT_NAME}
+        COMPONENT tests
+        EXCLUDE_FROM_ALL)
 
 if(TARGET ie_wheel)
     add_dependencies(ie_wheel ${PROJECT_NAME})

src/cmake/openvino.cmake

@@ -107,27 +107,27 @@ install(TARGETS ${TARGET_NAME} EXPORT OpenVINOTargets
 # Add openvino::runtine::dev target
 #
 
-add_library(${TARGET_NAME}_dev INTERFACE)
+add_library(openvino_runtime_dev INTERFACE)
-add_library(openvino::runtime::dev ALIAS ${TARGET_NAME}_dev)
+add_library(openvino::runtime::dev ALIAS openvino_runtime_dev)
 
-target_include_directories(${TARGET_NAME}_dev INTERFACE
+target_include_directories(openvino_runtime_dev INTERFACE
     $<BUILD_INTERFACE:${OpenVINO_SOURCE_DIR}/src/inference/dev_api>
     $<BUILD_INTERFACE:${OpenVINO_SOURCE_DIR}/src/common/low_precision_transformations/include>
-    $<TARGET_PROPERTY:openvino_gapi_preproc,INTERFACE_INCLUDE_DIRECTORIES>)
+    $<BUILD_INTERFACE:$<TARGET_PROPERTY:openvino_gapi_preproc,INTERFACE_INCLUDE_DIRECTORIES>>)
 
-target_compile_definitions(${TARGET_NAME}_dev INTERFACE
+target_compile_definitions(openvino_runtime_dev INTERFACE
     $<TARGET_PROPERTY:openvino_gapi_preproc,INTERFACE_COMPILE_DEFINITIONS>)
 
-target_link_libraries(${TARGET_NAME}_dev INTERFACE ${TARGET_NAME} openvino::core::dev)
+target_link_libraries(openvino_runtime_dev INTERFACE ${TARGET_NAME} openvino::core::dev)
 
-# TODO: remove once NPU will use explicltly `ov_set_threading_interface_for`
+ov_set_threading_interface_for(openvino_runtime_dev)
-ov_set_threading_interface_for(${TARGET_NAME}_dev)
+set_target_properties(openvino_runtime_dev PROPERTIES EXPORT_NAME runtime::dev)
-set_target_properties(${TARGET_NAME}_dev PROPERTIES EXPORT_NAME runtime::dev)
 
-openvino_developer_export_targets(COMPONENT core TARGETS openvino::runtime::dev)
+ov_developer_package_export_targets(TARGET openvino::runtime::dev
+                                    INSTALL_INCLUDE_DIRECTORIES "${OpenVINO_SOURCE_DIR}/src/inference/dev_api/")
 
 # Install static libraries for case BUILD_SHARED_LIBS=OFF
-ov_install_static_lib(${TARGET_NAME}_dev ${OV_CPACK_COMP_CORE})
+ov_install_static_lib(openvino_runtime_dev ${OV_CPACK_COMP_CORE})
 
 #
 # Install OpenVINO runtime

src/common/conditional_compilation/CMakeLists.txt

@@ -2,11 +2,12 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-set(TARGET_NAME conditional_compilation)
+set(TARGET_NAME openvino_conditional_compilation)
 
 add_library(${TARGET_NAME} INTERFACE)
 
 add_library(openvino::conditional_compilation ALIAS ${TARGET_NAME})
+set_target_properties(${TARGET_NAME} PROPERTIES EXPORT_NAME conditional_compilation)
 
 target_link_libraries(${TARGET_NAME} INTERFACE openvino::itt)
 
@@ -23,9 +24,7 @@ elseif(SELECTIVE_BUILD STREQUAL "ON")
     find_host_package (Python3 REQUIRED COMPONENTS Interpreter)
 
     file(TO_CMAKE_PATH ${SELECTIVE_BUILD_STAT} CMAKE_SELECTIVE_BUILD_STAT)
-
     file(GLOB STAT_FILES ${CMAKE_SELECTIVE_BUILD_STAT})
-
     if(NOT STAT_FILES)
         message(FATAL_ERROR "SELECTIVE_BUILD_STAT (${SELECTIVE_BUILD_STAT}) path doesn't contain valid csv files!")
     endif()
@@ -56,12 +55,16 @@ elseif(SELECTIVE_BUILD STREQUAL "ON")
     ov_force_include(${TARGET_NAME} INTERFACE ${GENERATED_HEADER})
 endif()
 
-ov_install_static_lib(${TARGET_NAME} ${OV_CPACK_COMP_CORE})
-
 file(GLOB_RECURSE hdrs ${CMAKE_CURRENT_SOURCE_DIR}/include/*.h ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp)
 ov_add_clang_format_target(${TARGET_NAME}_clang FOR_SOURCES ${hdrs})
-openvino_developer_export_targets(COMPONENT openvino_common TARGETS openvino::conditional_compilation)
 
 if(ENABLE_TESTS)
     add_subdirectory(tests)
 endif()
+
+# install & export
+
+ov_install_static_lib(${TARGET_NAME} ${OV_CPACK_COMP_CORE})
+
+ov_developer_package_export_targets(TARGET openvino::conditional_compilation
+                                    INSTALL_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/include/")

src/common/itt/CMakeLists.txt

@@ -36,7 +36,11 @@ endif()
 target_include_directories(${TARGET_NAME} PUBLIC
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>)
 
+ov_add_clang_format_target(${TARGET_NAME}_clang FOR_TARGETS ${TARGET_NAME})
+
+# install & export
+
 ov_install_static_lib(${TARGET_NAME} ${OV_CPACK_COMP_CORE})
 
-ov_add_clang_format_target(${TARGET_NAME}_clang FOR_TARGETS ${TARGET_NAME})
+ov_developer_package_export_targets(TARGET openvino::itt
-openvino_developer_export_targets(COMPONENT openvino_common TARGETS openvino::itt)
+                                    INSTALL_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/include/")

src/common/offline_transformations/CMakeLists.txt

@@ -2,13 +2,13 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-set(TARGET_NAME "offline_transformations")
+set(TARGET_NAME "openvino_offline_transformations")
-
-file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
-file(GLOB_RECURSE PUBLIC_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp)
 
 set(PUBLIC_HEADERS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
 
+file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
+file(GLOB_RECURSE PUBLIC_HEADERS ${PUBLIC_HEADERS_DIR}/*.hpp)
+
 # Create named folders for the sources within the .vcproj
 # Empty name lists them directly under the .vcproj
 
@@ -19,15 +19,20 @@ source_group("include" FILES ${PUBLIC_HEADERS})
 
 add_library(${TARGET_NAME} STATIC ${LIBRARY_SRC} ${PUBLIC_HEADERS})
 
+add_library(openvino::offline_transformations ALIAS ${TARGET_NAME})
+set_target_properties(${TARGET_NAME} PROPERTIES EXPORT_NAME offline_transformations)
+
 target_link_libraries(${TARGET_NAME} PRIVATE openvino::core::dev openvino::reference openvino::runtime)
 
-target_include_directories(${TARGET_NAME} PUBLIC ${PUBLIC_HEADERS_DIR}
+target_include_directories(${TARGET_NAME} PUBLIC $<BUILD_INTERFACE:${PUBLIC_HEADERS_DIR}>
-                                          PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src")
+                                          PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src"
+                                                  $<TARGET_PROPERTY:openvino::pugixml,INTERFACE_INCLUDE_DIRECTORIES>)
 
 add_cpplint_target(${TARGET_NAME}_cpplint FOR_TARGETS ${TARGET_NAME})
 
 ov_add_clang_format_target(${TARGET_NAME}_clang FOR_TARGETS ${TARGET_NAME})
 
-# developer package
+# install & export
 
-openvino_developer_export_targets(COMPONENT core TARGETS ${TARGET_NAME})
+ov_developer_package_export_targets(TARGET ${TARGET_NAME}
+                                    INSTALL_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/include/")

src/common/preprocessing/src/CMakeLists.txt

@@ -211,7 +211,7 @@ endif()
 
 # developer package
 
-openvino_developer_export_targets(COMPONENT core TARGETS ${TARGET_NAME})
+ov_developer_package_export_targets(TARGET ${TARGET_NAME})
 
 # install
 

src/common/snippets/CMakeLists.txt

@@ -46,8 +46,9 @@ endif()
 
 set_target_properties(${TARGET_NAME} PROPERTIES INTERPROCEDURAL_OPTIMIZATION_RELEASE ${ENABLE_LTO})
 
-# install
+# install & export
 
 ov_install_static_lib(${TARGET_NAME} ${OV_CPACK_COMP_CORE})
 
-openvino_developer_export_targets(COMPONENT ${OV_CPACK_COMP_CORE} TARGETS ${TARGET_NAME})
+ov_developer_package_export_targets(TARGET ${TARGET_NAME}
+                                    INSTALL_INCLUDE_DIRECTORIES "${PUBLIC_HEADERS_DIR}/")

src/common/transformations/CMakeLists.txt

@@ -4,11 +4,11 @@
 
 set(TARGET_NAME "inference_engine_transformations")
 
-file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
-file(GLOB_RECURSE PUBLIC_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp)
-
 set(PUBLIC_HEADERS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
 
+file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
+file(GLOB_RECURSE PUBLIC_HEADERS ${PUBLIC_HEADERS_DIR}/*.hpp)
+
 # Create named folders for the sources within the .vcproj
 # Empty name lists them directly under the .vcproj
 
@@ -27,8 +27,8 @@ ov_build_target_faster(${TARGET_NAME}_obj
 
 target_link_libraries(${TARGET_NAME}_obj PRIVATE openvino::reference openvino::itt openvino::builders openvino::core::dev openvino::shape_inference)
 
-target_include_directories(${TARGET_NAME}_obj PRIVATE $<BUILD_INTERFACE:${PUBLIC_HEADERS_DIR}>
+target_include_directories(${TARGET_NAME}_obj PRIVATE "${PUBLIC_HEADERS_DIR}"
-                                                     "${CMAKE_CURRENT_SOURCE_DIR}/src")
+                                                      "${CMAKE_CURRENT_SOURCE_DIR}/src")
 
 ov_add_clang_format_target(${TARGET_NAME}_clang FOR_TARGETS ${TARGET_NAME}_obj)
 
@@ -43,7 +43,7 @@ endif()
 add_library(${TARGET_NAME} INTERFACE)
 
 target_include_directories(${TARGET_NAME} INTERFACE
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<BUILD_INTERFACE:${PUBLIC_HEADERS_DIR}>
     $<BUILD_INTERFACE:$<TARGET_PROPERTY:ngraph,INTERFACE_INCLUDE_DIRECTORIES>>)
 
 target_link_libraries(${TARGET_NAME} INTERFACE openvino::runtime)

src/common/transformations/tests/CMakeLists.txt

@@ -15,7 +15,7 @@ ov_add_test_target(
     LINK_LIBRARIES
         gmock
         func_test_utils
-        offline_transformations
+        openvino::offline_transformations
         sharedTestClasses
         ov_lpt_models
     ADD_CLANG_FORMAT

src/common/util/CMakeLists.txt

@@ -4,11 +4,11 @@
 
 set(TARGET_NAME openvino_util)
 
-file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
-file(GLOB_RECURSE PUBLIC_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp)
-
 set(UTIL_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include/)
 
+file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
+file(GLOB_RECURSE PUBLIC_HEADERS ${UTIL_INCLUDE_DIR}/*.hpp)
+
 if (WIN32)
     # Remove linux specific files
     file(GLOB_RECURSE LIN_FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/os/lin/*.cpp
@@ -41,13 +41,15 @@ target_link_libraries(${TARGET_NAME} PRIVATE ${CMAKE_DL_LIBS})
 if (WIN32)
     target_link_libraries(${TARGET_NAME} PRIVATE Shlwapi)
 endif()
-target_include_directories(${TARGET_NAME} PUBLIC
+target_include_directories(${TARGET_NAME} PUBLIC $<BUILD_INTERFACE:${UTIL_INCLUDE_DIR}>)
-    $<BUILD_INTERFACE:${UTIL_INCLUDE_DIR}>)
-
-ov_install_static_lib(${TARGET_NAME} ${OV_CPACK_COMP_CORE})
 
 ov_add_clang_format_target(${TARGET_NAME}_clang FOR_TARGETS ${TARGET_NAME})
 ov_ncc_naming_style(FOR_TARGET ${TARGET_NAME}
                     SOURCE_DIRECTORIES ${UTIL_INCLUDE_DIR})
 
-openvino_developer_export_targets(COMPONENT core TARGETS ${TARGET_NAME})
+# install & export
+
+ov_install_static_lib(${TARGET_NAME} ${OV_CPACK_COMP_CORE})
+
+ov_developer_package_export_targets(TARGET ${TARGET_NAME}
+                                    INSTALL_INCLUDE_DIRECTORIES "${UTIL_INCLUDE_DIR}/")

src/core/CMakeLists.txt

@@ -36,25 +36,29 @@ source_group("src" FILES ${LIBRARY_SRC})
 source_group("include" FILES ${PUBLIC_HEADERS})
 
 #
-# Create ov_core_dev library
+# Create openvino_core_dev library
 #
 
-add_library(ov_core_dev INTERFACE)
+add_library(openvino_core_dev INTERFACE)
-add_library(openvino::core::dev ALIAS ov_core_dev)
+add_library(openvino::core::dev ALIAS openvino_core_dev)
 
-target_include_directories(ov_core_dev INTERFACE
+target_include_directories(openvino_core_dev INTERFACE
     $<BUILD_INTERFACE:${OV_CORE_INCLUDE_PATH}>
     $<BUILD_INTERFACE:${OpenVINO_SOURCE_DIR}/src/core/dev_api>
     $<BUILD_INTERFACE:${OpenVINO_SOURCE_DIR}/src/frontends/common/include>
     $<BUILD_INTERFACE:${OpenVINO_SOURCE_DIR}/src/common/transformations/include>)
 
-target_link_libraries(ov_core_dev INTERFACE openvino::itt openvino::util)
+target_link_libraries(openvino_core_dev INTERFACE openvino::itt openvino::util)
 
-set_target_properties(ov_core_dev PROPERTIES EXPORT_NAME core::dev)
+set_target_properties(openvino_core_dev PROPERTIES EXPORT_NAME core::dev)
-openvino_developer_export_targets(COMPONENT core TARGETS openvino::core::dev)
+ov_developer_package_export_targets(TARGET openvino::core::dev
+                                    INSTALL_INCLUDE_DIRECTORIES
+                                        "${OV_CORE_DEV_API_PATH}/"
+                                        "${OpenVINO_SOURCE_DIR}/src/common/transformations/include/"
+                                        "${OpenVINO_SOURCE_DIR}/src/common/low_precision_transformations/include/")
 
 # Install interface libraries for case BUILD_SHARED_LIBS=OFF
-ov_install_static_lib(ov_core_dev ${OV_CPACK_COMP_CORE})
+ov_install_static_lib(openvino_core_dev ${OV_CPACK_COMP_CORE})
 
 # Fix error LNK1248: image size (...) exceeds maximum allowable size (FFFFFFFF)
 # the symbolic debugging information will be stored in a separate .pdb file.

src/core/builder/CMakeLists.txt

@@ -4,11 +4,11 @@
 
 set(TARGET_NAME "openvino_builders")
 
-file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
-file(GLOB_RECURSE PUBLIC_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp)
-
 set(BUILDER_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include/)
 
+file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
+file(GLOB_RECURSE PUBLIC_HEADERS ${BUILDER_INCLUDE_DIR}/*.hpp)
+
 # Create named folders for the sources within the .vcproj
 # Empty name lists them directly under the .vcproj
 
@@ -35,8 +35,9 @@ endif()
 
 ov_add_clang_format_target(${TARGET_NAME}_clang FOR_TARGETS ${TARGET_NAME})
 
+# install & export
+
 ov_install_static_lib(openvino_builders ${OV_CPACK_COMP_CORE})
 
-# developer package
+ov_developer_package_export_targets(TARGET openvino::builders
-
+                                    INSTALL_INCLUDE_DIRECTORIES "${BUILDER_INCLUDE_DIR}/")
-openvino_developer_export_targets(COMPONENT core TARGETS openvino::builders)

src/core/reference/CMakeLists.txt

@@ -4,11 +4,11 @@
 
 set(TARGET_NAME "openvino_reference")
 
-file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
-file(GLOB_RECURSE PUBLIC_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp)
-
 set(REF_IMPL_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
 
+file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
+file(GLOB_RECURSE PUBLIC_HEADERS ${REF_IMPL_INCLUDE_DIR}/*.hpp)
+
 # Create named folders for the sources within the .vcproj
 # Empty name lists them directly under the .vcproj
 
@@ -46,7 +46,9 @@ target_link_libraries(${TARGET_NAME} PRIVATE Threads::Threads openvino::core::de
 
 ov_add_clang_format_target(${TARGET_NAME}_clang FOR_TARGETS ${TARGET_NAME})
 
+# install & export
+
 ov_install_static_lib(${TARGET_NAME} ${OV_CPACK_COMP_CORE})
 
-# developer package
+ov_developer_package_export_targets(TARGET openvino::reference
-openvino_developer_export_targets(COMPONENT core TARGETS openvino::reference)
+                                    INSTALL_INCLUDE_DIRECTORIES "${REF_IMPL_INCLUDE_DIR}/")

src/core/shape_inference/CMakeLists.txt

@@ -4,11 +4,11 @@
 
 set(TARGET_NAME "openvino_shape_inference")
 
-file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
-file(GLOB_RECURSE PUBLIC_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/include/*.hpp)
-
 set(SHAPE_INFER_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
 
+file(GLOB_RECURSE LIBRARY_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
+file(GLOB_RECURSE PUBLIC_HEADERS ${SHAPE_INFER_INCLUDE_DIR}/*.hpp)
+
 # Create named folders for the sources within the .vcproj
 # Empty name lists them directly under the .vcproj
 
@@ -24,7 +24,7 @@ set_target_properties(${TARGET_NAME} PROPERTIES EXPORT_NAME shape_inference)
 target_include_directories(${TARGET_NAME} PUBLIC
     $<BUILD_INTERFACE:${SHAPE_INFER_INCLUDE_DIR}>
     $<BUILD_INTERFACE:${OV_CORE_INCLUDE_PATH}>
-    $<BUILD_INTERFACE:$<TARGET_PROPERTY:openvino::core::dev,INTERFACE_INCLUDE_DIRECTORIES>>)
+    $<TARGET_PROPERTY:openvino::core::dev,INTERFACE_INCLUDE_DIRECTORIES>)
 
 ov_add_clang_format_target(${TARGET_NAME}_clang FOR_TARGETS ${TARGET_NAME})
 
@@ -32,7 +32,9 @@ if(NOT BUILD_SHARED_LIBS)
     target_compile_definitions(${TARGET_NAME} PUBLIC OPENVINO_STATIC_LIBRARY)
 endif()
 
+# developer package
+
 ov_install_static_lib(${TARGET_NAME} ${OV_CPACK_COMP_CORE})
 
-# developer package
+ov_developer_package_export_targets(TARGET ${TARGET_NAME}
-openvino_developer_export_targets(COMPONENT core TARGETS ${TARGET_NAME})
+                                    INSTALL_INCLUDE_DIRECTORIES "${SHAPE_INFER_INCLUDE_DIR}/")

src/frontends/tests/frontend/shared/CMakeLists.txt

@@ -17,8 +17,10 @@ target_include_directories(${TARGET_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../
 
 target_link_libraries(${TARGET_NAME}
         PUBLIC
-                offline_transformations
+                openvino::offline_transformations
-                common_test_utils func_test_utils openvino::util
+                common_test_utils
+                func_test_utils
+                openvino::util
                 openvino::runtime
         PRIVATE
                 cnpy)

src/inference/CMakeLists.txt

@@ -199,8 +199,8 @@ if(WIN32)
     set_target_properties(${TARGET_NAME}_s PROPERTIES COMPILE_PDB_NAME ${TARGET_NAME}_s)
 endif()
 
-target_link_libraries(${TARGET_NAME}_s PRIVATE openvino::itt ${CMAKE_DL_LIBS} ngraph
+target_link_libraries(${TARGET_NAME}_s PRIVATE openvino::itt ${CMAKE_DL_LIBS}
-    frontend_common::static inference_engine_transformations openvino::pugixml)
+    openvino::runtime::dev openvino::pugixml)
 
 target_compile_definitions(${TARGET_NAME}_s PUBLIC USE_STATIC_IE)
 
@@ -215,7 +215,8 @@ set_target_properties(${TARGET_NAME}_obj
 
 # Export for developer package
 
-openvino_developer_export_targets(COMPONENT core_legacy TARGETS ${TARGET_NAME}_plugin_api)
+ov_developer_package_export_targets(TARGET ${TARGET_NAME}_s)
+ov_developer_package_export_targets(TARGET ${TARGET_NAME}_plugin_api)
 
 # Install static libraries for case BUILD_SHARED_LIBS=OFF
 

src/plugins/auto/tests/functional/CMakeLists.txt

@@ -31,4 +31,4 @@ ov_add_test_target(
 )
 
 target_compile_definitions(${TARGET_NAME} PRIVATE ${COMPILE_DEFINITIONS})
-set_ie_threading_interface_for(${TARGET_NAME})
+ov_set_threading_interface_for(${TARGET_NAME})

src/plugins/intel_gna/tests/deprecated/helpers/single_layer_common.hpp

@@ -20,10 +20,6 @@
 # include <regex>
 # define REPLACE_WITH_STR(SRC, PATTERN, STR) SRC = std::regex_replace(SRC, std::regex(PATTERN), STR)
 # define FIND_STR(SRC, PATTERN) std::regex_search(SRC, std::regex(PATTERN))
-#elif defined USE_BOOST_RE
-# include <boost/regex.hpp>
-# define REPLACE_WITH_STR(SRC, PATTERN, STR) SRC = boost::regex_replace(SRC, boost::regex(PATTERN), STR)
-# define FIND_STR(SRC, PATTERN) boost::regex_search(SRC, boost::regex(PATTERN))
 #else
 # error "Cannot implement regex"
 # define REPLACE_WITH_STR(SRC, PATTERN, STR)

src/plugins/intel_gpu/tests/unit/CMakeLists.txt

@@ -23,14 +23,12 @@ file(GLOB_RECURSE SOURCES_MAIN
   )
 
 if (NOT ENABLE_ONEDNN_FOR_GPU)
-    set(EXCLUDE_DIR "/onednn/")
+    set(EXCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/onednn/")
-    foreach (SOURCE_FILE ${SOURCES_MAIN})
+    foreach (SOURCE_FILE IN LISTS SOURCES_MAIN)
-        string (FIND ${SOURCE_FILE} ${EXCLUDE_DIR} EXCLUDE_DIR_FOUND)
+        if (SOURCE_FILE MATCHES "${EXCLUDE_DIR}.*")
-        if (NOT ${EXCLUDE_DIR_FOUND} EQUAL -1)
-            message (Exclude : ${SOURCE_FILE})
             list (REMOVE_ITEM SOURCES_MAIN ${SOURCE_FILE})
         endif ()
-    endforeach(SOURCE_FILE)
+    endforeach()
 endif()
 
 if (MSVC)

src/plugins/template/CMakeLists.txt

@@ -7,8 +7,6 @@ cmake_minimum_required(VERSION 3.13)
 
 project(OpenVINOTemplatePlugin)
 
-set(TEMPLATE_PLUGIN_SOURCE_DIR ${OpenVINOTemplatePlugin_SOURCE_DIR})
-
 find_package(OpenVINODeveloperPackage REQUIRED)
 
 ov_option(ENABLE_TEMPLATE_REGISTRATION "Enables registration of TEMPLATE plugin" OFF)

src/plugins/template/backend/CMakeLists.txt

@@ -2,12 +2,11 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
-add_definitions(-DIN_OV_COMPONENT)
+set(TARGET_NAME openvino_interpreter_backend)
-ov_deprecated_no_errors()
 
-file(GLOB OPS_SRC 
+add_definitions(-DIN_OV_COMPONENT)
-    "${CMAKE_CURRENT_SOURCE_DIR}/ops/*.cpp"
+
-    )
+file(GLOB OPS_SRC "${CMAKE_CURRENT_SOURCE_DIR}/ops/*.cpp")
 
 set (SRC
     backend.cpp
@@ -24,31 +23,38 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     ov_add_compiler_flags(/wd4018)
 endif()
 
-add_library(interpreter_backend STATIC EXCLUDE_FROM_ALL ${OPS_SRC} ${SRC})
+add_library(${TARGET_NAME} STATIC EXCLUDE_FROM_ALL ${OPS_SRC} ${SRC})
-add_library(openvino::interpreter_backend ALIAS interpreter_backend)
+
+add_library(openvino::interpreter_backend ALIAS ${TARGET_NAME})
+set_target_properties(${TARGET_NAME} PROPERTIES EXPORT_NAME interpreter_backend)
 
 if(CMAKE_COMPILER_IS_GNUCXX)
     ov_add_compiler_flags(-Wno-missing-declarations)
 endif()
 
-ov_build_target_faster(interpreter_backend UNITY)
+ov_build_target_faster(${TARGET_NAME} UNITY)
 
-target_compile_definitions(interpreter_backend
+target_compile_definitions(${TARGET_NAME}
     PRIVATE
         SHARED_LIB_PREFIX="${CMAKE_SHARED_LIBRARY_PREFIX}"
         SHARED_LIB_SUFFIX="${OV_BUILD_POSTFIX}${CMAKE_SHARED_LIBRARY_SUFFIX}"
 )
-target_link_libraries(interpreter_backend PRIVATE openvino::builders openvino::reference openvino::util openvino::runtime::dev openvino::shape_inference)
+target_link_libraries(${TARGET_NAME} PRIVATE openvino::builders openvino::reference openvino::util openvino::runtime::dev openvino::shape_inference)
 
-target_include_directories(interpreter_backend PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/ops/>)
+target_include_directories(${TARGET_NAME} PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+                                                 $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/ops/>
+                                                 $<INSTALL_INTERFACE:developer_package/include/${TARGET_NAME}>)
 
 file(GLOB_RECURSE all_backends_src "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/*.hpp")
-ov_add_clang_format_target(interpreter_backend_clang FOR_SOURCES ${all_backends_src})
+ov_add_clang_format_target(${TARGET_NAME}_clang FOR_SOURCES ${all_backends_src})
 
-# developer package
+# install & export
 
-openvino_developer_export_targets(COMPONENT core TARGETS interpreter_backend)
+ov_install_static_lib(${TARGET_NAME} ${OV_CPACK_COMP_CORE})
 
-# install
+ov_developer_package_export_targets(TARGET openvino::interpreter_backend)
 
-ov_install_static_lib(interpreter_backend ${OV_CPACK_COMP_CORE})
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/"
+        DESTINATION developer_package/include/${TARGET_NAME}
+        COMPONENT developer_package EXCLUDE_FROM_ALL
+        FILES_MATCHING PATTERN "*.hpp")

src/plugins/template/src/CMakeLists.txt

@@ -26,7 +26,7 @@ ov_mark_target_as_cc(${TARGET_NAME})
 
 target_include_directories(${TARGET_NAME} PRIVATE
     "${CMAKE_CURRENT_SOURCE_DIR}"
-    "${TEMPLATE_PLUGIN_SOURCE_DIR}/include")
+    "${OpenVINOTemplatePlugin_SOURCE_DIR}/include")
 
 # link common OpenVINO Runtime libraries
 target_link_libraries(${TARGET_NAME} PRIVATE

src/plugins/template/tests/functional/CMakeLists.txt

@@ -18,7 +18,7 @@ ov_add_test_target(
             openvino::funcSharedTests
             openvino::runtime::dev
         INCLUDES
-            "${TEMPLATE_PLUGIN_SOURCE_DIR}/include"
+            "${OpenVINOTemplatePlugin_SOURCE_DIR}/include"
             "${CMAKE_CURRENT_SOURCE_DIR}/op_reference"
         ADD_CLANG_FORMAT
         LABELS

src/tests/functional/plugin/conformance/subgraphs_dumper/CMakeLists.txt

@@ -18,7 +18,7 @@ ov_add_target(
         ROOT ${CMAKE_CURRENT_SOURCE_DIR}/src
         INCLUDES
             PRIVATE
-                ${CMAKE_CURRENT_SOURCE_DIR}/include
+                "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
         LINK_LIBRARIES
             PRIVATE
                 ${LIBRARIES}
@@ -34,7 +34,7 @@ ov_add_target(
         ROOT "${CMAKE_CURRENT_SOURCE_DIR}/src"
         INCLUDES
             PUBLIC
-                ${CMAKE_CURRENT_SOURCE_DIR}/include
+                "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
         LINK_LIBRARIES
             PUBLIC
                 ${LIBRARIES}
@@ -46,4 +46,4 @@ ov_add_target(
         ADD_CPPLINT
 )
 
-ov_build_target_faster(${TARGET_NAME} UNITY)
+ov_build_target_faster(${TARGET_NAME} UNITY)

src/tests/functional/plugin/conformance/test_runner/conformance_infra/CMakeLists.txt

@@ -14,8 +14,8 @@ ov_add_target(
         ADD_CPPLINT
         INCLUDES
             PUBLIC
-                ${CMAKE_CURRENT_SOURCE_DIR}/include
+                "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
-                ${OpenVINO_SOURCE_DIR}/src/tests/functional/plugin/conformance/subgraphs_dumper_new/include/cache/meta/
+                "$<BUILD_INTERFACE:${OpenVINO_SOURCE_DIR}/src/tests/functional/plugin/conformance/subgraphs_dumper_new/include/cache/meta>"
         LINK_LIBRARIES
             PUBLIC
                 gflags

src/tests/functional/plugin/shared/CMakeLists.txt

@@ -52,13 +52,11 @@ ov_add_target(
         ADDITIONAL_SOURCE_DIRS
             ${CMAKE_CURRENT_SOURCE_DIR}/src
         ADD_CPPLINT
-        DEVELOPER_PACKAGE
-            tests
         EXCLUDED_SOURCE_PATHS ${EXCLUDED_SOURCE_PATHS}
         DEFINES ${DEFINES}
         INCLUDES
             PUBLIC
-                ${PUBLIC_HEADERS_DIR}
+                "$<BUILD_INTERFACE:${PUBLIC_HEADERS_DIR}>"
         LINK_LIBRARIES
             PUBLIC
                 openvino::pugixml
@@ -86,3 +84,8 @@ if (ENABLE_INTEL_CPU)
         "${CMAKE_CURRENT_SOURCE_DIR}/src/behavior/ov_executable_network/get_metric.cpp"
         PROPERTIES COMPILE_DEFINITIONS ENABLE_INTEL_CPU=1)
 endif()
+
+# install & export
+
+ov_developer_package_export_targets(TARGET ${TARGET_NAME}
+                                    INSTALL_INCLUDE_DIRECTORIES "${PUBLIC_HEADERS_DIR}/")

src/tests/functional/shared_test_classes/CMakeLists.txt

@@ -9,11 +9,9 @@ ov_add_target(
         TYPE STATIC
         ROOT "${CMAKE_CURRENT_SOURCE_DIR}/include"
         ADD_CPPLINT
-        DEVELOPER_PACKAGE
-            tests
         INCLUDES
             PUBLIC
-                "${CMAKE_CURRENT_SOURCE_DIR}/include"
+                "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
         ADDITIONAL_SOURCE_DIRS
             ${CMAKE_CURRENT_SOURCE_DIR}/src
         LINK_LIBRARIES
@@ -25,3 +23,8 @@ ov_add_target(
 ov_build_target_faster(${TARGET_NAME}
         PCH PRIVATE "src/precomp.hpp"
         )
+
+# install & export
+
+ov_developer_package_export_targets(TARGET ${TARGET_NAME}
+                                    INSTALL_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/include/")

src/tests/ov_helpers/ov_lpt_models/CMakeLists.txt

@@ -12,7 +12,7 @@ ov_add_target(
         ROOT ${PUBLIC_HEADERS_DIR}
         INCLUDES
             PUBLIC
-                ${PUBLIC_HEADERS_DIR}
+                "$<BUILD_INTERFACE:${PUBLIC_HEADERS_DIR}>"
         ADDITIONAL_SOURCE_DIRS
             ${CMAKE_CURRENT_SOURCE_DIR}/src
         LINK_LIBRARIES
@@ -20,13 +20,14 @@ ov_add_target(
                 ov_models
                 openvino::runtime::dev
         ADD_CPPLINT
-        DEPENDENCIES
-            ov_models
-        DEVELOPER_PACKAGE
-            tests
 )
 
 ov_build_target_faster(${TARGET_NAME}
     UNITY
     PCH PRIVATE "src/precomp.hpp"
 )
+
+# install & export
+
+ov_developer_package_export_targets(TARGET ${TARGET_NAME}
+                                    INSTALL_INCLUDE_DIRECTORIES "${PUBLIC_HEADERS_DIR}/")

src/tests/ov_helpers/ov_models/CMakeLists.txt

@@ -12,22 +12,25 @@ ov_add_target(
         ROOT ${PUBLIC_HEADERS_DIR}
         INCLUDES
             PUBLIC
-                ${PUBLIC_HEADERS_DIR}
+                "$<BUILD_INTERFACE:${PUBLIC_HEADERS_DIR}>"
         ADDITIONAL_SOURCE_DIRS
             ${CMAKE_CURRENT_SOURCE_DIR}/src
         LINK_LIBRARIES
             PUBLIC
                 openvino::runtime
                 openvino::reference
-                interpreter_backend
+                openvino::interpreter_backend
                 openvino::runtime::dev
                 common_test_utils
         ADD_CLANG_FORMAT
-        DEVELOPER_PACKAGE
-            tests
 )
 
 ov_build_target_faster(${TARGET_NAME}
     UNITY
     PCH PRIVATE "src/precomp.hpp"
 )
+
+# install & export
+
+ov_developer_package_export_targets(TARGET ${TARGET_NAME}
+                                    INSTALL_INCLUDE_DIRECTORIES "${PUBLIC_HEADERS_DIR}/")

src/tests/ov_helpers/ov_snippets_models/CMakeLists.txt

@@ -5,8 +5,6 @@
 set(TARGET_NAME ov_snippets_models)
 
 set(PUBLIC_HEADERS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
-set(SNIPPETS_INCLUDES "$<TARGET_PROPERTY:openvino::snippets,SOURCE_DIR>/include")
-set(COMMON_TEST_UTILS_INCLUDES "$<TARGET_PROPERTY:common_test_utils,INTERFACE_INCLUDE_DIRECTORIES>")
 
 ov_add_target(
         NAME ${TARGET_NAME}
@@ -14,11 +12,8 @@ ov_add_target(
         ROOT ${PUBLIC_HEADERS_DIR}
         INCLUDES
             PUBLIC
-                ${PUBLIC_HEADERS_DIR}
+                "$<BUILD_INTERFACE:${PUBLIC_HEADERS_DIR}>"
-                ${COMMON_TEST_UTILS_INCLUDES}
+                "$<BUILD_INTERFACE:${COMMON_TEST_UTILS_INCLUDES}>"
-            PRIVATE
-                ${SNIPPETS_INCLUDES}
-
         ADDITIONAL_SOURCE_DIRS
             ${CMAKE_CURRENT_SOURCE_DIR}/src
         LINK_LIBRARIES
@@ -28,11 +23,14 @@ ov_add_target(
                 openvino::snippets
                 ov_lpt_models
         ADD_CPPLINT
-        DEVELOPER_PACKAGE
-            tests
 )
 
 ov_build_target_faster(${TARGET_NAME}
     UNITY
     PCH PRIVATE "src/precomp.hpp"
 )
+
+# install & export
+
+ov_developer_package_export_targets(TARGET ${TARGET_NAME}
+                                    INSTALL_INCLUDE_DIRECTORIES "${PUBLIC_HEADERS_DIR}/")

src/tests/test_utils/common_test_utils/CMakeLists.txt

@@ -23,8 +23,6 @@ function(add_common_utils ADD_TARGET_NAME)
             EXCLUDED_SOURCE_PATHS
                 ${TARGET_EXCLUDED_SOURCE_PATHS}
             ADD_CLANG_FORMAT
-            DEVELOPER_PACKAGE
-                tests
             LINK_LIBRARIES
                 PUBLIC
                     gtest
@@ -38,12 +36,14 @@ function(add_common_utils ADD_TARGET_NAME)
                     openvino::shape_inference
                 INCLUDES
                     PUBLIC
-                        "${CMAKE_CURRENT_SOURCE_DIR}/include"
+                        "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
                     PRIVATE
                         "${CMAKE_CURRENT_SOURCE_DIR}/src"
-
     )
 
+    ov_developer_package_export_targets(TARGET ${ADD_TARGET_NAME}
+                                        INSTALL_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/include/")
+
     if(ENABLE_CONFORMANCE_PGQL)
         target_compile_definitions(${ADD_TARGET_NAME} PUBLIC ENABLE_CONFORMANCE_PGQL)
     endif()
@@ -58,31 +58,14 @@ function(add_common_utils ADD_TARGET_NAME)
         PCH PRIVATE "src/precomp.hpp"
     )
 
-    # detecting regex support
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9)
-        set(USE_BOOST_RE ON)
-    endif()
-    if (USE_BOOST_RE)
-        target_compile_definitions(${ADD_TARGET_NAME} PUBLIC USE_BOOST_RE)
-
-        debug_message(STATUS "Adding boost dependency")
-        if (CMAKE_VERBOSE_MAKEFILE)
-            set(Boost_DEBUG on)
-        endif ()
-        find_package(Boost REQUIRED COMPONENTS regex)
-        target_link_libraries(${ADD_TARGET_NAME} PUBLIC ${Boost_REGEX_LIBRARY})
-        target_include_directories(${ADD_TARGET_NAME} PUBLIC ${Boost_INCLUDE_DIRS})
-    endif ()
-
     target_include_directories(${ADD_TARGET_NAME}
         PUBLIC
             $<TARGET_PROPERTY:openvino::runtime,INTERFACE_INCLUDE_DIRECTORIES>
         PRIVATE
             $<TARGET_PROPERTY:openvino::runtime::dev,INTERFACE_INCLUDE_DIRECTORIES>)
-    target_include_directories(${ADD_TARGET_NAME} SYSTEM PUBLIC ${OV_TESTS_ROOT}/test_utils)
+    target_include_directories(${ADD_TARGET_NAME} SYSTEM PUBLIC "$<BUILD_INTERFACE:${OV_TESTS_ROOT}/test_utils>")
 
     target_compile_definitions(${ADD_TARGET_NAME} PUBLIC ${ARGN})
-
 endfunction()
 
 # Keep old name so that library can be used from NPU repo

src/tests/test_utils/functional_test_utils/CMakeLists.txt

@@ -9,11 +9,9 @@ ov_add_target(
     TYPE STATIC
     ROOT ${CMAKE_CURRENT_SOURCE_DIR}
     ADD_CLANG_FORMAT
-    DEVELOPER_PACKAGE
-        tests
     INCLUDES
         PUBLIC
-        "${CMAKE_CURRENT_SOURCE_DIR}/include"
+            "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
     ADDITIONAL_SOURCE_DIRS
         ${CMAKE_CURRENT_SOURCE_DIR}/src
     LINK_LIBRARIES
@@ -24,13 +22,17 @@ ov_add_target(
         PRIVATE
             ov_models
             openvino::pugixml
-    INCLUDES
-        PUBLIC
-            $<TARGET_PROPERTY:openvino::runtime::dev,INTERFACE_INCLUDE_DIRECTORIES>
 )
 
-install(DIRECTORY layer_tests_summary DESTINATION tests/functional_test_utils COMPONENT tests EXCLUDE_FROM_ALL)
-
 ov_build_target_faster(${TARGET_NAME}
     PCH PRIVATE "src/precomp.hpp"
 )
+
+# install & export
+
+install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/layer_tests_summary"
+        DESTINATION tests/functional_test_utils
+        COMPONENT tests EXCLUDE_FROM_ALL)
+
+ov_developer_package_export_targets(TARGET ${TARGET_NAME}
+                                    INSTALL_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/include/")

src/tests/test_utils/unit_test_utils/CMakeLists.txt

@@ -15,14 +15,20 @@ ov_add_target(
         TYPE STATIC
         ROOT ${CMAKE_CURRENT_SOURCE_DIR}
         ADD_CLANG_FORMAT
-        DEVELOPER_PACKAGE
-            tests
         LINK_LIBRARIES
             PUBLIC
                 common_test_utils_s
                 inference_engine_s
                 gmock
+        DEPENDENCIES
+            mock_engine
         INCLUDES
             PUBLIC
-                "${CMAKE_CURRENT_SOURCE_DIR}/.."
+                "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..>"
 )
+
+# install & export
+
+ov_developer_package_export_targets(TARGET ${TARGET_NAME}
+                                    INSTALL_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/../unit_test_utils"
+                                    INSTALL_DESTIONATION "developer_package/include/unit_test_utils/unit_test_utils")

thirdparty/dependencies.cmake

@@ -51,9 +51,6 @@ if(X86_64 OR X86 OR UNIVERSAL2)
         # conan creates alias xbyak::xbyak, no extra steps are required
     else()
         add_subdirectory(thirdparty/xbyak EXCLUDE_FROM_ALL)
-        # export and install xbyak
-        openvino_developer_export_targets(COMPONENT openvino_common TARGETS xbyak::xbyak)
-        ov_install_static_lib(xbyak ${OV_CPACK_COMP_CORE})
     endif()
 endif()
 
@@ -269,12 +266,32 @@ if(NOT TARGET openvino::pugixml)
     function(ov_build_pugixml)
         function(ov_build_pugixml_static)
             set(BUILD_SHARED_LIBS OFF)
+            function(install)
+                cmake_parse_arguments(_install "" "EXPORT" "" ${ARGV})
+                if(_install_EXPORT STREQUAL "pugixml-targets")
+                    # does nothing!
+                    # we need to override 'export' command to prevent cmake issue with multiple
+                    # export sets for pugixml-target. Currently, it's installed only by OpenVINO
+                else()
+                    _install(${ARGV})
+                endif()
+            endfunction()
+            function(export)
+                cmake_parse_arguments(_export "" "EXPORT" "" ${ARGV})
+                if(_export_EXPORT STREQUAL "pugixml-targets")
+                    # does nothing!
+                    # we need to override 'export' command to prevent cmake issue with multiple
+                    # export sets for pugixml-target. Currently, it's installed only by OpenVINO
+                else()
+                    _export(${ARGV})
+                endif()
+            endfunction()
             add_subdirectory(thirdparty/pugixml EXCLUDE_FROM_ALL)
         endfunction()
         ov_build_pugixml_static()
         set_property(TARGET pugixml-static PROPERTY EXPORT_NAME pugixml)
         add_library(openvino::pugixml ALIAS pugixml-static)
-        openvino_developer_export_targets(COMPONENT openvino_common TARGETS openvino::pugixml)
+        ov_developer_package_export_targets(TARGET openvino::pugixml)
         ov_install_static_lib(pugixml-static ${OV_CPACK_COMP_CORE})
     endfunction()
 
@@ -300,7 +317,7 @@ if(ENABLE_GAPI_PREPROCESSING)
         add_subdirectory(thirdparty/ade EXCLUDE_FROM_ALL)
 
         set_target_properties(ade PROPERTIES FOLDER thirdparty)
-        openvino_developer_export_targets(COMPONENT openvino_common TARGETS ade)
+        ov_developer_package_export_targets(TARGET ade)
 
         ov_install_static_lib(ade ${OV_CPACK_COMP_CORE})
     endif()
@@ -316,7 +333,7 @@ if(ENABLE_GAPI_PREPROCESSING)
     endif()
 
     set_target_properties(fluid PROPERTIES FOLDER thirdparty)
-    openvino_developer_export_targets(COMPONENT openvino_common TARGETS fluid)
+    ov_developer_package_export_targets(TARGET fluid)
 
     ov_install_static_lib(fluid ${OV_CPACK_COMP_CORE})
 endif()
@@ -369,7 +386,7 @@ if(ENABLE_SAMPLES OR ENABLE_TESTS)
 
     if(NOT TARGET gflags)
         add_subdirectory(thirdparty/gflags EXCLUDE_FROM_ALL)
-        openvino_developer_export_targets(COMPONENT openvino_common TARGETS gflags)
+        ov_developer_package_export_targets(TARGET gflags)
     endif()
 endif()
 
@@ -391,8 +408,14 @@ if(ENABLE_TESTS)
         endforeach()
     else()
         add_subdirectory(thirdparty/gtest EXCLUDE_FROM_ALL)
-        openvino_developer_export_targets(COMPONENT tests
+        # install & export
-                                          TARGETS gmock gmock_main gtest gtest_main)
+        set(googletest_root "${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/gtest/gtest")
+        ov_developer_package_export_targets(TARGET gtest_main
+                                            INSTALL_INCLUDE_DIRECTORIES "${googletest_root}/googletest/include/")
+        ov_developer_package_export_targets(TARGET gtest
+                                            INSTALL_INCLUDE_DIRECTORIES "${googletest_root}/googletest/include/")
+        ov_developer_package_export_targets(TARGET gmock
+                                            INSTALL_INCLUDE_DIRECTORIES "${googletest_root}/googlemock/include/")
     endif()
 endif()
 
@@ -585,8 +608,9 @@ if(ENABLE_SAMPLES)
     else()
         add_subdirectory(thirdparty/json EXCLUDE_FROM_ALL)
 
-        # this is required only because of NPU plugin reused this
+        # this is required only because of NPU plugin reused this: export & install
-        openvino_developer_export_targets(COMPONENT openvino_common TARGETS nlohmann_json)
+        ov_developer_package_export_targets(TARGET nlohmann_json
+                                            INSTALL_INCLUDE_DIRECTORIES "${OpenVINO_SOURCE_DIR}/thirdparty/json/nlohmann_json/include")
 
         # for nlohmann library versions older than v3.0.0
         if(NOT TARGET nlohmann_json::nlohmann_json)

thirdparty/gtest/CMakeLists.txt

@@ -14,16 +14,31 @@ set(INSTALL_GTEST OFF CACHE BOOL "" FORCE)
 
 add_subdirectory(gtest EXCLUDE_FROM_ALL)
 
-get_target_property(gtest_include_dirs gtest INTERFACE_INCLUDE_DIRECTORIES)
+function(_ov_gtest_filter_install_interface TARGET TYPE)
-set_target_properties(gtest PROPERTIES INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${gtest_include_dirs}")
+    set(final_include_dirs "$<INSTALL_INTERFACE:developer_package/include/${TYPE}>")
 
-get_target_property(gmock_include_dirs gtest INTERFACE_INCLUDE_DIRECTORIES)
+    get_target_property(include_dirs ${TARGET} INTERFACE_INCLUDE_DIRECTORIES)
-set_target_properties(gmock PROPERTIES INTERFACE_SYSTEM_INCLUDE_DIRECTORIES
+    foreach(include_dir IN LISTS include_dirs)
-    "${gmock_include_dirs};${gmock_SOURCE_DIR}/include")
+        if(NOT include_dir MATCHES ".*INSTALL_INTERFACE.*")
+            # remove leading and trailing parts of generator expressions
+            string(REPLACE "$<BUILD_INTERFACE:" "" include_dir "${include_dir}")
+            string(REPLACE ">" "" include_dir "${include_dir}")
+            # wrap to BUILD_INTERFACE again
+            list(APPEND final_include_dirs "$<BUILD_INTERFACE:${include_dir}>")
+        endif()
+    endforeach()
 
-set(gtest_targets gtest gtest_main gmock gmock_main)
+    set_target_properties(${TARGET} PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES "${final_include_dirs}"
+        INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${final_include_dirs}")
+endfunction()
 
-foreach(target IN LISTS gtest_targets)
+_ov_gtest_filter_install_interface(gtest gtest)
+_ov_gtest_filter_install_interface(gtest_main gtest)
+_ov_gtest_filter_install_interface(gmock gmock)
+_ov_gtest_filter_install_interface(gmock_main gmock)
+
+foreach(target gtest gtest_main gmock gmock_main)
     # If we have specified /Z7 option, remove -Zi option which comes from gtest
     if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
         get_target_property(_target_cxx_flags ${target} COMPILE_OPTIONS)
@@ -41,8 +56,7 @@ foreach(target IN LISTS gtest_targets)
             target_compile_options(${target} PRIVATE -Wno-deprecated-copy)
         endif()
     endif()
+    # disable warnings
     ov_disable_all_warnings(${target})
+    set_target_properties(${target} PROPERTIES FOLDER thirdparty)
 endforeach()
-
-set_target_properties(${gtest_targets}
-                      PROPERTIES FOLDER thirdparty)

thirdparty/ittapi/CMakeLists.txt

@@ -4,8 +4,8 @@
 
 if(DEFINED INTEL_VTUNE_DIR OR DEFINED ENV{INTEL_VTUNE_DIR})
     find_package(ITT
-                    PATHS "${OpenVINO_SOURCE_DIR}/src/common/itt/cmake"
+                 PATHS "${OpenVINO_SOURCE_DIR}/src/common/itt/cmake"
-                    NO_DEFAULT_PATH)
+                 NO_DEFAULT_PATH)
     if(NOT ITT_FOUND)
         message(WARNING "Profiling option enabled, but no ITT library was found under INTEL_VTUNE_DIR")
     endif()
@@ -25,6 +25,6 @@ else()
     # create alias ittapi::ittnotify
     add_library(ittapi::ittnotify ALIAS ittnotify)
 
-    openvino_developer_export_targets(COMPONENT openvino_common TARGETS ittapi::ittnotify)
+    ov_developer_package_export_targets(TARGET ittapi::ittnotify)
     ov_install_static_lib(ittnotify ${OV_CPACK_COMP_CORE})
 endif()