IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master' into add_mxnet_operations

Browse Source
This commit is contained in:
yekruglov 2021-12-17 12:09:59 +03:00
commit 74df3b3970
262 changed files with 2297 additions and 1619 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.ci/azure/windows.yml
View File

@ -83,7 +83,7 @@ jobs:
displayName: 'Make dir' displayName: 'Make dir'
- script: | - script: |
certutil -urlcache -split -f https://openvinoweb.z5.web.core.windows.net/incredibuild/install_ib_console.bat install_ib_console.bat curl -O https://openvinoweb.z5.web.core.windows.net/incredibuild/install_ib_console.bat
call install_ib_console.bat call install_ib_console.bat
workingDirectory: $(WORK_DIR) workingDirectory: $(WORK_DIR)
displayName: 'Install IncrediBuild' displayName: 'Install IncrediBuild'
@ -117,9 +117,9 @@ jobs:
python -m pip install -r $(REPO_DIR)\tools\mo\requirements.txt python -m pip install -r $(REPO_DIR)\tools\mo\requirements.txt
python -m pip install -r $(REPO_DIR)\tools\mo\requirements_dev.txt python -m pip install -r $(REPO_DIR)\tools\mo\requirements_dev.txt
rem Speed up build rem Speed up build
certutil -urlcache -split -f https://github.com/Kitware/CMake/releases/download/v$(CMAKE_VERSION)/cmake-$(CMAKE_VERSION)-windows-x86_64.zip cmake-$(CMAKE_VERSION)-windows-x86_64.zip powershell -command "Invoke-WebRequest https://github.com/Kitware/CMake/releases/download/v$(CMAKE_VERSION)/cmake-$(CMAKE_VERSION)-windows-x86_64.zip -OutFile cmake-$(CMAKE_VERSION)-windows-x86_64.zip"
powershell -command "Expand-Archive -Force cmake-$(CMAKE_VERSION)-windows-x86_64.zip" powershell -command "Expand-Archive -Force cmake-$(CMAKE_VERSION)-windows-x86_64.zip"
certutil -urlcache -split -f https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-win.zip ninja-win.zip powershell -command "Invoke-WebRequest https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-win.zip -OutFile ninja-win.zip"
powershell -command "Expand-Archive -Force ninja-win.zip" powershell -command "Expand-Archive -Force ninja-win.zip"
git clone https://github.com/google/gtest-parallel.git git clone https://github.com/google/gtest-parallel.git
workingDirectory: $(WORK_DIR) workingDirectory: $(WORK_DIR)

2
.ci/azure/windows_conditional_compilation.yml
View File

@ -59,7 +59,7 @@ jobs:
- script: | - script: |
rem Speed up build rem Speed up build
certutil -urlcache -split -f https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-win.zip ninja-win.zip powershell -command "Invoke-WebRequest https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-win.zip -OutFile ninja-win.zip"
powershell -command "Expand-Archive -Force ninja-win.zip" powershell -command "Expand-Archive -Force ninja-win.zip"
workingDirectory: $(WORK_DIR) workingDirectory: $(WORK_DIR)
displayName: 'Install dependencies' displayName: 'Install dependencies'

4
cmake/developer_package/frontends/frontends.cmake
View File

@ -2,7 +2,7 @@
# SPDX-License-Identifier: Apache-2.0 # SPDX-License-Identifier: Apache-2.0
# #
set(FRONTEND_INSTALL_INCLUDE "runtime/include/ngraph/frontend") set(FRONTEND_INSTALL_INCLUDE "runtime/include/")
set(FRONTEND_NAME_SUFFIX "_ov_frontend") set(FRONTEND_NAME_SUFFIX "_ov_frontend")
set(FRONTEND_NAMES "" CACHE INTERNAL "") set(FRONTEND_NAMES "" CACHE INTERNAL "")
@ -225,7 +225,7 @@ macro(ov_add_frontend)
if(OV_FRONTEND_LINKABLE_FRONTEND) if(OV_FRONTEND_LINKABLE_FRONTEND)
# install -dev part # install -dev part
install(DIRECTORY ${${TARGET_NAME}_INCLUDE_DIR}/${OV_FRONTEND_NAME}_frontend install(DIRECTORY ${${TARGET_NAME}_INCLUDE_DIR}/
DESTINATION ${FRONTEND_INSTALL_INCLUDE} DESTINATION ${FRONTEND_INSTALL_INCLUDE}
COMPONENT core_dev COMPONENT core_dev
FILES_MATCHING PATTERN "*.hpp") FILES_MATCHING PATTERN "*.hpp")

2
cmake/developer_package/frontends/ov_frontends.hpp.in
View File

@ -4,7 +4,7 @@
#pragma once #pragma once
#include "common/frontend.hpp" #include "openvino/frontend/frontend.hpp"
@OV_FRONTEND_DECLARATIONS@ @OV_FRONTEND_DECLARATIONS@

15
inference-engine/ie_bridges/python/wheel/.env.in
View File

@ -1,15 +0,0 @@
WHEEL_PACKAGE_NAME=@WHEEL_PACKAGE_NAME@
WHEEL_VERSION=@WHEEL_VERSION@
WHEEL_BUILD=@WHEEL_BUILD@
WHEEL_LICENCE_TYPE=@WHEEL_LICENCE_TYPE@
WHEEL_AUTHOR=@WHEEL_AUTHOR@
WHEEL_AUTHOR_EMAIL=@WHEEL_AUTHOR_EMAIL@
WHEEL_DESC=@WHEEL_DESC@
WHEEL_LICENSE=@WHEEL_LICENSE@
WHEEL_REQUIREMENTS=@WHEEL_REQUIREMENTS@
WHEEL_OVERVIEW=@WHEEL_OVERVIEW@
CMAKE_BUILD_DIR=@CMAKE_BINARY_DIR@
OV_RUNTIME_LIBS_DIR=@IE_CPACK_RUNTIME_PATH@
TBB_LIBS_DIR=@TBB_LIBS_DIR@
PY_PACKAGES_DIR=@PY_PACKAGES_DIR@

43
inference-engine/ie_bridges/python/wheel/CMakeLists.txt
View File

@ -1,40 +1,14 @@
# Copyright (C) 2018-2021 Intel Corporation # Copyright (C) 2018-2021 Intel Corporation
# SPDX-License-Identifier: Apache-2.0 # SPDX-License-Identifier: Apache-2.0
# #
set(WHEEL_PACKAGE_NAME "openvino" CACHE STRING "Name of the package")
set(WHEEL_LICENCE_TYPE "OSI Approved :: Apache Software License" CACHE STRING "License type for the package")
set(WHEEL_AUTHOR "Intel Corporation" CACHE STRING "Package author’s name")
set(WHEEL_AUTHOR_EMAIL "openvino_pushbot@intel.com" CACHE STRING "Email address of the package author")
set(WHEEL_DESC "Inference Engine Python* API" CACHE STRING "Short, summary description of the package")
set(WHEEL_URL "https://docs.openvinotoolkit.org/latest/index.html" CACHE STRING "Home page url")
set(WHEEL_DOWNLOAD_URL "https://github.com/openvinotoolkit/openvino/tags" CACHE STRING "Download page url")
set(WHEEL_VERSION "${IE_VERSION}" CACHE STRING "Version of this release" FORCE) set(WHEEL_VERSION "${IE_VERSION}" CACHE STRING "Version of this release" FORCE)
set(WHEEL_BUILD "${IE_VERSION_BUILD}" CACHE STRING "Build number of this release" FORCE) set(WHEEL_BUILD "${IE_VERSION_BUILD}" CACHE STRING "Build number of this release" FORCE)
set(WHEEL_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE" CACHE STRING "Wheel license file")
set(WHEEL_REQUIREMENTS "${CMAKE_CURRENT_SOURCE_DIR}/meta/openvino.requirements.txt" CACHE STRING "Wheel requirements.txt file")
set(WHEEL_OVERVIEW "${CMAKE_CURRENT_SOURCE_DIR}/meta/pypi_overview.md" CACHE STRING "Detailed description")
set(SETUP_PY "${CMAKE_CURRENT_SOURCE_DIR}/setup.py")
set(SETUP_ENV "${CMAKE_CURRENT_SOURCE_DIR}/.env.in")
set(SETUP_ENV_OUT "${CMAKE_CURRENT_SOURCE_DIR}/.env")
set(PY_PACKAGES_DIR ${PYTHON_BRIDGE_CPACK_PATH}/${PYTHON_VERSION}) set(PY_PACKAGES_DIR ${PYTHON_BRIDGE_CPACK_PATH}/${PYTHON_VERSION})
set(TBB_LIBS_DIR runtime/3rdparty/tbb/lib) set(TBB_LIBS_DIR runtime/3rdparty/tbb/lib)
if(WIN32)
if(APPLE)
set(WHEEL_PLATFORM macosx_10_15_x86_64)
elseif(UNIX)
set(WHEEL_PLATFORM manylinux2014_x86_64)
elseif(WIN32)
set(WHEEL_PLATFORM win_amd64)
set(TBB_LIBS_DIR runtime/3rdparty/tbb/bin) set(TBB_LIBS_DIR runtime/3rdparty/tbb/bin)
else()
message(FATAL_ERROR "This platform is not supported")
endif() endif()
configure_file(${SETUP_ENV} ${SETUP_ENV_OUT} @ONLY)
if(LINUX) if(LINUX)
find_host_program(patchelf_program find_host_program(patchelf_program
NAMES patchelf NAMES patchelf
@ -55,21 +29,30 @@ endforeach()
execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import wheel.bdist_wheel ; print(f'{wheel.bdist_wheel.get_abi_tag()}')" OUTPUT_VARIABLE PYTHON_ABI) execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import wheel.bdist_wheel ; print(f'{wheel.bdist_wheel.get_abi_tag()}')" OUTPUT_VARIABLE PYTHON_ABI)
execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import wheel.vendored.packaging.tags as tags ; print(f'{tags.interpreter_name()}{tags.interpreter_version()}')" OUTPUT_VARIABLE INTERPRETER) execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import wheel.vendored.packaging.tags as tags ; print(f'{tags.interpreter_name()}{tags.interpreter_version()}')" OUTPUT_VARIABLE INTERPRETER)
execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import wheel.vendored.packaging.tags as tags ; print(f'{next(tags._platform_tags())}')" OUTPUT_VARIABLE WHEEL_PLATFORM)
string(STRIP ${PYTHON_ABI} PYTHON_ABI) string(STRIP ${PYTHON_ABI} PYTHON_ABI)
string(STRIP ${INTERPRETER} INTERPRETER) string(STRIP ${INTERPRETER} INTERPRETER)
string(STRIP ${WHEEL_PLATFORM} WHEEL_PLATFORM)
set(openvino_wheel_name "openvino-${WHEEL_VERSION}-${WHEEL_BUILD}-${INTERPRETER}-${PYTHON_ABI}-${WHEEL_PLATFORM}.whl") set(openvino_wheel_name "openvino-${WHEEL_VERSION}-${WHEEL_BUILD}-${INTERPRETER}-${PYTHON_ABI}-${WHEEL_PLATFORM}.whl")
set(openvino_wheels_output_dir "${CMAKE_BINARY_DIR}/wheels") set(openvino_wheels_output_dir "${CMAKE_BINARY_DIR}/wheels")
set(openvino_wheel_path "${openvino_wheels_output_dir}/${openvino_wheel_name}") set(openvino_wheel_path "${openvino_wheels_output_dir}/${openvino_wheel_name}")
add_custom_command(OUTPUT ${openvino_wheel_path} add_custom_command(OUTPUT ${openvino_wheel_path}
COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}"
COMMAND ${CMAKE_COMMAND} -E copy_directory "${CMAKE_SOURCE_DIR}/licensing" "${CMAKE_BINARY_DIR}/licensing"
COMMAND ${CMAKE_COMMAND} -E remove_directory "${CMAKE_CURRENT_BINARY_DIR}/site-packages" COMMAND ${CMAKE_COMMAND} -E remove_directory "${CMAKE_CURRENT_BINARY_DIR}/site-packages"
COMMAND ${PYTHON_EXECUTABLE} ${SETUP_PY} clean bdist_wheel COMMAND ${CMAKE_COMMAND} -E env WHEEL_VERSION=${WHEEL_VERSION}
WHEEL_BUILD=${WHEEL_BUILD}
CMAKE_BUILD_DIR=${CMAKE_BINARY_DIR}
OV_RUNTIME_LIBS_DIR=${IE_CPACK_RUNTIME_PATH}
TBB_LIBS_DIR=${TBB_LIBS_DIR}
PY_PACKAGES_DIR=${PY_PACKAGES_DIR}
${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/setup.py" clean bdist_wheel
--dist-dir ${openvino_wheels_output_dir} --dist-dir ${openvino_wheels_output_dir}
--build=${WHEEL_BUILD} --build=${WHEEL_BUILD}
--plat-name=${WHEEL_PLATFORM} --plat-name=${WHEEL_PLATFORM}
# COMMAND ${CMAKE_COMMAND} -E remove ${SETUP_ENV_OUT} DEPENDS ${openvino_wheel_deps}
DEPENDS ${openvino_wheel_deps} ${SETUP_ENV_OUT}
WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}" WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
COMMENT "Building Python wheel ${openvino_wheel_name}" COMMENT "Building Python wheel ${openvino_wheel_name}"
VERBATIM) VERBATIM)

28
inference-engine/ie_bridges/python/wheel/meta/openvino-dev.requirements.txt
View File

@ -1,28 +0,0 @@
defusedxml>=0.7.1
scipy~=1.5.4
jstyleson~=0.0.2
numpy>=1.16.6,<1.20
addict>=2.4.0
pandas~=1.1.5
hyperopt~=0.1.2
networkx~=2.5
tqdm>=4.54.1
texttable~=1.6.3
py-cpuinfo>=7.0.0
PyYAML>=5.4.1
pillow>=8.1.2
scikit-image>=0.17.2
scikit-learn>=0.24.1
yamlloader>=0.5
shapely>=1.7.1
nibabel>=3.2.1
pydicom>=2.1.2
sentencepiece>=0.1.95
tokenizers>=0.10.1
editdistance>=0.5.3
parasail>=1.2.4
fast-ctc-decode>=0.2.5
rawpy>=0.16.0
nltk>=3.5
opencv-python==4.5.*
progress>=1.5

22
inference-engine/ie_bridges/python/wheel/meta/openvino-dev.setup.cfg
View File

@ -1,22 +0,0 @@
[options]
py_modules =
mo
mo_tf
mo_caffe
mo_mxnet
mo_onnx
mo_kaldi
[options.package_data]
* = *
[options.entry_points]
console_scripts =
[metadata]
license_files =
readme*
*LICENSE*
*license*
*third-party-programs*
*EULA*

1
inference-engine/ie_bridges/python/wheel/meta/openvino.requirements.txt
View File

@ -1 +0,0 @@
numpy>=1.16.6,<1.20

32
inference-engine/ie_bridges/python/wheel/meta/pypi_overview.md
View File

@ -1,32 +0,0 @@
## OpenVINO™ Toolkit
OpenVINO™ toolkit quickly deploys applications and solutions that emulate human vision. Based on Convolutional Neural Networks (CNNs), the toolkit extends computer vision (CV) workloads across Intel® hardware, maximizing performance. The OpenVINO™ toolkit includes the Deep Learning Deployment Toolkit (DLDT).
OpenVINO™ toolkit:
- Enables CNN-based deep learning inference on the edge
- Supports heterogeneous execution across an Intel® CPU, Intel® Integrated Graphics, Intel® Neural Compute Stick 2, and Intel® Vision Accelerator Design with Intel® Movidius™ VPUs
- Speeds time-to-market via an easy-to-use library of computer vision functions and pre-optimized kernels
- Includes optimized calls for computer vision standards, including OpenCV\* and OpenCL™
Operating Systems:
- Ubuntu* 18.04 long-term support (LTS), 64-bit
- Windows* 10, 64-bit
- macOS* 10.15, 64-bit
## Install the Runtime Package Using the PyPI Repository
1. Set up and update pip to the highest version:
```sh
python3 -m pip install --upgrade pip
```
2. Install the Intel® distribution of OpenVINO™ toolkit:
```sh
pip install openvino
```
3. Verify that the package is installed:
```sh
python3 -c "from openvino.inference_engine import IECore"
```
Now you are ready to develop and run your application.

2
inference-engine/ie_bridges/python/wheel/requirements-dev.txt
View File

@ -1,3 +1,3 @@
setuptools>=53.0.0 setuptools>=53.0.0
wheel>=0.36.2 wheel>=0.36.2
python-decouple>=3.4

14
inference-engine/ie_bridges/python/wheel/setup.cfg
View File

@ -1,7 +1,11 @@
[metadata] [metadata]
license_files = license_files =
readme* readme*
*LICENSE* *LICENSE*
*license* *license*
*third-party-programs* *third-party-programs*
*EULA* ../../../../licensing/runtime-third-party-programs.txt
../../../../licensing/tbb_third-party-programs.txt
../../../../licensing/onednn_third-party-programs.txt
../../../../LICENSE

34
inference-engine/ie_bridges/python/wheel/setup.py
View File

