[Snippets] ov::Node replaced with lowered::Expression in emitter constructors (#19481)
This commit is contained in:
Vladislav Golubev
GitHub
parent
45cc4fdb33
commit
94bdaea965
@ -25,9 +25,7 @@ public:
|
||||
/**
|
||||
* @brief Default constructor
|
||||
*/
|
||||
Emitter(const std::shared_ptr<ov::Node>& n) {}
|
||||
|
||||
Emitter(std::vector<std::pair<std::shared_ptr<Emitter>, RegInfo>>& region) {}
|
||||
Emitter() {}
|
||||
|
||||
/**
|
||||
* @brief called by generator to generate code to produce target code for a specific operation
|
||||
@ -51,7 +49,5 @@ public:
|
||||
virtual ~Emitter() = default;
|
||||
};
|
||||
|
||||
using AllocatedEmitter = std::pair<std::shared_ptr<Emitter>, ov::snippets::RegInfo>;
|
||||
|
||||
} // namespace snippets
|
||||
} // namespace ov
|
||||
|
||||
@ -8,7 +8,6 @@
|
||||
#include <openvino/opsets/opset1.hpp>
|
||||
|
||||
#include "snippets/emitter.hpp"
|
||||
#include "snippets/target_machine.hpp"
|
||||
#include "snippets/lowered/port_connector.hpp"
|
||||
#include "snippets/lowered/expression_port.hpp"
|
||||
|
||||
@ -47,7 +46,6 @@ public:
|
||||
size_t get_output_count() const { return m_output_port_connectors.size(); }
|
||||
|
||||
void validate() const;
|
||||
void init_emitter(const std::shared_ptr<const TargetMachine>& target);
|
||||
|
||||
ExpressionPort get_input_port(size_t i);
|
||||
ExpressionPort get_output_port(size_t i);
|
||||
|
||||
@ -7,6 +7,7 @@
|
||||
#include <list>
|
||||
|
||||
#include "expression.hpp"
|
||||
#include "snippets/target_machine.hpp"
|
||||
|
||||
namespace ov {
|
||||
namespace snippets {
|
||||
|
||||
@ -9,12 +9,12 @@
|
||||
#pragma once
|
||||
|
||||
#include "emitter.hpp"
|
||||
#include "snippets/lowered/expression.hpp"
|
||||
|
||||
namespace ov {
|
||||
namespace snippets {
|
||||
|
||||
typedef std::pair<std::function<std::shared_ptr<Emitter>(const std::shared_ptr<ov::Node>&)>,
|
||||
std::function<std::set<std::vector<element::Type>>(const std::shared_ptr<ov::Node>&)>> jitters_value;
|
||||
typedef std::pair<std::function<std::shared_ptr<Emitter>(const lowered::ExpressionPtr&)>,
|
||||
std::function<std::set<ov::element::TypeVector>(const std::shared_ptr<ov::Node>&)>> jitters_value;
|
||||
|
||||
/**
|
||||
* @interface TargetMachine
|
||||
@ -46,30 +46,14 @@ public:
|
||||
* @brief called by generator to all the emitter for a target machine
|
||||
* @return a map by node's type info with callbacks to create an instance of emitter for corresponding operation type
|
||||
*/
|
||||
std::function<std::shared_ptr<Emitter>(const std::shared_ptr<Node>)> get(const ov::DiscreteTypeInfo& type) const {
|
||||
auto jitter = jitters.find(type);
|
||||
if (jitter == jitters.end()) {
|
||||
OPENVINO_THROW(std::string("Target code emitter is not available for ") + type.name + " operation.");
|
||||
}
|
||||
return jitter->second.first;
|
||||
}
|
||||
|
||||
std::function<std::set<std::vector<element::Type>>(const std::shared_ptr<ov::Node>&)>
|
||||
get_supported_precisions(const ov::DiscreteTypeInfo type) const {
|
||||
auto jitter = jitters.find(type);
|
||||
if (jitter == jitters.end()) {
|
||||
OPENVINO_THROW(std::string("Target code emitter is not available for ") + type.name + " operation.");
|
||||
}
|
||||
return jitter->second.second;
|
||||
}
|
||||
std::function<std::shared_ptr<Emitter>(const lowered::ExpressionPtr&)> get(const ov::DiscreteTypeInfo& type) const;
|
||||
std::function<std::set<ov::element::TypeVector>(const std::shared_ptr<ov::Node>&)> get_supported_precisions(const ov::DiscreteTypeInfo& type) const;
|
||||
|
||||
/**
|
||||
* @brief checks if emitter for a specific operation is supported
|
||||
* @return true, if supported
|
||||
*/
|
||||
bool has(const ov::DiscreteTypeInfo type) const {
|
||||
return jitters.find(type) != jitters.end();
|
||||
}
|
||||
bool has(const ov::DiscreteTypeInfo& type) const;
|
||||
virtual ~TargetMachine() = default;
|
||||
|
||||
protected:
|
||||
|
||||
@ -34,7 +34,8 @@ Generator::LoweringResult Generator::generate(lowered::LinearIR& linear_ir, cons
|
||||
OV_ITT_TASK_NEXT(GENERATE, "::EmitCode")
|
||||
auto loops2DKernel = std::make_shared<op::Kernel>(linear_ir);
|
||||
loops2DKernel->compile_params = compile_params;
|
||||
std::shared_ptr<Emitter> kernel = target->get(op::Kernel::get_type_info_static())(loops2DKernel);
|
||||
auto loops2DKernelExpr = linear_ir.create_expression(loops2DKernel, std::vector<lowered::PortConnectorPtr>{});
|
||||
std::shared_ptr<Emitter> kernel = target->get(op::Kernel::get_type_info_static())(loops2DKernelExpr);
|
||||
|
||||
kernel->emit_code({}, {});
|
||||
|
||||
|
||||
@ -78,10 +78,6 @@ void Expression::set_reg_info(RegInfo rinfo) {
|
||||
}
|
||||
}
|
||||
|
||||
void Expression::init_emitter(const std::shared_ptr<const TargetMachine>& target) {
|
||||
m_emitter = target->get(m_source_node->get_type_info())(m_source_node);
|
||||
}
|
||||
|
||||
void Expression::validate() const {
|
||||
OPENVINO_ASSERT(m_input_port_descriptors.size() == m_input_port_connectors.size(),
|
||||
"The count of input ports and input port connectors must be equal");
|
||||
|
||||
@ -152,7 +152,7 @@ void LinearIR::debug_print(bool tds_as_pointers) const {
|
||||
void LinearIR::init_emitters(const std::shared_ptr<TargetMachine>& target) {
|
||||
for (auto& expr : m_expressions) {
|
||||
if (!expr->get_emitter())
|
||||
expr->init_emitter(target);
|
||||
expr->m_emitter = target->get(expr->get_node()->get_type_info())(expr);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
27
src/common/snippets/src/lowered/target_machine.cpp
Normal file
27
src/common/snippets/src/lowered/target_machine.cpp
Normal file
@ -0,0 +1,27 @@
|
||||
// Copyright (C) 2023 Intel Corporation
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
//
|
||||
|
||||
#include "snippets/target_machine.hpp"
|
||||
|
||||
using namespace ov::snippets;
|
||||
std::function<std::shared_ptr<Emitter>(const lowered::ExpressionPtr&)> TargetMachine::get(const ov::DiscreteTypeInfo& type) const {
|
||||
auto jitter = jitters.find(type);
|
||||
if (jitter == jitters.end()) {
|
||||
OPENVINO_THROW(std::string("Target code emitter is not available for ") + type.name + " operation.");
|
||||
}
|
||||
return jitter->second.first;
|
||||
}
|
||||
|
||||
std::function<std::set<ov::element::TypeVector>(const std::shared_ptr<ov::Node>&)>
|
||||
TargetMachine::get_supported_precisions(const ov::DiscreteTypeInfo& type) const {
|
||||
auto jitter = jitters.find(type);
|
||||
if (jitter == jitters.end()) {
|
||||
OPENVINO_THROW(std::string("Target code emitter is not available for ") + type.name + " operation.");
|
||||
}
|
||||
return jitter->second.second;
|
||||
}
|
||||
|
||||
bool TargetMachine::has(const ov::DiscreteTypeInfo& type) const {
|
||||
return jitters.find(type) != jitters.end();
|
||||
}
|
||||
@ -15,8 +15,7 @@ using BlockedShapeVector = ov::snippets::op::Subgraph::BlockedShapeVector;
|
||||
|
||||
class DummyEmitter : public ov::snippets::Emitter {
|
||||
public:
|
||||
// Here I pass Add to Emitter, but could be any other op, since it's ignored anyway.
|
||||
DummyEmitter(const std::vector<ov::Node::type_info_t>& custom_opset = {}) : ov::snippets::Emitter(std::make_shared<ov::op::v1::Add>()) {}
|
||||
DummyEmitter(const std::vector<ov::Node::type_info_t>& custom_opset = {}) : ov::snippets::Emitter() {}
|
||||
void emit_code(const std::vector<size_t>&,
|
||||
const std::vector<size_t>&,
|
||||
const std::vector<size_t>&,
|
||||
|
||||
@ -6,6 +6,7 @@
|
||||
#include "lowering_utils.hpp"
|
||||
#include "snippets/pass/tokenization.hpp"
|
||||
#include "snippets/pass/collapse_subgraph.hpp"
|
||||
#include "snippets/lowered/expression.hpp"
|
||||
|
||||
|
||||
namespace ov {
|
||||
@ -14,7 +15,7 @@ namespace snippets {
|
||||
|
||||
DummyTargetMachine::DummyTargetMachine(const std::vector<ov::Node::type_info_t>&custom_opset) {
|
||||
auto dummy_functor = ov::snippets::jitters_value {
|
||||
[](const std::shared_ptr<ov::Node>& n) { return std::make_shared<DummyEmitter>(); },
|
||||
[](const ov::snippets::lowered::ExpressionPtr& n) { return std::make_shared<DummyEmitter>(); },
|
||||
[](const std::shared_ptr<ov::Node>& n) { return std::set<std::vector<element::Type>>{};}
|
||||
};
|
||||
|
||||
|
||||
@ -5,6 +5,8 @@
|
||||
#include "pass/precision_propagation.hpp"
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "snippets/lowered/expression.hpp"
|
||||
#include "snippets/pass/propagate_precision.hpp"
|
||||
#include "snippets/op/convert_saturation.hpp"
|
||||
#include "common_test_utils/common_utils.hpp"
|
||||
@ -23,14 +25,14 @@ public:
|
||||
const std::set<std::vector<element::Type>>& op2_supported_precisions)
|
||||
: DummyTargetMachine() {
|
||||
jitters[DummyAdd::get_type_info_static()] = ov::snippets::jitters_value {
|
||||
[](const std::shared_ptr<ov::Node>& n) { return std::make_shared<DummyEmitter>(); },
|
||||
[](const ov::snippets::lowered::ExpressionPtr& n) { return std::make_shared<DummyEmitter>(); },
|
||||
[op1_supported_precisions](const std::shared_ptr<ov::Node>& n) { return op1_supported_precisions; }};
|
||||
jitters[op::v1::Maximum::get_type_info_static()] = ov::snippets::jitters_value{
|
||||
[](const std::shared_ptr<ov::Node>& n) { return std::make_shared<DummyEmitter>(); },
|
||||
[](const ov::snippets::lowered::ExpressionPtr& n) { return std::make_shared<DummyEmitter>(); },
|
||||
[op2_supported_precisions](const std::shared_ptr<ov::Node>&n) { return op2_supported_precisions; }};
|
||||
|
||||
auto default_jitter = ov::snippets::jitters_value{
|
||||
[](const std::shared_ptr<ov::Node>& n) { return std::make_shared<DummyEmitter>(); },
|
||||
[](const ov::snippets::lowered::ExpressionPtr& n) { return std::make_shared<DummyEmitter>(); },
|
||||
[](const std::shared_ptr<ov::Node>& n) { return std::set<std::vector<element::Type>>{};} };
|
||||
jitters[ov::snippets::op::ConvertSaturation::get_type_info_static()] = default_jitter;
|
||||
}
|
||||
|
||||
@ -27,9 +27,18 @@
|
||||
|
||||
using namespace std;
|
||||
|
||||
#define CREATE_EMITTER(e_type) { \
|
||||
[this](const std::shared_ptr<ngraph::Node>& n) -> std::shared_ptr<snippets::Emitter> { \
|
||||
return std::make_shared<e_type>(h.get(), isa, n); \
|
||||
#define CREATE_SNIPPETS_EMITTER(e_type) { \
|
||||
[this](const ov::snippets::lowered::ExpressionPtr& expr) -> std::shared_ptr<snippets::Emitter> { \
|
||||
return std::make_shared<e_type>(h.get(), isa, expr); \
|
||||
}, \
|
||||
[](const std::shared_ptr<ngraph::Node>& n) -> std::set<std::vector<element::Type>> { \
|
||||
return e_type::get_supported_precisions(n); \
|
||||
} \
|
||||
};
|
||||
|
||||
#define CREATE_CPU_EMITTER(e_type) { \
|
||||
[this](const ov::snippets::lowered::ExpressionPtr& expr) -> std::shared_ptr<snippets::Emitter> { \
|
||||
return std::make_shared<e_type>(h.get(), isa, expr->get_node()); \
|
||||
}, \
|
||||
[](const std::shared_ptr<ngraph::Node>& n) -> std::set<std::vector<element::Type>> { \
|
||||
return e_type::get_supported_precisions(n); \
|
||||
@ -52,101 +61,101 @@ public:
|
||||
ov::intel_cpu::CPUTargetMachine::CPUTargetMachine(dnnl::impl::cpu::x64::cpu_isa_t host_isa)
|
||||
: TargetMachine(), h(new jit_snippet()), isa(host_isa) {
|
||||
// data movement
|
||||
jitters[ov::op::v0::Parameter::get_type_info_static()] = CREATE_EMITTER(NopEmitter);
|
||||
jitters[ov::op::v0::Result::get_type_info_static()] = CREATE_EMITTER(NopEmitter);
|
||||
jitters[snippets::op::Buffer::get_type_info_static()] = CREATE_EMITTER(NopEmitter);
|
||||
jitters[snippets::op::VectorBuffer::get_type_info_static()] = CREATE_EMITTER(NopEmitter);
|
||||
// jitters[ov::op::v1::Constant::get_type_info_static()] = CREATE_EMITTER(); // Not supported
|
||||
jitters[ov::op::v0::Parameter::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(NopEmitter);
|
||||
jitters[ov::op::v0::Result::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(NopEmitter);
|
||||
jitters[snippets::op::Buffer::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(NopEmitter);
|
||||
jitters[snippets::op::VectorBuffer::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(NopEmitter);
|
||||
// jitters[ov::op::v1::Constant::get_type_info_static()] = CREATE_CPU_EMITTER(); // Not supported
|
||||
|
||||
jitters[snippets::op::Load::get_type_info_static()] = CREATE_EMITTER(LoadEmitter);
|
||||
jitters[snippets::op::LoadReshape::get_type_info_static()] = CREATE_EMITTER(LoadEmitter);
|
||||
jitters[snippets::op::BroadcastLoad::get_type_info_static()] = CREATE_EMITTER(BroadcastLoadEmitter);
|
||||
jitters[ov::intel_cpu::LoadConvertSaturation::get_type_info_static()] = CREATE_EMITTER(LoadConvertEmitter);
|
||||
jitters[ov::intel_cpu::LoadConvertTruncation::get_type_info_static()] = CREATE_EMITTER(LoadConvertEmitter);
|
||||
jitters[snippets::op::Load::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(LoadEmitter);
|
||||
jitters[snippets::op::LoadReshape::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(LoadEmitter);
|
||||
jitters[snippets::op::BroadcastLoad::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(BroadcastLoadEmitter);
|
||||
jitters[ov::intel_cpu::LoadConvertSaturation::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(LoadConvertEmitter);
|
||||
jitters[ov::intel_cpu::LoadConvertTruncation::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(LoadConvertEmitter);
|
||||
|
||||
jitters[snippets::op::Store::get_type_info_static()] = CREATE_EMITTER(StoreEmitter);
|
||||
jitters[ov::intel_cpu::StoreConvertSaturation::get_type_info_static()] = CREATE_EMITTER(StoreConvertEmitter);
|
||||
jitters[ov::intel_cpu::StoreConvertTruncation::get_type_info_static()] = CREATE_EMITTER(StoreConvertEmitter);
|
||||
jitters[snippets::op::Store::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(StoreEmitter);
|
||||
jitters[ov::intel_cpu::StoreConvertSaturation::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(StoreConvertEmitter);
|
||||
jitters[ov::intel_cpu::StoreConvertTruncation::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(StoreConvertEmitter);
|
||||
|
||||
jitters[snippets::op::Scalar::get_type_info_static()] = CREATE_EMITTER(ScalarEmitter);
|
||||
jitters[snippets::op::BroadcastMove::get_type_info_static()] = CREATE_EMITTER(BroadcastMoveEmitter);
|
||||
// jitters[snippets::op::Nop::get_type_info_static()] = CREATE_EMITTER(NopEmitter); // Not supported
|
||||
// jitters[ov::op::v1::Broadcast::get_type_info_static()] = CREATE_EMITTER(); // Not supported
|
||||
jitters[snippets::op::Scalar::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(ScalarEmitter);
|
||||
jitters[snippets::op::BroadcastMove::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(BroadcastMoveEmitter);
|
||||
// jitters[snippets::op::Nop::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(NopEmitter); // Not supported
|
||||
// jitters[ov::op::v1::Broadcast::get_type_info_static()] = CREATE_CPU_EMITTER(); // Not supported
|
||||
|
||||
jitters[snippets::op::ConvertTruncation::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_convert_truncation_emitter);
|
||||
jitters[snippets::op::ConvertSaturation::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_convert_saturation_emitter);
|
||||
// jitters[ov::op::v1::FakeQuantize::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[snippets::op::ConvertTruncation::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_convert_truncation_emitter);
|
||||
jitters[snippets::op::ConvertSaturation::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_convert_saturation_emitter);
|
||||
// jitters[ov::op::v1::FakeQuantize::get_type_info_static()] = CREATE_CPU_EMITTER(); // not supported
|
||||
|
||||
// ternary
|
||||
jitters[ov::op::v1::Select::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_select_emitter);
|
||||
jitters[ov::intel_cpu::FusedMulAdd::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_mul_add_emitter);
|
||||
jitters[ov::op::v1::Select::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_select_emitter);
|
||||
jitters[ov::intel_cpu::FusedMulAdd::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_mul_add_emitter);
|
||||
|
||||
// binary
|
||||
jitters[ov::op::v1::Add::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_add_emitter);
|
||||
jitters[ov::op::v1::Divide::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_divide_emitter);
|
||||
jitters[ov::op::v1::Equal::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_equal_emitter);
|
||||
jitters[ov::op::v1::FloorMod::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_floor_mod_emitter);
|
||||
jitters[ov::op::v1::Greater::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_greater_emitter);
|
||||
jitters[ov::op::v1::GreaterEqual::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_greater_equal_emitter);
|
||||
jitters[ov::op::v1::Less::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_less_emitter);
|
||||
jitters[ov::op::v1::LessEqual::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_less_equal_emitter);
|
||||
jitters[ov::op::v1::LogicalAnd::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_logical_and_emitter);
|
||||
jitters[ov::op::v1::LogicalOr::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_logical_or_emitter);
|
||||
jitters[ov::op::v1::LogicalXor::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_logical_xor_emitter);
|
||||
jitters[ov::op::v1::Maximum::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_maximum_emitter);
|
||||
jitters[ov::op::v1::Minimum::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_minimum_emitter);
|
||||
jitters[ov::op::v1::Mod::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_mod_emitter);
|
||||
jitters[ov::op::v1::Multiply::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_multiply_emitter);
|
||||
jitters[ov::op::v1::NotEqual::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_not_equal_emitter);
|
||||
jitters[snippets::op::PowerStatic::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_power_static_emitter);
|
||||
jitters[ov::op::v1::Power::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_power_dynamic_emitter);
|
||||
jitters[ov::op::v0::PRelu::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_prelu_emitter);
|
||||
jitters[ov::op::v0::SquaredDifference::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_squared_difference_emitter);
|
||||
jitters[ov::op::v1::Subtract::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_subtract_emitter);
|
||||
jitters[ov::op::v0::Xor::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_logical_xor_emitter);
|
||||
jitters[ov::op::v1::Add::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_add_emitter);
|
||||
jitters[ov::op::v1::Divide::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_divide_emitter);
|
||||
jitters[ov::op::v1::Equal::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_equal_emitter);
|
||||
jitters[ov::op::v1::FloorMod::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_floor_mod_emitter);
|
||||
jitters[ov::op::v1::Greater::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_greater_emitter);
|
||||
jitters[ov::op::v1::GreaterEqual::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_greater_equal_emitter);
|
||||
jitters[ov::op::v1::Less::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_less_emitter);
|
||||
jitters[ov::op::v1::LessEqual::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_less_equal_emitter);
|
||||
jitters[ov::op::v1::LogicalAnd::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_logical_and_emitter);
|
||||
jitters[ov::op::v1::LogicalOr::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_logical_or_emitter);
|
||||
jitters[ov::op::v1::LogicalXor::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_logical_xor_emitter);
|
||||
jitters[ov::op::v1::Maximum::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_maximum_emitter);
|
||||
jitters[ov::op::v1::Minimum::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_minimum_emitter);
|
||||
jitters[ov::op::v1::Mod::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_mod_emitter);
|
||||
jitters[ov::op::v1::Multiply::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_multiply_emitter);
|
||||
jitters[ov::op::v1::NotEqual::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_not_equal_emitter);
|
||||
jitters[snippets::op::PowerStatic::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_power_static_emitter);
|
||||
jitters[ov::op::v1::Power::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_power_dynamic_emitter);
|
||||
jitters[ov::op::v0::PRelu::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_prelu_emitter);
|
||||
jitters[ov::op::v0::SquaredDifference::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_squared_difference_emitter);
|
||||
jitters[ov::op::v1::Subtract::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_subtract_emitter);
|
||||
jitters[ov::op::v0::Xor::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_logical_xor_emitter);
|
||||
|
||||
// unary
|
||||
jitters[ov::op::v0::Abs::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_abs_emitter);
|
||||
// jitters[ov::op::v1::Acos::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
// jitters[ov::op::v1::Asin::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
// jitters[ov::op::v1::Atan::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ov::op::v0::Ceiling::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_ceiling_emitter);
|
||||
jitters[ov::op::v0::Clamp::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_clamp_emitter);
|
||||
// jitters[ov::op::v1::Cos::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
// jitters[ov::op::v1::Cosh::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ov::op::v0::Elu::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_elu_emitter);
|
||||
jitters[ov::op::v0::Erf::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_erf_emitter);
|
||||
jitters[ov::op::v0::Exp::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_exp_emitter);
|
||||
jitters[ov::op::v0::Floor::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_floor_emitter);
|
||||
jitters[ngraph::opset5::Round::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_round_emitter);
|
||||
// jitters[ov::op::v1::Log::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ov::op::v1::LogicalNot::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_logical_not_emitter);
|
||||
jitters[ov::op::v0::Negative::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_negative_emitter);
|
||||
jitters[ov::op::v0::Relu::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_relu_emitter);
|
||||
// jitters[ov::op::v1::Sign::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ov::op::v0::Sigmoid::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_sigmoid_emitter);
|
||||
// jitters[ov::op::v1::Sin::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
// jitters[ov::op::v1::Sinh::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ov::op::v0::Sqrt::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_sqrt_emitter);
|
||||
// jitters[ov::op::v1::Tan::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ov::op::v0::Tanh::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_tanh_emitter);
|
||||
jitters[ov::op::v0::Abs::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_abs_emitter);
|
||||
// jitters[ov::op::v1::Acos::get_type_info_static()] = CREATE_CPU_EMITTER(); // not supported
|
||||
// jitters[ov::op::v1::Asin::get_type_info_static()] = CREATE_CPU_EMITTER(); // not supported
|
||||
// jitters[ov::op::v1::Atan::get_type_info_static()] = CREATE_CPU_EMITTER(); // not supported
|
||||
jitters[ov::op::v0::Ceiling::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_ceiling_emitter);
|
||||
jitters[ov::op::v0::Clamp::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_clamp_emitter);
|
||||
// jitters[ov::op::v1::Cos::get_type_info_static()] = CREATE_CPU_EMITTER(); // not supported
|
||||
// jitters[ov::op::v1::Cosh::get_type_info_static()] = CREATE_CPU_EMITTER(); // not supported
|
||||
jitters[ov::op::v0::Elu::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_elu_emitter);
|
||||
jitters[ov::op::v0::Erf::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_erf_emitter);
|
||||
jitters[ov::op::v0::Exp::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_exp_emitter);
|
||||
jitters[ov::op::v0::Floor::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_floor_emitter);
|
||||
jitters[ngraph::opset5::Round::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_round_emitter);
|
||||
// jitters[ov::op::v1::Log::get_type_info_static()] = CREATE_CPU_EMITTER(); // not supported
|
||||
jitters[ov::op::v1::LogicalNot::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_logical_not_emitter);
|
||||
jitters[ov::op::v0::Negative::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_negative_emitter);
|
||||
jitters[ov::op::v0::Relu::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_relu_emitter);
|
||||
// jitters[ov::op::v1::Sign::get_type_info_static()] = CREATE_CPU_EMITTER(); // not supported
|
||||
jitters[ov::op::v0::Sigmoid::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_sigmoid_emitter);
|
||||
// jitters[ov::op::v1::Sin::get_type_info_static()] = CREATE_CPU_EMITTER(); // not supported
|
||||
// jitters[ov::op::v1::Sinh::get_type_info_static()] = CREATE_CPU_EMITTER(); // not supported
|
||||
jitters[ov::op::v0::Sqrt::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_sqrt_emitter);
|
||||
// jitters[ov::op::v1::Tan::get_type_info_static()] = CREATE_CPU_EMITTER(); // not supported
|
||||
jitters[ov::op::v0::Tanh::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_tanh_emitter);
|
||||
|
||||
jitters[ov::intel_cpu::SwishNode::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_swish_emitter);
|
||||
jitters[ngraph::op::v4::HSwish::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_hswish_emitter);
|
||||
// jitters[ov::op::v1::HardSigmoid::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
// jitters[ov::op::v1::Selu::get_type_info_static()] = CREATE_EMITTER(); // not supported
|
||||
jitters[ngraph::op::v0::Gelu::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_gelu_v0_emitter);
|
||||
jitters[ngraph::op::v7::Gelu::get_type_info_static()] = CREATE_EMITTER(ov::intel_cpu::jit_gelu_v7_emitter);
|
||||
jitters[snippets::op::Fill::get_type_info_static()] = CREATE_EMITTER(FillEmitter);
|
||||
jitters[ov::intel_cpu::SwishNode::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_swish_emitter);
|
||||
jitters[ngraph::op::v4::HSwish::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_hswish_emitter);
|
||||
// jitters[ov::op::v1::HardSigmoid::get_type_info_static()] = CREATE_CPU_EMITTER(); // not supported
|
||||
// jitters[ov::op::v1::Selu::get_type_info_static()] = CREATE_CPU_EMITTER(); // not supported
|
||||
jitters[ngraph::op::v0::Gelu::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_gelu_v0_emitter);
|
||||
jitters[ngraph::op::v7::Gelu::get_type_info_static()] = CREATE_CPU_EMITTER(ov::intel_cpu::jit_gelu_v7_emitter);
|
||||
jitters[snippets::op::Fill::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(FillEmitter);
|
||||
|
||||
jitters[snippets::op::HorizonMax::get_type_info_static()] = CREATE_EMITTER(HorizonEmitter);
|
||||
jitters[snippets::op::HorizonSum::get_type_info_static()] = CREATE_EMITTER(HorizonEmitter);
|
||||
jitters[snippets::op::HorizonMax::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(HorizonEmitter);
|
||||
jitters[snippets::op::HorizonSum::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(HorizonEmitter);
|
||||
|
||||
jitters[snippets::op::Kernel::get_type_info_static()] = CREATE_EMITTER(KernelEmitter);
|
||||
jitters[snippets::op::LoopBegin::get_type_info_static()] = CREATE_EMITTER(LoopBeginEmitter);
|
||||
jitters[snippets::op::LoopEnd::get_type_info_static()] = CREATE_EMITTER(LoopEndEmitter);
|
||||
jitters[ov::intel_cpu::BrgemmCPU::get_type_info_static()] = CREATE_EMITTER(BrgemmEmitter);
|
||||
jitters[ov::intel_cpu::BrgemmCopyB::get_type_info_static()] = CREATE_EMITTER(BrgemmCopyBEmitter);
|
||||
jitters[snippets::op::Kernel::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(KernelEmitter);
|
||||
jitters[snippets::op::LoopBegin::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(LoopBeginEmitter);
|
||||
jitters[snippets::op::LoopEnd::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(LoopEndEmitter);
|
||||
jitters[ov::intel_cpu::BrgemmCPU::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(BrgemmEmitter);
|
||||
jitters[ov::intel_cpu::BrgemmCopyB::get_type_info_static()] = CREATE_SNIPPETS_EMITTER(BrgemmCopyBEmitter);
|
||||
}
|
||||
|
||||
size_t ov::intel_cpu::CPUTargetMachine::get_lanes() const {
|
||||
|
||||
@ -18,7 +18,7 @@ namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
jit_convert_emitter::jit_convert_emitter(jit_generator *host, cpu_isa_t host_isa, const std::shared_ptr<ngraph::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
input_type = node->get_input_element_type(0);
|
||||
output_type = node->get_output_element_type(0);
|
||||
|
||||
|
||||
@ -18,7 +18,7 @@ std::set<std::vector<element::Type>> jit_dnnl_emitter::get_supported_precisions(
|
||||
}
|
||||
|
||||
jit_dnnl_emitter::jit_dnnl_emitter(jit_generator *host, cpu_isa_t host_isa, const std::shared_ptr<ngraph::Node>& node, InferenceEngine::Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
|
||||
kind = dnnl_eltwise_tanh;
|
||||
alpha = 0.f;
|
||||
|
||||
@ -36,7 +36,7 @@ InferenceEngine::Precision get_arithmetic_binary_exec_precision(const std::share
|
||||
|
||||
/// ADD ///
|
||||
jit_add_emitter::jit_add_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node)
|
||||
: jit_emitter(host, host_isa, node, get_arithmetic_binary_exec_precision(node)) {}
|
||||
: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
|
||||
jit_add_emitter::jit_add_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -83,7 +83,7 @@ std::set<std::vector<element::Type>> jit_add_emitter::get_supported_precisions(c
|
||||
|
||||
/// MUL_ADD ///
|
||||
jit_mul_add_emitter::jit_mul_add_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node)
|
||||
: jit_emitter(host, host_isa, node, get_arithmetic_binary_exec_precision(node)) {}
|
||||
: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
|
||||
jit_mul_add_emitter::jit_mul_add_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -174,7 +174,7 @@ std::set<std::vector<element::Type>> jit_mul_add_emitter::get_supported_precisio
|
||||
|
||||
/// SUB ///
|
||||
jit_subtract_emitter::jit_subtract_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node)
|
||||
: jit_emitter(host, host_isa, node, get_arithmetic_binary_exec_precision(node)) {}
|
||||
: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
|
||||
jit_subtract_emitter::jit_subtract_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -221,7 +221,7 @@ std::set<std::vector<element::Type>> jit_subtract_emitter::get_supported_precisi
|
||||
|
||||
/// MULTIPLY ///
|
||||
jit_multiply_emitter::jit_multiply_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node)
|
||||
: jit_emitter(host, host_isa, node, get_arithmetic_binary_exec_precision(node)) {}
|
||||
: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
|
||||
jit_multiply_emitter::jit_multiply_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -268,7 +268,7 @@ std::set<std::vector<element::Type>> jit_multiply_emitter::get_supported_precisi
|
||||
|
||||
/// DIVIDE ///
|
||||
jit_divide_emitter::jit_divide_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, get_arithmetic_binary_exec_precision(node)) {}
|
||||
: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
|
||||
jit_divide_emitter::jit_divide_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -333,7 +333,7 @@ size_t jit_divide_emitter::aux_vecs_count() const {
|
||||
|
||||
/// FLOOR ///
|
||||
jit_floor_emitter::jit_floor_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {}
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
jit_floor_emitter::jit_floor_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -365,7 +365,7 @@ void jit_floor_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const s
|
||||
|
||||
/// CEILING ///
|
||||
jit_ceiling_emitter::jit_ceiling_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {}
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
jit_ceiling_emitter::jit_ceiling_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -398,7 +398,7 @@ void jit_ceiling_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const
|
||||
|
||||
/// FLOOR_MOD ///
|
||||
jit_floor_mod_emitter::jit_floor_mod_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {}
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
jit_floor_mod_emitter::jit_floor_mod_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -452,7 +452,7 @@ size_t jit_floor_mod_emitter::aux_vecs_count() const {
|
||||
|
||||
/// MOD ///
|
||||
jit_mod_emitter::jit_mod_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {}
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
jit_mod_emitter::jit_mod_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -506,7 +506,7 @@ size_t jit_mod_emitter::aux_vecs_count() const {
|
||||
|
||||
/// MAXIMUM ///
|
||||
jit_maximum_emitter::jit_maximum_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node)
|
||||
: jit_emitter(host, host_isa, node, get_arithmetic_binary_exec_precision(node)) {}
|
||||
: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
|
||||
jit_maximum_emitter::jit_maximum_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -554,7 +554,7 @@ std::set<std::vector<element::Type>> jit_maximum_emitter::get_supported_precisio
|
||||
|
||||
/// MINIMUM ///
|
||||
jit_minimum_emitter::jit_minimum_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node)
|
||||
: jit_emitter(host, host_isa, node, get_arithmetic_binary_exec_precision(node)) {}
|
||||
: jit_emitter(host, host_isa, get_arithmetic_binary_exec_precision(node)) {}
|
||||
jit_minimum_emitter::jit_minimum_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -603,7 +603,7 @@ std::set<std::vector<element::Type>> jit_minimum_emitter::get_supported_precisio
|
||||
/// SQUARED_DIFFERENCE ///
|
||||
jit_squared_difference_emitter::jit_squared_difference_emitter(
|
||||
x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {}
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
jit_squared_difference_emitter::jit_squared_difference_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -658,7 +658,7 @@ std::set<std::vector<element::Type>> jit_squared_difference_emitter::get_support
|
||||
/// POWER_DYNAMIC ///
|
||||
jit_power_dynamic_emitter::jit_power_dynamic_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node,
|
||||
Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {}
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
jit_power_dynamic_emitter::jit_power_dynamic_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -769,7 +769,7 @@ void jit_power_dynamic_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs,
|
||||
|
||||
/// EQUAL ///
|
||||
jit_equal_emitter::jit_equal_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
prepare_table();
|
||||
}
|
||||
jit_equal_emitter::jit_equal_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
@ -832,7 +832,7 @@ size_t jit_equal_emitter::aux_vecs_count() const {
|
||||
|
||||
/// NOT_EQUAL ///
|
||||
jit_not_equal_emitter::jit_not_equal_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
prepare_table();
|
||||
}
|
||||
jit_not_equal_emitter::jit_not_equal_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
@ -895,7 +895,7 @@ size_t jit_not_equal_emitter::aux_vecs_count() const {
|
||||
|
||||
/// GREATER ///
|
||||
jit_greater_emitter::jit_greater_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
prepare_table();
|
||||
}
|
||||
jit_greater_emitter::jit_greater_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
@ -959,7 +959,7 @@ size_t jit_greater_emitter::aux_vecs_count() const {
|
||||
/// GREATER_EQUAL ///
|
||||
jit_greater_equal_emitter::jit_greater_equal_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node,
|
||||
Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
prepare_table();
|
||||
}
|
||||
jit_greater_equal_emitter::jit_greater_equal_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
@ -1022,7 +1022,7 @@ size_t jit_greater_equal_emitter::aux_vecs_count() const {
|
||||
|
||||
/// LESS ///
|
||||
jit_less_emitter::jit_less_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
prepare_table();
|
||||
}
|
||||
jit_less_emitter::jit_less_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
@ -1085,7 +1085,7 @@ size_t jit_less_emitter::aux_vecs_count() const {
|
||||
|
||||
/// LESS_EQUAL ///
|
||||
jit_less_equal_emitter::jit_less_equal_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
prepare_table();
|
||||
}
|
||||
jit_less_equal_emitter::jit_less_equal_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
@ -1149,7 +1149,7 @@ size_t jit_less_equal_emitter::aux_vecs_count() const {
|
||||
|
||||
/// LOGICAL_AND ///
|
||||
jit_logical_and_emitter::jit_logical_and_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
prepare_table();
|
||||
}
|
||||
jit_logical_and_emitter::jit_logical_and_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
@ -1233,7 +1233,7 @@ size_t jit_logical_and_emitter::aux_vecs_count() const {
|
||||
|
||||
/// LOGICAL_OR ///
|
||||
jit_logical_or_emitter::jit_logical_or_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
prepare_table();
|
||||
}
|
||||
jit_logical_or_emitter::jit_logical_or_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
@ -1316,7 +1316,7 @@ size_t jit_logical_or_emitter::aux_vecs_count() const {
|
||||
|
||||
/// LOGICAL_XOR ///
|
||||
jit_logical_xor_emitter::jit_logical_xor_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
prepare_table();
|
||||
}
|
||||
jit_logical_xor_emitter::jit_logical_xor_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
@ -1399,7 +1399,7 @@ size_t jit_logical_xor_emitter::aux_vecs_count() const {
|
||||
|
||||
/// LOGICAL_NOT ///
|
||||
jit_logical_not_emitter::jit_logical_not_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
prepare_table();
|
||||
}
|
||||
jit_logical_not_emitter::jit_logical_not_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
@ -1461,7 +1461,7 @@ size_t jit_logical_not_emitter::aux_vecs_count() const {
|
||||
|
||||
/// POWER_STATIC ///
|
||||
jit_power_static_emitter::jit_power_static_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
auto powerStaticNode = ov::as_type_ptr<ov::snippets::op::PowerStatic>(node);
|
||||
if (powerStaticNode == nullptr) {
|
||||
IE_THROW() << "Can't cast to snippets::op::PowerStatic";
|
||||
@ -1652,7 +1652,7 @@ size_t jit_power_static_emitter::aux_vecs_count() const {
|
||||
|
||||
/// PRELU ///
|
||||
jit_prelu_emitter::jit_prelu_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
prepare_table();
|
||||
}
|
||||
jit_prelu_emitter::jit_prelu_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
@ -1714,7 +1714,7 @@ size_t jit_prelu_emitter::aux_vecs_count() const {
|
||||
|
||||
/// SQRT ///
|
||||
jit_sqrt_emitter::jit_sqrt_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {}
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
jit_sqrt_emitter::jit_sqrt_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
@ -1747,7 +1747,7 @@ void jit_sqrt_emitter::emit_isa(const std::vector<size_t> &in_vec_idxs, const st
|
||||
|
||||
/// Negate ///
|
||||
jit_negative_emitter::jit_negative_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {}
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
size_t jit_negative_emitter::get_inputs_num() const { return 1; }
|
||||
|
||||
@ -1783,7 +1783,7 @@ jit_erf_emitter::jit_erf_emitter(x64::jit_generator *host, x64::cpu_isa_t host_i
|
||||
}
|
||||
|
||||
jit_erf_emitter::jit_erf_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
prepare_table();
|
||||
}
|
||||
|
||||
@ -1963,7 +1963,7 @@ size_t jit_erf_emitter::aux_vecs_count() const {
|
||||
|
||||
/// SOFT SIGN ///
|
||||
jit_soft_sign_emitter::jit_soft_sign_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ov::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {
|
||||
: jit_emitter(host, host_isa, exec_prc) {
|
||||
prepare_table();
|
||||
}
|
||||
jit_soft_sign_emitter::jit_soft_sign_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
@ -2182,7 +2182,7 @@ void jit_is_nan_emitter::register_table_entries() {
|
||||
|
||||
/// SELECT ///
|
||||
jit_select_emitter::jit_select_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, const std::shared_ptr<ngraph::Node>& node, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, node, exec_prc) {}
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
jit_select_emitter::jit_select_emitter(x64::jit_generator *host, x64::cpu_isa_t host_isa, Precision exec_prc)
|
||||
: jit_emitter(host, host_isa, exec_prc) {}
|
||||
|
||||
|
||||
@ -574,7 +574,7 @@ public:
|
||||
prepare_table();
|
||||
}
|
||||
jit_is_finite_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t hostIsa, const std::shared_ptr<ov::Node>& node,
|
||||
InferenceEngine::Precision execPrc = InferenceEngine::Precision::FP32) : jit_emitter(host, hostIsa, node, execPrc) {
|
||||
InferenceEngine::Precision execPrc = InferenceEngine::Precision::FP32) : jit_emitter(host, hostIsa, execPrc) {
|
||||
prepare_table();
|
||||
}
|
||||
|
||||
@ -602,7 +602,7 @@ public:
|
||||
prepare_table();
|
||||
}
|
||||
jit_is_inf_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t hostIsa, const std::shared_ptr<ov::Node>& node,
|
||||
InferenceEngine::Precision execPrc = InferenceEngine::Precision::FP32): jit_emitter(host, hostIsa, node, execPrc) {
|
||||
InferenceEngine::Precision execPrc = InferenceEngine::Precision::FP32): jit_emitter(host, hostIsa, execPrc) {
|
||||
prepare_table();
|
||||
}
|
||||
|
||||
@ -632,7 +632,7 @@ public:
|
||||
prepare_table();
|
||||
}
|
||||
jit_is_nan_emitter(dnnl::impl::cpu::x64::jit_generator *host, dnnl::impl::cpu::x64::cpu_isa_t hostIsa, const std::shared_ptr<ov::Node>& node,
|
||||
InferenceEngine::Precision execPrc = InferenceEngine::Precision::FP32) : jit_emitter(host, hostIsa, node, execPrc) {
|
||||
InferenceEngine::Precision execPrc = InferenceEngine::Precision::FP32) : jit_emitter(host, hostIsa, execPrc) {
|
||||
prepare_table();
|
||||
}
|
||||
|
||||
|
||||
@ -32,13 +32,7 @@ class jit_emitter : public ov::snippets::Emitter {
|
||||
public:
|
||||
jit_emitter(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa,
|
||||
InferenceEngine::Precision exec_prc = InferenceEngine::Precision::FP32, emitter_in_out_map in_out_type = emitter_in_out_map::vec_to_vec)
|
||||
: Emitter(nullptr), h(host), host_isa_(host_isa), exec_prc_(exec_prc), l_table (new Xbyak::Label()), in_out_type_(in_out_type) {
|
||||
k_mask = Xbyak::Opmask(1); // FIXME: in general case we need preserve k_mask state as well
|
||||
}
|
||||
|
||||
jit_emitter(dnnl::impl::cpu::x64::jit_generator* host, dnnl::impl::cpu::x64::cpu_isa_t host_isa, const std::shared_ptr<ngraph::Node>& n,
|
||||
InferenceEngine::Precision exec_prc = InferenceEngine::Precision::FP32, emitter_in_out_map in_out_type = emitter_in_out_map::vec_to_vec)
|
||||
: Emitter(n), h(host), host_isa_(host_isa), exec_prc_(exec_prc), l_table (new Xbyak::Label()), in_out_type_(in_out_type) {
|
||||
: Emitter(), h(host), host_isa_(host_isa), exec_prc_(exec_prc), l_table (new Xbyak::Label()), in_out_type_(in_out_type) {
|
||||
k_mask = Xbyak::Opmask(1); // FIXME: in general case we need preserve k_mask state as well
|
||||
}
|
||||
|
||||
|
||||
@ -20,6 +20,10 @@ using namespace dnnl::impl::cpu::x64;
|
||||
namespace ov {
|
||||
namespace intel_cpu {
|
||||
|
||||
using jit_generator = dnnl::impl::cpu::x64::jit_generator;
|
||||
using cpu_isa_t = dnnl::impl::cpu::x64::cpu_isa_t;
|
||||
using ExpressionPtr = ov::snippets::lowered::ExpressionPtr;
|
||||
|
||||
namespace {
|
||||
constexpr size_t gpr_size = 8;
|
||||
} // namespace
|
||||
@ -29,8 +33,8 @@ inline static void transform_idxs_to_regs(const std::vector<size_t>& idxs, std::
|
||||
std::transform(idxs.begin(), idxs.end(), regs.begin(), [](size_t idx){return Reg64(static_cast<int>(idx));});
|
||||
}
|
||||
|
||||
jit_container_emitter::jit_container_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n) : jit_emitter(h, isa, n) {
|
||||
jit_container_emitter::jit_container_emitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr)
|
||||
: jit_emitter(h, isa) {
|
||||
in_out_type_ = emitter_in_out_map::gpr_to_gpr;
|
||||
}
|
||||
|
||||
@ -92,12 +96,11 @@ void jit_container_emitter::map_abstract_registers(mapping_info& gpr_map_pool,
|
||||
}
|
||||
}
|
||||
|
||||
KernelEmitter::KernelEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n) :
|
||||
jit_container_emitter(h, isa, n),
|
||||
reg_indexes_idx(abi_param1.getIdx()),
|
||||
reg_const_params_idx(abi_param2.getIdx()) {
|
||||
const auto kernel = ov::as_type_ptr<snippets::op::Kernel>(n);
|
||||
KernelEmitter::KernelEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr)
|
||||
: jit_container_emitter(h, isa, expr),
|
||||
reg_indexes_idx(abi_param1.getIdx()),
|
||||
reg_const_params_idx(abi_param2.getIdx()) {
|
||||
const auto kernel = ov::as_type_ptr<snippets::op::Kernel>(expr->get_node());
|
||||
if (!kernel)
|
||||
IE_THROW() << "KernelEmitter invoked with invalid op argument";
|
||||
if (kernel->region.empty())
|
||||
@ -312,10 +315,8 @@ void KernelEmitter::emit_impl(const std::vector<size_t>& in,
|
||||
h->postamble();
|
||||
}
|
||||
|
||||
|
||||
LoopBeginEmitter::LoopBeginEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n) : jit_emitter(h, isa, n) {
|
||||
loop_begin = ov::as_type_ptr<snippets::op::LoopBegin>(n);
|
||||
LoopBeginEmitter::LoopBeginEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr) : jit_emitter(h, isa) {
|
||||
loop_begin = ov::as_type_ptr<snippets::op::LoopBegin>(expr->get_node());
|
||||
if (!loop_begin)
|
||||
IE_THROW() << "LoopBeginEmitter invoked with invalid op argument";
|
||||
const auto& target_inputs = loop_begin->output(loop_begin->get_output_size() - 1).get_target_inputs();
|
||||
@ -359,9 +360,8 @@ void LoopBeginEmitter::emit_impl(const std::vector<size_t>& in,
|
||||
loop_begin->begin_address = h->getCurr();
|
||||
}
|
||||
|
||||
LoopEndEmitter::LoopEndEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n) : jit_emitter(h, isa, n) {
|
||||
loop_end = ov::as_type_ptr<snippets::op::LoopEnd>(n);
|
||||
LoopEndEmitter::LoopEndEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr) : jit_emitter(h, isa) {
|
||||
loop_end = ov::as_type_ptr<snippets::op::LoopEnd>(expr->get_node());
|
||||
if (!loop_end)
|
||||
IE_THROW() << "LoopEndEmitter invoked with invalid op argument";
|
||||
loop_begin = loop_end->get_loop_begin();
|
||||
@ -388,7 +388,7 @@ void LoopEndEmitter::emit_code(const std::vector<size_t> &in,
|
||||
|
||||
|
||||
void LoopEndEmitter::validate_arguments(const std::vector<size_t> &in,
|
||||
const std::vector<size_t> &out) const {
|
||||
const std::vector<size_t> &out) const {
|
||||
if (out.size() != num_outputs)
|
||||
IE_THROW() << "Invalid number of out arguments: expected " << num_outputs << " got " << out.size();
|
||||
if (in.size() != num_inputs)
|
||||
@ -425,18 +425,22 @@ void LoopEndEmitter::emit_impl(const std::vector<size_t>& in,
|
||||
}
|
||||
}
|
||||
|
||||
ParameterEmitter::ParameterEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n) : NopEmitter(h, isa, n) {
|
||||
NopEmitter::NopEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr) : jit_emitter(h, isa) {
|
||||
in_out_type_ = emitter_in_out_map::gpr_to_gpr;
|
||||
}
|
||||
|
||||
ResultEmitter::ResultEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n) : NopEmitter(h, isa, n) {
|
||||
ParameterEmitter::ParameterEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr)
|
||||
: NopEmitter(h, isa, expr) {
|
||||
in_out_type_ = emitter_in_out_map::gpr_to_gpr;
|
||||
}
|
||||
|
||||
BroadcastMoveEmitter::BroadcastMoveEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n) : jit_emitter(h, isa, n) {
|
||||
ResultEmitter::ResultEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr) : NopEmitter(h, isa, expr) {
|
||||
in_out_type_ = emitter_in_out_map::gpr_to_gpr;
|
||||
}
|
||||
|
||||
BroadcastMoveEmitter::BroadcastMoveEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr)
|
||||
: jit_emitter(h, isa) {
|
||||
const auto n = expr->get_node();
|
||||
if (n->get_input_element_type(0) != n->get_output_element_type(0))
|
||||
IE_THROW() << "BroadcastMoveEmitter supports only equal input and output types but gets: "
|
||||
<< n->get_input_element_type(0) << " and " << n->get_output_element_type(0);
|
||||
@ -456,7 +460,7 @@ void BroadcastMoveEmitter::emit_impl(const std::vector<size_t>& in,
|
||||
}
|
||||
}
|
||||
|
||||
template <dnnl::impl::cpu::x64::cpu_isa_t isa>
|
||||
template <cpu_isa_t isa>
|
||||
void BroadcastMoveEmitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
|
||||
using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,
|
||||
Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
|
||||
@ -471,9 +475,9 @@ void BroadcastMoveEmitter::emit_isa(const std::vector<size_t> &in, const std::ve
|
||||
}
|
||||
}
|
||||
|
||||
ScalarEmitter::ScalarEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n) : jit_emitter(h, isa, n) {
|
||||
const auto precision = n->get_output_element_type(0);
|
||||
ScalarEmitter::ScalarEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr) : jit_emitter(h, isa) {
|
||||
const auto n = expr->get_node();
|
||||
const auto& precision = n->get_output_element_type(0);
|
||||
switch (precision) {
|
||||
case element::i32: {
|
||||
value = ov::as_type_ptr<ov::op::v0::Constant>(n)->cast_vector<int32_t>()[0];
|
||||
@ -504,7 +508,7 @@ void ScalarEmitter::emit_impl(const std::vector<size_t>& in,
|
||||
}
|
||||
}
|
||||
|
||||
template <dnnl::impl::cpu::x64::cpu_isa_t isa>
|
||||
template <cpu_isa_t isa>
|
||||
void ScalarEmitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
|
||||
using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,
|
||||
Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
|
||||
@ -512,19 +516,17 @@ void ScalarEmitter::emit_isa(const std::vector<size_t> &in, const std::vector<si
|
||||
h->uni_vbroadcastss(vmm_dst, table_val("scalar"));
|
||||
}
|
||||
|
||||
|
||||
MemoryEmitter::MemoryEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n) : jit_emitter(h, isa, n) {
|
||||
MemoryEmitter::MemoryEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr) : jit_emitter(h, isa) {
|
||||
const auto n = expr->get_node();
|
||||
src_prc = InferenceEngine::details::convertPrecision(n->get_input_element_type(0));
|
||||
dst_prc = InferenceEngine::details::convertPrecision(n->get_output_element_type(0));
|
||||
}
|
||||
|
||||
StoreEmitter::StoreEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n) : MemoryEmitter(h, isa, n) {
|
||||
StoreEmitter::StoreEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr) : MemoryEmitter(h, isa, expr) {
|
||||
if (src_prc != dst_prc)
|
||||
IE_THROW() << "StoreEmitter supports only equal input and output types but gets: " << src_prc.name() << " and " << dst_prc.name();
|
||||
|
||||
const auto store = ov::as_type_ptr<snippets::op::Store>(n);
|
||||
const auto store = ov::as_type_ptr<snippets::op::Store>(expr->get_node());
|
||||
count = store->get_count();
|
||||
byte_offset = store->get_offset();
|
||||
in_out_type_ = emitter_in_out_map::vec_to_gpr;
|
||||
@ -544,7 +546,7 @@ void StoreEmitter::emit_impl(const std::vector<size_t>& in,
|
||||
}
|
||||
}
|
||||
|
||||
template <dnnl::impl::cpu::x64::cpu_isa_t isa>
|
||||
template <cpu_isa_t isa>
|
||||
void StoreEmitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
|
||||
if (!store_emitter)
|
||||
IE_THROW() << "Store CPU emitter isn't initialized for StoreEmitter!";
|
||||
@ -555,12 +557,11 @@ void StoreEmitter::emit_data() const {
|
||||
store_emitter->emit_data();
|
||||
}
|
||||
|
||||
LoadEmitter::LoadEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n) : MemoryEmitter(h, isa, n) {
|
||||
LoadEmitter::LoadEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr) : MemoryEmitter(h, isa, expr) {
|
||||
if (src_prc != dst_prc)
|
||||
IE_THROW() << "LoadEmitter supports only equal input and output types but gets: " << src_prc.name() << " and " << dst_prc.name();
|
||||
|
||||
const auto load = std::dynamic_pointer_cast<snippets::op::Load>(n);
|
||||
const auto load = std::dynamic_pointer_cast<snippets::op::Load>(expr->get_node());
|
||||
count = load->get_count();
|
||||
byte_offset = load->get_offset();
|
||||
in_out_type_ = emitter_in_out_map::gpr_to_vec;
|
||||
@ -580,7 +581,7 @@ void LoadEmitter::emit_impl(const std::vector<size_t>& in,
|
||||
}
|
||||
}
|
||||
|
||||
template <dnnl::impl::cpu::x64::cpu_isa_t isa>
|
||||
template <cpu_isa_t isa>
|
||||
void LoadEmitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
|
||||
if (!load_emitter)
|
||||
IE_THROW() << "Load CPU emitter isn't initialized for LoadEmitter!";
|
||||
@ -591,12 +592,12 @@ void LoadEmitter::emit_data() const {
|
||||
load_emitter->emit_data();
|
||||
}
|
||||
|
||||
BroadcastLoadEmitter::BroadcastLoadEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n) : MemoryEmitter(h, isa, n) {
|
||||
BroadcastLoadEmitter::BroadcastLoadEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr)
|
||||
: MemoryEmitter(h, isa, expr) {
|
||||
if (src_prc != dst_prc)
|
||||
IE_THROW() << "BroadcastEmitters support only equal input and output types but gets: " << src_prc.name() << " and " << dst_prc.name();
|
||||
|
||||
const auto broadcast_load = std::dynamic_pointer_cast<snippets::op::BroadcastLoad>(n);
|
||||
const auto broadcast_load = std::dynamic_pointer_cast<snippets::op::BroadcastLoad>(expr->get_node());
|
||||
byte_offset = broadcast_load->get_offset();
|
||||
in_out_type_ = emitter_in_out_map::gpr_to_vec;
|
||||
}
|
||||
@ -614,7 +615,7 @@ void BroadcastLoadEmitter::emit_impl(const std::vector<size_t>& in,
|
||||
}
|
||||
}
|
||||
|
||||
template <dnnl::impl::cpu::x64::cpu_isa_t isa>
|
||||
template <cpu_isa_t isa>
|
||||
void BroadcastLoadEmitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
|
||||
using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,
|
||||
Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
|
||||
@ -631,9 +632,9 @@ void BroadcastLoadEmitter::emit_isa(const std::vector<size_t> &in, const std::ve
|
||||
}
|
||||
}
|
||||
|
||||
LoadConvertEmitter::LoadConvertEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n)
|
||||
: MemoryEmitter(h, isa, n) {
|
||||
const auto load = ov::as_type_ptr<snippets::op::Load>(n);
|
||||
LoadConvertEmitter::LoadConvertEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr)
|
||||
: MemoryEmitter(h, isa, expr) {
|
||||
const auto load = ov::as_type_ptr<snippets::op::Load>(expr->get_node());
|
||||
count = load->get_count();
|
||||
byte_offset = load->get_offset();
|
||||
in_out_type_ = emitter_in_out_map::gpr_to_vec;
|
||||
@ -653,7 +654,7 @@ void LoadConvertEmitter::emit_impl(const std::vector<size_t>& in,
|
||||
}
|
||||
}
|
||||
|
||||
template <dnnl::impl::cpu::x64::cpu_isa_t isa>
|
||||
template <cpu_isa_t isa>
|
||||
void LoadConvertEmitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
|
||||
if (!load_emitter)
|
||||
IE_THROW() << "Load CPU emitter isn't initialized for LoadEmitter!";
|
||||
@ -664,16 +665,16 @@ void LoadConvertEmitter::emit_data() const {
|
||||
load_emitter->emit_data();
|
||||
}
|
||||
|
||||
StoreConvertEmitter::StoreConvertEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n) : MemoryEmitter(h, isa, n) {
|
||||
const auto store = ov::as_type_ptr<snippets::op::Store>(n);
|
||||
StoreConvertEmitter::StoreConvertEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr)
|
||||
: MemoryEmitter(h, isa, expr) {
|
||||
const auto store = ov::as_type_ptr<snippets::op::Store>(expr->get_node());
|
||||
count = store->get_count();
|
||||
byte_offset = store->get_offset();
|
||||
in_out_type_ = emitter_in_out_map::vec_to_gpr;
|
||||
|
||||
if (ov::is_type<ov::intel_cpu::StoreConvertTruncation>(n)) {
|
||||
if (ov::is_type<ov::intel_cpu::StoreConvertTruncation>(expr->get_node())) {
|
||||
store_emitter.reset(new jit_store_emitter(h, isa, src_prc, dst_prc, count, arithmetic_mode::truncation));
|
||||
} else if (ov::is_type<ov::intel_cpu::StoreConvertSaturation>(n)) {
|
||||
} else if (ov::is_type<ov::intel_cpu::StoreConvertSaturation>(expr->get_node())) {
|
||||
store_emitter.reset(new jit_store_emitter(h, isa, src_prc, dst_prc, count, arithmetic_mode::saturation));
|
||||
}
|
||||
}
|
||||
@ -691,7 +692,7 @@ void StoreConvertEmitter::emit_impl(const std::vector<size_t>& in,
|
||||
}
|
||||
}
|
||||
|
||||
template <dnnl::impl::cpu::x64::cpu_isa_t isa>
|
||||
template <cpu_isa_t isa>
|
||||
void StoreConvertEmitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
|
||||
if (!store_emitter)
|
||||
IE_THROW() << "Store CPU emitter isn't initialized for StoreEmitter!";
|
||||
@ -704,12 +705,12 @@ void StoreConvertEmitter::emit_data() const {
|
||||
size_t BrgemmEmitter::getBrgIdx(size_t kIdx, size_t nIdx) {
|
||||
return kIdx * BRGEMM_N_KERNEL_NUM + nIdx;
|
||||
}
|
||||
BrgemmEmitter::BrgemmEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& node) : jit_emitter(h, isa, node) {
|
||||
|
||||
BrgemmEmitter::BrgemmEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr) : jit_emitter(h, isa) {
|
||||
m_brgCtxs.fill(brgemmCtx());
|
||||
std::generate(m_brgKernels.begin(), m_brgKernels.end(), [](){ return nullptr; });
|
||||
in_out_type_ = emitter_in_out_map::gpr_to_gpr;
|
||||
const auto& brgemm_node = as_type_ptr<ov::intel_cpu::BrgemmCPU>(node);
|
||||
const auto& brgemm_node = as_type_ptr<ov::intel_cpu::BrgemmCPU>(expr->get_node());
|
||||
if (brgemm_node->is_dynamic())
|
||||
IE_THROW() << "Snippets don't support code generation for dynamic Brgemm";
|
||||
const auto brgemm_copy = brgemm_node->is_with_data_repacking() ? brgemm_node->get_brgemm_copy() : nullptr;
|
||||
@ -1190,10 +1191,10 @@ void BrgemmEmitter::kernel_execute(const brgemm_kernel_t *brg_kernel,
|
||||
(*brg_kernel)(&brgemm_p);
|
||||
}
|
||||
|
||||
BrgemmCopyBEmitter::BrgemmCopyBEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n)
|
||||
: jit_emitter(h, isa, n) {
|
||||
BrgemmCopyBEmitter::BrgemmCopyBEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr)
|
||||
: jit_emitter(h, isa) {
|
||||
in_out_type_ = emitter_in_out_map::gpr_to_gpr;
|
||||
const auto brgemm_repack = ov::as_type_ptr<ov::intel_cpu::BrgemmCopyB>(n);
|
||||
const auto brgemm_repack = ov::as_type_ptr<ov::intel_cpu::BrgemmCopyB>(expr->get_node());
|
||||
if (!brgemm_repack)
|
||||
IE_THROW() << "BrgemmCopyBEmitters expects BrgemmCopyB node";
|
||||
|
||||
@ -1442,11 +1443,11 @@ void BrgemmCopyBEmitter::execute(matmul::jit_brgemm_matmul_copy_b_t *kernel, con
|
||||
(*kernel)(&ctx);
|
||||
}
|
||||
|
||||
HorizonEmitter::HorizonEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n) :
|
||||
jit_emitter(h, isa, n, Precision::FP32, emitter_in_out_map::vec_to_vec) {
|
||||
if (ov::is_type<const snippets::op::HorizonMax>(n)) {
|
||||
HorizonEmitter::HorizonEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr)
|
||||
: jit_emitter(h, isa, Precision::FP32, emitter_in_out_map::vec_to_vec) {
|
||||
if (ov::is_type<const snippets::op::HorizonMax>(expr->get_node())) {
|
||||
m_op_type = OpType::max;
|
||||
} else if (ov::is_type<const snippets::op::HorizonSum>(n)) {
|
||||
} else if (ov::is_type<const snippets::op::HorizonSum>(expr->get_node())) {
|
||||
m_op_type = OpType::sum;
|
||||
} else {
|
||||
OPENVINO_THROW("HorizonEmitter exprects HorizonMax or HorizonSum ops");
|
||||
@ -1466,7 +1467,7 @@ void HorizonEmitter::emit_impl(const std::vector<size_t>& in,
|
||||
}
|
||||
}
|
||||
|
||||
template <dnnl::impl::cpu::x64::cpu_isa_t isa>
|
||||
template <cpu_isa_t isa>
|
||||
void HorizonEmitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
|
||||
using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,
|
||||
Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
|
||||
@ -1510,9 +1511,9 @@ void HorizonEmitter::perform_op(const Vmm &vmm1, const Vmm &vmm2, const Vmm &vmm
|
||||
}
|
||||
}
|
||||
|
||||
FillEmitter::FillEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n) :
|
||||
jit_emitter(h, isa, n, Precision::FP32, emitter_in_out_map::vec_to_vec) {
|
||||
const auto fill = ov::as_type_ptr<snippets::op::Fill>(n);
|
||||
FillEmitter::FillEmitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr)
|
||||
: jit_emitter(h, isa, Precision::FP32, emitter_in_out_map::vec_to_vec) {
|
||||
const auto fill = ov::as_type_ptr<snippets::op::Fill>(expr->get_node());
|
||||
if (fill->get_element_type().size() != 4) {
|
||||
IE_THROW() << "Fill emitter supports only 4 Byte element types but gets: " << fill->get_element_type();
|
||||
}
|
||||
@ -1548,7 +1549,7 @@ void FillEmitter::emit_impl(const std::vector<size_t>& in,
|
||||
}
|
||||
}
|
||||
|
||||
template <dnnl::impl::cpu::x64::cpu_isa_t isa>
|
||||
template <cpu_isa_t isa>
|
||||
void FillEmitter::emit_isa(const std::vector<size_t> &in, const std::vector<size_t> &out) const {
|
||||
using Vmm = typename dnnl::impl::utils::conditional3<isa == dnnl::impl::cpu::x64::sse41,
|
||||
Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
|
||||
@ -1593,5 +1594,5 @@ void FillEmitter::fill_tail(const Vmm& src_vmm, const Vmm& dst_vmm) const {
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
} // namespace intel_cpu
|
||||
} // namespace ov
|
||||
|
||||
@ -8,6 +8,7 @@
|
||||
#include <ie_ngraph_utils.hpp>
|
||||
|
||||
#include "snippets/lowered/linear_ir.hpp"
|
||||
#include "snippets/lowered/expression.hpp"
|
||||
|
||||
#include "jit_emitter.hpp"
|
||||
#include "jit_load_store_emitters.hpp"
|
||||
@ -44,8 +45,9 @@ struct jit_snippets_compile_args {
|
||||
///
|
||||
class jit_container_emitter: public jit_emitter {
|
||||
public:
|
||||
jit_container_emitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n);
|
||||
jit_container_emitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
// mapping info contains abstract_to_physical map + regs_pool
|
||||
using mapping_info = std::pair<std::map<size_t, size_t>, std::vector<size_t>&>;
|
||||
protected:
|
||||
@ -74,8 +76,9 @@ protected:
|
||||
|
||||
class KernelEmitter : public jit_container_emitter {
|
||||
public:
|
||||
KernelEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n);
|
||||
KernelEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override {return 0;}
|
||||
void emit_code(const std::vector<size_t> &in,
|
||||
@ -111,7 +114,9 @@ private:
|
||||
|
||||
class LoopBeginEmitter : public jit_emitter {
|
||||
public:
|
||||
LoopBeginEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
LoopBeginEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
void emit_code(const std::vector<size_t> &in,
|
||||
const std::vector<size_t> &out) const;
|
||||
// todo: it is purely virtual in the base class, but do we need it?
|
||||
@ -131,7 +136,9 @@ private:
|
||||
|
||||
class LoopEndEmitter : public jit_emitter {
|
||||
public:
|
||||
LoopEndEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
LoopEndEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
void emit_code(const std::vector<size_t> &in,
|
||||
const std::vector<size_t> &out) const;
|
||||
// todo: it is purely virtual in the base class, but do we need it?
|
||||
@ -161,10 +168,9 @@ private:
|
||||
|
||||
class NopEmitter : public jit_emitter {
|
||||
public:
|
||||
NopEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n)
|
||||
: jit_emitter(h, isa, n) {
|
||||
in_out_type_ = emitter_in_out_map::gpr_to_gpr;
|
||||
}
|
||||
NopEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override {return 0;}
|
||||
|
||||
@ -176,21 +182,26 @@ private:
|
||||
|
||||
class ParameterEmitter : public NopEmitter {
|
||||
public:
|
||||
ParameterEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const std::shared_ptr<ov::Node>& n);
|
||||
ParameterEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override { return 0; }
|
||||
};
|
||||
|
||||
class ResultEmitter : public NopEmitter {
|
||||
public:
|
||||
ResultEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
ResultEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
size_t get_inputs_num() const override {return 1;}
|
||||
};
|
||||
|
||||
class BroadcastMoveEmitter : public jit_emitter {
|
||||
public:
|
||||
BroadcastMoveEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
BroadcastMoveEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override {return 1;}
|
||||
|
||||
@ -207,7 +218,9 @@ private:
|
||||
|
||||
class ScalarEmitter : public jit_emitter {
|
||||
public:
|
||||
ScalarEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
ScalarEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override {return 0;}
|
||||
|
||||
@ -236,7 +249,9 @@ private:
|
||||
/// Blocked parameter to tell if input is actually blocked. Broadcast means broadcast by W in other cases no need to substitute load.
|
||||
class MemoryEmitter : public jit_emitter {
|
||||
public:
|
||||
MemoryEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
MemoryEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
protected:
|
||||
InferenceEngine::Precision src_prc;
|
||||
@ -248,7 +263,9 @@ protected:
|
||||
|
||||
class StoreEmitter : public MemoryEmitter {
|
||||
public:
|
||||
StoreEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
StoreEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override {return 1;}
|
||||
|
||||
@ -266,7 +283,9 @@ private:
|
||||
|
||||
class LoadEmitter : public MemoryEmitter {
|
||||
public:
|
||||
LoadEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
LoadEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override {return 0;}
|
||||
|
||||
@ -284,7 +303,9 @@ private:
|
||||
|
||||
class BroadcastLoadEmitter : public MemoryEmitter {
|
||||
public:
|
||||
BroadcastLoadEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
BroadcastLoadEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override {return 0;}
|
||||
|
||||
@ -298,7 +319,9 @@ private:
|
||||
|
||||
class LoadConvertEmitter : public MemoryEmitter {
|
||||
public:
|
||||
LoadConvertEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
LoadConvertEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override {return 0;}
|
||||
|
||||
@ -316,7 +339,9 @@ private:
|
||||
|
||||
class StoreConvertEmitter : public MemoryEmitter {
|
||||
public:
|
||||
StoreConvertEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
StoreConvertEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override {return 1;}
|
||||
|
||||
@ -334,7 +359,9 @@ private:
|
||||
|
||||
class BrgemmEmitter : public jit_emitter {
|
||||
public:
|
||||
BrgemmEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
BrgemmEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override { return m_with_scratch ? 3 : 2; }
|
||||
static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ngraph::Node>& node = nullptr);
|
||||
@ -395,7 +422,9 @@ private:
|
||||
|
||||
class BrgemmCopyBEmitter : public jit_emitter {
|
||||
public:
|
||||
BrgemmCopyBEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
BrgemmCopyBEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override {return 1;}
|
||||
static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ngraph::Node>& node = nullptr) {
|
||||
@ -432,7 +461,9 @@ private:
|
||||
|
||||
class HorizonEmitter : public jit_emitter {
|
||||
public:
|
||||
HorizonEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
HorizonEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override {return 1;}
|
||||
static std::set<std::vector<element::Type>> get_supported_precisions(const std::shared_ptr<ngraph::Node>& node = nullptr) {
|
||||
@ -457,7 +488,9 @@ private:
|
||||
};
|
||||
class FillEmitter : public jit_emitter {
|
||||
public:
|
||||
FillEmitter(dnnl::impl::cpu::x64::jit_generator* h, dnnl::impl::cpu::x64::cpu_isa_t isa, const std::shared_ptr<ov::Node>& n);
|
||||
FillEmitter(dnnl::impl::cpu::x64::jit_generator* h,
|
||||
dnnl::impl::cpu::x64::cpu_isa_t isa,
|
||||
const ov::snippets::lowered::ExpressionPtr& expr);
|
||||
|
||||
size_t get_inputs_num() const override {return 1;}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user