Merge branch 'master' into onednn_kv_cache_compression

Author: p-durandin

src/common/snippets/docs/debug_capabilities/README.md

@@ -9,4 +9,4 @@ Use the following cmake option to enable snippets debug capabilities:
 
 * [Performance counters](perf_count.md)
 * [Snippets segfault detector](snippets_segfault_detector.md)
-* [LIR passes serialization](LIR_passes_serialization.md)
+* [Linear IR passes serialization](linear_ir_passes_serialization.md)

src/common/snippets/docs/debug_capabilities/perf_count.md

@@ -5,4 +5,4 @@ Subgraph in snippets could be very large. Sometimes developers are interested th
 There are two perf count modes.
  - `Chrono` : Perf count via chrono call. This is a universal method, and support multi-threads scenario to print perf count data for each thread.
  - `BackendSpecific` : Perf count provided by backend. This is for device specific requirement. For example, for sake of more light overhead and more accurate result, x86 or x86-64 CPU specific mode via reading RDTSC register is implemented. At current this x86 or x86-64 CPU BackendSpecific mode only support single thread.
- One can select prefered mode by setting `perf_count_mode` default value in [snippets Config](../../include/snippets/utils/debug_caps.hpp)
+ One can select prefered mode by setting `perf_count_mode` default value in [snippets Config](../../include/snippets/utils/debug_caps_config.hpp)

src/common/snippets/docs/mha_optimization_guide.md