@ -21,7 +21,6 @@ from setuptools import setup, find_namespace_packages, Extension
from setuptools.command.build_ext import build_ext from setuptools.command.build_ext import build_ext
from setuptools.command.build_clib import build_clib from setuptools.command.build_clib import build_clib
from setuptools.command.install import install from setuptools.command.install import install
from decouple import config
WHEEL_LIBS_INSTALL_DIR = os.path.join('openvino', 'libs') WHEEL_LIBS_INSTALL_DIR = os.path.join('openvino', 'libs')
WHEEL_LIBS_PACKAGE = 'openvino.libs' WHEEL_LIBS_PACKAGE = 'openvino.libs'
@ -41,10 +40,11 @@ elif machine == 'aarch64':
ARCH = 'arm64' ARCH = 'arm64'
# The following variables can be defined in environment or .env file # The following variables can be defined in environment or .env file
CMAKE_BUILD_DIR = config('CMAKE_BUILD_DIR', '.') SCRIPT_DIR = Path(__file__).resolve().parents[0]
OV_RUNTIME_LIBS_DIR = config('OV_RUNTIME_LIBS_DIR', f'runtime/{LIBS_DIR}/{ARCH}/{CONFIG}') CMAKE_BUILD_DIR = os.getenv('CMAKE_BUILD_DIR', '.')
TBB_LIBS_DIR = config('TBB_LIBS_DIR', f'runtime/3rdparty/tbb/{LIBS_DIR}') OV_RUNTIME_LIBS_DIR = os.getenv('OV_RUNTIME_LIBS_DIR', f'runtime/{LIBS_DIR}/{ARCH}/{CONFIG}')
PY_PACKAGES_DIR = config('PY_PACKAGES_DIR', f'python/{PYTHON_VERSION}') TBB_LIBS_DIR = os.getenv('TBB_LIBS_DIR', f'runtime/3rdparty/tbb/{LIBS_DIR}')
PY_PACKAGES_DIR = os.getenv('PY_PACKAGES_DIR', f'python/{PYTHON_VERSION}')
LIBS_RPATH = '$ORIGIN' if sys.platform == 'linux' else '@loader_path' LIBS_RPATH = '$ORIGIN' if sys.platform == 'linux' else '@loader_path'
LIB_INSTALL_CFG = { LIB_INSTALL_CFG = {
@ -428,28 +428,28 @@ if not any(pl in sys.platform for pl in platforms):
sys.exit(f'Unsupported platform: {sys.platform}, expected: linux, win32, darwin') sys.exit(f'Unsupported platform: {sys.platform}, expected: linux, win32, darwin')
# copy license file into the build directory # copy license file into the build directory
package_license = config('WHEEL_LICENSE', '') package_license = os.getenv('WHEEL_LICENSE', SCRIPT_DIR.parents[3] / 'LICENSE')
if os.path.exists(package_license): if os.path.exists(package_license):
copyfile(package_license, 'LICENSE') copyfile(package_license, 'LICENSE')
packages = find_namespace_packages(get_package_dir(PY_INSTALL_CFG)) packages = find_namespace_packages(get_package_dir(PY_INSTALL_CFG))
package_data: typing.Dict[str, list] = {} package_data: typing.Dict[str, list] = {}
pkg_name = config('WHEEL_PACKAGE_NAME', 'openvino') pkg_name = os.getenv('WHEEL_PACKAGE_NAME', 'openvino')
ext_modules = find_prebuilt_extensions(get_dir_list(PY_INSTALL_CFG)) if pkg_name == 'openvino' else [] ext_modules = find_prebuilt_extensions(get_dir_list(PY_INSTALL_CFG)) if pkg_name == 'openvino' else []
setup( setup(
version=config('WHEEL_VERSION', '0.0.0'), version=os.getenv('WHEEL_VERSION', '0.0.0'),
build=config('WHEEL_BUILD', '000'), build=os.getenv('WHEEL_BUILD', '000'),
author_email=config('WHEEL_AUTHOR_EMAIL', 'openvino_pushbot@intel.com'), author_email=os.getenv('WHEEL_AUTHOR_EMAIL', 'openvino_pushbot@intel.com'),
name=pkg_name, name=pkg_name,
license=config('WHEEL_LICENCE_TYPE', 'OSI Approved :: Apache Software License'), license=os.getenv('WHEEL_LICENCE_TYPE', 'OSI Approved :: Apache Software License'),
author=config('WHEEL_AUTHOR', 'Intel Corporation'), author=os.getenv('WHEEL_AUTHOR', 'Intel(R) Corporation'),
description=config('WHEEL_DESC', 'Inference Engine Python* API'), description=os.getenv('WHEEL_DESC', 'OpenVINO(TM) Runtime'),
install_requires=get_dependencies(config('WHEEL_REQUIREMENTS', 'meta/openvino.requirements.txt')), install_requires=get_dependencies(os.getenv('WHEEL_REQUIREMENTS', SCRIPT_DIR.parents[0] / 'requirements.txt')),
long_description=get_description(config('WHEEL_OVERVIEW', 'meta/pypi_overview.md')), long_description=get_description(os.getenv('WHEEL_OVERVIEW', SCRIPT_DIR.parents[3] / 'docs/install_guides/pypi-openvino-rt.md')),
long_description_content_type='text/markdown', long_description_content_type='text/markdown',
download_url=config('WHEEL_DOWNLOAD_URL', 'https://github.com/openvinotoolkit/openvino/tags'), download_url=os.getenv('WHEEL_DOWNLOAD_URL', 'https://github.com/openvinotoolkit/openvino/tags'),
url=config('WHEEL_URL', 'https://docs.openvinotoolkit.org/latest/index.html'), url=os.getenv('WHEEL_URL', 'https://docs.openvinotoolkit.org/latest/index.html'),
cmdclass={ cmdclass={
'build': CustomBuild, 'build': CustomBuild,
'install': CustomInstall, 'install': CustomInstall,

10
inference-engine/src/mkldnn_plugin/cpu_shape.h
View File

@ -25,6 +25,8 @@ public:
type = shape.is_static() ? ShapeType::Static : ShapeType::Dynamic; type = shape.is_static() ? ShapeType::Static : ShapeType::Dynamic;
initDims(); initDims();
hasZeroDimensions = std::any_of(dims.begin(), dims.end(), [](size_t dim) { return dim == 0; } );
} }
explicit Shape(const InferenceEngine::SizeVector& shape) { explicit Shape(const InferenceEngine::SizeVector& shape) {
@ -33,6 +35,8 @@ public:
type = ShapeType::Static; type = ShapeType::Static;
initDims(); initDims();
hasZeroDimensions = std::any_of(dims.begin(), dims.end(), [](size_t dim) { return dim == 0; } );
} }
/** /**
@ -106,6 +110,10 @@ public:
return type == ShapeType::Dynamic; return type == ShapeType::Dynamic;
} }
bool hasZeroDims() const {
return hasZeroDimensions;
}
size_t getRank() const { size_t getRank() const {
return minDims.size(); return minDims.size();
} }
@ -169,6 +177,8 @@ private:
Dynamic Dynamic
} type {ShapeType::Static}; } type {ShapeType::Static};
bool hasZeroDimensions = false;
VectorDims minDims; VectorDims minDims;
VectorDims maxDims; VectorDims maxDims;
VectorDims dims; VectorDims dims;

50
inference-engine/src/mkldnn_plugin/memory_desc/cpu_blocked_memory_desc.cpp
View File

@ -16,7 +16,8 @@ CpuBlockedMemoryDesc::CpuBlockedMemoryDesc(InferenceEngine::Precision prc, const
offsetPadding = 0; offsetPadding = 0;
offsetPaddingToData.resize(dims.size(), 0); offsetPaddingToData.resize(dims.size(), 0);
strides.resize(order.size()); strides.resize(order.size());
strides[strides.size() - 1] = 1; // for empty tensor case we fill all strides with 0 values
strides[strides.size() - 1] = shape.hasZeroDims() ? 0 : 1;
for (size_t i = 2; i <= order.size(); i++) { for (size_t i = 2; i <= order.size(); i++) {
strides[strides.size() - i] = strides[strides.size() - (i - 1)] * blockedDims[blockedDims.size() - (i - 1)]; strides[strides.size() - i] = strides[strides.size() - (i - 1)] * blockedDims[blockedDims.size() - (i - 1)];
} }
@ -33,6 +34,15 @@ CpuBlockedMemoryDesc::CpuBlockedMemoryDesc(InferenceEngine::Precision prc, const
IE_THROW() << "CpuBlockedMemoryDesc doesn't support undefined blockedDims."; IE_THROW() << "CpuBlockedMemoryDesc doesn't support undefined blockedDims.";
} }
if (shape.hasZeroDims()) {
const auto& dims = shape.getDims();
for (size_t i = 0; i < shape.getRank(); i++) {
if (dims[order[i]] == 0 && !dimsEqualWeak(blockedDims[i], 0)) {
IE_THROW() << "Can't create CpuBlockedMemoryDesc. Mistmatch zero dims in dims and blocked dims";
}
}
}
this->order = order; this->order = order;
this->blockedDims = blockedDims; this->blockedDims = blockedDims;
this->offsetPadding = offsetPadding; this->offsetPadding = offsetPadding;
@ -44,7 +54,9 @@ CpuBlockedMemoryDesc::CpuBlockedMemoryDesc(InferenceEngine::Precision prc, const
} }
if (strides.empty() && !order.empty()) { if (strides.empty() && !order.empty()) {
if (std::any_of(this->blockedDims.begin(), this->blockedDims.end(), [](size_t val) { return val == Shape::UNDEFINED_DIM; })) { if (shape.hasZeroDims()) {
this->strides.resize(order.size(), 0);
} else if (std::any_of(this->blockedDims.begin(), this->blockedDims.end(), [](size_t val) { return val == Shape::UNDEFINED_DIM; })) {
this->strides.resize(order.size(), Shape::UNDEFINED_DIM); this->strides.resize(order.size(), Shape::UNDEFINED_DIM);
} else { } else {
this->strides.resize(order.size()); this->strides.resize(order.size());
@ -54,6 +66,9 @@ CpuBlockedMemoryDesc::CpuBlockedMemoryDesc(InferenceEngine::Precision prc, const
} }
} }
} else { } else {
if (shape.hasZeroDims() && std::any_of(strides.begin(), strides.end(), [](size_t stride) { return stride != 0; } )) {
IE_THROW() << "Can't create CpuBlockedMemoryDesc with zero dim, but with non zero strides";
}
this->strides = strides; this->strides = strides;
} }
@ -92,11 +107,16 @@ bool CpuBlockedMemoryDesc::isCompatible(const DnnlBlockedMemoryDesc &rhs) const
return rhs.isCompatible(*this); return rhs.isCompatible(*this);
} }
bool CpuBlockedMemoryDesc::canComputeMemSizeZeroDims() const {
return getShape().hasZeroDims() && getOffsetPadding() != Shape::UNDEFINED_DIM;
}
size_t CpuBlockedMemoryDesc::getCurrentMemSizeImp() const { size_t CpuBlockedMemoryDesc::getCurrentMemSizeImp() const {
int64_t e_size = getOffsetPadding() + 1; // size in bytes (from begin of data to last element) int64_t e_size = getOffsetPadding() + 1; // size in bytes (from begin of data to last element)
for (int j = 0; j < getBlockDims().size(); j++) if (!getShape().hasZeroDims()) {
e_size += (getBlockDims()[j] - 1) * getStrides()[j]; for (int j = 0; j < getBlockDims().size(); j++)
e_size += (getBlockDims()[j] - 1) * getStrides()[j];
}
e_size *= getPrecision() == InferenceEngine::Precision::BIN ? 1 : getPrecision().size(); e_size *= getPrecision() == InferenceEngine::Precision::BIN ? 1 : getPrecision().size();
@ -104,14 +124,14 @@ size_t CpuBlockedMemoryDesc::getCurrentMemSizeImp() const {
} }
size_t CpuBlockedMemoryDesc::getMaxMemSize() const { size_t CpuBlockedMemoryDesc::getMaxMemSize() const {
if (shape.isStatic()) { if (shape.isStatic() || shape.hasZeroDims()) {
return getCurrentMemSize(); return getCurrentMemSize();
} }
auto& maxDims = shape.getMaxDims(); const auto& maxDims = shape.getMaxDims();
if (std::any_of(maxDims.begin(), maxDims.end(), [](size_t x){ return Shape::UNDEFINED_DIM == x || if (std::any_of(maxDims.begin(), maxDims.end(), [](size_t x){ return Shape::UNDEFINED_DIM == x ||
// WA: for some nodes ngraph compute upper bound depending on precision max value // WA: for some nodes ngraph compute upper bound depending on precision max value
std::numeric_limits<int32_t>::max() == x; })) { x >= std::numeric_limits<int32_t>::max(); })) {
return UNDEFINED_SIZE; return UNDEFINED_SIZE;
} }
@ -270,15 +290,23 @@ bool CpuBlockedMemoryDesc::blocksExtended() const {
} }
size_t CpuBlockedMemoryDesc::getPaddedElementsCount() const { size_t CpuBlockedMemoryDesc::getPaddedElementsCount() const {
if (std::any_of(blockedDims.begin(), blockedDims.end(), [](Dim dim) { return dim == Shape::UNDEFINED_DIM; })) if (getShape().hasZeroDims()) {
return 0;
}
if (std::any_of(blockedDims.begin(), blockedDims.end(), [](Dim dim) { return dim == Shape::UNDEFINED_DIM; })) {
IE_THROW() << "Can't compute padded elements count for non undefined blocked dims"; IE_THROW() << "Can't compute padded elements count for non undefined blocked dims";
}
return std::accumulate(blockedDims.begin(), blockedDims.end(), size_t{1}, std::multiplies<size_t>()); return std::accumulate(blockedDims.begin(), blockedDims.end(), size_t{1}, std::multiplies<size_t>());
} }
MemoryDescPtr CpuBlockedMemoryDesc::cloneWithUndefStridesAndOffset() const { MemoryDescPtr CpuBlockedMemoryDesc::cloneWithUndefStridesAndOffset() const {
const auto orderSize = getOrder().size(); const auto orderSize = getOrder().size();
return std::make_shared<CpuBlockedMemoryDesc>(getPrecision(), getShape(), getBlockDims(), getOrder(), Shape::UNDEFINED_DIM, CpuBlockedMemoryDescPtr newDesc = std::make_shared<CpuBlockedMemoryDesc>(*this);
VectorDims(orderSize, 0), VectorDims(orderSize, Shape::UNDEFINED_DIM)); newDesc->strides = VectorDims(orderSize, Shape::UNDEFINED_DIM);
newDesc->offsetPadding = Shape::UNDEFINED_DIM;
newDesc->offsetPaddingToData = VectorDims(orderSize, 0);
newDesc->status = descStatus::Undefined;
return newDesc;
} }
MemoryDescPtr CpuBlockedMemoryDesc::cloneWithDefaultStridesAndOffset() const { MemoryDescPtr CpuBlockedMemoryDesc::cloneWithDefaultStridesAndOffset() const {

1
inference-engine/src/mkldnn_plugin/memory_desc/cpu_blocked_memory_desc.h
View File

@ -84,6 +84,7 @@ public:
private: private:
size_t getElementOffset(size_t elemNumber) const override; size_t getElementOffset(size_t elemNumber) const override;
bool canComputeMemSizeZeroDims() const override;
size_t getCurrentMemSizeImp() const override; size_t getCurrentMemSizeImp() const override;
size_t getOffset(const InferenceEngine::SizeVector& v) const; size_t getOffset(const InferenceEngine::SizeVector& v) const;
bool isPlainFormat() const; bool isPlainFormat() const;

7
inference-engine/src/mkldnn_plugin/memory_desc/cpu_memory_desc.h
View File

@ -93,7 +93,7 @@ public:
*/ */
size_t getCurrentMemSize() const { size_t getCurrentMemSize() const {
size_t retVal = UNDEFINED_SIZE; size_t retVal = UNDEFINED_SIZE;
if (isDefined()) { if (canComputeMemSize()) {
retVal = getCurrentMemSizeImp(); retVal = getCurrentMemSizeImp();
} }
return retVal; return retVal;
@ -140,8 +140,13 @@ protected:
// Get offset to the n'th element. Returns physical index of the element by the logical one considering padding, layout, blocking etc. // Get offset to the n'th element. Returns physical index of the element by the logical one considering padding, layout, blocking etc.
virtual size_t getElementOffset(size_t elemNumber) const = 0; virtual size_t getElementOffset(size_t elemNumber) const = 0;
virtual bool canComputeMemSizeZeroDims() const = 0;
virtual bool isDefinedImp() const = 0; virtual bool isDefinedImp() const = 0;
bool canComputeMemSize() const {
return isDefined() || canComputeMemSizeZeroDims();
}
virtual MemoryDescPtr cloneWithNewDimsImp(const VectorDims& dims) const = 0; virtual MemoryDescPtr cloneWithNewDimsImp(const VectorDims& dims) const = 0;
MemoryDescType type; MemoryDescType type;

43
inference-engine/src/mkldnn_plugin/memory_desc/cpu_memory_desc_utils.cpp
View File

@ -48,17 +48,37 @@ DnnlBlockedMemoryDesc MemoryDescUtils::convertToDnnlBlockedMemoryDesc(const Memo
CpuBlockedMemoryDesc MemoryDescUtils::convertToCpuBlockedMemoryDesc(const InferenceEngine::TensorDesc& desc) { CpuBlockedMemoryDesc MemoryDescUtils::convertToCpuBlockedMemoryDesc(const InferenceEngine::TensorDesc& desc) {
if (desc.getLayout() == InferenceEngine::Layout::ANY) if (desc.getLayout() == InferenceEngine::Layout::ANY)
IE_THROW() << "Cannot convert InferenceEngine::TensorDesc with ANY layout to CpuBlockedMemoryDesc"; IE_THROW() << "Cannot convert InferenceEngine::TensorDesc with ANY layout to CpuBlockedMemoryDesc";
const auto &blkDesc = desc.getBlockingDesc();
return CpuBlockedMemoryDesc(desc.getPrecision(), Shape(desc.getDims()), blkDesc.getBlockDims(), blkDesc.getOrder(), blkDesc.getOffsetPadding(), const auto& blkDesc = desc.getBlockingDesc();
blkDesc.getOffsetPaddingToData(), blkDesc.getStrides()); const auto& dims = desc.getDims();
auto strides = blkDesc.getStrides();
// for empty tensor case InferenceEngine::TensorDesc fill strides with non zero values before first 0 dims
// i.e. dims[1, 0, 2, 3] -> strides [0, 6, 3, 1]
if (std::any_of(dims.begin(), dims.end(), [](size_t dim){ return dim == 0; })) {
std::fill(strides.begin(), strides.end(), 0);
}
return CpuBlockedMemoryDesc(desc.getPrecision(), Shape(dims), blkDesc.getBlockDims(), blkDesc.getOrder(), blkDesc.getOffsetPadding(),
blkDesc.getOffsetPaddingToData(), strides);
} }
DnnlBlockedMemoryDesc MemoryDescUtils::convertToDnnlBlockedMemoryDesc(const InferenceEngine::TensorDesc& desc) { DnnlBlockedMemoryDesc MemoryDescUtils::convertToDnnlBlockedMemoryDesc(const InferenceEngine::TensorDesc& desc) {
const auto &blkDesc = desc.getBlockingDesc();
if (desc.getLayout() == InferenceEngine::Layout::ANY) if (desc.getLayout() == InferenceEngine::Layout::ANY)
IE_THROW() << "Cannot convert InferenceEngine::TensorDesc with ANY layout to DnnlBlockedMemoryDesc"; IE_THROW() << "Cannot convert InferenceEngine::TensorDesc with ANY layout to DnnlBlockedMemoryDesc";
const auto& blkDesc = desc.getBlockingDesc();
const auto& dims = desc.getDims();
auto strides = blkDesc.getStrides();
// for empty tensor case InferenceEngine::TensorDesc fill strides with non zero values before first 0 dims
// i.e. dims[1, 0, 2, 3] -> strides [0, 6, 3, 1]
if (std::any_of(dims.begin(), dims.end(), [](size_t dim){ return dim == 0; })) {
std::fill(strides.begin(), strides.end(), 0);
}
return DnnlBlockedMemoryDesc(desc.getPrecision(), Shape(desc.getDims()), blkDesc.getBlockDims(), blkDesc.getOrder(), blkDesc.getOffsetPadding(), return DnnlBlockedMemoryDesc(desc.getPrecision(), Shape(desc.getDims()), blkDesc.getBlockDims(), blkDesc.getOrder(), blkDesc.getOffsetPadding(),
blkDesc.getOffsetPaddingToData(), blkDesc.getStrides()); blkDesc.getOffsetPaddingToData(), strides);
} }
BlockedMemoryDescPtr MemoryDescUtils::convertToBlockedMemoryDesc(const MemoryDescPtr &desc) { BlockedMemoryDescPtr MemoryDescUtils::convertToBlockedMemoryDesc(const MemoryDescPtr &desc) {
@ -80,9 +100,16 @@ InferenceEngine::Blob::Ptr MemoryDescUtils::interpretAsBlob(const MKLDNNMemory &
InferenceEngine::TensorDesc MemoryDescUtils::convertToTensorDesc(const MemoryDesc& desc) { InferenceEngine::TensorDesc MemoryDescUtils::convertToTensorDesc(const MemoryDesc& desc) {
if (auto blockingDesc = dynamic_cast<const BlockedMemoryDesc*>(&desc)) { if (auto blockingDesc = dynamic_cast<const BlockedMemoryDesc*>(&desc)) {
return InferenceEngine::TensorDesc(blockingDesc->getPrecision(), blockingDesc->getShape().getStaticDims(), InferenceEngine::BlockingDesc blkDesc = desc.getShape().hasZeroDims() ? InferenceEngine::BlockingDesc(blockingDesc->getBlockDims(),
{blockingDesc->getBlockDims(), blockingDesc->getOrder(), blockingDesc->getOffsetPadding(), blockingDesc->getOrder(),
blockingDesc->getOffsetPaddingToData(), blockingDesc->getStrides()}); blockingDesc->getOffsetPadding(),
blockingDesc->getOffsetPaddingToData()) :
InferenceEngine::BlockingDesc(blockingDesc->getBlockDims(),
blockingDesc->getOrder(),
blockingDesc->getOffsetPadding(),
blockingDesc->getOffsetPaddingToData(),
blockingDesc->getStrides());
return InferenceEngine::TensorDesc(blockingDesc->getPrecision(), blockingDesc->getShape().getStaticDims(), blkDesc);
} else { } else {
IE_THROW() << "Cannot convert MemoryDesc to InferenceEngine::TensorDesc"; IE_THROW() << "Cannot convert MemoryDesc to InferenceEngine::TensorDesc";
} }

61
inference-engine/src/mkldnn_plugin/memory_desc/dnnl_blocked_memory_desc.cpp
View File

@ -15,12 +15,17 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(InferenceEngine::Precision prc, con
const auto &dims = shape.getDims(); const auto &dims = shape.getDims();
if (!strides.empty()) { // custom strides if (!strides.empty()) { // custom strides
if (shape.hasZeroDims() && std::any_of(strides.begin(), strides.end(), [](size_t stride) { return stride != 0; } )) {
IE_THROW() << "Can't create DnnlBlockedMemoryDesc with zero dim, but with non zero strides";
}
desc = {MKLDNNExtensionUtils::convertToDnnlDims(dims), desc = {MKLDNNExtensionUtils::convertToDnnlDims(dims),
MKLDNNExtensionUtils::IEPrecisionToDataType(prc), MKLDNNExtensionUtils::IEPrecisionToDataType(prc),
MKLDNNExtensionUtils::convertToDnnlDims(strides)}; MKLDNNExtensionUtils::convertToDnnlDims(strides)};
} else { } else {
mkldnn::memory::dims plain_strides; mkldnn::memory::dims plain_strides;
if (std::any_of(dims.begin(), dims.end(), [](size_t val) { return val == Shape::UNDEFINED_DIM; })) { if (shape.hasZeroDims()) {
plain_strides.resize(ndims, 0);
} else if (std::any_of(dims.begin(), dims.end(), [](size_t val) { return val == Shape::UNDEFINED_DIM; })) {
plain_strides.resize(ndims, DNNL_RUNTIME_DIM_VAL); plain_strides.resize(ndims, DNNL_RUNTIME_DIM_VAL);
} else { } else {
plain_strides.resize(ndims, 1); plain_strides.resize(ndims, 1);
@ -58,8 +63,8 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(InferenceEngine::Precision prc, con
* Limitation of conversion first N elements of order should be permutation of [0,1,2 ... N] * Limitation of conversion first N elements of order should be permutation of [0,1,2 ... N]
*/ */
DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(InferenceEngine::Precision prc, const Shape& shape, const VectorDims& blockedDims, DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(InferenceEngine::Precision prc, const Shape& shape, const VectorDims& blockedDims,
const VectorDims& order, size_t offsetPadding, const VectorDims& offsetPaddingToData, const VectorDims& order, size_t offsetPadding, const VectorDims& offsetPaddingToData,
const VectorDims& strides) : MemoryDesc(shape, DnnlBlocked) { const VectorDims& strides) : MemoryDesc(shape, DnnlBlocked) {
using namespace mkldnn; using namespace mkldnn;
// scalar case // scalar case
if (shape.getRank() == 0) { if (shape.getRank() == 0) {
@ -90,8 +95,8 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(InferenceEngine::Precision prc, con
IE_THROW() << "DnnlBlockedMemoryDesc doesn't support undefined order."; IE_THROW() << "DnnlBlockedMemoryDesc doesn't support undefined order.";
} }
if (std::any_of(blockedDims.begin() + shape.getRank(), blockedDims.end(), [](size_t val) { return val == Shape::UNDEFINED_DIM; })) { if (std::any_of(blockedDims.begin() + shape.getRank(), blockedDims.end(), [](size_t val) { return val == Shape::UNDEFINED_DIM || val == 0; })) {
IE_THROW() << "DnnlBlockedMemoryDesc doesn't support undefined blockedDims."; IE_THROW() << "DnnlBlockedMemoryDesc doesn't support undefined or zero blockedDims.";
} }
auto dims = MKLDNNExtensionUtils::convertToDnnlDims(shape.getDims()); auto dims = MKLDNNExtensionUtils::convertToDnnlDims(shape.getDims());
@ -106,7 +111,12 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(InferenceEngine::Precision prc, con
size_t inner_ndims = order.size() - dims.size(); size_t inner_ndims = order.size() - dims.size();
const bool emptyDesc = shape.hasZeroDims();
if (!strides.empty()) { if (!strides.empty()) {
if (emptyDesc && std::any_of(strides.begin(), strides.end(), [](size_t dim) { return dim != 0; } )) {
IE_THROW() << "Can't create DnnlBlockedMemoryDesc with zero dim, but with non zero strides";
}
bool is_descending_strides = true; bool is_descending_strides = true;
for (int i = 1; i < strides.size(); i++) { for (int i = 1; i < strides.size(); i++) {
is_descending_strides &= (strides[i - 1] >= strides[i]); is_descending_strides &= (strides[i - 1] >= strides[i]);
@ -118,7 +128,7 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(InferenceEngine::Precision prc, con
IE_THROW() << "Can not construct DnnlBlockedMemoryDesc from strides: " << vec2str(strides); IE_THROW() << "Can not construct DnnlBlockedMemoryDesc from strides: " << vec2str(strides);
} }
if (!strides.empty() && std::none_of(strides.begin(), strides.end(), [](size_t x) { return Shape::UNDEFINED_DIM == x; })) { if (!strides.empty() && !emptyDesc && std::none_of(strides.begin(), strides.end(), [](size_t x) { return Shape::UNDEFINED_DIM == x; })) {
bool inner_block_are_dense = one_of(strides.back(), 0, 1); // stride 1 - is dense case, 0 - broad casted bool inner_block_are_dense = one_of(strides.back(), 0, 1); // stride 1 - is dense case, 0 - broad casted
for (int i = outer_ndims; i < strides.size() - 1; i++) { for (int i = outer_ndims; i < strides.size() - 1; i++) {
inner_block_are_dense &= (strides[i] == strides[i + 1] * blockedDims[i + 1]); inner_block_are_dense &= (strides[i] == strides[i + 1] * blockedDims[i + 1]);
@ -203,6 +213,11 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(const Shape& shape, mkldnn::memory:
order.swap(perm); order.swap(perm);
order.insert(order.end(), inner_idxs.begin(), inner_idxs.end()); order.insert(order.end(), inner_idxs.begin(), inner_idxs.end());
if (shape.hasZeroDims()) {
auto& blk = desc.data.format_desc.blocking;
std::fill(std::begin(blk.strides), std::begin(blk.strides) + desc.data.ndims, 0);
}
initBlockedParams(); initBlockedParams();
} }
@ -296,6 +311,12 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(const mkldnn::memory::desc& mdesc)
IE_THROW(Unexpected) << "Can't create DnnlBlockedMemoryDesc from not blocking desc"; IE_THROW(Unexpected) << "Can't create DnnlBlockedMemoryDesc from not blocking desc";
order = extractOrder(desc); order = extractOrder(desc);
if (getShape().hasZeroDims()) {
auto& blk = desc.data.format_desc.blocking;
std::fill(std::begin(blk.strides), std::begin(blk.strides) + desc.data.ndims, 0);
}
initBlockedParams(); initBlockedParams();
} }
@ -368,6 +389,7 @@ bool DnnlBlockedMemoryDesc::isTailCFormat() const {
static mkldnn::memory::desc cloneDescWithNewDims(const mkldnn::memory::desc& desc, const VectorDims& dims, const VectorDims& order) { static mkldnn::memory::desc cloneDescWithNewDims(const mkldnn::memory::desc& desc, const VectorDims& dims, const VectorDims& order) {
using namespace dnnl::impl::utils; using namespace dnnl::impl::utils;
auto mklDims = MKLDNNExtensionUtils::convertToDnnlDims(dims); auto mklDims = MKLDNNExtensionUtils::convertToDnnlDims(dims);
const auto offsetPadding = desc.data.offset0;
mkldnn::memory::desc newMklDesc = desc; mkldnn::memory::desc newMklDesc = desc;
array_copy(newMklDesc.data.dims, mklDims.data(), mklDims.size()); array_copy(newMklDesc.data.dims, mklDims.data(), mklDims.size());
std::vector<int> perm(order.begin(), order.begin() + mklDims.size()); std::vector<int> perm(order.begin(), order.begin() + mklDims.size());
@ -379,6 +401,9 @@ static mkldnn::memory::desc cloneDescWithNewDims(const mkldnn::memory::desc& des
if (retCode != dnnl::impl::status::success) { if (retCode != dnnl::impl::status::success) {
IE_THROW() << "Can not clone DnnlBlockedMemoryDesc with dims: " << MemoryDescUtils::dims2str(dims); IE_THROW() << "Can not clone DnnlBlockedMemoryDesc with dims: " << MemoryDescUtils::dims2str(dims);
} }
// dnnl::impl::fill_blocked always set offset0 to 0
// so we need to restore actual value
newMklDesc.data.offset0 = offsetPadding;
return newMklDesc; return newMklDesc;
} }
@ -476,14 +501,14 @@ bool DnnlBlockedMemoryDesc::isSame(mkldnn::memory::format_tag fmt) const {
} }
size_t DnnlBlockedMemoryDesc::getMaxMemSize() const { size_t DnnlBlockedMemoryDesc::getMaxMemSize() const {
if (shape.isStatic()) { if (shape.isStatic() || shape.hasZeroDims()) {
return getCurrentMemSize(); return getCurrentMemSize();
} }
auto& maxDims = shape.getMaxDims(); const auto& maxDims = shape.getMaxDims();
if (std::any_of(maxDims.begin(), maxDims.end(), [](size_t x){ return Shape::UNDEFINED_DIM == x || if (std::any_of(maxDims.begin(), maxDims.end(), [](size_t x){ return Shape::UNDEFINED_DIM == x ||
// WA: for some nodes ngraph compute upper bound depending on precision max value // WA: for some nodes ngraph compute upper bound depending on precision max value
std::numeric_limits<int32_t>::max() == x; })) { x >= std::numeric_limits<int32_t>::max(); })) {
return UNDEFINED_SIZE; return UNDEFINED_SIZE;
} }
@ -492,6 +517,13 @@ size_t DnnlBlockedMemoryDesc::getMaxMemSize() const {
} }
size_t DnnlBlockedMemoryDesc::getPaddedElementsCount() const { size_t DnnlBlockedMemoryDesc::getPaddedElementsCount() const {
if (getShape().hasZeroDims()) {
return 0;
}
if (std::any_of(std::begin(desc.data.padded_dims), std::begin(desc.data.padded_dims) + desc.data.ndims,
[](dnnl_dim_t dim) { return dim == DNNL_RUNTIME_DIM_VAL; })) {
IE_THROW() << "Can't compute padded elements count for non undefined blocked dims";
}
return std::accumulate(std::begin(desc.data.padded_dims), std::begin(desc.data.padded_dims) + desc.data.ndims, size_t{1}, return std::accumulate(std::begin(desc.data.padded_dims), std::begin(desc.data.padded_dims) + desc.data.ndims, size_t{1},
std::multiplies<int64_t>()); std::multiplies<int64_t>());
} }
@ -548,7 +580,7 @@ void DnnlBlockedMemoryDesc::initStrides() {
const size_t total_ndims = outer_ndims + inner_ndims; const size_t total_ndims = outer_ndims + inner_ndims;
// strides of inner dims. In case of 4i16o4i will be {64, 4, 1} // strides of inner dims. In case of 4i16o4i will be {64, 4, 1}
VectorDims inner_strides(inner_ndims, 1); VectorDims inner_strides(inner_ndims, getShape().hasZeroDims() ? 0 : 1);
for (size_t i = 1; i < blk_desc.inner_nblks; i++) { for (size_t i = 1; i < blk_desc.inner_nblks; i++) {
inner_strides[blk_desc.inner_nblks - 1 - i] = inner_strides[blk_desc.inner_nblks - i] * blk_desc.inner_blks[blk_desc.inner_nblks - i]; inner_strides[blk_desc.inner_nblks - 1 - i] = inner_strides[blk_desc.inner_nblks - i] * blk_desc.inner_blks[blk_desc.inner_nblks - i];
} }
@ -600,7 +632,9 @@ void DnnlBlockedMemoryDesc::recomputeDefaultStrides() {
IE_THROW() << "Can't recompute stride: order size != blocked dims size"; IE_THROW() << "Can't recompute stride: order size != blocked dims size";
auto &oneDnnStrides = desc.data.format_desc.blocking.strides; auto &oneDnnStrides = desc.data.format_desc.blocking.strides;
if (std::any_of(blockedDims.begin(), blockedDims.end(), [](Dim val) { return val == Shape::UNDEFINED_DIM; })) { if (getShape().hasZeroDims()) {
std::fill(std::begin(oneDnnStrides), std::begin(oneDnnStrides) + getShape().getRank(), 0);
} else if (std::any_of(blockedDims.begin(), blockedDims.end(), [](Dim val) { return val == Shape::UNDEFINED_DIM; })) {
std::fill(std::begin(oneDnnStrides), std::begin(oneDnnStrides) + rank, DNNL_RUNTIME_DIM_VAL); std::fill(std::begin(oneDnnStrides), std::begin(oneDnnStrides) + rank, DNNL_RUNTIME_DIM_VAL);
initStrides(); initStrides();
} else { } else {
@ -633,6 +667,11 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(const mkldnn::memory::desc& mdesc,
desc = cloneDescWithNewDims(mdesc, shape.getDims(), order); desc = cloneDescWithNewDims(mdesc, shape.getDims(), order);
if (shape.hasZeroDims()) {
auto& blk = desc.data.format_desc.blocking;
std::fill(std::begin(blk.strides), std::begin(blk.strides) + desc.data.ndims, 0);
}
initBlockedParams(); initBlockedParams();
} }

2
inference-engine/src/mkldnn_plugin/memory_desc/dnnl_blocked_memory_desc.h
View File

@ -71,7 +71,7 @@ private:
explicit DnnlBlockedMemoryDesc(const mkldnn::memory::desc& mdesc); explicit DnnlBlockedMemoryDesc(const mkldnn::memory::desc& mdesc);
// Creates DnnlBlockedMemoryDesc using the shape parameter as a true shape but all other params (layout, blocks, etc.) are used from the mdesc, but // Creates DnnlBlockedMemoryDesc using the shape parameter as a true shape but all other params (layout, blocks, etc.) are used from the mdesc, but
// the mdesc own shape is ignored. The main purpose of this constructor is making dynamic descriptor form some dummy mdesc, which stores info about // the mdesc own shape is ignored. The main purpose of this constructor is making dynamic descriptor from some dummy mdesc, which stores info about
// layout, blocking, strides, etc., and the provided dynamic shape. // layout, blocking, strides, etc., and the provided dynamic shape.
DnnlBlockedMemoryDesc(const mkldnn::memory::desc& mdesc, const Shape& shape); DnnlBlockedMemoryDesc(const mkldnn::memory::desc& mdesc, const Shape& shape);

4
inference-engine/src/mkldnn_plugin/memory_desc/dnnl_memory_desc.cpp
View File

@ -15,6 +15,10 @@ DnnlMemoryDesc::DnnlMemoryDesc(const mkldnn::memory::desc& desc) :
IE_THROW(Unexpected) << "Memory format any is prohibited!"; IE_THROW(Unexpected) << "Memory format any is prohibited!";
} }
bool DnnlMemoryDesc::canComputeMemSizeZeroDims() const {
return getShape().hasZeroDims() && desc.data.offset0 != DNNL_RUNTIME_DIM_VAL;
}
size_t DnnlMemoryDesc::getCurrentMemSizeImp() const { size_t DnnlMemoryDesc::getCurrentMemSizeImp() const {
return MKLDNNExtensionUtils::getMemSizeForDnnlDesc(desc); return MKLDNNExtensionUtils::getMemSizeForDnnlDesc(desc);
} }

1
inference-engine/src/mkldnn_plugin/memory_desc/dnnl_memory_desc.h
View File

@ -63,6 +63,7 @@ private:
size_t getElementOffset(size_t elemNumber) const override; size_t getElementOffset(size_t elemNumber) const override;
bool canComputeMemSizeZeroDims() const override;
size_t getCurrentMemSizeImp() const override; size_t getCurrentMemSizeImp() const override;
bool isDefinedImp() const override; bool isDefinedImp() const override;
MemoryDescPtr cloneWithNewDimsImp(const VectorDims& dims) const override; MemoryDescPtr cloneWithNewDimsImp(const VectorDims& dims) const override;

29
inference-engine/src/mkldnn_plugin/mkldnn_graph.cpp
View File

@ -384,15 +384,16 @@ void MKLDNNGraph::InitOptimalPrimitiveDescriptors() {
void MKLDNNGraph::ExtractConstantAndExecutableNodes() { void MKLDNNGraph::ExtractConstantAndExecutableNodes() {
OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::MKLDNN_LT, "MKLDNNGraph::ExtractConstantAndExecutableNodes"); OV_ITT_SCOPE(FIRST_INFERENCE, itt::domains::MKLDNN_LT, "MKLDNNGraph::ExtractConstantAndExecutableNodes");
for (const auto& graphNode : graphNodes) { for (const auto& graphNode : graphNodes) {
if (graphNode->isConstant()) if (graphNode->isConstant()) {
constantGraphNodes.emplace_back(graphNode); constantGraphNodes.emplace_back(graphNode);
else if (CPU_DEBUG_CAPS_ALWAYS_TRUE(graphNode->isExecutable())) } else if (CPU_DEBUG_CAPS_ALWAYS_TRUE(graphNode->isExecutable())) {
/* @todo /* @todo
* Revise implementation. * Revise implementation.
* With current way it is possible that with debug_caps enabled * With current way it is possible that with debug_caps enabled
* we execute a node, which is not ready to be executed * we execute a node, which is not ready to be executed
*/ */
executableGraphNodes.emplace_back(graphNode); executableGraphNodes.emplace_back(graphNode);
}
} }
} }
@ -792,7 +793,7 @@ void MKLDNNGraph::PullOutputData(BlobMap &out) {
// check for empty output blob // check for empty output blob
if (std::any_of(outDims.begin(), outDims.end(), [](const Dim dim) {return dim == 0;})) { if (std::any_of(outDims.begin(), outDims.end(), [](const Dim dim) {return dim == 0;})) {
return; continue;
} }
auto srcPrec = actualDesc.getPrecision(); auto srcPrec = actualDesc.getPrecision();
@ -835,10 +836,11 @@ inline void MKLDNNGraph::ExecuteNode(const MKLDNNNodePtr& node, const mkldnn::st
DUMP(node, infer_count); DUMP(node, infer_count);
OV_ITT_SCOPED_TASK(itt::domains::MKLDNNPlugin, node->profiling.execute); OV_ITT_SCOPED_TASK(itt::domains::MKLDNNPlugin, node->profiling.execute);
if (node->isDynamicNode()) if (node->isDynamicNode()) {
node->executeDynamic(stream); node->executeDynamic(stream);
else } else {
node->execute(stream); node->execute(stream);
}
} }
void MKLDNNGraph::Infer(MKLDNNInferRequest* request, int batch) { void MKLDNNGraph::Infer(MKLDNNInferRequest* request, int batch) {
@ -854,7 +856,6 @@ void MKLDNNGraph::Infer(MKLDNNInferRequest* request, int batch) {
if (request) if (request)
request->ThrowIfCanceled(); request->ThrowIfCanceled();
ExecuteNode(node, stream); ExecuteNode(node, stream);
} }
@ -993,22 +994,6 @@ Config MKLDNNGraph::getProperty() const {
return config; return config;
} }
Blob::Ptr MKLDNNGraph::getInputBlob(const std::string& name) {
auto itr = inputNodesMap.find(name);
if (itr != inputNodesMap.end()) {
return MemoryDescUtils::interpretAsBlob(itr->second->getChildEdgeAt(0)->getMemory());
}
return nullptr;
}
Blob::Ptr MKLDNNGraph::getOutputBlob(const std::string& name) {
auto itr = outputNodesMap.find(name);
if (itr != outputNodesMap.end()) {
return MemoryDescUtils::interpretAsBlob(itr->second->getParentEdgeAt(0)->getMemory());
}
return nullptr;
}
void MKLDNNGraph::RemoveEdge(MKLDNNEdgePtr& edge) { void MKLDNNGraph::RemoveEdge(MKLDNNEdgePtr& edge) {
for (auto it = graphEdges.begin(); it != graphEdges.end(); it++) { for (auto it = graphEdges.begin(); it != graphEdges.end(); it++) {
if ((*it) == edge) { if ((*it) == edge) {

3
inference-engine/src/mkldnn_plugin/mkldnn_graph.h
View File

@ -44,9 +44,6 @@ public:
void setProperty(const std::map<std::string, std::string> &properties); void setProperty(const std::map<std::string, std::string> &properties);
Config getProperty() const; Config getProperty() const;
InferenceEngine::Blob::Ptr getInputBlob(const std::string& name);
InferenceEngine::Blob::Ptr getOutputBlob(const std::string& name);
template<typename NET> template<typename NET>
void CreateGraph(NET &network, void CreateGraph(NET &network,
const MKLDNNExtensionManager::Ptr& extMgr, const MKLDNNExtensionManager::Ptr& extMgr,

3
inference-engine/src/mkldnn_plugin/mkldnn_infer_request.cpp
View File

@ -190,8 +190,9 @@ void MKLDNNPlugin::MKLDNNInferRequest::redefineMemoryForInputNodes() {
const auto inputNode = cpuInputNodes.find(blob.first); const auto inputNode = cpuInputNodes.find(blob.first);
if (inputNode == cpuInputNodes.end()) if (inputNode == cpuInputNodes.end())
IE_THROW() << "CPU execution graph doesn't contain input node with name: " << blob.first; IE_THROW() << "CPU execution graph doesn't contain input node with name: " << blob.first;
if (inputNode->second->isDynamicNode()) if (inputNode->second->isDynamicNode()) {
inputNode->second->redefineOutputMemory({blob.second->getTensorDesc().getDims()}); inputNode->second->redefineOutputMemory({blob.second->getTensorDesc().getDims()});
}
} }
} }

62
inference-engine/src/mkldnn_plugin/mkldnn_node.cpp
View File

@ -84,7 +84,7 @@ MKLDNNNode::MKLDNNNode(const std::shared_ptr<ngraph::Node>& op, const mkldnn::en
for (size_t i = 0; i < op->get_input_size(); i++) { for (size_t i = 0; i < op->get_input_size(); i++) {
const auto &shape = op->get_input_partial_shape(i); const auto &shape = op->get_input_partial_shape(i);
if (shape.rank().is_dynamic()) { if (shape.rank().is_dynamic()) {
IE_THROW(Unexpected) << "CPU plug-in doesn't support operation with dynamic rank"; IE_THROW(Unexpected) << "CPU plug-in doesn't support " << getTypeStr() << " operation with dynamic rank. Operation name: " << getName();
} }
bool isScalar = shape.rank().get_length() == 0; bool isScalar = shape.rank().get_length() == 0;
@ -99,7 +99,7 @@ MKLDNNNode::MKLDNNNode(const std::shared_ptr<ngraph::Node>& op, const mkldnn::en
for (size_t i = 0; i < op->get_output_size(); i++) { for (size_t i = 0; i < op->get_output_size(); i++) {
const auto &shape = op->get_output_partial_shape(i); const auto &shape = op->get_output_partial_shape(i);
if (shape.rank().is_dynamic()) { if (shape.rank().is_dynamic()) {
IE_THROW(Unexpected) << "CPU plug-in doesn't support operation with dynamic rank"; IE_THROW(Unexpected) << "CPU plug-in doesn't support " << getTypeStr() << " operation with dynamic rank. Operation name: " << getName();
} }
bool isScalar = shape.rank().get_length() == 0; bool isScalar = shape.rank().get_length() == 0;
@ -230,6 +230,15 @@ bool MKLDNNNode::isEdgesEmpty(const std::vector<MKLDNNEdgeWeakPtr>& edges) const
return true; return true;
} }
void MKLDNNNode::createPrimitive() {
if (inputShapesDefined() && isExecutable()) {
if (needPrepareParams()) {
prepareParams();
}
updateLastInputDims();
}
}
void MKLDNNNode::selectOptimalPrimitiveDescriptor() { void MKLDNNNode::selectOptimalPrimitiveDescriptor() {
selectPreferPrimitiveDescriptor(getPrimitivesPriority(), false); selectPreferPrimitiveDescriptor(getPrimitivesPriority(), false);
} }
@ -510,12 +519,14 @@ void MKLDNNNode::executeDynamic(mkldnn::stream strm) {
if (needShapeInfer()) { if (needShapeInfer()) {
redefineOutputMemory(shapeInfer()); redefineOutputMemory(shapeInfer());
} }
if (needPrepareParams()) { if (isExecutable()) {
IE_ASSERT(inputShapesDefined()) << "Can't prepare params for " << getTypeStr() << " node with name: " << getName() << if (needPrepareParams()) {
" since the input shapes are not defined."; IE_ASSERT(inputShapesDefined()) << "Can't prepare params for " << getTypeStr() << " node with name: " << getName() <<
prepareParams(); " since the input shapes are not defined.";
prepareParams();
}
executeDynamicImpl(strm);
} }
executeDynamicImpl(strm);
updateLastInputDims(); updateLastInputDims();
} }
@ -1333,6 +1344,36 @@ std::pair<std::vector<float>, std::vector<float>> MKLDNNNode::getScalesAndShifts
return {scales, shifts}; return {scales, shifts};
} }
bool MKLDNNNode::isInputTensorAtPortEmpty(size_t port) const {
if (inputShapes.size() <= port) {
IE_THROW() << "Incorrect input port number for node " << getName();
}
return getParentEdgesAtPort(port)[0]->getMemory().GetShape().hasZeroDims();
}
bool MKLDNNNode::isOutputTensorAtPortEmpty(size_t port) const {
if (outputShapes.size() <= port) {
IE_THROW() << "Incorrect output port number for node " << getName();
}
return getChildEdgesAtPort(port)[0]->getMemory().GetShape().hasZeroDims();
}
bool MKLDNNNode::hasEmptyInputTensors() const {
for (size_t i = 0; i < getParentEdges().size(); i++) {
if (isInputTensorAtPortEmpty(i))
return true;
}
return false;
}
bool MKLDNNNode::hasEmptyOutputTensors() const {
for (size_t i = 0; i < outputShapes.size(); i++) {
if (isOutputTensorAtPortEmpty(i))
return true;
}
return false;
}
bool MKLDNNNode::inputShapesDefined() const { bool MKLDNNNode::inputShapesDefined() const {
for (size_t i = 0; i < getParentEdges().size(); i++) { for (size_t i = 0; i < getParentEdges().size(); i++) {
if (!getParentEdgesAtPort(i)[0]->getMemory().getDesc().isDefined()) if (!getParentEdgesAtPort(i)[0]->getMemory().getDesc().isDefined())
@ -1406,8 +1447,11 @@ std::vector<VectorDims> MKLDNNNode::shapeInferGeneric(const std::vector<Shape>&
std::vector<VectorDims> newOutputShapes(opToShapeInfer->get_output_size()); std::vector<VectorDims> newOutputShapes(opToShapeInfer->get_output_size());
for (size_t i = 0; i < newOutputShapes.size(); i++) { for (size_t i = 0; i < newOutputShapes.size(); i++) {
const auto &partShape = opToShapeInfer->get_output_partial_shape(i); const auto &partShape = opToShapeInfer->get_output_partial_shape(i);
if (partShape.is_dynamic()) if (partShape.is_dynamic()) {
IE_THROW(NotImplemented) << "CPU plug-in doesn't support default shape infer for nodes with internal dynamism"; IE_THROW(NotImplemented) << "CPU plug-in doesn't support default shape infer for node " << getTypeStr()
<< " with internal dynamism. Operation name: " << getName();
}
newOutputShapes[i] = partShape.get_shape(); newOutputShapes[i] = partShape.get_shape();
} }
return newOutputShapes; return newOutputShapes;

10
inference-engine/src/mkldnn_plugin/mkldnn_node.h
View File

@ -199,7 +199,7 @@ public:
// must be called only after MKLDNNGraph::InitEdges() // must be called only after MKLDNNGraph::InitEdges()
virtual bool isExecutable() const { virtual bool isExecutable() const {
return true; return !hasEmptyInputTensors();
} }
bool isConstant(); bool isConstant();
@ -370,7 +370,7 @@ public:
*/ */
virtual void filterSupportedPrimitiveDescriptors(); virtual void filterSupportedPrimitiveDescriptors();
virtual void createPrimitive() = 0; virtual void createPrimitive();
virtual void selectOptimalPrimitiveDescriptor(); virtual void selectOptimalPrimitiveDescriptor();
virtual void initOptimalPrimitiveDescriptor(); virtual void initOptimalPrimitiveDescriptor();
@ -728,6 +728,12 @@ protected:
bool isDynamic = false; bool isDynamic = false;
bool isInputTensorAtPortEmpty(size_t port) const;
bool isOutputTensorAtPortEmpty(size_t port) const;
bool hasEmptyInputTensors() const;
bool hasEmptyOutputTensors() const;
bool inputShapesDefined() const; bool inputShapesDefined() const;
bool outputShapesDefined() const; bool outputShapesDefined() const;
bool shapesDefined() const; bool shapesDefined() const;

2
inference-engine/src/mkldnn_plugin/mkldnn_nodes_factory.cpp
View File

@ -80,6 +80,7 @@
#include "nodes/mkldnn_reduce_node.h" #include "nodes/mkldnn_reduce_node.h"
#include "nodes/mkldnn_if_node.h" #include "nodes/mkldnn_if_node.h"
#include "nodes/mkldnn_ctc_greedy_decoder_node.h" #include "nodes/mkldnn_ctc_greedy_decoder_node.h"
#include "nodes/mkldnn_non_zero.h"
#define MKLDNN_NODE(__prim, __type) \ #define MKLDNN_NODE(__prim, __type) \
registerNodeIfRequired(MKLDNNPlugin, __prim, __type, MKLDNNNodeImpl<__prim>) registerNodeIfRequired(MKLDNNPlugin, __prim, __type, MKLDNNNodeImpl<__prim>)
@ -168,4 +169,5 @@ MKLDNNPlugin::MKLDNNNode::NodesFactory::NodesFactory()
MKLDNN_NODE(MKLDNNTopKNode, TopK); MKLDNN_NODE(MKLDNNTopKNode, TopK);
MKLDNN_NODE(MKLDNNStridedSliceNode, StridedSlice); MKLDNN_NODE(MKLDNNStridedSliceNode, StridedSlice);
MKLDNN_NODE(MKLDNNGRNNode, GRN); MKLDNN_NODE(MKLDNNGRNNode, GRN);
MKLDNN_NODE(MKLDNNNonZeroNode, NonZero);
} }

45
inference-engine/src/mkldnn_plugin/nodes/common/dnnl_executor.cpp Normal file
View File

@ -0,0 +1,45 @@
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "dnnl_executor.h"
using namespace mkldnn;
using namespace MKLDNNPlugin;
DnnlExecutor::IntermReorder::IntermReorder(const mkldnn::memory::desc& descSrc,
const mkldnn::memory::desc& descDst,
const mkldnn::engine& engine) : m_descSrc(descSrc), m_descDst(descDst) {
auto reorderPd = mkldnn::reorder::primitive_desc(engine, descSrc, engine, descDst);
m_reorder = mkldnn::reorder(reorderPd);
}
void DnnlExecutor::IntermReorder::exec(mkldnn::memory& memSrc, mkldnn::memory& memDst, mkldnn::stream strm) {
m_reorder.execute(strm, memSrc, memDst);
}
void DnnlExecutor::exec(std::unordered_map<int, mkldnn::memory> primArgs, mkldnn::stream strm) {
for (auto &inReorder : inputReorders) {
if (primArgs.count(inReorder.first)) {
mkldnn::memory memDst(inReorder.second.getDstDesc(), strm.get_engine());
inReorder.second.exec(primArgs[inReorder.first], memDst, strm);
primArgs[inReorder.first] = memDst;
} else {
IE_THROW() << "DnnlExecutor has reorder for input " << inReorder.first << ", but doesn't have source memory";
}
}
std::unordered_map<int, mkldnn::memory> outputMem;
for (auto &outReorder : outputReorders) {
if (primArgs.count(outReorder.first)) {
mkldnn::memory memSrc(outReorder.second.getSrcDesc(), strm.get_engine());
outputMem[outReorder.first] = primArgs[outReorder.first];
primArgs[outReorder.first] = memSrc;
} else {
IE_THROW() << "DnnlExecutor has reorder for output " << outReorder.first << ", but doesn't have destination memory";
}
}
(*execPrim).execute(strm, primArgs);
for (auto &outReorder : outputReorders) {
outReorder.second.exec(primArgs[outReorder.first], outputMem[outReorder.first], strm);
}
}

39
inference-engine/src/mkldnn_plugin/nodes/common/dnnl_executor.h Normal file
View File

@ -0,0 +1,39 @@
// Copyright (C) 2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
#include "mkldnn_memory.h"
#include "mkldnn_primitive.h"
namespace MKLDNNPlugin {
class DnnlExecutor {
protected:
class IntermReorder {
public:
IntermReorder(const mkldnn::memory::desc& descSrc, const mkldnn::memory::desc& descDst, const mkldnn::engine& engine);
void exec(mkldnn::memory& memSrc, mkldnn::memory& memDst, mkldnn::stream strm);
const mkldnn::memory::desc& getSrcDesc() const { return m_descSrc; }
const mkldnn::memory::desc& getDstDesc() const { return m_descDst; }
private:
mkldnn::reorder m_reorder;
mkldnn::memory::desc m_descSrc;
mkldnn::memory::desc m_descDst;
};
public:
void exec(std::unordered_map<int, mkldnn::memory> primArgs, mkldnn::stream strm);
virtual ~DnnlExecutor() = default;
protected:
DnnlExecutor() = default;
MKLDNNPrimitive execPrim;
// key is the port number for the primitive that needs memory reordering
std::unordered_map<int, IntermReorder> inputReorders;
std::unordered_map<int, IntermReorder> outputReorders;
};
} // namespace MKLDNNPlugin

6
inference-engine/src/mkldnn_plugin/nodes/mkldnn_adaptive_pooling.cpp
View File

@ -145,6 +145,10 @@ void MKLDNNAdaptivePoolingNode::initSupportedPrimitiveDescriptors() {
} }
} }
void MKLDNNAdaptivePoolingNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
void MKLDNNAdaptivePoolingNode::execute(mkldnn::stream strm) { void MKLDNNAdaptivePoolingNode::execute(mkldnn::stream strm) {
auto inputPrec = getParentEdgeAt(0)->getMemory().GetDataType(); auto inputPrec = getParentEdgeAt(0)->getMemory().GetDataType();
auto outputPrec = getChildEdgeAt(0)->getMemory().GetDataType(); auto outputPrec = getChildEdgeAt(0)->getMemory().GetDataType();
@ -283,8 +287,6 @@ bool MKLDNNAdaptivePoolingNode::created() const {
return getType() == AdaptivePooling; return getType() == AdaptivePooling;
} }
void MKLDNNAdaptivePoolingNode::createPrimitive() {}
inline void MKLDNNAdaptivePoolingNode::setBinBorders(size_t *startPtr, size_t *endPtr, size_t idx, size_t inputLength, size_t outputLength) { inline void MKLDNNAdaptivePoolingNode::setBinBorders(size_t *startPtr, size_t *endPtr, size_t idx, size_t inputLength, size_t outputLength) {
*(startPtr) = idx * inputLength / outputLength; *(startPtr) = idx * inputLength / outputLength;
*(endPtr) = ceil(static_cast<float>((idx + 1) * inputLength) / outputLength); *(endPtr) = ceil(static_cast<float>((idx + 1) * inputLength) / outputLength);

3
inference-engine/src/mkldnn_plugin/nodes/mkldnn_adaptive_pooling.h
View File

@ -18,7 +18,6 @@ public:
void getSupportedDescriptors() override; void getSupportedDescriptors() override;
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
@ -36,7 +35,7 @@ protected:
bool needShapeInfer() const override; bool needShapeInfer() const override;
std::vector<VectorDims> shapeInfer() const override; std::vector<VectorDims> shapeInfer() const override;
bool needPrepareParams() const override { return false; }; bool needPrepareParams() const override { return false; };
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); }; void executeDynamicImpl(mkldnn::stream strm) override;
}; };
} // namespace MKLDNNPlugin } // namespace MKLDNNPlugin

4
inference-engine/src/mkldnn_plugin/nodes/mkldnn_batch_to_space_node.cpp
View File

@ -225,6 +225,10 @@ void MKLDNNBatchToSpaceNode::batchToSpaceKernel() {
}); });
} }
void MKLDNNBatchToSpaceNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
void MKLDNNBatchToSpaceNode::execute(mkldnn::stream strm) { void MKLDNNBatchToSpaceNode::execute(mkldnn::stream strm) {
switch (getParentEdgeAt(0)->getMemory().getDesc().getPrecision().size()) { switch (getParentEdgeAt(0)->getMemory().getDesc().getPrecision().size()) {
case 1: batchToSpaceKernel<PrecisionTrait<Precision::U8>::value_type>(); break; case 1: batchToSpaceKernel<PrecisionTrait<Precision::U8>::value_type>(); break;

3
inference-engine/src/mkldnn_plugin/nodes/mkldnn_batch_to_space_node.h
View File

@ -18,12 +18,11 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override {};
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
bool needPrepareParams() const override { return false; }; bool needPrepareParams() const override { return false; };
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); }; void executeDynamicImpl(mkldnn::stream strm) override;
static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept; static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept;

16
inference-engine/src/mkldnn_plugin/nodes/mkldnn_broadcast_node.cpp
View File

@ -107,14 +107,6 @@ void MKLDNNBroadcastNode::initSupportedPrimitiveDescriptors() {
supportedPrimitiveDescriptors = getSupportedConfigs(this); supportedPrimitiveDescriptors = getSupportedConfigs(this);
} }
void MKLDNNBroadcastNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
bool MKLDNNBroadcastNode::needPrepareParams() const { bool MKLDNNBroadcastNode::needPrepareParams() const {
return needPrepareParamsVar; return needPrepareParamsVar;
} }
@ -215,6 +207,14 @@ std::vector<VectorDims> MKLDNNBroadcastNode::shapeInfer() const {
return newOutputShapes; return newOutputShapes;
} }
bool MKLDNNBroadcastNode::isExecutable() const {
return !isInputTensorAtPortEmpty(0);
}
void MKLDNNBroadcastNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
void MKLDNNBroadcastNode::execute(mkldnn::stream strm) { void MKLDNNBroadcastNode::execute(mkldnn::stream strm) {
if (optimizedCase) { if (optimizedCase) {
optimizedExecute(getParentEdgeAt(INPUT_DATA_IDX)->getMemoryPtr(), getChildEdgeAt(0)->getMemoryPtr()); optimizedExecute(getParentEdgeAt(INPUT_DATA_IDX)->getMemoryPtr(), getChildEdgeAt(0)->getMemoryPtr());

6
inference-engine/src/mkldnn_plugin/nodes/mkldnn_broadcast_node.h
View File

@ -19,13 +19,11 @@ public:
void getSupportedDescriptors() override; void getSupportedDescriptors() override;
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
void executeDynamicImpl(mkldnn::stream strm) override { void executeDynamicImpl(mkldnn::stream strm) override;
execute(strm);
}
bool created() const override; bool created() const override;
bool isExecutable() const override;
static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept; static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
protected: protected:

8
inference-engine/src/mkldnn_plugin/nodes/mkldnn_bucketize_node.cpp
View File

@ -203,12 +203,8 @@ void MKLDNNBucketizeNode::prepareParams() {
std::accumulate(input_tensor_dims.begin(), input_tensor_dims.end(), size_t(1), std::multiplies<size_t>()); std::accumulate(input_tensor_dims.begin(), input_tensor_dims.end(), size_t(1), std::multiplies<size_t>());
} }
void MKLDNNBucketizeNode::createPrimitive() { bool MKLDNNBucketizeNode::isExecutable() const {
if (inputShapesDefined()) { return !isInputTensorAtPortEmpty(0);
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
} }
std::vector<VectorDims> MKLDNNBucketizeNode::shapeInfer() const { std::vector<VectorDims> MKLDNNBucketizeNode::shapeInfer() const {

3
inference-engine/src/mkldnn_plugin/nodes/mkldnn_bucketize_node.h
View File

@ -15,15 +15,16 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
void executeDynamicImpl(mkldnn::stream strm) override { void executeDynamicImpl(mkldnn::stream strm) override {
execute(strm); execute(strm);
} }
void prepareParams() override; void prepareParams() override;
std::vector<VectorDims> shapeInfer() const override; std::vector<VectorDims> shapeInfer() const override;
bool isExecutable() const override;
static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept; static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept;
private: private:

49
inference-engine/src/mkldnn_plugin/nodes/mkldnn_concat_node.cpp
View File

@ -31,6 +31,10 @@ namespace {
constexpr size_t channelAxis = 1lu; constexpr size_t channelAxis = 1lu;
} }
bool MKLDNNConcatNode::isExecutable() const {
return !hasEmptyOutputTensors() && !isOptimized();
}
bool MKLDNNConcatNode::isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept { bool MKLDNNConcatNode::isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept {
try { try {
const auto concatOp = ngraph::as_type_ptr<const ngraph::op::v0::Concat>(op); const auto concatOp = ngraph::as_type_ptr<const ngraph::op::v0::Concat>(op);
@ -173,7 +177,7 @@ void MKLDNNConcatNode::initSupportedPrimitiveDescriptors() {
} }
// TODO [DS]: inplace // TODO [DS]: inplace
if (!canBeInPlace) if (!canBeInPlace || std::any_of(inputShapes.begin(), inputShapes.end(), [](const Shape& shape) { return shape.hasZeroDims(); }))
return; return;
// Optimized inplace case // Optimized inplace case
@ -353,7 +357,6 @@ void MKLDNNConcatNode::prepareParams() {
IE_THROW() << "Preferable primitive descriptor is not set."; IE_THROW() << "Preferable primitive descriptor is not set.";
std::vector<memory::desc> srcs_d; std::vector<memory::desc> srcs_d;
for (size_t i = 0; i < getParentEdges().size(); i++) { for (size_t i = 0; i < getParentEdges().size(); i++) {
const auto& srcMemPtr = getParentEdgesAtPort(i)[0]->getMemoryPtr(); const auto& srcMemPtr = getParentEdgesAtPort(i)[0]->getMemoryPtr();
if (!srcMemPtr || !srcMemPtr->GetPrimitivePtr()) { if (!srcMemPtr || !srcMemPtr->GetPrimitivePtr()) {
@ -362,6 +365,10 @@ void MKLDNNConcatNode::prepareParams() {
<< getName() << "."; << getName() << ".";
} }
if (srcMemPtr->GetShape().hasZeroDims()) {
continue;
}
auto desc = srcMemPtr->GetDescWithType<DnnlMemoryDesc>()->getDnnlDesc(); auto desc = srcMemPtr->GetDescWithType<DnnlMemoryDesc>()->getDnnlDesc();
const auto& dims = srcMemPtr->getStaticDims(); const auto& dims = srcMemPtr->getStaticDims();
for (size_t j = 0; j < dims.size(); j++) { for (size_t j = 0; j < dims.size(); j++) {
@ -382,14 +389,6 @@ void MKLDNNConcatNode::prepareParams() {
prim.reset(new concat(primitive_desc)); prim.reset(new concat(primitive_desc));
} }
void MKLDNNConcatNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
size_t MKLDNNConcatNode::inverseOrder(const SizeVector& order, size_t axis) { size_t MKLDNNConcatNode::inverseOrder(const SizeVector& order, size_t axis) {
for (size_t i = 0; i < order.size(); i++) { for (size_t i = 0; i < order.size(); i++) {
if (axis == order[i]) { if (axis == order[i]) {
@ -489,16 +488,23 @@ void MKLDNNConcatNode::execute(mkldnn::stream strm) {
return; return;
} }
const MKLDNNMemory& dst_memory = getChildEdgeAt(0)->getMemory();
if (canOptimizeNspc) { if (canOptimizeNspc) {
execNspcSpecCase(); execNspcSpecCase();
return; return;
} }
const MKLDNNMemory& dst_memory = getChildEdgeAt(0)->getMemory();
const size_t num_src = getParentEdges().size(); const size_t num_src = getParentEdges().size();
std::unordered_map<int, memory> mem_ags {{DNNL_ARG_DST, dst_memory.GetPrimitive()}}; std::unordered_map<int, memory> mem_ags {{DNNL_ARG_DST, dst_memory.GetPrimitive()}};
for (int i = 0; i < num_src; i++) size_t nonZeroInShapes = 0;
mem_ags[DNNL_ARG_MULTIPLE_SRC + i] = getParentEdgeAt(i)->getMemory().GetPrimitive(); for (int i = 0; i < num_src; i++) {
const auto& srcMem = getParentEdgesAtPort(i)[0]->getMemory();
if (srcMem.GetShape().hasZeroDims()) {
continue;
}
mem_ags[DNNL_ARG_MULTIPLE_SRC + nonZeroInShapes] = srcMem.GetPrimitive();
nonZeroInShapes++;
}
(*prim).execute(strm, mem_ags); (*prim).execute(strm, mem_ags);
} }
@ -518,21 +524,32 @@ void MKLDNNConcatNode::execNspcSpecCase() {
std::vector<const uint8_t*> src_ptrs; std::vector<const uint8_t*> src_ptrs;
std::vector<uint8_t*> dst_ptrs; std::vector<uint8_t*> dst_ptrs;
size_t nonZeroInShapes = 0;
int firstNonZeroEdge = -1;
for (size_t i = 0; i < num_src; i++) { for (size_t i = 0; i < num_src; i++) {
const MKLDNNMemory& src_mem = getParentEdgeAt(i)->getMemory(); const MKLDNNMemory& src_mem = getParentEdgesAtPort(i)[0]->getMemory();
if (src_mem.GetShape().hasZeroDims()) {
continue;
}
const size_t num_channels = src_mem.getStaticDims()[channelAxis]; const size_t num_channels = src_mem.getStaticDims()[channelAxis];
channelsDataSize.push_back(num_channels * dataSize); channelsDataSize.push_back(num_channels * dataSize);
src_ptrs.push_back(reinterpret_cast<const uint8_t*>(src_mem.GetData())); src_ptrs.push_back(reinterpret_cast<const uint8_t*>(src_mem.GetData()));
dst_ptrs.push_back(dst_ptr + channels_size); dst_ptrs.push_back(dst_ptr + channels_size);
channels_size += num_channels * dataSize; channels_size += num_channels * dataSize;
if (firstNonZeroEdge == -1) {
firstNonZeroEdge = i;
}
nonZeroInShapes++;
} }
const size_t iter_count = getParentEdgeAt(0)->getMemory().GetSize() / channelsDataSize[0]; const size_t iter_count = getParentEdgeAt(firstNonZeroEdge)->getMemory().GetSize() / channelsDataSize[0];
parallel_for(iter_count, [&](int i) { parallel_for(iter_count, [&](int i) {
const size_t dst_off = i * channels_size; const size_t dst_off = i * channels_size;
for (int j = 0; j < num_src; j++) { for (int j = 0; j < nonZeroInShapes; j++) {
cpu_memcpy(dst_ptrs[j] + dst_off, src_ptrs[j] + i * channelsDataSize[j], channelsDataSize[j]); cpu_memcpy(dst_ptrs[j] + dst_off, src_ptrs[j] + i * channelsDataSize[j], channelsDataSize[j]);
} }
}); });

5
inference-engine/src/mkldnn_plugin/nodes/mkldnn_concat_node.h
View File

@ -19,7 +19,6 @@ public:
void getSupportedDescriptors() override; void getSupportedDescriptors() override;
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void initOptimalPrimitiveDescriptor() override; void initOptimalPrimitiveDescriptor() override;
void createPrimitive() override;
void selectOptimalPrimitiveDescriptor() override; void selectOptimalPrimitiveDescriptor() override;
bool created() const override; bool created() const override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
@ -28,10 +27,8 @@ public:
bool isOptimized() const; bool isOptimized() const;
InferenceEngine::Precision getRuntimePrecision() const override; InferenceEngine::Precision getRuntimePrecision() const override;
bool isExecutable() const override {
return !isOptimized();
}
bool isExecutable() const override;
bool needPrepareParams() const override; bool needPrepareParams() const override;
void prepareParams() override; void prepareParams() override;

175
inference-engine/src/mkldnn_plugin/nodes/mkldnn_conv_node.cpp
View File

@ -487,15 +487,6 @@ void MKLDNNConvolutionNode::initSupportedPrimitiveDescriptors() {
} }
} }
void MKLDNNConvolutionNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
bool MKLDNNConvolutionNode::created() const { bool MKLDNNConvolutionNode::created() const {
return getType() == Convolution; return getType() == Convolution;
} }
@ -545,7 +536,14 @@ MKLDNNConvolutionNode::createDescriptorInternal(const mkldnn::memory::desc& inpu
void MKLDNNConvolutionNode::createDescriptor(const std::vector<MemoryDescPtr>& inputDesc, void MKLDNNConvolutionNode::createDescriptor(const std::vector<MemoryDescPtr>& inputDesc,
const std::vector<MemoryDescPtr>& outputDesc) { const std::vector<MemoryDescPtr>& outputDesc) {
auto inpDesc = inputDesc[0]->isDefined() ? inputDesc[0] : MemoryDescUtils::makeDummyDesc(*inputDesc[0]); MemoryDescPtr inpDesc;
if (inputDesc[0]->isDefined()) {
inpDesc = inputDesc[0];
} else {
auto dummyInDims = MemoryDescUtils::makeDummyShape(inputDesc[0]->getShape()).getStaticDims();
dummyInDims[1] = IC;
inpDesc = inputDesc[0]->cloneWithNewDims(dummyInDims);
}
DnnlMemoryDescPtr definedInpMemDesc = MemoryDescUtils::convertToDnnlMemoryDesc(inpDesc); DnnlMemoryDescPtr definedInpMemDesc = MemoryDescUtils::convertToDnnlMemoryDesc(inpDesc);
DnnlMemoryDescPtr definedOutMemDesc; DnnlMemoryDescPtr definedOutMemDesc;
@ -906,14 +904,57 @@ InferenceEngine::Blob::Ptr MKLDNNConvolutionNode::createInternalBlob(InferenceEn
return internalBlob; return internalBlob;
} }
std::shared_ptr<MKLDNNDescriptor> MKLDNNConvolutionNode::createMkldnnConvDesc(const mkldnn::memory::desc& srcDesc,
const mkldnn::memory::desc& wghDesc,
const mkldnn::memory::desc& dstDesc,
const mkldnn::memory::desc& biasDesc) {
std::shared_ptr<mkldnn::convolution_forward::desc> dnnlConvDesc;
auto alg = isWinograd() ? mkldnn::algorithm::convolution_winograd : mkldnn::algorithm::convolution_direct;
if (withBiases) {
// WA to align IR bias representation (3 to 5 rank tensors) to oneDNN representation (1 rank tensor)
mkldnn::memory::desc dnnlBiasDesc = biasDesc.reshape(MKLDNNExtensionUtils::convertToDnnlDims(biasesDims));
return std::make_shared<MKLDNNDescriptor>(createDescriptorInternal(srcDesc,
wghDesc,
dnnlBiasDesc,
dstDesc,
alg));
} else {
return std::make_shared<MKLDNNDescriptor>(createDescriptorInternal(srcDesc,
wghDesc,
dstDesc,
alg));
}
}
void MKLDNNConvolutionNode::prepareParams() { void MKLDNNConvolutionNode::prepareParams() {
auto srcMemPtr = getParentEdgesAtPort(0)[0]->getMemoryPtr();
auto wghMemPtr = getParentEdgesAtPort(1)[0]->getMemoryPtr();
auto dstMemPtr = getChildEdgesAtPort(0)[0]->getMemoryPtr();
if (!dstMemPtr || !dstMemPtr->GetPrimitivePtr())
IE_THROW() << "Destination memory didn't allocate.";
if (!srcMemPtr || !srcMemPtr->GetPrimitivePtr())
IE_THROW() << "Input memory didn't allocate.";
if (!wghMemPtr || !wghMemPtr->GetPrimitivePtr())
IE_THROW() << "Weight memory didn't allocate.";
MKLDNNMemoryPtr biasMemPtr = nullptr;
if (withBiases) {
biasMemPtr = getParentEdgesAtPort(2)[0]->getMemoryPtr();
if (!biasMemPtr || !biasMemPtr->GetPrimitivePtr())
IE_THROW() << "Input memory didn't allocate.";
}
const NodeDesc *selected_pd = getSelectedPrimitiveDescriptor(); const NodeDesc *selected_pd = getSelectedPrimitiveDescriptor();
if (selected_pd == nullptr) if (selected_pd == nullptr)
IE_THROW() << "Preferable primitive descriptor is not set for node " << getName() << "."; IE_THROW() << "Preferable primitive descriptor is not set for node " << getName() << ".";
auto inMemoryDesc = getParentEdgesAtPort(0).front()->getMemory().GetDescWithType<DnnlMemoryDesc>(); auto inMemoryDesc = srcMemPtr->GetDescWithType<DnnlMemoryDesc>();
auto weightMemoryDesc = getParentEdgesAtPort(1).front()->getMemory().GetDescWithType<DnnlMemoryDesc>(); auto weightMemoryDesc = wghMemPtr->GetDescWithType<DnnlMemoryDesc>();
auto outMemoryDesc = getChildEdgesAtPort(0).front()->getMemory().GetDescWithType<DnnlMemoryDesc>(); auto outMemoryDesc = dstMemPtr->GetDescWithType<DnnlMemoryDesc>();
mkldnn::memory::desc biasDesc;
if (biasMemPtr) {
biasDesc = biasMemPtr->GetDescWithType<DnnlMemoryDesc>()->getDnnlDesc();
}
auto initPrimitiveAttr = [&]() { auto initPrimitiveAttr = [&]() {
mkldnn::primitive_attr attr; mkldnn::primitive_attr attr;
@ -934,55 +975,95 @@ void MKLDNNConvolutionNode::prepareParams() {
pAttrLocal = initPrimitiveAttr(); pAttrLocal = initPrimitiveAttr();
} }
std::shared_ptr<mkldnn::convolution_forward::desc> dnnlConvDesc; std::shared_ptr<MKLDNNDescriptor> desc = createMkldnnConvDesc(inMemoryDesc->getDnnlDesc(),
auto alg = isWinograd() ? mkldnn::algorithm::convolution_winograd : mkldnn::algorithm::convolution_direct; weightMemoryDesc->getDnnlDesc(),
outMemoryDesc->getDnnlDesc(),
biasDesc);
if (withBiases) { auto itpd = desc->createPrimitiveDescriptorIterator(getEngine(), *pAttrLocal);
auto biasMemoryDesc = getParentEdgesAtPort(2).front()->getMemory().GetDescWithType<DnnlMemoryDesc>();
// WA to align IR bias representation (3 to 5 rank tensors) to oneDNN representation (1 rank tensor)
mkldnn::memory::desc dnnlBiasDesc = biasMemoryDesc->getDnnlDesc().reshape(MKLDNNExtensionUtils::convertToDnnlDims(biasesDims));
dnnlConvDesc = createDescriptorInternal(inMemoryDesc->getDnnlDesc(),
weightMemoryDesc->getDnnlDesc(),
dnnlBiasDesc,
outMemoryDesc->getDnnlDesc(),
alg);
} else {
dnnlConvDesc = createDescriptorInternal(inMemoryDesc->getDnnlDesc(),
weightMemoryDesc->getDnnlDesc(),
outMemoryDesc->getDnnlDesc(),
alg);
}
MKLDNNDescriptor desc(dnnlConvDesc);
auto itpd = desc.createPrimitiveDescriptorIterator(getEngine(), *pAttrLocal);
convolution_forward::primitive_desc prim_desc; convolution_forward::primitive_desc prim_desc;
while (static_cast<bool>(itpd)) {
execPtr = nullptr;
while (static_cast<bool>(itpd)) {
impl_desc_type impl_type = parse_impl_name(itpd.impl_info_str()); impl_desc_type impl_type = parse_impl_name(itpd.impl_info_str());
if (impl_type == selected_pd->getImplementationType()) { if (impl_type == selected_pd->getImplementationType()) {
prim_desc = convolution_forward::primitive_desc(itpd.get()); prim_desc = convolution_forward::primitive_desc(itpd.get());
execPtr = std::make_shared<ConvolutionExecutor>(prim_desc,
srcMemPtr->GetPrimitive().get_desc(),
wghMemPtr->GetPrimitive().get_desc(),
dstMemPtr->GetPrimitive().get_desc(),
getEngine());
break; break;
} }
if (!itpd.next_impl())
IE_THROW() << "Primitive descriptor was not found for node " << getName() << "."; if (!itpd.next_impl()) {
auto inDesc = mkldnn::memory::desc(MKLDNNExtensionUtils::convertToDnnlDims(srcMemPtr->getStaticDims()),
srcMemPtr->GetDataType(),
memory::format_tag::any);
auto wghDesc = mkldnn::memory::desc(MKLDNNExtensionUtils::convertToDnnlDims(wghMemPtr->getStaticDims()),
wghMemPtr->GetDataType(),
memory::format_tag::any);
auto outDesc = mkldnn::memory::desc(MKLDNNExtensionUtils::convertToDnnlDims(dstMemPtr->getStaticDims()),
dstMemPtr->GetDataType(),
memory::format_tag::any);
std::shared_ptr<MKLDNNDescriptor> reorderConvDesc = createMkldnnConvDesc(inDesc, wghDesc, outDesc, biasDesc);
auto reordItpd = reorderConvDesc->createPrimitiveDescriptorIterator(getEngine(), *pAttrLocal);
if (static_cast<bool>(reordItpd)) {
auto prim_desc = convolution_forward::primitive_desc(reordItpd.get());
execPtr = std::make_shared<ConvolutionExecutor>(prim_desc, srcMemPtr->GetPrimitive().get_desc(),
wghMemPtr->GetPrimitive().get_desc(),
dstMemPtr->GetPrimitive().get_desc(),
getEngine());
break;
}
}
} }
if (execPtr) {
primArgs[DNNL_ARG_SRC] = srcMemPtr->GetPrimitive();
primArgs[DNNL_ARG_WEIGHTS] = wghMemPtr->GetPrimitive();
primArgs[DNNL_ARG_DST] = dstMemPtr->GetPrimitive();
prim.reset(new convolution_forward(prim_desc)); if (withBiases) {
primArgs[DNNL_ARG_BIAS] = biasMemPtr->GetPrimitive();
}
primArgs[DNNL_ARG_SRC] = getParentEdgesAtPort(0)[0]->getMemoryPtr()->GetPrimitive(); MKLDNNNode::appendPostOpArgs(*pAttrLocal, primArgs, binaryPostOpsArgs);
primArgs[DNNL_ARG_WEIGHTS] = getWeights(); } else {
primArgs[DNNL_ARG_DST] = getChildEdgesAtPort(0)[0]->getMemoryPtr()->GetPrimitive(); IE_THROW() << "Primitive descriptor was not found for node " << getName() << ".";
if (withBiases) {
primArgs[DNNL_ARG_BIAS] = getBias();
} }
appendPostOpArgs(*pAttrLocal, primArgs, binaryPostOpsArgs);
} }
void MKLDNNConvolutionNode::executeDynamicImpl(dnnl::stream strm) { MKLDNNConvolutionNode::ConvolutionExecutor::ConvolutionExecutor(const mkldnn::convolution_forward::primitive_desc& pd,
const mkldnn::memory::desc& inMemDesc,
const mkldnn::memory::desc& weightMemDesc,
const mkldnn::memory::desc& outMemDesc,
const mkldnn::engine& engine) {
execPrim.reset(new mkldnn::convolution_forward(pd));
if (inMemDesc != pd.src_desc()) {
inputReorders.insert({DNNL_ARG_SRC, IntermReorder(inMemDesc, pd.src_desc(), engine)});
}
if (weightMemDesc != pd.weights_desc()) {
inputReorders.insert({DNNL_ARG_WEIGHTS, IntermReorder(weightMemDesc, pd.weights_desc(), engine)});
}
if (outMemDesc != pd.dst_desc()) {
outputReorders.insert({DNNL_ARG_DST, IntermReorder(pd.dst_desc(), outMemDesc, engine)});
}
}
void MKLDNNConvolutionNode::execute(mkldnn::stream strm) {
if (!execPtr) {
IE_THROW() << "Can't execute Convolution node with name: " << getName() << ", because executor is not compiled";
}
execPtr->exec(primArgs, strm);
}
void MKLDNNConvolutionNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm); execute(strm);
} }

20
inference-engine/src/mkldnn_plugin/nodes/mkldnn_conv_node.h
View File

@ -9,6 +9,7 @@
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
#include "common/dnnl_executor.h"
namespace MKLDNNPlugin { namespace MKLDNNPlugin {
@ -23,7 +24,6 @@ public:
void createDescriptor(const std::vector<MemoryDescPtr>& inputDesc, void createDescriptor(const std::vector<MemoryDescPtr>& inputDesc,
const std::vector<MemoryDescPtr>& outputDesc) override; const std::vector<MemoryDescPtr>& outputDesc) override;
void initDescriptor(const NodeConfig& config) override; void initDescriptor(const NodeConfig& config) override;
void createPrimitive() override;
void selectOptimalPrimitiveDescriptor() override; void selectOptimalPrimitiveDescriptor() override;
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void filterSupportedPrimitiveDescriptors() override; void filterSupportedPrimitiveDescriptors() override;
@ -65,7 +65,25 @@ protected:
InferenceEngine::Precision fusedEltwisePrecision(const MKLDNNNodePtr& fusingNode) const; InferenceEngine::Precision fusedEltwisePrecision(const MKLDNNNodePtr& fusingNode) const;
private: private:
using executorPtr = std::shared_ptr<DnnlExecutor>;
executorPtr execPtr = nullptr;
class ConvolutionExecutor : public DnnlExecutor {
public:
ConvolutionExecutor(const mkldnn::convolution_forward::primitive_desc& pd,
const mkldnn::memory::desc& inMemDesc,
const mkldnn::memory::desc& weightMemDesc,
const mkldnn::memory::desc& outMemDesc,
const mkldnn::engine& engine);
};
std::shared_ptr<MKLDNNDescriptor> createMkldnnConvDesc(const mkldnn::memory::desc& srcDesc,
const mkldnn::memory::desc& wghDesc,
const mkldnn::memory::desc& dstDesc,
const mkldnn::memory::desc& biasDesc);
void prepareParams() override; void prepareParams() override;
void execute(mkldnn::stream strm) override;
void executeDynamicImpl(mkldnn::stream strm) override; void executeDynamicImpl(mkldnn::stream strm) override;
void addZeroPoints(mkldnn::primitive_attr& attr) const; void addZeroPoints(mkldnn::primitive_attr& attr) const;

11
inference-engine/src/mkldnn_plugin/nodes/mkldnn_convert_node.cpp
View File

@ -129,15 +129,8 @@ void MKLDNNConvertNode::initSupportedPrimitiveDescriptors() {
} }
} }
void MKLDNNConvertNode::createPrimitive() { void MKLDNNConvertNode::executeDynamicImpl(mkldnn::stream strm) {
auto& dstMemPtr = getChildEdgeAt(0)->getMemoryPtr(); execute(strm);
auto& srcMemPtr = getParentEdgeAt(0)->getMemoryPtr();
if (!dstMemPtr || !dstMemPtr->GetPrimitivePtr())
IE_THROW() << errorPrefix << " has not allocated destination memory";
if (!srcMemPtr || !srcMemPtr->GetPrimitivePtr())
IE_THROW() << errorPrefix << " has not allocated input memory";
if (getSelectedPrimitiveDescriptor() == nullptr)
IE_THROW() << errorPrefix << " has nullable preferable primitive descriptor";
} }
void MKLDNNConvertNode::execute(mkldnn::stream strm) { void MKLDNNConvertNode::execute(mkldnn::stream strm) {

3
inference-engine/src/mkldnn_plugin/nodes/mkldnn_convert_node.h
View File

@ -19,9 +19,8 @@ public:
void getSupportedDescriptors() override; void getSupportedDescriptors() override;
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); } void executeDynamicImpl(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
bool canBeInPlace() const override { bool canBeInPlace() const override {
return false; return false;

10
inference-engine/src/mkldnn_plugin/nodes/mkldnn_ctc_greedy_decoder_node.cpp
View File

@ -165,14 +165,8 @@ bool MKLDNNCTCGreedyDecoderNode::created() const {
return getType() == CTCGreedyDecoder; return getType() == CTCGreedyDecoder;
} }
void MKLDNNCTCGreedyDecoderNode::executeDynamicImpl(dnnl::stream strm) { void MKLDNNCTCGreedyDecoderNode::executeDynamicImpl(mkldnn::stream strm) {
MKLDNNCTCGreedyDecoderNode::execute(strm); execute(strm);
}
void MKLDNNCTCGreedyDecoderNode::createPrimitive() {
if (inputShapesDefined()) {
updateLastInputDims();
}
} }
bool MKLDNNCTCGreedyDecoderNode::needPrepareParams() const { bool MKLDNNCTCGreedyDecoderNode::needPrepareParams() const {

1
inference-engine/src/mkldnn_plugin/nodes/mkldnn_ctc_greedy_decoder_node.h
View File

@ -15,7 +15,6 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
void executeDynamicImpl(dnnl::stream strm) override; void executeDynamicImpl(dnnl::stream strm) override;

10
inference-engine/src/mkldnn_plugin/nodes/mkldnn_ctc_greedy_decoder_seq_len_node.cpp
View File

@ -168,14 +168,8 @@ bool MKLDNNCTCGreedyDecoderSeqLenNode::created() const {
return getType() == CTCGreedyDecoderSeqLen; return getType() == CTCGreedyDecoderSeqLen;
} }
void MKLDNNCTCGreedyDecoderSeqLenNode::createPrimitive() { void MKLDNNCTCGreedyDecoderSeqLenNode::executeDynamicImpl(mkldnn::stream strm) {
if (inputShapesDefined()) { execute(strm);
updateLastInputDims();
}
}
void MKLDNNCTCGreedyDecoderSeqLenNode::executeDynamicImpl(dnnl::stream strm) {
MKLDNNCTCGreedyDecoderSeqLenNode::execute(strm);
} }
bool MKLDNNCTCGreedyDecoderSeqLenNode::needPrepareParams() const { bool MKLDNNCTCGreedyDecoderSeqLenNode::needPrepareParams() const {

1
inference-engine/src/mkldnn_plugin/nodes/mkldnn_ctc_greedy_decoder_seq_len_node.h
View File

@ -15,7 +15,6 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
void executeDynamicImpl(dnnl::stream strm) override; void executeDynamicImpl(dnnl::stream strm) override;

8
inference-engine/src/mkldnn_plugin/nodes/mkldnn_ctc_loss_node.cpp
View File

@ -57,12 +57,8 @@ void MKLDNNCTCLossNode::initSupportedPrimitiveDescriptors() {
impl_desc_type::ref_any); impl_desc_type::ref_any);
} }
void MKLDNNCTCLossNode::createPrimitive() { void MKLDNNCTCLossNode::executeDynamicImpl(mkldnn::stream strm) {
if (inputShapesDefined()) { execute(strm);
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
} }
void MKLDNNCTCLossNode::execute(mkldnn::stream strm) { void MKLDNNCTCLossNode::execute(mkldnn::stream strm) {

3
inference-engine/src/mkldnn_plugin/nodes/mkldnn_ctc_loss_node.h
View File

@ -15,13 +15,12 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept; static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept;
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); }; void executeDynamicImpl(mkldnn::stream strm) override;
bool needPrepareParams() const override { return false; }; bool needPrepareParams() const override { return false; };
private: private:

8
inference-engine/src/mkldnn_plugin/nodes/mkldnn_cum_sum_node.cpp
View File

@ -258,13 +258,7 @@ bool MKLDNNCumSumNode::needPrepareParams() const {
} }
void MKLDNNCumSumNode::executeDynamicImpl(mkldnn::stream strm) { void MKLDNNCumSumNode::executeDynamicImpl(mkldnn::stream strm) {
return execute(strm); execute(strm);
}
void MKLDNNCumSumNode::createPrimitive() {
if (inputShapesDefined()) {
updateLastInputDims();
}
} }
REG_MKLDNN_PRIM_FOR(MKLDNNCumSumNode, CumSum) REG_MKLDNN_PRIM_FOR(MKLDNNCumSumNode, CumSum)

1
inference-engine/src/mkldnn_plugin/nodes/mkldnn_cum_sum_node.h
View File

@ -15,7 +15,6 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;

131
inference-engine/src/mkldnn_plugin/nodes/mkldnn_deconv_node.cpp
View File

@ -475,7 +475,7 @@ void MKLDNNDeconvolutionNode::execute(mkldnn::stream strm) {
if (!execPtr) { if (!execPtr) {
IE_THROW() << "Can't execute Deconvolution node with name: " << getName() << ", because executor is not compiled"; IE_THROW() << "Can't execute Deconvolution node with name: " << getName() << ", because executor is not compiled";
} }
execPtr->exec(strm); execPtr->exec(primArgs, strm);
if (externOutShape) { if (externOutShape) {
lastOutputSpatialDims = readOutputSpatialDims(); lastOutputSpatialDims = readOutputSpatialDims();
@ -519,12 +519,18 @@ void MKLDNNDeconvolutionNode::createDeconvPrim(std::shared_ptr<MKLDNNDescriptor>
prepareMemory(itpd); prepareMemory(itpd);
} }
auto prim_desc = deconvolution_forward::primitive_desc(itpd.get()); auto prim_desc = deconvolution_forward::primitive_desc(itpd.get());
execPtr = std::make_shared<DeconvExecutorInt8>(prim_desc, srcMemPtr, internalBlobMemory.front(), dstMemPtr, *attr, execPtr = std::make_shared<DeconvExecutorInt8>(prim_desc,
binaryPostOpsArgs, getEngine()); srcMemPtr->GetPrimitive().get_desc(),
internalBlobMemory.front()->GetPrimitive().get_desc(),
dstMemPtr->GetPrimitive().get_desc(),
getEngine());
} else { } else {
auto prim_desc = convolution_backward_data::primitive_desc(itpd.get()); auto prim_desc = convolution_backward_data::primitive_desc(itpd.get());
execPtr = std::make_shared<DeconvExecutorDefault>(prim_desc, srcMemPtr, wghMemPtr, dstMemPtr, *attr, execPtr = std::make_shared<DeconvExecutorDefault>(prim_desc,
binaryPostOpsArgs, getEngine()); srcMemPtr->GetPrimitive().get_desc(),
wghMemPtr->GetPrimitive().get_desc(),
dstMemPtr->GetPrimitive().get_desc(),
getEngine());
} }
return; return;
} }
@ -544,8 +550,11 @@ void MKLDNNDeconvolutionNode::createDeconvPrim(std::shared_ptr<MKLDNNDescriptor>
auto anyDeconvItpd = anyDeconvDesc->createPrimitiveDescriptorIterator(getEngine(), *attr); auto anyDeconvItpd = anyDeconvDesc->createPrimitiveDescriptorIterator(getEngine(), *attr);
if (static_cast<bool>(anyDeconvItpd)) { if (static_cast<bool>(anyDeconvItpd)) {
auto prim_desc = convolution_backward_data::primitive_desc(anyDeconvItpd.get()); auto prim_desc = convolution_backward_data::primitive_desc(anyDeconvItpd.get());
execPtr = std::make_shared<DeconvExecutorDefault>(prim_desc, srcMemPtr, wghMemPtr, dstMemPtr, *attr, execPtr = std::make_shared<DeconvExecutorDefault>(prim_desc,
binaryPostOpsArgs, getEngine()); srcMemPtr->GetPrimitive().get_desc(),
wghMemPtr->GetPrimitive().get_desc(),
dstMemPtr->GetPrimitive().get_desc(),
getEngine());
return; return;
} }
} }
@ -555,12 +564,15 @@ void MKLDNNDeconvolutionNode::createDeconvPrim(std::shared_ptr<MKLDNNDescriptor>
void MKLDNNDeconvolutionNode::prepareParams() { void MKLDNNDeconvolutionNode::prepareParams() {
auto srcMemPtr = getParentEdgesAtPort(0)[0]->getMemoryPtr(); auto srcMemPtr = getParentEdgesAtPort(0)[0]->getMemoryPtr();
auto wghMemPtr = getParentEdgesAtPort(1)[0]->getMemoryPtr();
auto dstMemPtr = getChildEdgesAtPort(0)[0]->getMemoryPtr(); auto dstMemPtr = getChildEdgesAtPort(0)[0]->getMemoryPtr();
if (!dstMemPtr || !dstMemPtr->GetPrimitivePtr()) if (!dstMemPtr || !dstMemPtr->GetPrimitivePtr())
IE_THROW() << "Destination memory didn't allocate."; IE_THROW() << "Destination memory didn't allocate.";
if (!srcMemPtr || !srcMemPtr->GetPrimitivePtr()) if (!srcMemPtr || !srcMemPtr->GetPrimitivePtr())
IE_THROW() << "Input memory didn't allocate."; IE_THROW() << "Input memory didn't allocate.";
const NodeDesc *selected_pd = getSelectedPrimitiveDescriptor(); const NodeDesc *selected_pd = getSelectedPrimitiveDescriptor();
if (!wghMemPtr || !wghMemPtr->GetPrimitivePtr())
IE_THROW() << "Weight memory didn't allocate.";
if (selected_pd == nullptr) if (selected_pd == nullptr)
IE_THROW() << "Preferable primitive descriptor is not set for node " << getName() << "."; IE_THROW() << "Preferable primitive descriptor is not set for node " << getName() << ".";
@ -610,7 +622,18 @@ void MKLDNNDeconvolutionNode::prepareParams() {
selected_pd->getImplementationType() == MKLDNNPlugin::impl_desc_type::jit_avx512_winograd); selected_pd->getImplementationType() == MKLDNNPlugin::impl_desc_type::jit_avx512_winograd);
} }
createDeconvPrim(desc, srcMemPtr, getParentEdgesAtPort(1)[0]->getMemoryPtr(), dstMemPtr, pAttrLocal, selected_pd->getImplementationType()); createDeconvPrim(desc, srcMemPtr, wghMemPtr, dstMemPtr, pAttrLocal, selected_pd->getImplementationType());
if (std::dynamic_pointer_cast<DeconvExecutorInt8>(execPtr)) {
primArgs = {{DNNL_ARG_SRC, srcMemPtr->GetPrimitive()},
{DNNL_ARG_WEIGHTS, internalBlobMemory.front()->GetPrimitive()},
{DNNL_ARG_DST, dstMemPtr->GetPrimitive()}};
} else {
primArgs = {{DNNL_ARG_DIFF_DST, srcMemPtr->GetPrimitive()},
{DNNL_ARG_WEIGHTS, wghMemPtr->GetPrimitive()},
{DNNL_ARG_DIFF_SRC, dstMemPtr->GetPrimitive()}};
}
MKLDNNNode::appendPostOpArgs(attr, primArgs, binaryPostOpsArgs);
} }
void MKLDNNDeconvolutionNode::createPrimitive() { void MKLDNNDeconvolutionNode::createPrimitive() {
@ -738,100 +761,44 @@ InferenceEngine::Precision MKLDNNDeconvolutionNode::getRuntimePrecision() const
return getMaxPrecision(inputPrecisions); return getMaxPrecision(inputPrecisions);
} }
MKLDNNDeconvolutionNode::DeconvExecutor::IntermReorder::IntermReorder(MKLDNNMemoryPtr memFrom,
const mkldnn::memory::desc& descTo,
const mkldnn::engine& engine) : m_memFrom(memFrom) {
m_memTo = std::make_shared<MKLDNNMemory>(engine);
m_memTo->Create(MKLDNNExtensionUtils::makeDescriptor(descTo));
m_reorder = mkldnn::reorder(m_memFrom->GetPrimitive(), m_memTo->GetPrimitive());
}
MKLDNNDeconvolutionNode::DeconvExecutor::IntermReorder::IntermReorder(const mkldnn::memory::desc& descFrom,
MKLDNNMemoryPtr memTo,
const mkldnn::engine& engine) : m_memTo(memTo) {
m_memFrom = std::make_shared<MKLDNNMemory>(engine);
m_memFrom->Create(MKLDNNExtensionUtils::makeDescriptor(descFrom));
m_reorder = mkldnn::reorder(m_memFrom->GetPrimitive(), m_memTo->GetPrimitive());
}
void MKLDNNDeconvolutionNode::DeconvExecutor::IntermReorder::exec(mkldnn::stream strm) {
auto src = m_memFrom->GetPrimitive();
auto dst = m_memTo->GetPrimitive();
m_reorder.execute(strm, src, dst);
}
void MKLDNNDeconvolutionNode::DeconvExecutor::exec(mkldnn::stream strm) {
for (auto &inReorder : inputReorders) {
inReorder.exec(strm);
}
(*execPrim).execute(strm, primArgs);
for (auto &outReorder : outputReorders) {
outReorder.exec(strm);
}
}
MKLDNNDeconvolutionNode::DeconvExecutorDefault::DeconvExecutorDefault(const mkldnn::convolution_backward_data::primitive_desc& pd, MKLDNNDeconvolutionNode::DeconvExecutorDefault::DeconvExecutorDefault(const mkldnn::convolution_backward_data::primitive_desc& pd,
MKLDNNMemoryPtr inMem, const mkldnn::memory::desc& inMemDesc,
MKLDNNMemoryPtr weightMem, const mkldnn::memory::desc& weightMemDesc,
MKLDNNMemoryPtr outMem, const mkldnn::memory::desc& outMemDesc,
const mkldnn::primitive_attr &attr,
const std::vector<MKLDNNMemoryPtr>& binPostOpsArgs,
const mkldnn::engine& engine) { const mkldnn::engine& engine) {
execPrim.reset(new mkldnn::convolution_backward_data(pd)); execPrim.reset(new mkldnn::convolution_backward_data(pd));
if (inMem->GetPrimitive().get_desc() != pd.diff_dst_desc()) { if (inMemDesc != pd.diff_dst_desc()) {
inputReorders.push_back(IntermReorder(inMem, pd.diff_dst_desc(), engine)); inputReorders.insert({DNNL_ARG_DIFF_DST, IntermReorder(inMemDesc, pd.diff_dst_desc(), engine)});
primArgs[DNNL_ARG_DIFF_DST] = inputReorders.back().getToMem()->GetPrimitive();
} else {
primArgs[DNNL_ARG_DIFF_DST] = inMem->GetPrimitive();
} }
if (weightMem->GetPrimitive().get_desc() != pd.weights_desc()) { if (weightMemDesc != pd.weights_desc()) {
inputReorders.push_back(IntermReorder(weightMem, pd.weights_desc(), engine)); inputReorders.insert({DNNL_ARG_WEIGHTS, IntermReorder(weightMemDesc, pd.weights_desc(), engine)});
primArgs[DNNL_ARG_WEIGHTS] = inputReorders.back().getToMem()->GetPrimitive();
} else {
primArgs[DNNL_ARG_WEIGHTS] = weightMem->GetPrimitive();
} }
if (outMem->GetPrimitive().get_desc() != pd.diff_src_desc()) { if (outMemDesc != pd.diff_src_desc()) {
outputReorders.push_back(IntermReorder(pd.diff_src_desc(), outMem, engine)); outputReorders.insert({DNNL_ARG_DIFF_SRC, IntermReorder(pd.diff_src_desc(), outMemDesc, engine)});
primArgs[DNNL_ARG_DIFF_SRC] = outputReorders.back().getFromMem()->GetPrimitive();
} else {
primArgs[DNNL_ARG_DIFF_SRC] = outMem->GetPrimitive();
} }
MKLDNNNode::appendPostOpArgs(attr, primArgs, binPostOpsArgs);
} }
MKLDNNDeconvolutionNode::DeconvExecutorInt8::DeconvExecutorInt8(const mkldnn::deconvolution_forward::primitive_desc& pd, MKLDNNDeconvolutionNode::DeconvExecutorInt8::DeconvExecutorInt8(const mkldnn::deconvolution_forward::primitive_desc& pd,
MKLDNNMemoryPtr inMem, const mkldnn::memory::desc& inMemDesc,
MKLDNNMemoryPtr weightMem, const mkldnn::memory::desc& weightMemDesc,
MKLDNNMemoryPtr outMem, const mkldnn::memory::desc& outMemDesc,
const mkldnn::primitive_attr &attr,
const std::vector<MKLDNNMemoryPtr>& binPostOpsArgs,
const mkldnn::engine& engine) { const mkldnn::engine& engine) {
execPrim.reset(new mkldnn::deconvolution_forward(pd)); execPrim.reset(new mkldnn::deconvolution_forward(pd));
if (inMem->GetPrimitive().get_desc() != pd.src_desc()) { if (inMemDesc != pd.src_desc()) {
inputReorders.push_back(IntermReorder(inMem, pd.src_desc(), engine)); inputReorders.insert({DNNL_ARG_SRC, IntermReorder(inMemDesc, pd.src_desc(), engine)});
primArgs[DNNL_ARG_SRC] = inputReorders.back().getToMem()->GetPrimitive();
} else {
primArgs[DNNL_ARG_SRC] = inMem->GetPrimitive();
} }
if (weightMem->GetPrimitive().get_desc() != pd.weights_desc()) { if (weightMemDesc != pd.weights_desc()) {
inputReorders.push_back(IntermReorder(weightMem, pd.weights_desc(), engine)); inputReorders.insert({DNNL_ARG_WEIGHTS, IntermReorder(weightMemDesc, pd.weights_desc(), engine)});
primArgs[DNNL_ARG_WEIGHTS] = inputReorders.back().getToMem()->GetPrimitive();
} else {
primArgs[DNNL_ARG_WEIGHTS] = weightMem->GetPrimitive();
} }
if (outMem->GetPrimitive().get_desc() != pd.dst_desc()) { if (outMemDesc != pd.dst_desc()) {
outputReorders.push_back(IntermReorder(pd.dst_desc(), outMem, engine)); outputReorders.insert({DNNL_ARG_DST, IntermReorder(pd.dst_desc(), outMemDesc, engine)});
primArgs[DNNL_ARG_DST] = outputReorders.back().getFromMem()->GetPrimitive();
} else {
primArgs[DNNL_ARG_DST] = outMem->GetPrimitive();
} }
MKLDNNNode::appendPostOpArgs(attr, primArgs, binPostOpsArgs);
} }
std::vector<int32_t> MKLDNNDeconvolutionNode::readOutputSpatialDims() const { std::vector<int32_t> MKLDNNDeconvolutionNode::readOutputSpatialDims() const {

51
inference-engine/src/mkldnn_plugin/nodes/mkldnn_deconv_node.h
View File

@ -9,6 +9,7 @@
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
#include "common/dnnl_executor.h"
namespace MKLDNNPlugin { namespace MKLDNNPlugin {
@ -53,56 +54,24 @@ public:
std::vector<VectorDims> shapeInfer() const override; std::vector<VectorDims> shapeInfer() const override;
private: private:
class DeconvExecutor { using executorPtr = std::shared_ptr<DnnlExecutor>;
protected:
class IntermReorder {
public:
IntermReorder(MKLDNNMemoryPtr memFrom, const mkldnn::memory::desc& descTo, const mkldnn::engine& engine);
IntermReorder(const mkldnn::memory::desc& descFrom, MKLDNNMemoryPtr memTo, const mkldnn::engine& engine);
MKLDNNMemoryPtr getFromMem() const { return m_memFrom; }
MKLDNNMemoryPtr getToMem() const { return m_memTo; }
void exec(mkldnn::stream strm);
private:
MKLDNNMemoryPtr m_memFrom;
MKLDNNMemoryPtr m_memTo;
mkldnn::reorder m_reorder;
};
public:
void exec(mkldnn::stream strm);
virtual ~DeconvExecutor() = default;
protected:
DeconvExecutor() = default;
std::vector<IntermReorder> inputReorders;
MKLDNNPrimitive execPrim;
std::vector<IntermReorder> outputReorders;
std::unordered_map<int, mkldnn::memory> primArgs;
};
using executorPtr = std::shared_ptr<DeconvExecutor>;
executorPtr execPtr = nullptr; executorPtr execPtr = nullptr;
class DeconvExecutorDefault : public DeconvExecutor { class DeconvExecutorDefault : public DnnlExecutor {
public: public:
DeconvExecutorDefault(const mkldnn::convolution_backward_data::primitive_desc& pd, DeconvExecutorDefault(const mkldnn::convolution_backward_data::primitive_desc& pd,
MKLDNNMemoryPtr inMem, const mkldnn::memory::desc& inMemDesc,
MKLDNNMemoryPtr weightMem, const mkldnn::memory::desc& weightMemDesc,
MKLDNNMemoryPtr outMem, const mkldnn::memory::desc& outMemDesc,
const mkldnn::primitive_attr &attr,
const std::vector<MKLDNNMemoryPtr>& binPostOpsArgs,
const mkldnn::engine& engine); const mkldnn::engine& engine);
}; };
class DeconvExecutorInt8 : public DeconvExecutor { class DeconvExecutorInt8 : public DnnlExecutor {
public: public:
DeconvExecutorInt8(const mkldnn::deconvolution_forward::primitive_desc& pd, DeconvExecutorInt8(const mkldnn::deconvolution_forward::primitive_desc& pd,
MKLDNNMemoryPtr inMem, const mkldnn::memory::desc& inMemDesc,
MKLDNNMemoryPtr weightMem, const mkldnn::memory::desc& weightMemDesc,
MKLDNNMemoryPtr outMem, const mkldnn::memory::desc& outMemDesc,
const mkldnn::primitive_attr &attr,
const std::vector<MKLDNNMemoryPtr>& binPostOpsArgs,
const mkldnn::engine& engine); const mkldnn::engine& engine);
}; };

14
inference-engine/src/mkldnn_plugin/nodes/mkldnn_detection_output_node.cpp
View File

@ -49,15 +49,7 @@ bool MKLDNNDetectionOutputNode::isSupportedOperation(const std::shared_ptr<const
return true; return true;
} }
void MKLDNNDetectionOutputNode::createPrimitive() { MKLDNNDetectionOutputNode::MKLDNNDetectionOutputNode(const std::shared_ptr<ngraph::Node>& op, const mkldnn::engine& eng,
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
MKLDNNDetectionOutputNode::MKLDNNDetectionOutputNode(const std::shared_ptr<ov::Node>& op, const mkldnn::engine& eng,
MKLDNNWeightsSharing::Ptr &cache) : MKLDNNNode(op, eng, cache) { MKLDNNWeightsSharing::Ptr &cache) : MKLDNNNode(op, eng, cache) {
std::string errorMessage; std::string errorMessage;
if (!isSupportedOperation(op, errorMessage)) { if (!isSupportedOperation(op, errorMessage)) {
@ -170,6 +162,10 @@ struct ConfidenceComparatorDO {
const float* confData; const float* confData;
}; };
void MKLDNNDetectionOutputNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
void MKLDNNDetectionOutputNode::execute(mkldnn::stream strm) { void MKLDNNDetectionOutputNode::execute(mkldnn::stream strm) {
float *dstData = reinterpret_cast<float *>(getChildEdgesAtPort(0)[0]->getMemoryPtr()->GetPtr()); float *dstData = reinterpret_cast<float *>(getChildEdgesAtPort(0)[0]->getMemoryPtr()->GetPtr());

3
inference-engine/src/mkldnn_plugin/nodes/mkldnn_detection_output_node.h
View File

@ -16,7 +16,6 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
@ -24,7 +23,7 @@ public:
protected: protected:
void prepareParams() override; void prepareParams() override;
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); } void executeDynamicImpl(mkldnn::stream strm) override;
private: private:
static const int ID_LOC = 0; static const int ID_LOC = 0;

12
inference-engine/src/mkldnn_plugin/nodes/mkldnn_eltwise_node.cpp
View File

@ -1525,14 +1525,6 @@ void MKLDNNEltwiseNode::selectOptimalPrimitiveDescriptor() {
selectPreferPrimitiveDescriptor(getPrimitivesPriority(), true); selectPreferPrimitiveDescriptor(getPrimitivesPriority(), true);
} }
void MKLDNNEltwiseNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
void MKLDNNEltwiseNode::initOptimalPrimitiveDescriptor() { void MKLDNNEltwiseNode::initOptimalPrimitiveDescriptor() {
auto selected_pd = getSelectedPrimitiveDescriptor(); auto selected_pd = getSelectedPrimitiveDescriptor();
if (selected_pd == nullptr) if (selected_pd == nullptr)
@ -1683,6 +1675,10 @@ void MKLDNNEltwiseNode::executeReference(const jit_eltwise_params &jep, const ji
}); });
} }
void MKLDNNEltwiseNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
void MKLDNNEltwiseNode::execute(mkldnn::stream strm) { void MKLDNNEltwiseNode::execute(mkldnn::stream strm) {
if (execPtr) { if (execPtr) {
jit_eltwise_call_args_ptrs args_ptrs = {}; jit_eltwise_call_args_ptrs args_ptrs = {};

4
inference-engine/src/mkldnn_plugin/nodes/mkldnn_eltwise_node.h
View File

@ -90,13 +90,11 @@ public:
bool isWithBroadcast(); bool isWithBroadcast();
bool isSpecialConvolutionAddFusing() const { return specialConvolutionAddFusing; } bool isSpecialConvolutionAddFusing() const { return specialConvolutionAddFusing; }
void createPrimitive() override;
std::vector<VectorDims> shapeInfer() const override; std::vector<VectorDims> shapeInfer() const override;
bool needPrepareParams() const override; bool needPrepareParams() const override;
void prepareParams() override; void prepareParams() override;
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); } void executeDynamicImpl(mkldnn::stream strm) override;
enum BroadcastingPolicy { enum BroadcastingPolicy {
PerChannel, PerChannel,

16
inference-engine/src/mkldnn_plugin/nodes/mkldnn_embedding_bag_offset_sum_node.cpp
View File

@ -70,14 +70,6 @@ void MKLDNNEmbeddingBagOffsetSumNode::initSupportedPrimitiveDescriptors() {
addSupportedPrimDesc(inDataConfigurators, {{LayoutType::ncsp, inDataPrecision}}, impl_desc_type::ref_any); addSupportedPrimDesc(inDataConfigurators, {{LayoutType::ncsp, inDataPrecision}}, impl_desc_type::ref_any);
} }
void MKLDNNEmbeddingBagOffsetSumNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
void MKLDNNEmbeddingBagOffsetSumNode::prepareParams() { void MKLDNNEmbeddingBagOffsetSumNode::prepareParams() {
_indicesLen = getParentEdgesAtPort(INDICES_IDX)[0]->getMemory().getStaticDims()[0]; _indicesLen = getParentEdgesAtPort(INDICES_IDX)[0]->getMemory().getStaticDims()[0];
_offsetsLen = getParentEdgesAtPort(OFFSETS_IDX)[0]->getMemory().getStaticDims()[0]; _offsetsLen = getParentEdgesAtPort(OFFSETS_IDX)[0]->getMemory().getStaticDims()[0];
@ -126,6 +118,14 @@ void MKLDNNEmbeddingBagOffsetSumNode::getIndices(int embIndex, const int*& indic
weightsIdx = offsetsData_[embIndex]; weightsIdx = offsetsData_[embIndex];
} }
void MKLDNNEmbeddingBagOffsetSumNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
bool MKLDNNEmbeddingBagOffsetSumNode::isExecutable() const {
return !isInputTensorAtPortEmpty(0);
}
void MKLDNNEmbeddingBagOffsetSumNode::execute(mkldnn::stream strm) { void MKLDNNEmbeddingBagOffsetSumNode::execute(mkldnn::stream strm) {
const auto *srcData = reinterpret_cast<const uint8_t *>(getParentEdgeAt(0)->getMemoryPtr()->GetPtr()); const auto *srcData = reinterpret_cast<const uint8_t *>(getParentEdgeAt(0)->getMemoryPtr()->GetPtr());
auto *dstData = reinterpret_cast<uint8_t *>(getChildEdgeAt(0)->getMemoryPtr()->GetPtr()); auto *dstData = reinterpret_cast<uint8_t *>(getChildEdgeAt(0)->getMemoryPtr()->GetPtr());

4
inference-engine/src/mkldnn_plugin/nodes/mkldnn_embedding_bag_offset_sum_node.h
View File

@ -19,15 +19,15 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
bool isExecutable() const override;
static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept; static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept;
protected: protected:
void prepareParams() override; void prepareParams() override;
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); } void executeDynamicImpl(mkldnn::stream strm) override;
private: private:
void initFromInputs() override; void initFromInputs() override;

16
inference-engine/src/mkldnn_plugin/nodes/mkldnn_embedding_bag_packed_sum_node.cpp
View File

@ -64,14 +64,6 @@ void MKLDNNEmbeddingBagPackedSumNode::initSupportedPrimitiveDescriptors() {
addSupportedPrimDesc(inDataConfigurators, {{LayoutType::ncsp, inDataPrecision}}, impl_desc_type::ref_any); addSupportedPrimDesc(inDataConfigurators, {{LayoutType::ncsp, inDataPrecision}}, impl_desc_type::ref_any);
} }
void MKLDNNEmbeddingBagPackedSumNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
void MKLDNNEmbeddingBagPackedSumNode::prepareParams() { void MKLDNNEmbeddingBagPackedSumNode::prepareParams() {
_batch = getParentEdgesAtPort(INDICES_IDX)[0]->getMemory().getStaticDims()[0]; _batch = getParentEdgesAtPort(INDICES_IDX)[0]->getMemory().getStaticDims()[0];
_indicesPerBag = getParentEdgesAtPort(INDICES_IDX)[0]->getMemory().getStaticDims()[1]; _indicesPerBag = getParentEdgesAtPort(INDICES_IDX)[0]->getMemory().getStaticDims()[1];
@ -94,6 +86,14 @@ void MKLDNNEmbeddingBagPackedSumNode::getIndices(int embIndex, const int*& indic
weightsIdx = embIndex * _indicesPerBag; weightsIdx = embIndex * _indicesPerBag;
} }
void MKLDNNEmbeddingBagPackedSumNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
bool MKLDNNEmbeddingBagPackedSumNode::isExecutable() const {
return !isInputTensorAtPortEmpty(0);
}
void MKLDNNEmbeddingBagPackedSumNode::execute(mkldnn::stream strm) { void MKLDNNEmbeddingBagPackedSumNode::execute(mkldnn::stream strm) {
const auto *srcData = reinterpret_cast<const uint8_t *>(getParentEdgeAt(0)->getMemoryPtr()->GetPtr()); const auto *srcData = reinterpret_cast<const uint8_t *>(getParentEdgeAt(0)->getMemoryPtr()->GetPtr());
auto *dstData = reinterpret_cast<uint8_t *>(getChildEdgeAt(0)->getMemoryPtr()->GetPtr()); auto *dstData = reinterpret_cast<uint8_t *>(getChildEdgeAt(0)->getMemoryPtr()->GetPtr());

4
inference-engine/src/mkldnn_plugin/nodes/mkldnn_embedding_bag_packed_sum_node.h
View File

@ -19,15 +19,15 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
bool isExecutable() const override;
static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept; static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept;
protected: protected:
void prepareParams() override; void prepareParams() override;
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); } void executeDynamicImpl(mkldnn::stream strm) override;
private: private:
void initFromInputs() override; void initFromInputs() override;

16
inference-engine/src/mkldnn_plugin/nodes/mkldnn_embedding_segments_sum_node.cpp
View File

@ -11,14 +11,6 @@
using namespace MKLDNNPlugin; using namespace MKLDNNPlugin;
using namespace InferenceEngine; using namespace InferenceEngine;
void MKLDNNEmbeddingSegmentsSumNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
bool MKLDNNEmbeddingSegmentsSumNode::isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept { bool MKLDNNEmbeddingSegmentsSumNode::isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept {
try { try {
const auto embBagSegSumOp = ngraph::as_type_ptr<const ngraph::op::v3::EmbeddingSegmentsSum>(op); const auto embBagSegSumOp = ngraph::as_type_ptr<const ngraph::op::v3::EmbeddingSegmentsSum>(op);
@ -129,6 +121,14 @@ void MKLDNNEmbeddingSegmentsSumNode::getIndices(int embIndex, const int*& indice
} }
} }
void MKLDNNEmbeddingSegmentsSumNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
bool MKLDNNEmbeddingSegmentsSumNode::isExecutable() const {
return !isInputTensorAtPortEmpty(0);
}
void MKLDNNEmbeddingSegmentsSumNode::execute(mkldnn::stream strm) { void MKLDNNEmbeddingSegmentsSumNode::execute(mkldnn::stream strm) {
const auto *srcData = reinterpret_cast<const uint8_t *>(getParentEdgeAt(0)->getMemoryPtr()->GetPtr()); const auto *srcData = reinterpret_cast<const uint8_t *>(getParentEdgeAt(0)->getMemoryPtr()->GetPtr());
auto *dstData = reinterpret_cast<uint8_t *>(getChildEdgeAt(0)->getMemoryPtr()->GetPtr()); auto *dstData = reinterpret_cast<uint8_t *>(getChildEdgeAt(0)->getMemoryPtr()->GetPtr());

4
inference-engine/src/mkldnn_plugin/nodes/mkldnn_embedding_segments_sum_node.h
View File

@ -19,15 +19,15 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
bool isExecutable() const override;
static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept; static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept;
protected: protected:
void prepareParams() override; void prepareParams() override;
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); } void executeDynamicImpl(mkldnn::stream strm) override;
private: private:
void initFromInputs() override; void initFromInputs() override;

6
inference-engine/src/mkldnn_plugin/nodes/mkldnn_experimental_detectron_detection_output_node.cpp
View File

@ -272,12 +272,6 @@ void MKLDNNExperimentalDetectronDetectionOutputNode::initSupportedPrimitiveDescr
impl_desc_type::ref_any); impl_desc_type::ref_any);
} }
void MKLDNNExperimentalDetectronDetectionOutputNode::createPrimitive() {
if (inputShapesDefined()) {
updateLastInputDims();
}
}
void MKLDNNExperimentalDetectronDetectionOutputNode::execute(mkldnn::stream strm) { void MKLDNNExperimentalDetectronDetectionOutputNode::execute(mkldnn::stream strm) {
const int rois_num = getParentEdgeAt(INPUT_ROIS)->getMemory().getStaticDims()[0]; const int rois_num = getParentEdgeAt(INPUT_ROIS)->getMemory().getStaticDims()[0];
assert(classes_num_ == static_cast<int>(getParentEdgeAt(INPUT_SCORES)->getMemory().getStaticDims()[1])); assert(classes_num_ == static_cast<int>(getParentEdgeAt(INPUT_SCORES)->getMemory().getStaticDims()[1]));

1
inference-engine/src/mkldnn_plugin/nodes/mkldnn_experimental_detectron_detection_output_node.h
View File

@ -15,7 +15,6 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;

6
inference-engine/src/mkldnn_plugin/nodes/mkldnn_experimental_detectron_generate_proposals_single_image_node.cpp
View File

@ -320,12 +320,6 @@ void MKLDNNExperimentalDetectronGenerateProposalsSingleImageNode::initSupportedP
impl_desc_type::ref_any); impl_desc_type::ref_any);
} }
void MKLDNNExperimentalDetectronGenerateProposalsSingleImageNode::createPrimitive() {
if (inputShapesDefined()) {
updateLastInputDims();
}
}
void MKLDNNExperimentalDetectronGenerateProposalsSingleImageNode::execute(mkldnn::stream strm) { void MKLDNNExperimentalDetectronGenerateProposalsSingleImageNode::execute(mkldnn::stream strm) {
try { try {
if (inputShapes.size() != 4 || outputShapes.size() != 2) { if (inputShapes.size() != 4 || outputShapes.size() != 2) {

1
inference-engine/src/mkldnn_plugin/nodes/mkldnn_experimental_detectron_generate_proposals_single_image_node.h
View File

@ -16,7 +16,6 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;

6
inference-engine/src/mkldnn_plugin/nodes/mkldnn_experimental_detectron_priorgridgenerator_node.cpp
View File

@ -56,12 +56,6 @@ void MKLDNNExperimentalDetectronPriorGridGeneratorNode::initSupportedPrimitiveDe
impl_desc_type::ref_any); impl_desc_type::ref_any);
} }
void MKLDNNExperimentalDetectronPriorGridGeneratorNode::createPrimitive() {
if (inputShapesDefined()) {
updateLastInputDims();
}
}
void MKLDNNExperimentalDetectronPriorGridGeneratorNode::execute(mkldnn::stream strm) { void MKLDNNExperimentalDetectronPriorGridGeneratorNode::execute(mkldnn::stream strm) {
const int num_priors_ = getParentEdgeAt(INPUT_PRIORS)->getMemory().getStaticDims()[0]; const int num_priors_ = getParentEdgeAt(INPUT_PRIORS)->getMemory().getStaticDims()[0];
assert(getParentEdgeAt(INPUT_PRIORS)->getMemory().getStaticDims()[1] == 4); assert(getParentEdgeAt(INPUT_PRIORS)->getMemory().getStaticDims()[1] == 4);

1
inference-engine/src/mkldnn_plugin/nodes/mkldnn_experimental_detectron_priorgridgenerator_node.h
View File

@ -15,7 +15,6 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;

1
inference-engine/src/mkldnn_plugin/nodes/mkldnn_experimental_detectron_roifeatureextractor_node.h
View File

@ -15,7 +15,6 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override {};
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;

1
inference-engine/src/mkldnn_plugin/nodes/mkldnn_experimental_detectron_topkrois_node.h
View File

@ -15,7 +15,6 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override {};
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;

10
inference-engine/src/mkldnn_plugin/nodes/mkldnn_extract_image_patches_node.cpp
View File

@ -327,14 +327,6 @@ MKLDNNExtractImagePatchesNode::MKLDNNExtractImagePatchesNode(const std::shared_p
IE_THROW() << errorPrefix << "must have the following attributes with shape {2}: sizes, strides, rates."; IE_THROW() << errorPrefix << "must have the following attributes with shape {2}: sizes, strides, rates.";
} }
void MKLDNNExtractImagePatchesNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
void MKLDNNExtractImagePatchesNode::prepareParams() { void MKLDNNExtractImagePatchesNode::prepareParams() {
const auto& srcMemPtr0 = getParentEdgeAt(0)->getMemoryPtr(); const auto& srcMemPtr0 = getParentEdgeAt(0)->getMemoryPtr();
const auto& dstMemPtr = getChildEdgeAt(0)->getMemoryPtr(); const auto& dstMemPtr = getChildEdgeAt(0)->getMemoryPtr();
@ -381,7 +373,7 @@ void MKLDNNExtractImagePatchesNode::execute(mkldnn::stream strm) {
} }
void MKLDNNExtractImagePatchesNode::executeDynamicImpl(mkldnn::stream strm) { void MKLDNNExtractImagePatchesNode::executeDynamicImpl(mkldnn::stream strm) {
return execute(strm); execute(strm);
} }
void MKLDNNExtractImagePatchesNode::ExtractImagePatchesRefExecutor::executeReference( void MKLDNNExtractImagePatchesNode::ExtractImagePatchesRefExecutor::executeReference(

1
inference-engine/src/mkldnn_plugin/nodes/mkldnn_extract_image_patches_node.h
View File

@ -45,7 +45,6 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;

11
inference-engine/src/mkldnn_plugin/nodes/mkldnn_fake_quantize_node.cpp
View File

@ -1387,13 +1387,6 @@ void MKLDNNFakeQuantizeNode::prepareParams() {
} }
} }
void MKLDNNFakeQuantizeNode::createPrimitive() {
if (inputShapesDefined()) {
prepareParams();
updateLastInputDims();
}
}
void MKLDNNFakeQuantizeNode::executeReference() { void MKLDNNFakeQuantizeNode::executeReference() {
auto &srcMemory = getParentEdgeAt(0)->getMemoryPtr(); auto &srcMemory = getParentEdgeAt(0)->getMemoryPtr();
auto &dstMemory = getChildEdgeAt(0)->getMemoryPtr(); auto &dstMemory = getChildEdgeAt(0)->getMemoryPtr();
@ -1652,6 +1645,10 @@ void MKLDNNFakeQuantizeNode::executeQuantization(const std::unique_ptr<jit_uni_q
} }
} }
void MKLDNNFakeQuantizeNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
void MKLDNNFakeQuantizeNode::execute(mkldnn::stream strm) { void MKLDNNFakeQuantizeNode::execute(mkldnn::stream strm) {
auto selectedPrimitiveDescriptor = getSelectedPrimitiveDescriptor(); auto selectedPrimitiveDescriptor = getSelectedPrimitiveDescriptor();
if (!selectedPrimitiveDescriptor) if (!selectedPrimitiveDescriptor)

3
inference-engine/src/mkldnn_plugin/nodes/mkldnn_fake_quantize_node.h
View File

@ -70,10 +70,9 @@ public:
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void getSupportedDescriptors() override; void getSupportedDescriptors() override;
void createPrimitive() override;
bool created() const override; bool created() const override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); } void executeDynamicImpl(mkldnn::stream strm) override;
size_t getAxis() const { return axis; } size_t getAxis() const { return axis; }

12
inference-engine/src/mkldnn_plugin/nodes/mkldnn_gather_elements_node.cpp
View File

@ -54,14 +54,6 @@ MKLDNNGatherElementsNode::MKLDNNGatherElementsNode(const std::shared_ptr<ngraph:
axis_ = axis; axis_ = axis;
} }
void MKLDNNGatherElementsNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
void MKLDNNGatherElementsNode::prepareParams() { void MKLDNNGatherElementsNode::prepareParams() {
const auto& dataDims = getParentEdgesAtPort(dataIndex_)[0]->getMemory().getStaticDims(); const auto& dataDims = getParentEdgesAtPort(dataIndex_)[0]->getMemory().getStaticDims();
const auto& dstDims = getChildEdgesAtPort(0)[0]->getMemory().getStaticDims(); const auto& dstDims = getChildEdgesAtPort(0)[0]->getMemory().getStaticDims();
@ -102,6 +94,10 @@ void MKLDNNGatherElementsNode::initSupportedPrimitiveDescriptors() {
impl_desc_type::ref_any); impl_desc_type::ref_any);
} }
void MKLDNNGatherElementsNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
template <typename dataType> template <typename dataType>
void MKLDNNGatherElementsNode::directExecution() { void MKLDNNGatherElementsNode::directExecution() {
const auto *srcData = reinterpret_cast<const dataType *>(getParentEdgeAt(dataIndex_)->getMemoryPtr()->GetPtr()); const auto *srcData = reinterpret_cast<const dataType *>(getParentEdgeAt(dataIndex_)->getMemoryPtr()->GetPtr());

3
inference-engine/src/mkldnn_plugin/nodes/mkldnn_gather_elements_node.h
View File

@ -18,14 +18,13 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept; static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
protected: protected:
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); } void executeDynamicImpl(mkldnn::stream strm) override;
void prepareParams() override; void prepareParams() override;
private: private:

10
inference-engine/src/mkldnn_plugin/nodes/mkldnn_gather_nd_node.cpp
View File

@ -80,14 +80,6 @@ void MKLDNNGatherNDNode::initSupportedPrimitiveDescriptors() {
impl_desc_type::ref_any); impl_desc_type::ref_any);
} }
void MKLDNNGatherNDNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
void MKLDNNGatherNDNode::prepareParams() { void MKLDNNGatherNDNode::prepareParams() {
auto& srcMemPtr = getParentEdgeAt(GATHERND_DATA)->getMemoryPtr(); auto& srcMemPtr = getParentEdgeAt(GATHERND_DATA)->getMemoryPtr();
auto& idxMemPtr = getParentEdgeAt(GATHERND_INDEXES)->getMemoryPtr(); auto& idxMemPtr = getParentEdgeAt(GATHERND_INDEXES)->getMemoryPtr();
@ -227,7 +219,7 @@ void MKLDNNGatherNDNode::GatherNDExecutor::gatherElementwise(const MKLDNNMemoryP
}); });
} }
void MKLDNNGatherNDNode::executeDynamicImpl(dnnl::stream strm) { void MKLDNNGatherNDNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm); execute(strm);
} }

1
inference-engine/src/mkldnn_plugin/nodes/mkldnn_gather_nd_node.h
View File

@ -18,7 +18,6 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;

10
inference-engine/src/mkldnn_plugin/nodes/mkldnn_gather_node.cpp
View File

@ -110,20 +110,12 @@ void MKLDNNGatherNode::prepareParams() {
} }
bool MKLDNNGatherNode::needPrepareParams() const { bool MKLDNNGatherNode::needPrepareParams() const {
bool result = MKLDNNNode::needPrepareParams(); bool result = inputShapesModified();
if (!isAxisInputConst) if (!isAxisInputConst)
result = result || axis != (reinterpret_cast<const int32_t*>(getParentEdgeAt(GATHER_AXIS)->getMemoryPtr()->GetPtr()))[0]; result = result || axis != (reinterpret_cast<const int32_t*>(getParentEdgeAt(GATHER_AXIS)->getMemoryPtr()->GetPtr()))[0];
return result; return result;
} }
void MKLDNNGatherNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
void MKLDNNGatherNode::execute(mkldnn::stream strm) { void MKLDNNGatherNode::execute(mkldnn::stream strm) {
const int32_t* srcIndexes = reinterpret_cast<const int32_t*>(getParentEdgeAt(GATHER_INDEXES)->getMemoryPtr()->GetPtr()); const int32_t* srcIndexes = reinterpret_cast<const int32_t*>(getParentEdgeAt(GATHER_INDEXES)->getMemoryPtr()->GetPtr());
const uint8_t* srcData = reinterpret_cast<const uint8_t*>(getParentEdgeAt(GATHER_DATA)->getMemoryPtr()->GetPtr()); const uint8_t* srcData = reinterpret_cast<const uint8_t*>(getParentEdgeAt(GATHER_DATA)->getMemoryPtr()->GetPtr());

1
inference-engine/src/mkldnn_plugin/nodes/mkldnn_gather_node.h
View File

@ -18,7 +18,6 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;

2
inference-engine/src/mkldnn_plugin/nodes/mkldnn_interpolate_node.cpp
View File

@ -2075,7 +2075,7 @@ void MKLDNNInterpolateNode::createPrimitive() {
interpAttrs.inPrc = srcMemPtr->getDesc().getPrecision(); interpAttrs.inPrc = srcMemPtr->getDesc().getPrecision();
interpAttrs.outPrc = dstMemPtr->getDesc().getPrecision(); interpAttrs.outPrc = dstMemPtr->getDesc().getPrecision();
if (shapesDefined()) { if (shapesDefined() && isExecutable()) {
if (needPrepareParams()) if (needPrepareParams())
prepareParams(); prepareParams();
updateLastInputDims(); updateLastInputDims();

12
inference-engine/src/mkldnn_plugin/nodes/mkldnn_log_softmax_node.cpp
View File

@ -60,14 +60,6 @@ void MKLDNNLogSoftmaxNode::initSupportedPrimitiveDescriptors() {
impl_desc_type::ref_any); impl_desc_type::ref_any);
} }
void MKLDNNLogSoftmaxNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
void MKLDNNLogSoftmaxNode::prepareParams() { void MKLDNNLogSoftmaxNode::prepareParams() {
const auto &dims = getParentEdgesAtPort(0)[0]->getMemory().getStaticDims(); const auto &dims = getParentEdgesAtPort(0)[0]->getMemory().getStaticDims();
reducedAxisStride = 1; reducedAxisStride = 1;
@ -87,6 +79,10 @@ void MKLDNNLogSoftmaxNode::prepareParams() {
reducedAxisStride *= dims[i]; reducedAxisStride *= dims[i];
} }
void MKLDNNLogSoftmaxNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
void MKLDNNLogSoftmaxNode::execute(mkldnn::stream strm) { void MKLDNNLogSoftmaxNode::execute(mkldnn::stream strm) {
const float *srcData = reinterpret_cast<const float *>(getParentEdgeAt(0)->getMemoryPtr()->GetPtr()); const float *srcData = reinterpret_cast<const float *>(getParentEdgeAt(0)->getMemoryPtr()->GetPtr());
float* dstData = reinterpret_cast<float *>(getChildEdgesAtPort(0)[0]->getMemoryPtr()->GetPtr()); float* dstData = reinterpret_cast<float *>(getChildEdgesAtPort(0)[0]->getMemoryPtr()->GetPtr());

3
inference-engine/src/mkldnn_plugin/nodes/mkldnn_log_softmax_node.h
View File

@ -16,12 +16,11 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
void prepareParams() override; void prepareParams() override;
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); }; void executeDynamicImpl(mkldnn::stream strm) override;
static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept; static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept;

12
inference-engine/src/mkldnn_plugin/nodes/mkldnn_lrn_node.cpp
View File

@ -110,14 +110,6 @@ std::shared_ptr<MemoryDesc> MKLDNNLrnNode::getSrcMemDesc(mkldnn::primitive_desc_
} }
} }
void MKLDNNLrnNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
void MKLDNNLrnNode::prepareParams() { void MKLDNNLrnNode::prepareParams() {
auto& srcMemPtr = getParentEdgeAt(0)->getMemoryPtr(); auto& srcMemPtr = getParentEdgeAt(0)->getMemoryPtr();
auto& dstMemPtr = getChildEdgeAt(0)->getMemoryPtr(); auto& dstMemPtr = getChildEdgeAt(0)->getMemoryPtr();
@ -174,8 +166,8 @@ std::vector<VectorDims> MKLDNNLrnNode::shapeInfer() const {
return { getParentEdgesAtPort(0).front()->getMemory().getStaticDims() }; return { getParentEdgesAtPort(0).front()->getMemory().getStaticDims() };
} }
void MKLDNNLrnNode::executeDynamicImpl(dnnl::stream strm) { void MKLDNNLrnNode::executeDynamicImpl(mkldnn::stream strm) {
MKLDNNNode::execute(strm); execute(strm);
} }
REG_MKLDNN_PRIM_FOR(MKLDNNLrnNode, Lrn); REG_MKLDNN_PRIM_FOR(MKLDNNLrnNode, Lrn);

1
inference-engine/src/mkldnn_plugin/nodes/mkldnn_lrn_node.h
View File

@ -23,7 +23,6 @@ public:
return static_cast<size_t>(getOriginalInputsNumber()); return static_cast<size_t>(getOriginalInputsNumber());
} }
std::shared_ptr<MemoryDesc> getSrcMemDesc(mkldnn::primitive_desc_iterator &primitive_desc_it, size_t idx) override; std::shared_ptr<MemoryDesc> getSrcMemDesc(mkldnn::primitive_desc_iterator &primitive_desc_it, size_t idx) override;
void createPrimitive() override;
bool created() const override; bool created() const override;
bool canBeInPlace() const override { bool canBeInPlace() const override {
return false; return false;

4
inference-engine/src/mkldnn_plugin/nodes/mkldnn_math_node.cpp
View File

@ -63,6 +63,10 @@ std::vector<VectorDims> MKLDNNMathNode::shapeInfer() const {
return std::vector<VectorDims>{getParentEdgesAtPort(0)[0]->getMemory().getStaticDims()}; return std::vector<VectorDims>{getParentEdgesAtPort(0)[0]->getMemory().getStaticDims()};
} }
void MKLDNNMathNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
void MKLDNNMathNode::execute(mkldnn::stream strm) { void MKLDNNMathNode::execute(mkldnn::stream strm) {
size_t dataSize = getChildEdgesAtPort(0)[0]->getMemory().GetShape().getElementsCount(); size_t dataSize = getChildEdgesAtPort(0)[0]->getMemory().GetShape().getElementsCount();
const float *src_data = reinterpret_cast<const float *>(getParentEdgeAt(0)->getMemoryPtr()->GetPtr()); const float *src_data = reinterpret_cast<const float *>(getParentEdgeAt(0)->getMemoryPtr()->GetPtr());

3
inference-engine/src/mkldnn_plugin/nodes/mkldnn_math_node.h
View File

@ -15,13 +15,12 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override {};
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
std::vector<VectorDims> shapeInfer() const override; std::vector<VectorDims> shapeInfer() const override;
bool needPrepareParams() const override { return false; }; bool needPrepareParams() const override { return false; };
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); }; void executeDynamicImpl(mkldnn::stream strm) override;
static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept; static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept;

8
inference-engine/src/mkldnn_plugin/nodes/mkldnn_matmul_node.cpp
View File

@ -313,14 +313,6 @@ void MKLDNNMatMulNode::initSupportedPrimitiveDescriptors() {
} }
} }
void MKLDNNMatMulNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
MemoryDescPtr MKLDNNMatMulNode::getSrcMemDesc(mkldnn::primitive_desc_iterator &primitive_desc_it, size_t idx) { MemoryDescPtr MKLDNNMatMulNode::getSrcMemDesc(mkldnn::primitive_desc_iterator &primitive_desc_it, size_t idx) {
auto desc = idx > 0 ? primitive_desc_it.weights_desc(idx - 1): primitive_desc_it.src_desc(idx); auto desc = idx > 0 ? primitive_desc_it.weights_desc(idx - 1): primitive_desc_it.src_desc(idx);

1
inference-engine/src/mkldnn_plugin/nodes/mkldnn_matmul_node.h
View File

@ -22,7 +22,6 @@ public:
const std::vector<MemoryDescPtr>& outputDesc) override; const std::vector<MemoryDescPtr>& outputDesc) override;
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
MemoryDescPtr getSrcMemDesc(mkldnn::primitive_desc_iterator &primitive_desc_it, size_t idx) override; MemoryDescPtr getSrcMemDesc(mkldnn::primitive_desc_iterator &primitive_desc_it, size_t idx) override;
void createPrimitive() override;
bool canFuse(const MKLDNNNodePtr& node) const override; bool canFuse(const MKLDNNNodePtr& node) const override;
bool created() const override; bool created() const override;
size_t getMaxBatch() const override; size_t getMaxBatch() const override;

24
inference-engine/src/mkldnn_plugin/nodes/mkldnn_matrix_nms_node.cpp
View File

@ -240,13 +240,6 @@ size_t MKLDNNMatrixNmsNode::nmsMatrix(const float* boxesData, const float* score
return numDet; return numDet;
} }
void MKLDNNMatrixNmsNode::createPrimitive() {
if (inputShapesDefined()) {
prepareParams();
updateLastInputDims();
}
}
void MKLDNNMatrixNmsNode::prepareParams() { void MKLDNNMatrixNmsNode::prepareParams() {
const auto& boxes_dims = getParentEdgeAt(NMS_BOXES)->getMemory().getStaticDims(); const auto& boxes_dims = getParentEdgeAt(NMS_BOXES)->getMemory().getStaticDims();
const auto& scores_dims = getParentEdgeAt(NMS_SCORES)->getMemory().getStaticDims(); const auto& scores_dims = getParentEdgeAt(NMS_SCORES)->getMemory().getStaticDims();
@ -288,6 +281,23 @@ void MKLDNNMatrixNmsNode::prepareParams() {
} }
} }
bool MKLDNNMatrixNmsNode::isExecutable() const {
return isDynamicNode() || MKLDNNNode::isExecutable();
}
void MKLDNNMatrixNmsNode::executeDynamicImpl(mkldnn::stream strm) {
if (hasEmptyInputTensors()) {
getChildEdgesAtPort(NMS_SELECTED_OUTPUTS)[0]->getMemoryPtr()->redefineDesc(
getBaseMemDescAtOutputPort(NMS_SELECTED_OUTPUTS)->cloneWithNewDims({0, 6}));
getChildEdgesAtPort(NMS_SELECTED_INDICES)[0]->getMemoryPtr()->redefineDesc(
getBaseMemDescAtOutputPort(NMS_SELECTED_INDICES)->cloneWithNewDims({0, 1}));
getChildEdgesAtPort(NMS_VALID_OUTPUTS)[0]->getMemoryPtr()->redefineDesc(
getBaseMemDescAtOutputPort(NMS_VALID_OUTPUTS)->cloneWithNewDims({0}));
return;
}
execute(strm);
}
void MKLDNNMatrixNmsNode::execute(mkldnn::stream strm) { void MKLDNNMatrixNmsNode::execute(mkldnn::stream strm) {
const float* boxes = reinterpret_cast<const float*>(getParentEdgeAt(NMS_BOXES)->getMemoryPtr()->GetPtr()); const float* boxes = reinterpret_cast<const float*>(getParentEdgeAt(NMS_BOXES)->getMemoryPtr()->GetPtr());
const float* scores = reinterpret_cast<const float*>(getParentEdgeAt(NMS_SCORES)->getMemoryPtr()->GetPtr()); const float* scores = reinterpret_cast<const float*>(getParentEdgeAt(NMS_SCORES)->getMemoryPtr()->GetPtr());

4
inference-engine/src/mkldnn_plugin/nodes/mkldnn_matrix_nms_node.h
View File

@ -27,13 +27,13 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept; static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept;
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); } bool isExecutable() const override;
void executeDynamicImpl(mkldnn::stream strm) override;
bool needShapeInfer() const override { return false; } bool needShapeInfer() const override { return false; }
void prepareParams() override; void prepareParams() override;

24
inference-engine/src/mkldnn_plugin/nodes/mkldnn_multiclass_nms.cpp
View File

@ -105,13 +105,6 @@ void MKLDNNMultiClassNmsNode::initSupportedPrimitiveDescriptors() {
impl_desc_type::ref_any); impl_desc_type::ref_any);
} }
void MKLDNNMultiClassNmsNode::createPrimitive() {
if (inputShapesDefined()) {
prepareParams();
updateLastInputDims();
}
}
void MKLDNNMultiClassNmsNode::prepareParams() { void MKLDNNMultiClassNmsNode::prepareParams() {
const auto& boxes_dims = getParentEdgeAt(NMS_BOXES)->getMemory().getStaticDims(); const auto& boxes_dims = getParentEdgeAt(NMS_BOXES)->getMemory().getStaticDims();
const auto& scores_dims = getParentEdgeAt(NMS_SCORES)->getMemory().getStaticDims(); const auto& scores_dims = getParentEdgeAt(NMS_SCORES)->getMemory().getStaticDims();
@ -145,6 +138,23 @@ void MKLDNNMultiClassNmsNode::prepareParams() {
m_numBoxOffset.resize(m_numBatches); m_numBoxOffset.resize(m_numBatches);
} }
bool MKLDNNMultiClassNmsNode::isExecutable() const {
return isDynamicNode() || MKLDNNNode::isExecutable();
}
void MKLDNNMultiClassNmsNode::executeDynamicImpl(mkldnn::stream strm) {
if (hasEmptyInputTensors()) {
getChildEdgesAtPort(NMS_SELECTEDOUTPUTS)[0]->getMemoryPtr()->redefineDesc(
getBaseMemDescAtOutputPort(NMS_SELECTEDOUTPUTS)->cloneWithNewDims({0, 6}));
getChildEdgesAtPort(NMS_SELECTEDINDICES)[0]->getMemoryPtr()->redefineDesc(
getBaseMemDescAtOutputPort(NMS_SELECTEDINDICES)->cloneWithNewDims({0, 1}));
getChildEdgesAtPort(NMS_SELECTEDNUM)[0]->getMemoryPtr()->redefineDesc(
getBaseMemDescAtOutputPort(NMS_SELECTEDNUM)->cloneWithNewDims({0}));
return;
}
execute(strm);
}
void MKLDNNMultiClassNmsNode::execute(mkldnn::stream strm) { void MKLDNNMultiClassNmsNode::execute(mkldnn::stream strm) {
const float* boxes = reinterpret_cast<const float*>(getParentEdgeAt(NMS_BOXES)->getMemoryPtr()->GetPtr()); const float* boxes = reinterpret_cast<const float*>(getParentEdgeAt(NMS_BOXES)->getMemoryPtr()->GetPtr());
const float* scores = reinterpret_cast<const float*>(getParentEdgeAt(NMS_SCORES)->getMemoryPtr()->GetPtr()); const float* scores = reinterpret_cast<const float*>(getParentEdgeAt(NMS_SCORES)->getMemoryPtr()->GetPtr());

4
inference-engine/src/mkldnn_plugin/nodes/mkldnn_multiclass_nms.hpp
View File

@ -23,13 +23,13 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept; static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept;
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); } bool isExecutable() const override;
void executeDynamicImpl(mkldnn::stream strm) override;
bool needShapeInfer() const override { return false; } bool needShapeInfer() const override { return false; }
void prepareParams() override; void prepareParams() override;

12
inference-engine/src/mkldnn_plugin/nodes/mkldnn_mvn_node.cpp
View File

@ -849,14 +849,6 @@ void MKLDNNMVNNode::prepareParams() {
} }
} }
void MKLDNNMVNNode::createPrimitive() {
if (inputShapesDefined()) {
if (needPrepareParams())
prepareParams();
updateLastInputDims();
}
}
void MKLDNNMVNNode::transformTo5DCase(const SizeVector& shape) { void MKLDNNMVNNode::transformTo5DCase(const SizeVector& shape) {
switch (shape.size()) { switch (shape.size()) {
// for 1 and 2 rank, if initAcrossChannels_ is true, adjust shape to fully vectorize under unified 5d procedure. // for 1 and 2 rank, if initAcrossChannels_ is true, adjust shape to fully vectorize under unified 5d procedure.
@ -908,6 +900,10 @@ void MKLDNNMVNNode::setPostOps(mkldnn::primitive_attr &attr, bool initWeights) {
attr.set_post_ops(ops); attr.set_post_ops(ops);
} }
void MKLDNNMVNNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
void MKLDNNMVNNode::execute(mkldnn::stream strm) { void MKLDNNMVNNode::execute(mkldnn::stream strm) {
auto &dstMemPtr = getChildEdgeAt(0)->getMemoryPtr(); auto &dstMemPtr = getChildEdgeAt(0)->getMemoryPtr();
auto &srcMemPtr = getParentEdgeAt(0)->getMemoryPtr(); auto &srcMemPtr = getParentEdgeAt(0)->getMemoryPtr();

3
inference-engine/src/mkldnn_plugin/nodes/mkldnn_mvn_node.h
View File

@ -77,10 +77,9 @@ public:
static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept; static bool isSupportedOperation(const std::shared_ptr<const ngraph::Node>& op, std::string& errorMessage) noexcept;
void getSupportedDescriptors() override; void getSupportedDescriptors() override;
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
bool created() const override; bool created() const override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
void executeDynamicImpl(mkldnn::stream strm) override { execute(strm); } void executeDynamicImpl(mkldnn::stream strm) override;
bool canBeInPlace() const override { bool canBeInPlace() const override {
return false; return false;
} }

19
inference-engine/src/mkldnn_plugin/nodes/mkldnn_non_max_suppression_node.cpp
View File

@ -147,14 +147,20 @@ void MKLDNNNonMaxSuppressionNode::prepareParams() {
i.resize(num_classes); i.resize(num_classes);
} }
void MKLDNNNonMaxSuppressionNode::createPrimitive() { bool MKLDNNNonMaxSuppressionNode::isExecutable() const {
if (inputShapesDefined()) { return isDynamicNode() || MKLDNNNode::isExecutable();
prepareParams();
updateLastInputDims();
}
} }
void MKLDNNNonMaxSuppressionNode::executeDynamicImpl(mkldnn::stream strm) { void MKLDNNNonMaxSuppressionNode::executeDynamicImpl(mkldnn::stream strm) {
if (hasEmptyInputTensors() || (inputShapes.size() > NMS_MAXOUTPUTBOXESPERCLASS &&
reinterpret_cast<int *>(getParentEdgeAt(NMS_MAXOUTPUTBOXESPERCLASS)->getMemoryPtr()->GetPtr())[0] == 0)) {
getChildEdgesAtPort(NMS_SELECTEDINDICES)[0]->getMemoryPtr()->redefineDesc(
getBaseMemDescAtOutputPort(NMS_SELECTEDINDICES)->cloneWithNewDims({0, 3}));
getChildEdgesAtPort(NMS_SELECTEDSCORES)[0]->getMemoryPtr()->redefineDesc(
getBaseMemDescAtOutputPort(NMS_SELECTEDSCORES)->cloneWithNewDims({0, 3}));
*reinterpret_cast<int *>(getChildEdgesAtPort(NMS_VALIDOUTPUTS)[0]->getMemoryPtr()->GetPtr()) = 0;
return;
}
execute(strm); execute(strm);
} }
@ -168,8 +174,9 @@ void MKLDNNNonMaxSuppressionNode::execute(mkldnn::stream strm) {
max_output_boxes_per_class = std::min(max_output_boxes_per_class, num_boxes); max_output_boxes_per_class = std::min(max_output_boxes_per_class, num_boxes);
if (max_output_boxes_per_class == 0) if (max_output_boxes_per_class == 0) {
return; return;
}
if (inputShapes.size() > NMS_IOUTHRESHOLD) if (inputShapes.size() > NMS_IOUTHRESHOLD)
iou_threshold = reinterpret_cast<float *>(getParentEdgeAt(NMS_IOUTHRESHOLD)->getMemoryPtr()->GetPtr())[0]; iou_threshold = reinterpret_cast<float *>(getParentEdgeAt(NMS_IOUTHRESHOLD)->getMemoryPtr()->GetPtr())[0];

2
inference-engine/src/mkldnn_plugin/nodes/mkldnn_non_max_suppression_node.h
View File

@ -20,7 +20,6 @@ public:
void getSupportedDescriptors() override {}; void getSupportedDescriptors() override {};
void initSupportedPrimitiveDescriptors() override; void initSupportedPrimitiveDescriptors() override;
void createPrimitive() override;
void execute(mkldnn::stream strm) override; void execute(mkldnn::stream strm) override;
bool created() const override; bool created() const override;
@ -52,6 +51,7 @@ public:
void executeDynamicImpl(mkldnn::stream strm) override; void executeDynamicImpl(mkldnn::stream strm) override;
bool isExecutable() const override;
bool needShapeInfer() const override { return false; } bool needShapeInfer() const override { return false; }
void prepareParams() override; void prepareParams() override;

6
inference-engine/src/mkldnn_plugin/nodes/mkldnn_non_zero.cpp
View File

@ -85,6 +85,11 @@ struct MKLDNNNonZeroNode::NonZeroExecute {
ctx.node.executeSpecified<T>(); ctx.node.executeSpecified<T>();
} }
}; };
void MKLDNNNonZeroNode::executeDynamicImpl(mkldnn::stream strm) {
execute(strm);
}
void MKLDNNNonZeroNode::execute(mkldnn::stream strm) { void MKLDNNNonZeroNode::execute(mkldnn::stream strm) {
auto inputPrec = getParentEdgesAtPort(0)[0]->getMemory().getDesc().getPrecision(); auto inputPrec = getParentEdgesAtPort(0)[0]->getMemory().getDesc().getPrecision();
NonZeroContext ctx = {*this }; NonZeroContext ctx = {*this };
@ -104,6 +109,7 @@ void MKLDNNNonZeroNode::executeSpecified() {
Shape inShape = getParentEdgeAt(0)->getMemory().GetShape(); Shape inShape = getParentEdgeAt(0)->getMemory().GetShape();
size_t inRank = inShape.getRank(); size_t inRank = inShape.getRank();
size_t nonZeroCount = getNonZeroElementsCount(src, inShape); size_t nonZeroCount = getNonZeroElementsCount(src, inShape);
if (isDynamicNode()) { if (isDynamicNode()) {
VectorDims newDims{inRank, nonZeroCount}; VectorDims newDims{inRank, nonZeroCount};
dstMemPtr->redefineDesc(getBaseMemDescAtOutputPort(0)->cloneWithNewDims(newDims)); dstMemPtr->redefineDesc(getBaseMemDescAtOutputPort(0)->cloneWithNewDims(newDims));

Some files were not shown because too many files have changed in this diff Show More