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

Intel compiler support (#24217) 

### Details:
 - Initial version of Intel compiler support
 - Only Linux is covered
- Current PR is a prerequisite for
https://github.com/openvinotoolkit/openvino/pull/23534
This commit is contained in:
Ilya Lavrenov 2024-04-27 18:03:28 +04:00 committed by GitHub
parent 3b0d2013b8
commit c121e896da
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
62 changed files with 170 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.github/workflows/code_snippets.yml vendored
View File

@ -36,6 +36,10 @@ jobs:
packages: ocl-icd-opencl-dev opencl-headers
version: 3.0
- name: Install scons
if: runner.os == 'macOS'
run: brew install scons
- name: CMake configure
run: cmake -DCMAKE_BUILD_TYPE=Release -DTHREADING=SEQ -B build

1
cmake/dependencies.cmake
View File

@ -158,6 +158,7 @@ function(ov_download_tbb)
update_deps_cache(TBB_DIR "${TBBROOT}/lib/cmake/TBB" "Path to TBB cmake folder")
elseif(EXISTS "${TBBROOT}/lib/cmake/tbb/TBBConfig.cmake")
# oneTBB release package version less than 2021.6.0
# or TBB from oneAPI package
update_deps_cache(TBB_DIR "${TBBROOT}/lib/cmake/tbb" "Path to TBB cmake folder")
elseif(EXISTS "${TBBROOT}/lib64/cmake/TBB/TBBConfig.cmake")
# 64-bits oneTBB case

47
cmake/developer_package/compile_flags/os_flags.cmake
View File

@ -20,7 +20,7 @@ macro(ov_disable_deprecated_warnings)
else()
set(ov_c_cxx_deprecated "-diag-disable=1478,1786")
endif()
elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_INTEL_LLVM)
set(ov_c_cxx_deprecated "-Wno-deprecated-declarations")
else()
message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
@ -48,7 +48,7 @@ macro(ov_deprecated_no_errors)
else()
set(ov_c_cxx_deprecated_no_errors "-diag-warning=1478,1786")
endif()
elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_INTEL_LLVM)
set(ov_c_cxx_deprecated_no_errors "-Wno-error=deprecated-declarations")
# Suppress #warning messages
set(ov_c_cxx_deprecated_no_errors "${ov_c_cxx_deprecated_no_errors} -Wno-cpp")
@ -68,7 +68,7 @@ endmacro()
# Exports flags for 3rdparty modules, but without errors
#
macro(ov_dev_package_no_errors)
if(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
if(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_INTEL_LLVM)
set(ov_c_cxx_dev_no_errors "-Wno-all")
if(SUGGEST_OVERRIDE_SUPPORTED)
set(ov_cxx_dev_no_errors "-Wno-error=suggest-override")
@ -100,7 +100,7 @@ endmacro()
macro(ov_sse42_optimization_flags flags)
if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
# No such option for MSVC 2019
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel" OR OV_COMPILER_IS_INTEL_LLVM)
if(WIN32)
set(${flags} /QxSSE4.2)
else()
@ -130,7 +130,7 @@ macro(ov_avx2_optimization_flags flags)
else()
set(${flags} -xCORE-AVX2)
endif()
elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_INTEL_LLVM)
set(${flags} -mavx2 -mfma -mf16c)
else()
message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
@ -152,7 +152,7 @@ macro(ov_avx512_optimization_flags flags)
else()
set(${flags} -xCOMMON-AVX512)
endif()
elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_INTEL_LLVM)
set(${flags} -mavx512f -mavx512bw -mavx512vl -mfma -mf16c)
else()
message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
@ -200,7 +200,7 @@ function(ov_disable_all_warnings)
if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
target_compile_options(${target} PRIVATE /WX-)
elseif(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
elseif(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
target_compile_options(${target} PRIVATE -w)
# required for LTO
set(link_interface INTERFACE_LINK_OPTIONS)
@ -239,7 +239,7 @@ endmacro()
function(ov_force_include target scope header_file)
if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
target_compile_options(${target} ${scope} /FI"${header_file}")
elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX)
elseif(OV_COMPILER_IS_CLANG OR CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_INTEL_LLVM)
target_compile_options(${target} ${scope} -include "${header_file}")
else()
message(WARNING "Unsupported CXX compiler ${CMAKE_CXX_COMPILER_ID}")
@ -314,7 +314,7 @@ set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
if(CMAKE_CL_64)
# Default char Type Is unsigned
# ov_add_compiler_flags(/J)
elseif(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
elseif(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
ov_add_compiler_flags(-fsigned-char)
endif()
@ -449,21 +449,11 @@ else()
# To guarantee OpenVINO can be used with gcc versions 7 through 12
# - https://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Dialect-Options.html
# - https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html
if(CMAKE_COMPILER_IS_GNUCXX)
if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "8")
# Enable __FILE__ trim only for release mode
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ffile-prefix-map=${OV_NATIVE_PROJECT_ROOT_DIR}/= -ffile-prefix-map=${OV_RELATIVE_BIN_PATH}/=")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffile-prefix-map=${OV_NATIVE_PROJECT_ROOT_DIR}/= -ffile-prefix-map=${OV_RELATIVE_BIN_PATH}/=")
endif()
# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wabi=11")
endif()
if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "10")
# Enable __FILE__ trim only for release mode
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ffile-prefix-map=${OV_NATIVE_PROJECT_ROOT_DIR}/= -ffile-prefix-map=${OV_RELATIVE_BIN_PATH}/=")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffile-prefix-map=${OV_NATIVE_PROJECT_ROOT_DIR}/= -ffile-prefix-map=${OV_RELATIVE_BIN_PATH}/=")
endif()
if((CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8) OR
(CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 10) OR OV_COMPILER_IS_INTEL_LLVM)
# Enable __FILE__ trim only for release mode
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -ffile-prefix-map=${OV_NATIVE_PROJECT_ROOT_DIR}/= -ffile-prefix-map=${OV_RELATIVE_BIN_PATH}/=")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -ffile-prefix-map=${OV_NATIVE_PROJECT_ROOT_DIR}/= -ffile-prefix-map=${OV_RELATIVE_BIN_PATH}/=")
endif()
#
@ -483,6 +473,10 @@ else()
ov_add_compiler_flags(-diag-disable=remark,177,2196)
endif()
if(OV_COMPILER_IS_INTEL_LLVM)
ov_add_compiler_flags(-Wno-tautological-constant-compare)
endif()
#
# Linker flags
#
@ -507,6 +501,11 @@ else()
endif()
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--gc-sections")
endif()
if(OV_COMPILER_IS_INTEL_LLVM)
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static-intel")
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-intel")
endif()
endif()
add_compile_definitions(

4
cmake/developer_package/compile_flags/sdl.cmake
View File

@ -2,7 +2,7 @@
# SPDX-License-Identifier: Apache-2.0
#
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM OR
(UNIX AND CMAKE_CXX_COMPILER_ID STREQUAL "Intel"))
set(OV_C_CXX_FLAGS "${OV_C_CXX_FLAGS} -Wformat -Wformat-security")
@ -32,7 +32,7 @@ if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR
if(NOT MINGW)
set(OV_LINKER_FLAGS "${OV_LINKER_FLAGS} -z noexecstack -z relro -z now")
endif()
elseif(OV_COMPILER_IS_CLANG)
elseif(OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
if(EMSCRIPTEN)
# emcc does not support fortification
# https://stackoverflow.com/questions/58854858/undefined-symbol-stack-chk-guard-in-libopenh264-so-when-building-ffmpeg-wit

2
cmake/developer_package/cross_compile/native_compile.cmake
View File

@ -62,7 +62,7 @@ function(ov_native_compile_external_project)
endif()
# compile flags
if(CMAKE_COMPILER_IS_GNUCXX)
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
set(compile_flags "-Wno-undef -Wno-error -Wno-deprecated-declarations")
endif()

2
cmake/developer_package/frontends/frontends.cmake
View File

@ -212,7 +212,7 @@ macro(ov_add_frontend)
endif()
# remove -Wmissing-declarations warning, because of frontends implementation specific
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
target_compile_options(${TARGET_NAME} PRIVATE -Wno-missing-declarations)
endif()

4
cmake/developer_package/target_flags.cmake
View File

@ -111,6 +111,10 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "^(Apple)?Clang$")
endif()
endif()
if(CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
set(OV_COMPILER_IS_INTEL_LLVM ON)
endif()
get_property(OV_GENERATOR_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
function(ov_get_compiler_definition definition var)

5
docs/snippets/CMakeLists.txt
View File

@ -4,11 +4,8 @@
set(TARGET_NAME openvino_docs_snippets)
if(CMAKE_COMPILER_IS_GNUCXX)
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
ov_add_compiler_flags(-Wall)
endif()
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
ov_add_compiler_flags(-Wno-unused-variable)
endif()
if(UNUSED_BUT_SET_VARIABLE_SUPPORTED)

3
docs/snippets/template_pattern_transformation.cpp
View File

@ -10,6 +10,7 @@
#include "openvino/opsets/opset3.hpp"
#include "openvino/pass/manager.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "transformations/utils/utils.hpp"
#include "template_model_transformation.hpp"
// ! [graph_rewrite:template_transformation_cpp]
@ -61,7 +62,7 @@ ov::pass::ReluReluFusionMatcher::ReluReluFusionMatcher() {
auto m_relu1 = ov::pass::pattern::wrap_type<ov::opset3::Relu>(pattern::consumers_count(1));
auto m_relu2 = ov::pass::pattern::wrap_type<ov::opset3::Relu>({m_relu1});
ov::matcher_pass_callback callback = [=](pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
// Map that helps to connect labels with matched outputs
auto& node_to_output = m.get_pattern_value_map();

12
src/bindings/python/src/pyopenvino/CMakeLists.txt
View File

@ -21,18 +21,18 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
set(CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
set(CMAKE_PDB_OUTPUT_DIRECTORY ${PYTHON_BRIDGE_OUTPUT_DIRECTORY})
# compile options
# compile and linker options
if(OV_COMPILER_IS_APPLECLANG)
add_link_options(-stdlib=libc++)
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
elseif(CMAKE_COMPILER_IS_GNUCXX)
# WA for GCC 7.5 "PYBIND11_NOINLINE inline" warning
add_compile_options(-Wno-error=attributes)
ov_add_compiler_flags(-Wno-error=attributes)
endif()
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
# for proper fix need to update pybind to version which does not use PyEval_InitThreads()
add_compile_options(-Wno-deprecated-declarations -Wno-undef)
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
# TODO: remove this deprecated API usage
ov_add_compiler_flags(-Wno-error=deprecated-declarations)
endif()
if(ENABLE_TESTS)

25
src/cmake/install_tbb.cmake
View File

@ -139,6 +139,8 @@ if(THREADING MATCHES "^(TBB|TBB_AUTO)$" AND
if(NOT DEFINED TBBROOT AND DEFINED ENV{TBBROOT})
file(TO_CMAKE_PATH $ENV{TBBROOT} TBBROOT)
endif()
# sometimes TBBROOT can be set with relative paths inside (e.g. oneAPI package)
get_filename_component(TBBROOT "${TBBROOT}" ABSOLUTE)
if(NOT DEFINED TBBROOT)
get_target_property(_tbb_include_dir TBB::tbb INTERFACE_INCLUDE_DIRECTORIES)
get_filename_component(TBBROOT ${_tbb_include_dir} PATH)
@ -163,6 +165,7 @@ if(THREADING MATCHES "^(TBB|TBB_AUTO)$" AND
# try to select proper library directory
_ov_get_tbb_location(TBB::tbb _tbb_lib_location)
get_filename_component(_tbb_libs_dir "${_tbb_lib_location}" DIRECTORY)
get_filename_component(_tbb_libs_dir "${_tbb_libs_dir}" REALPATH)
file(RELATIVE_PATH tbb_libs_dir "${TBBROOT}" "${_tbb_libs_dir}")
# install only meaningful directories
@ -176,10 +179,24 @@ if(THREADING MATCHES "^(TBB|TBB_AUTO)$" AND
set(tbb_component tbb)
set(exclude_pattern REGEX ".*(cmake|pkgconfig)$" EXCLUDE)
endif()
install(DIRECTORY "${TBBROOT}/${dir}/"
DESTINATION "${IE_TBBROOT_INSTALL}/${dir}"
COMPONENT ${tbb_component}
${exclude_pattern})
if(tbb_libs_dir STREQUAL dir)
file(GLOB _tbb_libs ${TBBROOT}/${tbb_libs_dir}/*)
foreach(_tbb_lib IN LISTS _tbb_libs)
if(_tbb_lib MATCHES ".*${CMAKE_SHARED_LIBRARY_SUFFIX}.*")
# resolve absolute path to avoid issues with installation
get_filename_component(_tbb_lib "${_tbb_lib}" REALPATH)
install(PROGRAMS "${_tbb_lib}"
DESTINATION "${IE_TBBROOT_INSTALL}/${dir}"
COMPONENT ${tbb_component})
endif()
endforeach()
else()
install(DIRECTORY "${TBBROOT}/${dir}/"
DESTINATION "${IE_TBBROOT_INSTALL}/${dir}"
COMPONENT ${tbb_component}
${exclude_pattern})
endif()
endif()
endforeach()

2
src/common/low_precision_transformations/src/assign_and_read_value.cpp
View File

@ -23,7 +23,7 @@ AssignAndReadValueTransformation::AssignAndReadValueTransformation(const std::sh
auto assign3 = pattern::wrap_type<opset3::Assign>({ pattern::wrap_type<ov::opset1::Multiply>() });
auto assign6 = pattern::wrap_type<opset6::Assign>({ pattern::wrap_type<ov::opset1::Multiply>() });
ov::graph_rewrite_callback callback = [=](pattern::Matcher& m) {
ov::graph_rewrite_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
const auto& opsMap = m.get_pattern_value_map();
auto op = m.get_match_root();
auto assignIt = opsMap.find(assign3);

2
src/common/low_precision_transformations/src/convert_subtract_constant.cpp
View File

@ -44,7 +44,7 @@ ov::pass::low_precision::ConvertSubtractConstant::ConvertSubtractConstant(const
auto multiplyConstantWrapper = ov::pass::pattern::wrap_type<opset1::Constant>(pattern::consumers_count(1));
auto multiplyWrapper = ov::pass::pattern::wrap_type<opset1::Multiply>({ subtractWrapper, multiplyConstantWrapper }, pattern::consumers_count(1));
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher & m) -> bool {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher & m) -> bool {
const auto& opsMap = m.get_pattern_value_map();
const auto weightsConvert = opsMap.at(weightsConvertWrapper).get_node_shared_ptr();
const auto quantizePrecision = weightsConvert->get_input_element_type(0);

2
src/common/low_precision_transformations/src/reshape.cpp
View File

@ -33,7 +33,7 @@ ReshapeTransformation::ReshapeTransformation(const Params& params) : LayerTransf
auto reshape_pattern = std::make_shared<pass::pattern::op::Or>(OutputVector{ reshape_pattern_const, reshape_pattern_nonconst });
auto matcher = pattern::wrap_type<ov::opset1::Reshape>({ mul_m, reshape_pattern });
ov::graph_rewrite_callback callback = [=](pattern::Matcher& m) {
ov::graph_rewrite_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
auto op = m.get_match_root();
if (transformation_callback(op)) {
return false;

3
src/common/snippets/src/pass/extract_reshapes_from_mha.cpp
View File

@ -10,6 +10,7 @@
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "snippets/itt.hpp"
#include "snippets/pass/mha_tokenization.hpp"
#include "transformations/utils/utils.hpp"
using namespace ov::pass;
@ -26,7 +27,7 @@ ov::snippets::pass::ExtractReshapesFromMHA::ExtractReshapesFromMHA() {
auto add_2_m = pattern::wrap_type<opset1::Add>({add_1_m, sparse_input_2_m}, static_shape_single_consumer);
auto reshape_2_m = pattern::wrap_type<opset1::Reshape>({add_2_m, pattern::wrap_type<opset1::Constant>()}, pattern::has_static_shape());
matcher_pass_callback callback = [=](pattern::Matcher& m) {
matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "Snippets::op::ExtractReshapesFromMHA")
const auto& pattern_map = m.get_pattern_value_map();
const auto& matmul = pattern_map.at(matmul_m);

3
src/common/snippets/src/pass/fq_decomposition.cpp
View File

@ -12,6 +12,7 @@
#include "openvino/pass/manager.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "openvino/pass/validate.hpp"
#include "transformations/utils/utils.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
#include "openvino/reference/broadcast.hpp"
@ -31,7 +32,7 @@ ov::snippets::pass::FakeQuantizeDecomposition::FakeQuantizeDecomposition() {
ov::pass::pattern::wrap_type<ov::op::v0::Constant>(),
ov::pass::pattern::wrap_type<ov::op::v0::Constant>()});
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "Snippets::op::FakeQuantizeDecomposition")
auto& pattern_to_output = m.get_pattern_value_map();
const auto fake_quantize_node = std::dynamic_pointer_cast<ov::op::v0::FakeQuantize>(

3
src/common/snippets/src/pass/matmul_to_brgemm.cpp
View File

@ -10,6 +10,7 @@
#include "openvino/core/rt_info.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "transformations/utils/utils.hpp"
namespace ov {
namespace snippets {
@ -33,7 +34,7 @@ MatMulToBrgemm::MatMulToBrgemm() {
MATCHER_SCOPE(MatMulToBrgemm);
auto matmul_pattern = ov::pass::pattern::wrap_type<ov::opset1::MatMul>({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()});
auto callback = [=](ov::pass::pattern::Matcher& m) {
auto callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "ov::intel_cpu::pass::MatMulToBrgemm")
auto& pm = m.get_pattern_value_map();
const auto matmul = as_type_ptr<ov::opset1::MatMul>(pm.at(matmul_pattern).get_node_shared_ptr());

3
src/common/snippets/src/pass/mha_tokenization.cpp
View File

@ -12,6 +12,7 @@
#include "snippets/pass/explicit_transpose_matmul_inputs.hpp"
#include "snippets/pass/mha_tokenization.hpp"
#include "snippets/utils.hpp"
#include "transformations/utils/utils.hpp"
namespace {
bool is_supported_tensor(const ov::descriptor::Tensor& t) {
@ -207,7 +208,7 @@ ov::snippets::pass::TokenizeMHASnippets::TokenizeMHASnippets(const SnippetsToken
ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()));
register_matcher(std::make_shared<ov::pass::pattern::Matcher>(m_matmul0, matcher_name),
[=](ov::pass::pattern::Matcher &m) {
[OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher &m) {
OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "Snippets::op::TokenizeMHASnippets")
auto& pattern_to_output = m.get_pattern_value_map();

3
src/common/snippets/src/pass/transpose_decomposition.cpp
View File

@ -8,6 +8,7 @@
#include "snippets/snippets_isa.hpp"
#include "snippets/lowered/port_descriptor.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "transformations/utils/utils.hpp"
namespace ov {
namespace snippets {
@ -41,7 +42,7 @@ TransposeDecomposition::TransposeDecomposition() {
auto match_order = ov::pass::pattern::wrap_type<ov::op::v0::Constant>();
auto match_transpose = ov::pass::pattern::wrap_type<ov::opset1::Transpose>({match_data, match_order});
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "Snippets::op::TransposeDecomposition")
auto& pattern_to_output = m.get_pattern_value_map();
const auto& data_input = pattern_to_output.at(match_data);

13
src/common/transformations/include/transformations/utils/utils.hpp
View File

@ -16,21 +16,10 @@
#include "openvino/op/constant.hpp"
#include "openvino/op/convert.hpp"
#include "openvino/pass/graph_rewrite.hpp"
#include "openvino/util/pp.hpp"
#include "transformations/rt_info/attributes.hpp"
#include "transformations_visibility.hpp"
/* This macro is intended to fix C++20 [=] lambda
warning. Although C++20 identifier is 202002L,
some compilers supporting C++20, or their drafts like
C++2a, producing the warning, are using 201402L value.
Also, MSVC requires a special check due to the
__cplusplus value compatibility issues.*/
#if (defined(_MSVC_LANG) && (_MSVC_LANG >= 202002L)) || (__cplusplus >= 201402L)
# define OV_CAPTURE_CPY_AND_THIS =, this
#else
# define OV_CAPTURE_CPY_AND_THIS =
#endif /* C++20 */
namespace ov {
namespace op {
namespace util {

2
src/common/transformations/src/transformations/op_conversions/convert_gather_to_compressed.cpp
View File

@ -55,7 +55,7 @@ ov::pass::ConvertGatherToGatherCompressed::ConvertGatherToGatherCompressed() {
std::make_shared<ov::pass::pattern::op::Or>(ov::OutputVector{reshape_m, last_convert_m, mul_m});
auto gather_m = wrap_type<ov::op::v8::Gather>({dicts_input_m, any_input(), wrap_type<ov::op::v0::Constant>()});
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
OPENVINO_ASSERT(pattern_map.count(gather_m));
OPENVINO_ASSERT(pattern_map.count(mul_const_m));

12
src/common/util/include/openvino/util/pp.hpp
View File

@ -51,3 +51,15 @@
// Ignores inputs
#define OV_PP_IGNORE(...)
/* This macro is intended to fix C++20 [=] lambda
warning. Although C++20 identifier is 202002L,
some compilers supporting C++20, or their drafts like
C++2a, producing the warning, are using 201402L value.
Also, MSVC requires a special check due to the
__cplusplus value compatibility issues.*/
#if (defined(_MSVC_LANG) && (_MSVC_LANG >= 202002L)) || (__cplusplus >= 202002L)
# define OV_CAPTURE_CPY_AND_THIS =, this
#else
# define OV_CAPTURE_CPY_AND_THIS =
#endif /* C++20 */

2
src/frontends/paddle/src/internal/pass/transform_fakequantize.cpp
View File

@ -54,7 +54,7 @@ ov::frontend::paddle::pass::TransformFakeQuantize::TransformFakeQuantize() {
const auto dq_real_scale_label = pattern::wrap_type<Multiply>();
const auto output_label = pattern::wrap_type<Multiply>({dq_sub_label, dq_real_scale_label});
matcher_pass_callback callback = [=](pattern::Matcher& m) -> bool {
matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) -> bool {
const auto& opsMap = m.get_pattern_value_map();
if (transformation_callback(m.get_match_root())) {
return false;

3
src/frontends/pytorch/src/transforms/remove_packing_ops.cpp
View File

@ -15,6 +15,7 @@
#include "openvino/op/transpose.hpp"
#include "openvino/pass/pattern/matcher.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "transformations/utils/utils.hpp"
#include "utils.hpp"
namespace ov {
@ -38,7 +39,7 @@ bool is_rnn(std::shared_ptr<Node> node) {
MovePackThroughLstm::MovePackThroughLstm() {
auto pack_op = pattern::wrap_type<PackPadded>();
ov::matcher_pass_callback callback = [=](pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
auto pack = m.get_match_root();
auto targets = pack->output(0).get_target_inputs();

2
src/plugins/intel_cpu/src/dnnl_extension_utils.h
View File

@ -14,7 +14,7 @@
#include "onednn/dnnl.h"
#include "onednn/iml_type_mapper.h"
#include "openvino/core/type/element_type.hpp"
#include <common/c_types_map.hpp>
#include "common/c_types_map.hpp"
namespace ov {
namespace intel_cpu {

5
src/plugins/intel_cpu/src/edge.cpp
View File

@ -5,6 +5,7 @@
#include "edge.h"
#include "node.h"
#include "dnnl_extension_utils.h"
#include "openvino/util/pp.hpp"
using namespace dnnl;
namespace ov {
@ -264,7 +265,7 @@ void Edge::allocateCommon(const std::function<MemoryPtr(const MemoryDesc&)>& all
}
void Edge::allocate(const void* mem_ptr) {
auto allocateFunc = [=](const MemoryDesc& inputDesc) -> MemoryPtr {
auto allocateFunc = [OV_CAPTURE_CPY_AND_THIS](const MemoryDesc& inputDesc) -> MemoryPtr {
auto parentPtr = getParent();
return std::make_shared<Memory>(parentPtr->getEngine(), inputDesc, mem_ptr, false); // no pads zeroing
};
@ -277,7 +278,7 @@ void Edge::allocate(MemoryMngrPtr memMngr) {
OPENVINO_THROW("Unexpected: Memory manager ptr is NULL");
}
auto allocateFunc = [=](const MemoryDesc& inputDesc) -> MemoryPtr {
auto allocateFunc = [OV_CAPTURE_CPY_AND_THIS](const MemoryDesc& inputDesc) -> MemoryPtr {
auto parentPtr = getParent();
return std::make_shared<Memory>(parentPtr->getEngine(), inputDesc, memMngr);
};

2
src/plugins/intel_cpu/src/node.cpp
View File

@ -1707,7 +1707,7 @@ void Node::fuseDQScales(const float* scaleData, const size_t scaleSize) {
DQScales[i] *= scaleData[i];
}
}
if (std::all_of(DQScales.begin(), DQScales.end(), [=](float val){ return (val == DQScales[0]);}))
if (std::all_of(DQScales.begin(), DQScales.end(), [OV_CAPTURE_CPY_AND_THIS](float val){ return (val == DQScales[0]);}))
DQScales.resize(1);
}

1
src/plugins/intel_cpu/src/nodes/causal_mask_preprocess.h
View File

@ -34,6 +34,7 @@ private:
virtual void execute(dnnl::stream strm,
intel_cpu::Node * pnode,
const intel_cpu::CausalMaskPreprocessNode::Config& config) = 0;
virtual ~Executor() = default;
};
template <typename T>
struct ExecutorCausalMaskPreprocess;

3
src/plugins/intel_cpu/src/nodes/def_conv.cpp
View File

@ -13,6 +13,7 @@
#include "openvino/core/parallel.hpp"
#include "memory_desc/dnnl_blocked_memory_desc.h"
#include "common/primitive_hashing_utils.hpp"
#include "openvino/util/pp.hpp"
#include "dnnl_types.h"
#include "dnnl_extension_utils.h"
@ -1129,7 +1130,7 @@ void DeformableConvolution::DefConvRefExecutor::exec(const float* src, const flo
const int channel_per_deformable_group = (IC * G) / DG;
const size_t group_wei_stride = weiStrides[0] * OC;
auto compKer = [=](int g, int mb, int oc, int oh, int ow) {
auto compKer = [OV_CAPTURE_CPY_AND_THIS](int g, int mb, int oc, int oh, int ow) {
float d = 0;
for (int ic = 0; ic < IC; ic++) {
const float *data_im_ptr = src + mb * srcStrides[0] + (g * IC + ic) * srcStrides[1];

2
src/plugins/intel_cpu/src/nodes/depth_to_space.cpp
View File

@ -137,7 +137,7 @@ void DepthToSpace::initSupportedPrimitiveDescriptors() {
std::vector<LayoutType> supportedTypes;
if (inputDataShape.getRank() > 2) {
const auto& srcDims = inputDataShape.getDims();
auto canUseBlocked = [=](const size_t block) {
auto canUseBlocked = [OV_CAPTURE_CPY_AND_THIS](const size_t block) {
return srcDims[1] != Shape::UNDEFINED_DIM && srcDims[1] % block == 0 && (srcDims[1] / block) % attrs.blockStep == 0 &&
(attrs.mode == Mode::DEPTH_FIRST ? block % attrs.blockStep == 0 : true);
};

1
src/plugins/intel_cpu/src/nodes/rdft.h
View File

@ -14,6 +14,7 @@ namespace node {
struct RDFTExecutor {
public:
RDFTExecutor(bool inverse) : isInverse(inverse) {}
virtual ~RDFTExecutor() = default;
void execute(float* inputPtr, float* outputPtr,
const std::vector<std::vector<float>>& twiddles,
size_t rank, const std::vector<int>& axes,

1
src/plugins/intel_cpu/src/nodes/rope.h
View File

@ -35,6 +35,7 @@ private:
const RoPENode::Config& config,
const std::vector<MemoryPtr>& inputs,
const std::vector<MemoryPtr>& outputs) = 0;
virtual ~Executor() = default;
};
template <typename T>
struct RoPEExecutorRotateHalf;

1
src/plugins/intel_cpu/src/nodes/scaled_attn.h
View File

@ -67,6 +67,7 @@ private:
virtual void execute(dnnl::stream strm, const Config& config, const std::vector<MemoryPtr>& inputs, const MemoryPtr output,
const MemoryPtr presentk_input, const MemoryPtr presentv_input, const MemoryPtr beam_input,
const PlainTensor& k_scale_zp, const PlainTensor& v_scale_zp) = 0;
virtual ~Executor() = default;
};
bool m_is_pageattn;

3
src/plugins/intel_cpu/src/nodes/space_to_depth.cpp
View File

@ -12,6 +12,7 @@
#include "cpu/x64/jit_generator.hpp"
#include "openvino/opsets/opset1.hpp"
#include <string>
#include "openvino/util/pp.hpp"
#include "common/blocked_desc_creator.h"
@ -140,7 +141,7 @@ void SpaceToDepth::initSupportedPrimitiveDescriptors() {
std::vector<LayoutType> supportedTypes;
if (inputDataShape.getRank() > 2) {
const auto& srcDims = inputDataShape.getDims();
auto canUseBlocked = [=](const size_t block) {
auto canUseBlocked = [OV_CAPTURE_CPY_AND_THIS](const size_t block) {
return srcDims[1] != Shape::UNDEFINED_DIM && srcDims[1] % block == 0 &&
(attrs.mode == Mode::DEPTH_FIRST ? block % attrs.blockStep == 0 : true);
};

3
src/plugins/intel_cpu/src/nodes/split.cpp
View File

@ -168,7 +168,8 @@ void Split::initSupportedPrimitiveDescriptors() {
const auto& parentdDims = inputShapes[0].getDims();
if (parentdDims[axis] != Shape::UNDEFINED_DIM &&
std::all_of(parentdDims.begin(), parentdDims.begin() + axis, [](size_t dim) { return dim == 1; }) &&
std::all_of(outputShapes.begin(), outputShapes.end(), [=](const Shape& shape){ return shape.getDims()[axis] != Shape::UNDEFINED_DIM; })) {
std::all_of(outputShapes.begin(), outputShapes.end(),
[OV_CAPTURE_CPY_AND_THIS](const Shape& shape){ return shape.getDims()[axis] != Shape::UNDEFINED_DIM; })) {
for (auto refPdIndex : pdIndexesToReuse) {
auto config = supportedPrimitiveDescriptors[refPdIndex].getConfig();

2
src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/causal_mask_preprocess_fusion.cpp
View File

@ -199,7 +199,7 @@ CausalMaskPreprocess::CausalMaskPreprocess() {
nullptr); // tensor_array<f32[?,1,?,..8192]>
auto result = index_Gather;
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
auto root = m.get_match_root();
PatternValidator validator(m);

5
src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_fq_rnn_to_quantized_rnn.cpp
View File

@ -11,7 +11,8 @@
#include "openvino/core/except.hpp"
#include "openvino/core/node_output.hpp"
#include "openvino/core/type/element_type.hpp"
#include <ov_ops/type_relaxed.hpp>
#include "ov_ops/type_relaxed.hpp"
#include "transformations/utils/utils.hpp"
#include "itt.hpp"
#include "openvino/core/type/element_type.hpp"
@ -78,7 +79,7 @@ ov::intel_cpu::ConvertFqRnnToQuantizedRnn::ConvertFqRnnToQuantizedRnn() {
gru_seq_m
});
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
auto rnn = m.get_match_root();
if (!rnn || transformation_callback(rnn))

4
src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/convert_matmul_to_fc.cpp
View File

@ -10,7 +10,7 @@
#include "openvino/op/reshape.hpp"
#include "openvino/core/rt_info.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include <transformations/utils/utils.hpp>
#include "transformations/utils/utils.hpp"
#include "itt.hpp"
@ -23,7 +23,7 @@ ov::intel_cpu::ConvertMatMulToFC::ConvertMatMulToFC() {
auto weights_m = ov::pass::pattern::any_input(weights_path);
auto matmul_m = ov::pass::pattern::wrap_type<ov::op::v0::MatMul>({ activations_m, weights_m }, ov::pass::pattern::has_static_rank());
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
auto matmul = std::dynamic_pointer_cast<ov::op::v0::MatMul>(pattern_map.at(matmul_m).get_node_shared_ptr());

3
src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/move_eltwise_up_data_movement.cpp
View File

@ -11,6 +11,7 @@
#include <openvino/opsets/opset8.hpp>
#include "openvino/core/rt_info.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "transformations/utils/utils.hpp"
#include "itt.hpp"
@ -45,7 +46,7 @@ ov::intel_cpu::MoveEltwiseUpThroughDataMov::MoveEltwiseUpThroughDataMov() {
ov::op::util::BinaryElementwiseArithmetic,
ov::op::v0::FakeQuantize>(ov::pass::pattern::has_static_rank());
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
auto eltwise = pattern_map.at(eltwise_pattern).get_node_shared_ptr();

10
src/plugins/intel_cpu/src/transformations/cpu_opset/common/pass/rope_fusion.cpp
View File

@ -57,7 +57,7 @@ ov::intel_cpu::RoPEFusionGPTNEOX::RoPEFusionGPTNEOX() {
// [x1, x2]*cos + [-x2, x1]*sin
auto result = makePattern<opset1::Add>({mul_cos, mul_sin}, {{"auto_broadcast", "numpy"}});
matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
PatternValidator validator(m);
if (!validator) {
return false;
@ -163,7 +163,7 @@ ov::intel_cpu::RoPEFusionCosSinPreprocess::RoPEFusionCosSinPreprocess() {
auto x = makePattern(ov::Rank(4));
auto rope = makePattern<RoPENode>({x, cos_tab, sin_tab});
matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
PatternValidator validator(m);
if (!validator) {
return false;
@ -211,7 +211,7 @@ ov::intel_cpu::RoPEFusionIOSlicing::RoPEFusionIOSlicing() {
auto x_emb = makePattern<RoPENode>({x, {}, {}}) | makePattern<RoPENode>({x, {}, {}, {}});
auto result = makePattern<opset1::Concat>({x_emb, y}, {{"axis", -1}});
matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
auto root = m.get_match_root();
@ -262,7 +262,7 @@ ov::intel_cpu::RoPEFusionPreprocess::RoPEFusionPreprocess() {
auto x = makePattern<opset1::Transpose>({input_slice | input_to_trans, {0, 2, 1, 3}});
auto result = makePattern<RoPENode>({x, {}, {}}) | makePattern<RoPENode>({x, {}, {}, {}});
matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
PatternValidator validator(m);
if (!validator) {
return false;
@ -794,7 +794,7 @@ ov::intel_cpu::RoPEShareCosSin::RoPEShareCosSin() {
auto sin_Sin = makePattern<opset1::Sin>({cat_Concat});
auto result = makePattern<opset1::Unsqueeze>({cos_Cos | sin_Sin, 1});
matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
auto root = m.get_match_root();
PatternValidator validator(m);

9
src/plugins/intel_cpu/src/transformations/cpu_opset/x64/pass/mha_fusion.cpp
View File

@ -10,6 +10,7 @@
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "openvino/pass/pattern/op/or.hpp"
#include "transformations/cpu_opset/x64/op/mha.hpp"
#include "transformations/utils/utils.hpp"
#include "simplify_fakequantize.hpp"
#include "itt.hpp"
@ -41,7 +42,7 @@ ov::intel_cpu::MHAFloatFusion::MHAFloatFusion() {
auto matmul1 = std::make_shared<ov::opset3::MatMul>(reshape1, transpose2);
auto transpose3 = std::make_shared<ov::opset3::Transpose>(matmul1, in10);
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
auto& pattern_to_output = m.get_pattern_value_map();
auto transpose0_in = pattern_to_output.at(in0);
auto transpose1_in = pattern_to_output.at(in1);
@ -180,7 +181,7 @@ ov::intel_cpu::MHAFloatFusion2::MHAFloatFusion2() {
auto matmul1 = std::make_shared<ov::opset3::MatMul>(softmax, transpose2);
auto transpose3 = std::make_shared<ov::opset3::Transpose>(matmul1, in10);
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
auto& pattern_to_output = m.get_pattern_value_map();
auto transpose0_in = pattern_to_output.at(in0);
auto transpose1_in = pattern_to_output.at(in1);
@ -293,7 +294,7 @@ ov::intel_cpu::MHAQuantFusion::MHAQuantFusion() {
ov::pass::pattern::wrap_type<ov::opset4::Constant>()});
auto transpose3 = std::make_shared<ov::opset3::Transpose>(fakeQuantize2, in10);
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
auto& pattern_to_output = m.get_pattern_value_map();
auto transpose0_in = pattern_to_output.at(in0);
auto transpose1_in = pattern_to_output.at(in1);
@ -473,7 +474,7 @@ ov::intel_cpu::MHAQuantFusion2::MHAQuantFusion2() {
auto in11 = std::make_shared<ov::pass::pattern::op::Or>(OutputVector{ matmul1, fakeQuantize1 });
auto transpose3 = std::make_shared<ov::opset3::Transpose>(in11, in10);
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
auto& pattern_to_output = m.get_pattern_value_map();
auto transpose0_in = pattern_to_output.at(in0);
auto transpose1_in = pattern_to_output.at(in1);

3
src/plugins/intel_cpu/src/transformations/snippets/x64/pass/mul_add_to_fma.cpp
View File

@ -7,6 +7,7 @@
#include "mul_add_to_fma.hpp"
#include "snippets/snippets_isa.hpp"
#include "transformations/snippets/x64/op/fused_mul_add.hpp"
#include "transformations/utils/utils.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "openvino/pass/pattern/matcher.hpp"
@ -28,7 +29,7 @@ ov::intel_cpu::pass::MulAddToFMA::MulAddToFMA() {
auto add_input_2 = ov::pass::pattern::any_input();
auto add_m = ov::pass::pattern::wrap_type<opset1::Add>({ mul_m, add_input_2 }, is_not_memory_access);
matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
OV_ITT_SCOPED_TASK(ov::pass::itt::domains::SnippetsTransform, "Snippets::op::MulAddToFMA_callback")
const auto& pattern_map = m.get_pattern_value_map();
const auto multiply = pattern_map.at(mul_m).get_node_shared_ptr();

9
src/plugins/intel_cpu/thirdparty/CMakeLists.txt vendored
View File

@ -16,6 +16,7 @@ if(ENABLE_LTO)
endif()
function(ov_add_onednn)
set(CMAKE_COMPILE_WARNING_AS_ERROR OFF)
set(CMAKE_DISABLE_FIND_PACKAGE_PythonInterp ON)
set(DNNL_ENABLE_JIT_PROFILING ${BUILD_SHARED_LIBS} CACHE BOOL "" FORCE)
if(BUILD_SHARED_LIBS AND ENABLE_PROFILING_ITT)
@ -59,7 +60,7 @@ function(ov_add_onednn)
endif()
if(AARCH64 OR ARM)
set(DNNL_USE_ACL ON CACHE BOOL "Use ARM Conpute Library kernels in oneDNN" FORCE)
set(DNNL_USE_ACL ON CACHE BOOL "Use ARM Compute Library kernels in oneDNN" FORCE)
endif()
set(SDL_cmake_included ON) ## to skip internal SDL flags. SDL flags are already set on OV level
@ -78,7 +79,7 @@ function(ov_add_onednn)
link_libraries(TBB::tbb)
endif()
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
ov_add_compiler_flags(-Wno-undef)
ov_add_compiler_flags(-Wno-missing-declarations)
if(ARM OR AARCH64)
@ -92,6 +93,10 @@ function(ov_add_onednn)
ov_add_compiler_flags(-Wno-restrict)
endif()
endif()
if(OV_COMPILER_IS_INTEL_LLVM)
ov_add_compiler_flags(-Wno-deprecated-this-capture)
ov_add_compiler_flags(-Wno-deprecated-enum-enum-conversion)
endif()
elseif(UNIX AND CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -diag-disable=10121")
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")

2
src/plugins/intel_gpu/include/intel_gpu/graph/kernel_impl_params.hpp
View File

@ -89,6 +89,8 @@ struct kernel_impl_params final {
, primary_input_idx(0) {
}
virtual ~kernel_impl_params() = default;
const layout& get_input_layout(size_t idx = 0) const {
OPENVINO_ASSERT(input_layouts.size() > idx,
"The size of input layouts must be greater than the requested index: ",

1
src/plugins/intel_gpu/include/intel_gpu/runtime/event.hpp
View File

@ -22,6 +22,7 @@ struct event {
public:
using ptr = std::shared_ptr<event>;
event() = default;
virtual ~event() = default;
void wait();
void set();

1
src/plugins/intel_gpu/src/kernel_selector/kernel_selector_params.h
View File

@ -441,6 +441,7 @@ struct base_activation_params {
m(m),
n(n) {}
virtual ~base_activation_params() = default;
virtual std::string to_string() const;
};

3
src/plugins/intel_gpu/src/plugin/transformations/bcast_and_pad_zp_buffers.cpp
View File

@ -12,6 +12,7 @@
#include "openvino/pass/graph_rewrite.hpp"
#include "openvino/pass/pattern/op/pattern.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "transformations/utils/utils.hpp"
#include <memory>
@ -79,7 +80,7 @@ BroadcastAndPadZeroPointBuffers::BroadcastAndPadZeroPointBuffers(size_t pad_size
auto convolution_m = wrap_type<op::Convolution>({ input_m, weights_m, bias_m, azp_m, wzp_m, cmp_m });
ov::matcher_pass_callback callback = [=](Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
if (transformation_callback(m.get_match_root())) {
return false;

3
src/plugins/intel_gpu/src/plugin/transformations/clamp_fp16_output.cpp
View File

@ -17,6 +17,7 @@
#include "openvino/pass/pattern/op/pattern.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "openvino/pass/pattern/op/or.hpp"
#include "transformations/utils/utils.hpp"
#include <memory>
@ -38,7 +39,7 @@ ClampFP16Output::ClampFP16Output() {
auto softmax_input_m = std::make_shared<Or>(ov::OutputVector{eltwise_m, reshape_m, matmul_m});
auto softmax_m = wrap_type<v8::Softmax>({softmax_input_m}, type_matches(ov::element::f16));
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
auto softmax = std::dynamic_pointer_cast<v8::Softmax>(pattern_map.at(softmax_m).get_node_shared_ptr());
if (!softmax || transformation_callback(softmax)) {

5
src/plugins/intel_gpu/src/plugin/transformations/convert_convolution.cpp
View File

@ -15,6 +15,7 @@
#include "openvino/pass/pattern/op/or.hpp"
#include "openvino/pass/pattern/op/pattern.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "transformations/utils/utils.hpp"
#include <memory>
@ -125,7 +126,7 @@ AsymmetricConvolutionMatcher::AsymmetricConvolutionMatcher() {
auto convolution_m = wrap_type<ov::op::v1::Convolution, ov::op::v1::GroupConvolution>({ conv_activations_m, conv_weights_m });
ov::matcher_pass_callback callback = [=](Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
if (transformation_callback(m.get_match_root())) {
return false;
@ -189,7 +190,7 @@ ConvolutionMatcher::ConvolutionMatcher() {
auto bias_val_m = wrap_type<ov::op::v0::Constant>();
auto convolution_m = wrap_type<ov::op::v1::Convolution, ov::op::v1::GroupConvolution>({ input_m, weights_m });
ov::matcher_pass_callback callback = [=](Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
if (transformation_callback(m.get_match_root())) {
return false;

2
src/plugins/intel_gpu/src/plugin/transformations/convert_fc_to_compressed.cpp
View File

@ -67,7 +67,7 @@ ConvertFullyConnectedToFullyConnectedCompressed::ConvertFullyConnectedToFullyCon
auto weights_input_m = std::make_shared<ov::pass::pattern::op::Or>(ov::OutputVector{reshape_m, transpose_m, mul_m});
auto fully_connected_m = wrap_type<op::FullyConnected>({data_m, weights_input_m, bias_m});
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
OPENVINO_ASSERT(pattern_map.count(fully_connected_m));
OPENVINO_ASSERT(pattern_map.count(mul_const_m));

2
src/plugins/intel_gpu/src/plugin/transformations/convert_matmul_to_fc.cpp
View File

@ -33,7 +33,7 @@ ConvertMatMulToFullyConnected::ConvertMatMulToFullyConnected() {
auto weights_m = ov::pass::pattern::any_input(weights_path);
auto matmul_m = ov::pass::pattern::wrap_type<ov::op::v0::MatMul>({ activations_m, weights_m }, ov::pass::pattern::has_static_rank());
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
auto matmul = std::dynamic_pointer_cast<ov::op::v0::MatMul>(pattern_map.at(matmul_m).get_node_shared_ptr());

3
src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_for_false_keepdims.cpp
View File

@ -11,6 +11,7 @@
#include "openvino/op/reduce_max.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/reshape.hpp"
#include "transformations/utils/utils.hpp"
#include "decompose_reduce_for_false_keepdims.hpp"
@ -34,7 +35,7 @@ DecomposeReduceForFalseKeepDims::DecomposeReduceForFalseKeepDims() {
ov::pass::pattern::has_static_shape());
// register callback
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
auto reduce =
as_type_ptr<op::util::ArithmeticReductionKeepDims>(pattern_map.at(reduce_pattern).get_node_shared_ptr());

2
src/plugins/intel_gpu/src/plugin/transformations/indirect_kv_cache.cpp
View File

@ -57,7 +57,7 @@ IndirectKVCache::IndirectKVCache() {
auto matmul_1 = wrap_type<ov::intel_gpu::op::Gemm>({any_input(), kv_cache});
auto matmul = std::make_shared<ov::pass::pattern::op::Or>(OutputVector{matmul_0, matmul_1});
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
if (transformation_callback(m.get_match_root())) {
return false;
}

2
src/plugins/intel_gpu/src/plugin/transformations/kv_cache_fusion.cpp
View File

@ -48,7 +48,7 @@ KVCacheFusionMatcher::KVCacheFusionMatcher() {
auto present_input = std::make_shared<ov::pass::pattern::op::Or>(OutputVector{concat, convert_present});
auto present = wrap_type<ov::op::v6::Assign>({present_input});
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
if (transformation_callback(m.get_match_root())) {
return false;
}

2
src/plugins/intel_gpu/src/plugin/transformations/swiglu_fusion.cpp
View File

@ -41,7 +41,7 @@ SwiGLUFusion::SwiGLUFusion() {
// Mul(Xw, Xv) = Swish(Xw) * Xv
auto mul_m = wrap_type<ov::op::v1::Multiply>({swish_m, variadic_split_m->output(1)});
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
OPENVINO_ASSERT(pattern_map.count(mul_m));
OPENVINO_ASSERT(pattern_map.count(swish_m));

4
src/plugins/intel_gpu/src/plugin/transformations/transpose_matmul_fusion.cpp
View File

@ -75,7 +75,7 @@ TransposeMatMulMatcher::TransposeMatMulMatcher() {
auto matmul_m = wrap_type<ov::op::v0::MatMul>({ matmul_in_a, matmul_in_b }, is_dynamic);
ov::matcher_pass_callback callback = [=](Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
auto matmul = std::dynamic_pointer_cast<ov::op::v0::MatMul>(pattern_map.at(matmul_m).get_node_shared_ptr());
@ -161,7 +161,7 @@ TransposeMatMulTransposeMatcher::TransposeMatMulTransposeMatcher() {
auto transpose_c_order_m = wrap_type<ov::op::v0::Constant>(consumers_count(1));
auto transpose_c_m = wrap_type<ov::op::v1::Transpose>({matmul_m, transpose_c_order_m});
ov::matcher_pass_callback callback = [=](Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
auto matmul = std::dynamic_pointer_cast<ov::op::v0::MatMul>(pattern_map.at(matmul_m).get_node_shared_ptr());

2
src/plugins/intel_gpu/src/plugin/transformations/unsqueeze_broadcast_reshape_matmul_fusion.cpp
View File

@ -49,7 +49,7 @@ UnsqueezeBroadcastReshapeMatmulFusion::UnsqueezeBroadcastReshapeMatmulFusion() {
auto reshape_m = wrap_type<ov::op::v1::Reshape>({broadcast_m, any_input()}, reshape_predicate);
auto matmul_m = wrap_type<op::Gemm>({input_a_m, reshape_m});
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
if (transformation_callback(m.get_match_root())) {
return false;
}

3
src/plugins/intel_gpu/tests/functional/subgraph_tests/condition.cpp
View File

@ -63,7 +63,8 @@ enum InnerBodyType {
};
public:
InnerBodyGenerator() { }
InnerBodyGenerator() = default;
virtual ~InnerBodyGenerator() = default;
virtual std::shared_ptr<ov::Model> get_function() { return _func; }
virtual std::shared_ptr<ov::op::v0::Parameter> get_input() { return _param; }

6
src/plugins/intel_gpu/thirdparty/CMakeLists.txt vendored
View File

@ -30,7 +30,7 @@ if(ENABLE_ONEDNN_FOR_GPU)
message(WARNING "Intel GPU plugin unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}")
endif()
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
ov_add_compiler_flags(-Wno-undef)
ov_add_compiler_flags(-Wno-missing-declarations)
if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 11 AND CMAKE_COMPILER_IS_GNUCXX)
@ -47,7 +47,9 @@ if(ENABLE_ONEDNN_FOR_GPU)
foreach(cmake_var IN ITEMS CMAKE_SYSTEM_NAME CMAKE_SYSTEM_VERSION
CMAKE_SYSTEM_PROCESSOR CMAKE_TOOLCHAIN_FILE)
list(APPEND cmake_extra_args "-D${cmake_var}=${${cmake_var}}")
if(${cmake_var})
list(APPEND cmake_extra_args "-D${cmake_var}=${${cmake_var}}")
endif()
endforeach()
if(OV_GENERATOR_MULTI_CONFIG)

3
thirdparty/cnpy/cnpy.cpp vendored
View File

@ -66,8 +66,6 @@ template<> std::vector<char>& cnpy::operator+=(std::vector<char>& lhs, const cha
void cnpy::parse_npy_header(unsigned char* buffer,size_t& word_size, std::vector<size_t>& shape, bool& fortran_order) {
//std::string magic_string(buffer,6);
uint8_t major_version = *reinterpret_cast<uint8_t*>(buffer+6);
uint8_t minor_version = *reinterpret_cast<uint8_t*>(buffer+7);
uint16_t header_len = *reinterpret_cast<uint16_t*>(buffer+8);
std::string header(reinterpret_cast<char*>(buffer+9),header_len);
@ -236,6 +234,7 @@ cnpy::NpyArray load_the_npz_array(FILE* fp, uint32_t compr_bytes, uint32_t uncom
err = inflate(&d_stream, Z_FINISH);
err = inflateEnd(&d_stream);
(void)err;
std::vector<size_t> shape(0);
size_t word_size = 0;

4
thirdparty/dependencies.cmake vendored
View File

@ -359,7 +359,7 @@ if(ENABLE_OV_PADDLE_FRONTEND OR ENABLE_OV_ONNX_FRONTEND OR ENABLE_OV_TF_FRONTEND
if(ENABLE_SYSTEM_PROTOBUF)
set(link_type INTERFACE)
endif()
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
get_target_property(original_name ${target_name} ALIASED_TARGET)
if(TARGET ${original_name})
# during build protobuf's cmake creates aliased targets
@ -453,7 +453,7 @@ if(ENABLE_SNAPPY_COMPRESSION)
ov_add_compiler_flags(/wd4245)
# 'var' : conversion from 'size_t' to 'type', possible loss of data
ov_add_compiler_flags(/wd4267)
elseif(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
elseif(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
# we need to pass -Wextra first, then -Wno-sign-compare
# otherwise, snappy's CMakeLists.txt will do it for us
ov_add_compiler_flags(-Wextra)

2
thirdparty/protobuf/CMakeLists.txt vendored
View File

@ -8,7 +8,7 @@
set(BUILD_SHARED_LIBS OFF)
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG OR OV_COMPILER_IS_INTEL_LLVM)
ov_add_compiler_flags(-Wno-all)
if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 11 AND CMAKE_COMPILER_IS_GNUCXX)
ov_add_compiler_flags(-Wno-stringop-overflow)