@@ -129,7 +129,7 @@ The heuristics for determining the optimal block sizes can be found in [BrgemmCP
 
 ### Blocking Order
 
-The lowered pass [BrgemmBlocking](../../../plugins/intel_cpu/src/transformations/snippets/x64/pass/lowered/brgemm_blocking.cpp) performs blocking loops creation on LinearIR.
+The lowered pass [BrgemmBlocking](../../../common/snippets/src/lowered/pass/brgemm_blocking.cpp) performs blocking loops creation on LinearIR.
 Currently, the order of blocking loops is following (from outer to inner): `M->N->K`.
 
 ## MHA Performance Tuning Recommendations

src/common/snippets/docs/snippets_design_guide.md

@@ -638,23 +638,23 @@ Consequently, all the ports connected to the same `PortConnector` will have the
 In other words, when all the `Expressions` that required input data in a certain register are evaluated, the register may be reused to hold another `Expression's` output. 
 `AssignRegisters` also supports two types of registers: general-purpose and vector ones. 
 Different types of registers are managed and assigned independently, and a particular register type required by an `Expression` is provided by the `ov::snippets::Generator` (or a derived generator for target-specific `Ops`).  
-2. `InsertTailLoop` injects tail-processing section after a loop body if needed. 
+2. `InsertSpecificIterations` injects initialization section before a loop body and tail-processing section after a loop body if needed. 
 Note that every loop has two parameters that specify how its body is evaluated: `work_amount` and `increment` The `work_amount` indicates how much of the data needs to be processed, it often equals to the dimension's size the loop is working on. 
 The `increment` defines how many data entries are processed on every loop iteration (it usually equals to vector size for the innermost loops of elementwise subgraph). 
 So if a loop's `work_amount` is not evenly divisible by its `increment`, it means that a tail processing is required. 
-`InsertTailLoop` duplicates the body of such a loop, rescales pointer increments and load/store masks appropriately, and injects these `Ops` immediately after the processed loop.
+`InsertSpecificIterations` duplicates the body of such a loop, rescales pointer increments and load/store masks appropriately, and injects these `Ops` immediately after the processed loop.
 3. `CleanupLoopOffsets` "fuses" the finalization offsets of loop with an outer loop's pointer increments and zeroes the offsets before `Result` operations.
 4. `OptimizeLoopSingleEvaluation` moves all pointer arithmetic to finalization offsets in `LoopEnd`, and marks the loops that will be executed only once.
 This information will be used during code emission to eliminate redundant instructions.
 
-Please see [assign_registers.cpp](../src/lowered/pass/assign_registers.cpp) and [insert_tail_loop.cpp](../src/lowered/pass/insert_tail_loop.cpp) for more info regarding the main passes in the `Preparation` stage. 
+Please see [assign_registers.cpp](../src/lowered/pass/assign_registers.cpp) and [insert_specific_iterations.cpp](../src/lowered/pass/insert_specific_iterations.cpp) for more info regarding the main passes in the `Preparation` stage. 
 When the `Preparation` is finished, the `Generator` constructs target-specific emitters by calling `init_emitter(target)` method for every `Expression` in the `LinearIR`, where the `target` is a `TargetMachine` instance.
 
 The `TargetMachine` is a class that provides generator with target-specific information, such as supported instruction sets, vector register size etc. 
 `TargetMachine` also maps the OpenVINO's `DiscreteTypeInfo` (stored in the `Expression`) to the emitter that actually implements the operation. 
 The mapping is done using the `jitters` map defined in [target_machine.hpp](../include/snippets/target_machine.hpp). 
 In order for this mechanism to work, every `Snippets'` code generation backend should create emitter implementations derived from the `Emitter` base class defined in [emitter.hpp](../include/snippets/emitter.hpp). 
-The backend then should create its own target machine class (derived from the common `TargetMachine`) and populate the `jitters` map, see the [cpu_generator.cpp](../../../plugins/intel_cpu/src/emitters/x64/cpu_generator.cpp) for an implementation example.
+The backend then should create its own target machine class (derived from the common `TargetMachine`) and populate the `jitters` map, see the [cpu_generator.cpp](../../../plugins/intel_cpu/src/emitters/snippets/x64/cpu_generator.cpp) for an implementation example.
 
 Note that `init_emitters(...)` only initializes the appropriate emitters, but do not actually emit any code. 
 To perform code emission, a `snippets::op::Kernel` operation is constructed (see [generator.cpp](../src/generator.cpp)), its constructor takes the `IR` with all the initialized emitters as an only input argument. 
@@ -663,7 +663,7 @@ Finally, the `kernel->emit_code({}, {})` command initiates the code emission.
 Note that the `emit_code(...)` is called only for the `KernelEmitter`, and the emitter is responsible for calling the same method for the rest of the expressions in the `IR` This encapsulation is needed because the `KernelEmitter` performs mapping of the assigned abstract registers to physical registers available on a particular platform. 
 Another important function of the `KernelEmitter` is to calculate input/output data offsets based on dimension indices provided in runtime, and to shift corresponding data-handling registers accordingly. 
 Keep in mind however, that the required functionality of the `KernelEmitter` depends on how the rest of the emitters are implemented (particularly for `Load`/`Store` `Ops`). 
-We've discussed above how the emitters for the `intel_cpu` plugin are implemented (see [jit_snippets_emitters.cpp](../../../plugins/intel_cpu/src/emitters/x64/jit_snippets_emitters.cpp) for more details), but a different backend might require a different approach depending on hardware specifics.
+We've discussed above how the emitters for the `intel_cpu` plugin are implemented (see [jit_snippets_emitters.cpp](../../../plugins/intel_cpu/src/emitters/snippets/x64/jit_snippets_emitters.cpp) for more details), but a different backend might require a different approach depending on hardware specifics.
 
 ## See also
 

src/common/util/include/openvino/util/cpp_version.hpp

@@ -0,0 +1,35 @@
+// Copyright (C) 2018-2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+/**
+ * @brief Define a separate value for every version of C++ standard upto currently supported by build setup.
+ */
+#if !(defined(_MSC_VER) && __cplusplus == 199711L)
+#    if __cplusplus >= 201103L
+#        define OPENVINO_CPP_VER_AT_LEAST_11
+#        if __cplusplus >= 201402L
+#            define OPENVINO_CPP_VER_AT_LEAST_14
+#            if __cplusplus >= 201703L
+#                define OPENVINO_CPP_VER_AT_LEAST_17
+#                if __cplusplus >= 202002L
+#                    define OPENVINO_CPP_VER_AT_LEAST_20
+#                endif
+#            endif
+#        endif
+#    endif
+#elif defined(_MSC_VER) && __cplusplus == 199711L
+#    if _MSVC_LANG >= 201103L
+#        define OPENVINO_CPP_VER_AT_LEAST_11
+#        if _MSVC_LANG >= 201402L
+#            define OPENVINO_CPP_VER_AT_LEAST_14
+#            if _MSVC_LANG >= 201703L
+#                define OPENVINO_CPP_VER_AT_LEAST_17
+#                if _MSVC_LANG >= 202002L
+#                    define OPENVINO_CPP_VER_AT_LEAST_20
+#                endif
+#            endif
+#        endif
+#    endif
+#endif

src/common/util/include/openvino/util/file_path.hpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2018-2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <cstdio>
+
+#include "openvino/util/filesystem.hpp"
+namespace ov {
+namespace util {
+
+#if defined(OPENVINO_HAS_FILESYSTEM)
+using Path = std::filesystem::path;
+#elif defined(OPENVINO_HAS_EXP_FILESYSTEM)
+// Known issues:
+// * error C2280: 'std::u32string std::experimental::filesystem::v1::path::u32string(void) const': attempting to
+// * filesystem error: Cannot convert character sequence: Invalid in or incomplete multibyte or wide character
+
+///
+/// @typedef Path
+/// @brief Alias for std::experimental::filesystem::path.
+///
+/// This alias is used to simplify the usage of filesystem paths.
+///
+/// @note The experimental version of std::filesystem::path may not support all features correctly.
+/// It is recommended to use this alias with caution and consider upgrading to C++17 or higher
+/// for full support of std::filesystem::path.
+///
+using Path = std::experimental::filesystem::path;
+#endif
+
+}  // namespace util
+}  // namespace ov

src/common/util/include/openvino/util/filesystem.hpp

@@ -4,28 +4,28 @@
 
 #pragma once
 
-#include "openvino/core/visibility.hpp"
+#include "openvino/util/cpp_version.hpp"
 
-#if defined(_MSC_VER) && defined(OPENVINO_CPP_VER_11)
+#if defined(_MSC_VER) && defined(OPENVINO_CPP_VER_AT_LEAST_17)
+#    define OPENVINO_HAS_FILESYSTEM
+#elif defined(_MSC_VER) && defined(OPENVINO_CPP_VER_AT_LEAST_11)
 #    define OPENVINO_HAS_EXP_FILESYSTEM
 #    define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING
 #    define _LIBCPP_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM
 #elif defined(__has_include)
-#    if defined(OPENVINO_CPP_VER_17) && (__has_include(<filesystem>)) && (!__has_include(<experimental/filesystem>))
+#    if defined(OPENVINO_CPP_VER_AT_LEAST_17) && (__has_include(<filesystem>))
 #        define OPENVINO_HAS_FILESYSTEM
-#    elif defined(OPENVINO_CPP_VER_11) && (__has_include(<experimental/filesystem>))
+#    elif defined(OPENVINO_CPP_VER_AT_LEAST_11) && (__has_include(<experimental/filesystem>))
 #        define OPENVINO_HAS_EXP_FILESYSTEM
 #        define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING
 #        define _LIBCPP_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM
 #    endif
 #endif
 
-#if !defined(OPENVINO_HAS_FILESYSTEM) && !defined(OPENVINO_HAS_EXP_FILESYSTEM)
-#    error "Neither #include <filesystem> nor #include <experimental/filesystem> is available."
-#elif defined(OPENVINO_HAS_FILESYSTEM)
+#if defined(OPENVINO_HAS_FILESYSTEM)
 #    include <filesystem>
-namespace std_fs = std::filesystem;
 #elif defined(OPENVINO_HAS_EXP_FILESYSTEM)
 #    include <experimental/filesystem>
-namespace std_fs = std::experimental::filesystem;
+#else
+#    error "Neither #include <filesystem> nor #include <experimental/filesystem> is available."
 #endif

src/core/include/openvino/core/graph_util.hpp

@@ -21,7 +21,7 @@
 #include "openvino/op/parameter.hpp"
 #include "openvino/pass/serialize.hpp"
 
-#ifdef OPENVINO_CPP_VER_17
+#ifdef OPENVINO_CPP_VER_AT_LEAST_17
 #    include <filesystem>
 #endif
 
@@ -299,7 +299,7 @@ void serialize(const std::shared_ptr<const ov::Model>& m,
                const std::string& bin_path = "",
                ov::pass::Serialize::Version version = ov::pass::Serialize::Version::UNSPECIFIED);
 
-#ifdef OPENVINO_CPP_VER_17
+#ifdef OPENVINO_CPP_VER_AT_LEAST_17
 template <class Path, std::enable_if_t<std::is_same_v<Path, std::filesystem::path>>* = nullptr>
 void serialize(const std::shared_ptr<const ov::Model>& m,
                const Path& xml_path,
@@ -327,7 +327,7 @@ void save_model(const std::shared_ptr<const ov::Model>& model,
                 bool compress_to_fp16 = true);
 #endif
 
-#ifdef OPENVINO_CPP_VER_17
+#ifdef OPENVINO_CPP_VER_AT_LEAST_17
 template <class Path, std::enable_if_t<std::is_same_v<Path, std::filesystem::path>>* = nullptr>
 void save_model(const std::shared_ptr<const ov::Model>& model, const Path& output_model, bool compress_to_fp16 = true) {
     save_model(model, output_model.string(), compress_to_fp16);

src/core/include/openvino/core/visibility.hpp

@@ -80,26 +80,26 @@
 
 #if !(defined(_MSC_VER) && __cplusplus == 199711L)
 #    if __cplusplus >= 201103L
-#        define OPENVINO_CPP_VER_11
+#        define OPENVINO_CPP_VER_AT_LEAST_11
 #        if __cplusplus >= 201402L
-#            define OPENVINO_CPP_VER_14
+#            define OPENVINO_CPP_VER_AT_LEAST_14
 #            if __cplusplus >= 201703L
-#                define OPENVINO_CPP_VER_17
+#                define OPENVINO_CPP_VER_AT_LEAST_17
 #                if __cplusplus >= 202002L
-#                    define OPENVINO_CPP_VER_20
+#                    define OPENVINO_CPP_VER_AT_LEAST_20
 #                endif
 #            endif
 #        endif
 #    endif
 #elif defined(_MSC_VER) && __cplusplus == 199711L
 #    if _MSVC_LANG >= 201103L
-#        define OPENVINO_CPP_VER_11
+#        define OPENVINO_CPP_VER_AT_LEAST_11
 #        if _MSVC_LANG >= 201402L
-#            define OPENVINO_CPP_VER_14
+#            define OPENVINO_CPP_VER_AT_LEAST_14
 #            if _MSVC_LANG >= 201703L
-#                define OPENVINO_CPP_VER_17
+#                define OPENVINO_CPP_VER_AT_LEAST_17
 #                if _MSVC_LANG >= 202002L
-#                    define OPENVINO_CPP_VER_20
+#                    define OPENVINO_CPP_VER_AT_LEAST_20
 #                endif
 #            endif
 #        endif

src/core/include/openvino/pass/serialize.hpp

@@ -11,7 +11,7 @@
 #include "openvino/opsets/opset.hpp"
 #include "openvino/pass/pass.hpp"
 
-#ifdef OPENVINO_CPP_VER_17
+#ifdef OPENVINO_CPP_VER_AT_LEAST_17
 #    include <filesystem>
 #endif
 
@@ -39,7 +39,7 @@ class OPENVINO_API Serialize : public ov::pass::ModelPass {
 
     Serialize(const std::string& xmlPath, const std::string& binPath, Version version = Version::UNSPECIFIED);
 
-#ifdef OPENVINO_CPP_VER_17
+#ifdef OPENVINO_CPP_VER_AT_LEAST_17
     Serialize(const std::filesystem::path& xmlPath,
               const std::filesystem::path& binPath,
               Version version = Version::UNSPECIFIED)

src/core/src/op/paged_attention.cpp

@@ -177,7 +177,8 @@ void PagedAttentionExtension::validate_and_infer_types() {
             get_input_partial_shape(15).rank().get_length(),
             ".");
         NODE_VALIDATION_CHECK(this,
-                              get_input_element_type(15).is_dynamic() || get_input_element_type(15) == element::f32,
+                              get_input_element_type(15).is_dynamic() || get_input_element_type(15) == element::f32 ||
+                                  get_input_element_type(15) == element::f16,
                               "Element type of `rotation_trig_lut` input should be f32, but it is ",
                               get_input_element_type(15),
                               ".");