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

[GPU] New headers and namespaces in some parts (#19229)

Browse Source
This commit is contained in:
Vladimir Paramuzov 2023-08-18 15:57:15 +04:00 committed by GitHub
parent 4f29e60742
commit 526d76c81f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
102 changed files with 1206 additions and 1152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/plugins/intel_gpu/include/intel_gpu/plugin/graph.hpp
View File

@ -25,7 +25,7 @@
#include "intel_gpu/plugin/custom_layer.hpp"
#include "intel_gpu/plugin/remote_context.hpp"
#include "intel_gpu/plugin/remote_blob.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
namespace ov {
namespace intel_gpu {
@ -96,7 +96,7 @@ public:
protected:
RemoteContextImpl::Ptr m_context;
std::shared_ptr<Program> m_program;
std::shared_ptr<ProgramBuilder> m_program;
std::string m_networkName;
ExecutionConfig m_config;
uint16_t m_stream_id;

51
src/plugins/intel_gpu/include/intel_gpu/plugin/program.hpp → src/plugins/intel_gpu/include/intel_gpu/plugin/program_builder.hpp
View File

@ -4,6 +4,17 @@
#pragma once
#include "openvino/core/node.hpp"
#include "openvino/runtime/profiling_info.hpp"
#include "intel_gpu/plugin/custom_layer.hpp"
#include "intel_gpu/runtime/engine.hpp"
#include "intel_gpu/runtime/execution_config.hpp"
#include "intel_gpu/graph/topology.hpp"
#include "intel_gpu/graph/program.hpp"
#include <cpp/ie_cnn_network.h>
#include <vector>
#include <map>
#include <memory>
@ -12,16 +23,6 @@
#include <mutex>
#include <set>
#include <cpp/ie_cnn_network.h>
#include <ngraph/ngraph.hpp>
#include "gpu/gpu_config.hpp"
#include "intel_gpu/plugin/custom_layer.hpp"
#include "intel_gpu/runtime/engine.hpp"
#include "intel_gpu/runtime/execution_config.hpp"
#include "intel_gpu/graph/topology.hpp"
#include "intel_gpu/graph/program.hpp"
// Forward declarations for cldnn part
namespace cldnn {
@ -34,8 +35,8 @@ enum class eltwise_mode : int32_t;
#define REGISTER_FACTORY_IMPL(op_version, op_name) \
void __register ## _ ## op_name ## _ ## op_version(); \
void __register ## _ ## op_name ## _ ## op_version() { \
Program::RegisterFactory<ov::op::op_version::op_name>( \
[](Program& p, const std::shared_ptr<ov::Node>& op) { \
ProgramBuilder::RegisterFactory<ov::op::op_version::op_name>( \
[](ProgramBuilder& p, const std::shared_ptr<ov::Node>& op) { \
auto op_casted = std::dynamic_pointer_cast<ov::op::op_version::op_name>(op); \
OPENVINO_ASSERT(op_casted, "[GPU] Invalid ov Node type passed into ", __PRETTY_FUNCTION__); \
Create##op_name##Op(p, op_casted); \
@ -52,10 +53,10 @@ struct is_smart_pointer<std::shared_ptr<T>> : std::true_type {};
template<class T>
struct is_smart_pointer<std::shared_ptr<const T>> : std::true_type {};
std::string layer_type_lower(const ngraph::Node* op);
std::string layer_type_name_ID(const ngraph::Node* op);
std::string layer_type_lower(const std::shared_ptr<ngraph::Node>& op);
std::string layer_type_name_ID(const std::shared_ptr<ngraph::Node>& op);
std::string layer_type_lower(const ov::Node* op);
std::string layer_type_name_ID(const ov::Node* op);
std::string layer_type_lower(const std::shared_ptr<ov::Node>& op);
std::string layer_type_name_ID(const std::shared_ptr<ov::Node>& op);
struct PerfCounter {
InferenceEngine::InferenceEngineProfileInfo::LayerStatus status;
@ -78,13 +79,13 @@ public:
long long cpu_avg() const { return (num == 0) ? 0 : cpu_uSec / num; }
};
class Program {
class ProgramBuilder {
public:
Program(InferenceEngine::CNNNetwork& network, cldnn::engine& engine, const ExecutionConfig& config,
ProgramBuilder(InferenceEngine::CNNNetwork& network, cldnn::engine& engine, const ExecutionConfig& config,
bool createTopologyOnly = false, bool partialBuild = false,
InferenceEngine::InputsDataMap* inputs = nullptr, InferenceEngine::OutputsDataMap* outputs = nullptr,
std::shared_ptr<ov::threading::IStreamsExecutor> task_executor = nullptr, bool innerProgram = false);
Program(cldnn::engine& engine, const ExecutionConfig& config,
ProgramBuilder(cldnn::engine& engine, const ExecutionConfig& config,
InferenceEngine::InputsDataMap* inputs = nullptr, InferenceEngine::OutputsDataMap* outputs = nullptr);
static const cldnn::primitive_id m_preProcessTag;
@ -129,14 +130,14 @@ public:
// Graph construction helpers
std::vector<cldnn::input_info> GetInputInfo(const std::shared_ptr<ngraph::Node>& op) const;
using factory_t = std::function<void(Program&, const std::shared_ptr<ngraph::Node>&)>;
using factory_t = std::function<void(ProgramBuilder&, const std::shared_ptr<ngraph::Node>&)>;
using factories_map_t = std::map<ngraph::DiscreteTypeInfo, factory_t>;
template<typename OpType>
static void RegisterFactory(factory_t func) {
std::lock_guard<std::mutex> lock(m_mutex);
if (Program::factories_map.find(OpType::get_type_info_static()) == Program::factories_map.end()) {
Program::factories_map.insert({OpType::get_type_info_static(), func});
if (ProgramBuilder::factories_map.find(OpType::get_type_info_static()) == ProgramBuilder::factories_map.end()) {
ProgramBuilder::factories_map.insert({OpType::get_type_info_static(), func});
}
}
@ -194,10 +195,10 @@ private:
void ChangeInputBatch(int batch);
};
void CreateCustomOp(Program& p, const std::shared_ptr<ngraph::Node>& node, CustomLayerPtr customLayer);
void CreateUnaryEltwiseOp(Program& p, const std::shared_ptr<ngraph::Node>& node,
void CreateCustomOp(ProgramBuilder& p, const std::shared_ptr<ngraph::Node>& node, CustomLayerPtr customLayer);
void CreateUnaryEltwiseOp(ProgramBuilder& p, const std::shared_ptr<ngraph::Node>& node,
cldnn::activation_func func, cldnn::activation_additional_params params);
void CreateElementwiseOp(Program& p,
void CreateElementwiseOp(ProgramBuilder& p,
const std::shared_ptr<ngraph::Node>& node,
cldnn::eltwise_mode mode,
std::vector<float> coefficients = {},

2
src/plugins/intel_gpu/include/intel_gpu/plugin/transformations_pipeline.hpp
View File

@ -6,7 +6,7 @@
#include <memory>
#include <ngraph/function.hpp>
#include "openvino/core/model.hpp"
#include "intel_gpu/runtime/execution_config.hpp"
#include "intel_gpu/runtime/device.hpp"

4
src/plugins/intel_gpu/include/intel_gpu/primitives/broadcast.hpp
View File

@ -97,7 +97,7 @@ struct broadcast : public primitive_base<broadcast> {
broadcast(const primitive_id& id,
const input_info& input,
const ov::Shape& target_shape,
const ngraph::AxisSet& axes_mapping,
const ov::AxisSet& axes_mapping,
const ov::op::BroadcastModeSpec& broadcast_spec = ov::op::BroadcastType::EXPLICIT,
const padding& output_padding = padding())
: primitive_base(id, {input}, {output_padding}),
@ -111,7 +111,7 @@ struct broadcast : public primitive_base<broadcast> {
broadcast(const primitive_id& id,
const input_info& input,
const input_info& target_shape_id,
const ngraph::AxisSet& axes_mapping,
const ov::AxisSet& axes_mapping,
const ov::op::BroadcastModeSpec& broadcast_spec = ov::op::BroadcastType::EXPLICIT,
const padding& output_padding = padding())
: primitive_base(id, {input, target_shape_id}, {output_padding}),

22
src/plugins/intel_gpu/include/intel_gpu/primitives/matrix_nms.hpp
View File

@ -3,10 +3,10 @@
//
#pragma once
#include <vector>
#include "ngraph/op/matrix_nms.hpp"
#include "openvino/op/matrix_nms.hpp"
#include "primitive.hpp"
#include <vector>
namespace cldnn {
@ -54,7 +54,7 @@ struct matrix_nms : public primitive_base<matrix_nms> {
attributes() {}
attributes(const ngraph::op::v8::MatrixNms::Attributes& attrs)
attributes(const ov::op::v8::MatrixNms::Attributes& attrs)
: attributes(from(attrs.sort_result_type),
attrs.sort_result_across_batch,
attrs.score_threshold,
@ -142,7 +142,7 @@ struct matrix_nms : public primitive_base<matrix_nms> {
const input_info& scores,
const input_info& second_output,
const input_info& third_output,
const ngraph::op::v8::MatrixNms::Attributes& attrs)
const ov::op::v8::MatrixNms::Attributes& attrs)
: primitive_base(id, {boxes, scores, second_output, third_output}),
attribs(attrs) {}
@ -194,23 +194,23 @@ struct matrix_nms : public primitive_base<matrix_nms> {
}
private:
static cldnn::matrix_nms::decay_function from(ngraph::op::v8::MatrixNms::DecayFunction decay) {
static cldnn::matrix_nms::decay_function from(ov::op::v8::MatrixNms::DecayFunction decay) {
switch (decay) {
case ngraph::op::v8::MatrixNms::DecayFunction::GAUSSIAN:
case ov::op::v8::MatrixNms::DecayFunction::GAUSSIAN:
return cldnn::matrix_nms::decay_function::gaussian;
case ngraph::op::v8::MatrixNms::DecayFunction::LINEAR:
case ov::op::v8::MatrixNms::DecayFunction::LINEAR:
default:
return cldnn::matrix_nms::decay_function::linear;
}
}
static cldnn::matrix_nms::sort_result_type from(ngraph::op::v8::MatrixNms::SortResultType type) {
static cldnn::matrix_nms::sort_result_type from(ov::op::v8::MatrixNms::SortResultType type) {
switch (type) {
case ngraph::op::v8::MatrixNms::SortResultType::CLASSID:
case ov::op::v8::MatrixNms::SortResultType::CLASSID:
return cldnn::matrix_nms::sort_result_type::class_id;
case ngraph::op::v8::MatrixNms::SortResultType::SCORE:
case ov::op::v8::MatrixNms::SortResultType::SCORE:
return cldnn::matrix_nms::sort_result_type::score;
case ngraph::op::v8::MatrixNms::SortResultType::NONE:
case ov::op::v8::MatrixNms::SortResultType::NONE:
default:
return cldnn::matrix_nms::sort_result_type::none;
}

17
src/plugins/intel_gpu/include/intel_gpu/primitives/multiclass_nms.hpp
View File

@ -3,13 +3,14 @@
//
#pragma once
#include <utility>
#include <vector>
#include "ngraph/op/multiclass_nms.hpp"
#include "openvino/op/multiclass_nms.hpp"
#include "openvino/core/type/element_type.hpp"
#include "primitive.hpp"
#include <utility>
#include <vector>
namespace cldnn {
/// @brief multiclass NMS
@ -71,7 +72,7 @@ struct multiclass_nms : public primitive_base<multiclass_nms> {
normalized(normalized),
nms_eta(nms_eta) {}
attributes(const ngraph::op::util::MulticlassNmsBase::Attributes& attrs)
attributes(const ov::op::util::MulticlassNmsBase::Attributes& attrs)
: attributes(from(attrs.sort_result_type),
attrs.sort_result_across_batch,
cldnn::element_type_to_data_type(attrs.output_type),
@ -110,13 +111,13 @@ struct multiclass_nms : public primitive_base<multiclass_nms> {
}
private:
static sort_result_type from(const ngraph::op::util::MulticlassNmsBase::SortResultType sort_result_type) {
static sort_result_type from(const ov::op::util::MulticlassNmsBase::SortResultType sort_result_type) {
switch (sort_result_type) {
case ngraph::op::util::MulticlassNmsBase::SortResultType::CLASSID:
case ov::op::util::MulticlassNmsBase::SortResultType::CLASSID:
return sort_result_type::classid;
case ngraph::op::util::MulticlassNmsBase::SortResultType::SCORE:
case ov::op::util::MulticlassNmsBase::SortResultType::SCORE:
return sort_result_type::score;
case ngraph::op::util::MulticlassNmsBase::SortResultType::NONE:
case ov::op::util::MulticlassNmsBase::SortResultType::NONE:
return sort_result_type::none;
default:
return sort_result_type::none;

1
src/plugins/intel_gpu/src/plugin/compiled_model.cpp
View File

@ -4,6 +4,7 @@
#include "intel_gpu/plugin/legacy_api_helper.hpp"
#include "openvino/pass/serialize.hpp"
#include "openvino/runtime/intel_gpu/properties.hpp"
#include "intel_gpu/graph/serialization/binary_buffer.hpp"

4
src/plugins/intel_gpu/src/plugin/custom_layer.cpp
View File

@ -7,7 +7,6 @@
#include "intel_gpu/runtime/itt.hpp"
#include "xml_parse_utils.h"
#include <description_buffer.hpp>
#include <map>
#include <fstream>
#include <streambuf>
@ -20,7 +19,6 @@
# include <windows.h>
#endif
using namespace InferenceEngine;
using namespace pugixml::utils;
#define CheckAndReturnError(cond, errorMsg) \
@ -198,7 +196,7 @@ bool CustomLayer::IsLegalSizeRule(const std::string & rule) {
try {
expr.Evaluate();
} catch (...) {
} catch (std::exception&) {
return false;
}
return true;

8
src/plugins/intel_gpu/src/plugin/graph.cpp
View File

@ -44,7 +44,7 @@ Graph::Graph(InferenceEngine::CNNNetwork& network, const RemoteContextImpl::Ptr&
, m_config(config)
, m_stream_id(stream_id)
, m_state(0) {
m_program = std::make_shared<Program>(network, get_engine(), config, false, false, inputs, outputs);
m_program = std::make_shared<ProgramBuilder>(network, get_engine(), config, false, false, inputs, outputs);
if (m_program->m_max_batch > 1)
m_config.set_property(ov::intel_gpu::max_dynamic_batch(m_program->m_max_batch));
Build();
@ -56,7 +56,7 @@ Graph::Graph(cldnn::BinaryInputBuffer &ib, const RemoteContextImpl::Ptr& context
, m_config(config)
, m_stream_id(stream_id)
, m_state(0) {
m_program = std::make_shared<Program>(get_engine(), config, inputs, outputs);
m_program = std::make_shared<ProgramBuilder>(get_engine(), config, inputs, outputs);
ib >> m_program->m_max_batch;
if (m_program->m_max_batch > 1)
m_config.set_property(ov::intel_gpu::max_dynamic_batch(m_program->m_max_batch));
@ -72,7 +72,7 @@ Graph::Graph(cldnn::BinaryInputBuffer &ib, const RemoteContextImpl::Ptr& context
}
ib >> m_program->inputLayouts;
Program::variables_state_info_map variablesStateInfoMap;
ProgramBuilder::variables_state_info_map variablesStateInfoMap;
ib >> variablesStateInfoMap;
for (const auto& variablesStateInfo : variablesStateInfoMap) {
m_program->AddVariableStateInfo(variablesStateInfo.first, *variablesStateInfo.second.begin());
@ -500,7 +500,7 @@ std::shared_ptr<ngraph::Function> Graph::GetExecGraphInfoByPrimitivesInfo(std::v
}
// Cache blob format:
// [ ov::intel_gpu::Program::inputLayouts ]
// [ ov::intel_gpu::ProgramBuilder::inputLayouts ]
// [ ov::intel_gpu::Graph::primitiveIDs ]
// [ ov::intel_gpu::Graph::outputDims ]
// [ cldnn::network ]

11
src/plugins/intel_gpu/src/plugin/ops/adaptive_pooling.cpp
View File

@ -2,10 +2,11 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "openvino/op/adaptive_max_pool.hpp"
#include "openvino/op/adaptive_avg_pool.hpp"
#include "ngraph/op/adaptive_max_pool.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/primitives/mutable_data.hpp"
#include "intel_gpu/primitives/adaptive_pooling.hpp"
@ -13,7 +14,7 @@
namespace ov {
namespace intel_gpu {
static void CreateAdaptiveAvgPoolOp(Program& p, const std::shared_ptr<ngraph::op::v8::AdaptiveAvgPool>& op) {
static void CreateAdaptiveAvgPoolOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::AdaptiveAvgPool>& op) {
validate_inputs_count(op, {2});
const auto inputs = p.GetInputInfo(op);
@ -25,7 +26,7 @@ static void CreateAdaptiveAvgPoolOp(Program& p, const std::shared_ptr<ngraph::op
p.add_primitive(*op, poolPrim);
}
static void CreateAdaptiveMaxPoolOp(Program& p, const std::shared_ptr<ngraph::op::v8::AdaptiveMaxPool>& op) {
static void CreateAdaptiveMaxPoolOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::AdaptiveMaxPool>& op) {
validate_inputs_count(op, {2});
OPENVINO_ASSERT(op->get_output_size() == 2, "[GPU] AdaptiveMaxPool requires 2 outputs");

12
src/plugins/intel_gpu/src/plugin/ops/batch_to_space.cpp
View File

@ -2,18 +2,18 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/batch_to_space.hpp"
#include "ngraph/op/constant.hpp"
#include "openvino/op/batch_to_space.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/primitives/batch_to_space.hpp"
namespace ov {
namespace intel_gpu {
static void CreateBatchToSpaceOp(Program& p, const std::shared_ptr<ngraph::op::v1::BatchToSpace>& op) {
static void CreateBatchToSpaceOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::BatchToSpace>& op) {
validate_inputs_count(op, {4});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -26,7 +26,7 @@ static void CreateBatchToSpaceOp(Program& p, const std::shared_ptr<ngraph::op::v
bool non_constant_input = false;
for (size_t i = 1; i < 4; ++i) {
auto inConst = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(i));
auto inConst = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(i));
bool is_const_input = (inConst != nullptr);
OPENVINO_ASSERT((i == 1) || (i >= 2 && non_constant_input != is_const_input),
@ -45,7 +45,7 @@ static void CreateBatchToSpaceOp(Program& p, const std::shared_ptr<ngraph::op::v
p.add_primitive(*op, batchToSpacePrim);
} else {
for (size_t i = 1; i < 4; ++i) {
auto inConst = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(i));
auto inConst = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(i));
std::vector<int32_t> sizes = inConst->cast_vector<int32_t>();
int32_t default_size = i == 1 ? 1 : 0;

24
src/plugins/intel_gpu/src/plugin/ops/broadcast.cpp
View File

@ -3,11 +3,11 @@
//
#include "openvino/core/except.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/broadcast.hpp"
#include "ngraph/op/constant.hpp"
#include "openvino/op/broadcast.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/primitives/broadcast.hpp"
#include "intel_gpu/primitives/reorder.hpp"
@ -16,7 +16,7 @@
namespace ov {
namespace intel_gpu {
static void CreateCommonBroadcastOp(Program& p, const std::shared_ptr<ngraph::Node>& op, const ngraph::AxisSet axis_mapping) {
static void CreateCommonBroadcastOp(ProgramBuilder& p, const std::shared_ptr<ov::Node>& op, const ov::AxisSet axis_mapping) {
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -61,9 +61,9 @@ static void CreateCommonBroadcastOp(Program& p, const std::shared_ptr<ngraph::No
}
ov::op::BroadcastModeSpec mode = ov::op::BroadcastType::NONE;
if (auto broadcast_v3 = std::dynamic_pointer_cast<ngraph::op::v3::Broadcast>(op)) {
if (auto broadcast_v3 = std::dynamic_pointer_cast<ov::op::v3::Broadcast>(op)) {
mode = broadcast_v3->get_broadcast_spec();
} else if (auto broadcast_v1 = std::dynamic_pointer_cast<ngraph::op::v1::Broadcast>(op)) {
} else if (auto broadcast_v1 = std::dynamic_pointer_cast<ov::op::v1::Broadcast>(op)) {
switch (broadcast_v1->get_broadcast_spec().m_type) {
case ov::op::AutoBroadcastType::NONE: mode = ov::op::BroadcastType::NONE; break;
case ov::op::AutoBroadcastType::NUMPY: mode = ov::op::BroadcastType::NUMPY; break;
@ -93,10 +93,10 @@ static void CreateCommonBroadcastOp(Program& p, const std::shared_ptr<ngraph::No
p.add_primitive(*op, broadcast_prim);
}
static void CreateBroadcastOp(Program& p, const std::shared_ptr<ngraph::op::v1::Broadcast>& op) {
static void CreateBroadcastOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Broadcast>& op) {
validate_inputs_count(op, {2, 3});
if (op->get_broadcast_spec().m_type == ngraph::op::AutoBroadcastType::NONE && op->get_input_size() == 3) {
auto axis_mapping_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(2));
if (op->get_broadcast_spec().m_type == ov::op::AutoBroadcastType::NONE && op->get_input_size() == 3) {
auto axis_mapping_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2));
OPENVINO_ASSERT(axis_mapping_node != nullptr, "[GPU] Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
auto axis_mapping = axis_mapping_node->get_axis_set_val();
@ -107,11 +107,11 @@ static void CreateBroadcastOp(Program& p, const std::shared_ptr<ngraph::op::v1::
}
}
static void CreateBroadcastOp(Program& p, const std::shared_ptr<ngraph::op::v3::Broadcast>& op) {
static void CreateBroadcastOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::Broadcast>& op) {
validate_inputs_count(op, {2, 3});
ngraph::AxisSet axis_mapping;
ov::AxisSet axis_mapping;
if (op->get_input_size() == 3) {
auto axis_mapping_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(2));
auto axis_mapping_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2));
OPENVINO_ASSERT(axis_mapping_node != nullptr, "[GPU] Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
axis_mapping = axis_mapping_node->get_axis_set_val();

8
src/plugins/intel_gpu/src/plugin/ops/bucketize.cpp
View File

@ -2,19 +2,17 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/bucketize.hpp"
#include "intel_gpu/primitives/bucketize.hpp"
#include <ngraph/op/bucketize.hpp>
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
namespace ov {
namespace intel_gpu {
namespace {
void CreateBucketizeOp(Program& p, const std::shared_ptr<ngraph::op::v3::Bucketize>& op) {
void CreateBucketizeOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::Bucketize>& op) {
validate_inputs_count(op, {2});
const cldnn::bucketize bucketize_prim(layer_type_name_ID(op),

6
src/plugins/intel_gpu/src/plugin/ops/concat.cpp
View File

@ -2,17 +2,17 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/concat.hpp"
#include "openvino/op/concat.hpp"
#include "intel_gpu/primitives/concatenation.hpp"
namespace ov {
namespace intel_gpu {
static void CreateConcatOp(Program& p, const std::shared_ptr<ngraph::op::v0::Concat>& op) {
static void CreateConcatOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Concat>& op) {
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
int64_t axis = op->get_axis();

15
src/plugins/intel_gpu/src/plugin/ops/condition.cpp
View File

@ -1,22 +1,21 @@
// Copyright (C) 2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "ngraph/op/if.hpp"
#include "ie_ngraph_utils.hpp"
#include "openvino/op/if.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/primitives/condition.hpp"
#include "ie_ngraph_utils.hpp"
namespace ov {
namespace intel_gpu {
const size_t idx_true = 0;
const size_t idx_false = 1;
static cldnn::condition::branch gen_branch(Program& p, const std::shared_ptr<ngraph::op::v8::If>& op, size_t idx) {
static cldnn::condition::branch gen_branch(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::If>& op, size_t idx) {
cldnn::condition::branch branch;
const auto& internal_body = (idx == idx_true)? op->get_then_body() : op->get_else_body();
InferenceEngine::CNNNetwork body_network(internal_body);
{
// CNNNetwork change the input/output data type to fp32 when input/output data type is fp16
@ -42,7 +41,7 @@ static cldnn::condition::branch gen_branch(Program& p, const std::shared_ptr<ngr
config.set_property(ov::intel_gpu::max_dynamic_batch(1));
config.set_property(ov::intel_gpu::allow_new_shape_infer(op->is_dynamic()));
Program prog(body_network, p.get_engine(), config, false, false, nullptr, nullptr, p.get_task_executor(), true);
ProgramBuilder prog(body_network, p.get_engine(), config, false, false, nullptr, nullptr, p.get_task_executor(), true);
branch.inner_program = prog.GetCompiledProgram();
auto& input_map = branch.input_map;
@ -66,7 +65,7 @@ static cldnn::condition::branch gen_branch(Program& p, const std::shared_ptr<ngr
return branch;
}
static void CreateIfOp(Program& p, const std::shared_ptr<ngraph::op::v8::If>& op) {
static void CreateIfOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::If>& op) {
auto inputs = p.GetInputInfo(op);
OPENVINO_ASSERT(inputs.size() >= 1, "Invalid inputs count (Not allowed no input)");
auto compare_node_pshape = op->get_input_partial_shape(0);

74
src/plugins/intel_gpu/src/plugin/ops/constant.cpp
View File

@ -2,20 +2,22 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/convolution.hpp"
#include "ngraph/op/binary_convolution.hpp"
#include "ngraph/op/deformable_convolution.hpp"
#include "ngraph/op/group_conv.hpp"
#include "ngraph/op/concat.hpp"
#include "ngraph/op/squared_difference.hpp"
#include "ngraph/op/gather.hpp"
#include "ngraph/op/split.hpp"
#include "ngraph/op/variadic_split.hpp"
#include "ngraph/op/util/op_types.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/convolution.hpp"
#include "openvino/op/convert.hpp"
#include "openvino/op/binary_convolution.hpp"
#include "openvino/op/deformable_convolution.hpp"
#include "openvino/op/group_conv.hpp"
#include "openvino/op/concat.hpp"
#include "openvino/op/squared_difference.hpp"
#include "openvino/op/gather.hpp"
#include "openvino/op/split.hpp"
#include "openvino/op/prelu.hpp"
#include "openvino/op/variadic_split.hpp"
#include "openvino/op/util/op_types.hpp"
#include "intel_gpu/primitives/data.hpp"
#include "intel_gpu/runtime/debug_configuration.hpp"
@ -23,7 +25,7 @@
namespace ov {
namespace intel_gpu {
static cldnn::tensor getConstTensor(const ngraph::Shape constDims) {
static cldnn::tensor getConstTensor(const ov::Shape constDims) {
std::vector<cldnn::tensor::value_type> shuffled_dims(constDims.size());
// cldnn tensor c-tor expects constants be in a reversed order (x, y, z, w, u, v)
@ -66,27 +68,27 @@ struct ConstProperties {
bool hasGroupDimension;
};
static void createClDnnConstant(Program& p, const ngraph::Shape& constDims, const std::shared_ptr<ngraph::op::v0::Constant>& op, const ConstProperties& props);
static void createClDnnConstant(ProgramBuilder& p, const ov::Shape& constDims, const std::shared_ptr<ov::op::v0::Constant>& op, const ConstProperties& props);
static void CreateConstantOp(Program& p, const std::shared_ptr<ngraph::op::v0::Constant>& op) {
ngraph::Shape constDims = op->get_shape();
static void CreateConstantOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Constant>& op) {
ov::Shape constDims = op->get_shape();
auto constUsers = op->get_output_target_inputs(0);
size_t numConstUsers = constUsers.size();
std::unordered_map<std::shared_ptr<ngraph::op::v0::Constant>, ConstProperties> consts = {
std::unordered_map<std::shared_ptr<ov::op::v0::Constant>, ConstProperties> consts = {
{op, {false, false, false}}
};
// handleConvWeights function is executed when one of the constant users is ConvolutionBackpropData or GroupConvolutionBackpropData.
// In that case, we mark that constant's O and I dimensions need to be swapped.
auto handleConvWeights = [&op] (ngraph::Node* conv, std::unordered_map<std::shared_ptr<ngraph::op::v0::Constant>, ConstProperties>& consts,
auto handleConvWeights = [&op] (ov::Node* conv, std::unordered_map<std::shared_ptr<ov::op::v0::Constant>, ConstProperties>& consts,
size_t& numConstUsers, bool hasGroupDimension) {
// If constant has multiple users - create its copy and replace 'conv' weights with the copy.
// This is to make sure that dimension change doesn't break other users of the constant node.
// It is a shallow copy, but that's fine since in createClDnnConstant
// every constant created here, gets memcopied to a brand new cldnn::memory.
if (numConstUsers > 1) {
auto constant = std::make_shared<ngraph::op::v0::Constant>(*(op.get()));
auto constant = std::make_shared<ov::op::v0::Constant>(*(op.get()));
conv->input(1).replace_source_output(constant);
consts.insert({constant, {false, true, hasGroupDimension}});
numConstUsers--;
@ -97,9 +99,9 @@ static void CreateConstantOp(Program& p, const std::shared_ptr<ngraph::op::v0::C
};
auto is_binary_eltwise = [&] (ov::Node* op) -> bool {
if (ngraph::op::is_binary_elementwise_arithmetic(op) ||
ngraph::op::is_binary_elementwise_logical(op) ||
ngraph::op::is_binary_elementwise_comparison(op)) {
if (ov::op::util::is_binary_elementwise_arithmetic(op) ||
ov::op::util::is_binary_elementwise_logical(op) ||
ov::op::util::is_binary_elementwise_comparison(op)) {
return true;
} else {
return false;
@ -116,7 +118,7 @@ static void CreateConstantOp(Program& p, const std::shared_ptr<ngraph::op::v0::C
};
auto is_convert_into_binary_eltwise = [&] (ov::Node* op) -> bool {
if (ngraph::is_type<ngraph::op::v0::Convert>(op)) {
if (ov::is_type<ov::op::v0::Convert>(op)) {
for (size_t i = 0; i < op->get_output_size(); ++i) {
auto convertUsers = op->get_output_target_inputs(i);
for (auto user : convertUsers) {
@ -136,24 +138,24 @@ static void CreateConstantOp(Program& p, const std::shared_ptr<ngraph::op::v0::C
// Also check if constant users is a backprop convolution - in that case O and I need to be swapped.
for (auto& node : constUsers) {
auto outOp = node.get_node();
if (auto castedOp = dynamic_cast<ngraph::op::v0::Concat*>(outOp)) {
if (auto castedOp = dynamic_cast<ov::op::v0::Concat*>(outOp)) {
if (castedOp->get_axis() == 0) {
consts[op].needsBatchInterpretation = constDims.size() == 1;
}
} else if (((is_binary_eltwise(outOp) || ngraph::is_type<ngraph::op::v0::SquaredDifference>(outOp)) && is_all_inputs_1d(outOp)) ||
} else if (((is_binary_eltwise(outOp) || ov::is_type<ov::op::v0::SquaredDifference>(outOp)) && is_all_inputs_1d(outOp)) ||
is_convert_into_binary_eltwise(outOp)) {
consts[op].needsBatchInterpretation = constDims.size() == 1;
} else if (ngraph::is_type<ngraph::op::v1::Gather>(outOp) ||
ngraph::is_type<ngraph::op::v7::Gather>(outOp) ||
ngraph::is_type<ngraph::op::v8::Gather>(outOp) ||
ngraph::is_type<ngraph::op::v1::Split>(outOp) ||
ngraph::is_type<ngraph::op::v1::VariadicSplit>(outOp)) {
} else if (ov::is_type<ov::op::v1::Gather>(outOp) ||
ov::is_type<ov::op::v7::Gather>(outOp) ||
ov::is_type<ov::op::v8::Gather>(outOp) ||
ov::is_type<ov::op::v1::Split>(outOp) ||
ov::is_type<ov::op::v1::VariadicSplit>(outOp)) {
consts[op].needsBatchInterpretation = constDims.size() == 1;
} else if (ngraph::is_type<ngraph::op::v1::ConvolutionBackpropData>(outOp) && node.get_index() == 1) {
} else if (ov::is_type<ov::op::v1::ConvolutionBackpropData>(outOp) && node.get_index() == 1) {
handleConvWeights(outOp, consts, numConstUsers, false);
} else if (ngraph::is_type<ngraph::op::v1::GroupConvolutionBackpropData>(outOp) && node.get_index() == 1) {
} else if (ov::is_type<ov::op::v1::GroupConvolutionBackpropData>(outOp) && node.get_index() == 1) {
handleConvWeights(outOp, consts, numConstUsers, true);
} else if (ngraph::is_type<ngraph::op::v0::PRelu>(outOp) && node.get_index() == 1) {
} else if (ov::is_type<ov::op::v0::PRelu>(outOp) && node.get_index() == 1) {
// PReLU slope tensor reshape policy
//
// 1. 1-dim slope is handled by 'getConstTensor' (if slope dimension is equal to the feature dimension of input).
@ -168,12 +170,12 @@ static void CreateConstantOp(Program& p, const std::shared_ptr<ngraph::op::v0::C
if ((constDims.size() != 1 && constDims.size() < input_shape.size()) ||
(constDims.size() == 1 && input_shape.is_static() && static_cast<int64_t>(constDims[0]) != input_shape[1].get_length())) {
// Reshape 'constDims' according to the numpy broadcasting rule.
ngraph::Shape slope_shape(input_shape.size(), 1);
ov::Shape slope_shape(input_shape.size(), 1);
for (size_t j = 1; j <= constDims.size(); j++)
slope_shape[slope_shape.size() - j] = constDims[constDims.size() - j];
constDims = slope_shape;
}
} else if (ngraph::is_type<ngraph::op::v1::GroupConvolution>(outOp) && node.get_index() == 1 && !p.use_new_shape_infer()) {
} else if (ov::is_type<ov::op::v1::GroupConvolution>(outOp) && node.get_index() == 1 && !p.use_new_shape_infer()) {
auto input_shape = outOp->get_input_partial_shape(0);
if (constDims.size() == 4 && input_shape.size() == 3) { // In case of weight dim 4 and input dim 3,
constDims.push_back(1); // The weight cldnn tensor adds 1d to the end as the input cldnn tensor does
@ -186,7 +188,7 @@ static void CreateConstantOp(Program& p, const std::shared_ptr<ngraph::op::v0::C
}
}
void createClDnnConstant(Program& p, const ngraph::Shape& constDims, const std::shared_ptr<ngraph::op::v0::Constant>& op, const ConstProperties& props) {
void createClDnnConstant(ProgramBuilder& p, const ov::Shape& constDims, const std::shared_ptr<ov::op::v0::Constant>& op, const ConstProperties& props) {
cldnn::tensor constTensor = getConstTensor(constDims);
auto constFormat = cldnn::format::get_default_format(constDims.size());

10
src/plugins/intel_gpu/src/plugin/ops/convert.cpp
View File

@ -2,18 +2,18 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/convert.hpp"
#include "ngraph/op/convert_like.hpp"
#include "openvino/op/convert.hpp"
#include "openvino/op/convert_like.hpp"
#include "intel_gpu/primitives/reorder.hpp"
namespace ov {
namespace intel_gpu {
static void CreateConvertLikeOp(Program& p, const std::shared_ptr<ngraph::op::v1::ConvertLike>& op) {
static void CreateConvertLikeOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::ConvertLike>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -27,7 +27,7 @@ static void CreateConvertLikeOp(Program& p, const std::shared_ptr<ngraph::op::v1
p.add_primitive(*op, reorderPrim);
}
static void CreateConvertOp(Program& p, const std::shared_ptr<ngraph::op::v0::Convert>& op) {
static void CreateConvertOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Convert>& op) {
validate_inputs_count(op, {1});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

21
src/plugins/intel_gpu/src/plugin/ops/convert_color.cpp
View File

@ -2,17 +2,22 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "openvino/core/preprocess/input_tensor_info.hpp"
#include "openvino/op/nv12_to_bgr.hpp"
#include "openvino/op/nv12_to_rgb.hpp"
#include "openvino/op/i420_to_bgr.hpp"
#include "openvino/op/i420_to_rgb.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/primitives/convert_color.hpp"
#include "intel_gpu/primitives/concatenation.hpp"
#include "openvino/core/preprocess/input_tensor_info.hpp"
namespace ov {
namespace intel_gpu {
static void CreateCommonConvertColorOp(Program& p, const std::shared_ptr<ngraph::Node>& op,
static void CreateCommonConvertColorOp(ProgramBuilder& p, const std::shared_ptr<ov::Node>& op,
const cldnn::convert_color::color_format from_color,
const cldnn::convert_color::color_format to_color) {
auto inputs = p.GetInputInfo(op);
@ -28,7 +33,7 @@ static void CreateCommonConvertColorOp(Program& p, const std::shared_ptr<ngraph:
if (op->get_input_node_ptr(0)->output(0).get_rt_info().count(ov::preprocess::TensorInfoMemoryType::get_type_info_static())) {
std::string mem_type = op->get_input_node_ptr(0)->output(0).get_rt_info().at(ov::preprocess::TensorInfoMemoryType::get_type_info_static())
.as<ov::preprocess::TensorInfoMemoryType>().value;
if (mem_type.find(GPU_CONFIG_KEY(SURFACE)) != std::string::npos) {
if (mem_type.find(ov::intel_gpu::memory_type::surface) != std::string::npos) {
memory_type = cldnn::convert_color::memory_type::image;
}
}
@ -64,22 +69,22 @@ static void CreateCommonConvertColorOp(Program& p, const std::shared_ptr<ngraph:
}
}
static void CreateNV12toRGBOp(Program& p, const std::shared_ptr<ngraph::op::v8::NV12toRGB>& op) {
static void CreateNV12toRGBOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::NV12toRGB>& op) {
validate_inputs_count(op, {1, 2});
CreateCommonConvertColorOp(p, op, cldnn::convert_color::color_format::NV12, cldnn::convert_color::color_format::RGB);
}
static void CreateNV12toBGROp(Program& p, const std::shared_ptr<ngraph::op::v8::NV12toBGR>& op) {
static void CreateNV12toBGROp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::NV12toBGR>& op) {
validate_inputs_count(op, {1, 2});
CreateCommonConvertColorOp(p, op, cldnn::convert_color::color_format::NV12, cldnn::convert_color::color_format::BGR);
}
static void CreateI420toRGBOp(Program& p, const std::shared_ptr<ngraph::op::v8::I420toRGB>& op) {
static void CreateI420toRGBOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::I420toRGB>& op) {
validate_inputs_count(op, {1, 3});
CreateCommonConvertColorOp(p, op, cldnn::convert_color::color_format::I420, cldnn::convert_color::color_format::RGB);
}
static void CreateI420toBGROp(Program& p, const std::shared_ptr<ngraph::op::v8::I420toBGR>& op) {
static void CreateI420toBGROp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::I420toBGR>& op) {
validate_inputs_count(op, {1, 3});
CreateCommonConvertColorOp(p, op, cldnn::convert_color::color_format::I420, cldnn::convert_color::color_format::BGR);
}

42
src/plugins/intel_gpu/src/plugin/ops/convolution.cpp
View File

@ -2,16 +2,16 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/convolution.hpp"
#include "ngraph/op/binary_convolution.hpp"
#include "ngraph/op/deformable_convolution.hpp"
#include "ngraph/op/group_conv.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/fake_quantize.hpp"
#include "ngraph/op/util/op_types.hpp"
#include "openvino/op/convolution.hpp"
#include "openvino/op/binary_convolution.hpp"
#include "openvino/op/deformable_convolution.hpp"
#include "openvino/op/group_conv.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/fake_quantize.hpp"
#include "openvino/op/util/op_types.hpp"
#include "intel_gpu/primitives/convolution.hpp"
#include "intel_gpu/primitives/deconvolution.hpp"
@ -22,7 +22,7 @@
namespace ov {
namespace intel_gpu {
static void CreateGroupConvolutionOp(Program& p, const std::shared_ptr<ngraph::op::v1::GroupConvolution>& op) {
static void CreateGroupConvolutionOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::GroupConvolution>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -61,7 +61,7 @@ static void CreateGroupConvolutionOp(Program& p, const std::shared_ptr<ngraph::o
p.add_primitive(*op, convPrim);
}
static void CreateConvolutionOp(Program& p, const std::shared_ptr<ngraph::op::v1::Convolution>& op) {
static void CreateConvolutionOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Convolution>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -99,7 +99,7 @@ static void CreateConvolutionOp(Program& p, const std::shared_ptr<ngraph::op::v1
p.add_primitive(*op, convPrim);
}
static void CreateConvolutionBackpropDataOp(Program& p, const std::shared_ptr<ngraph::op::v1::ConvolutionBackpropData>& op) {
static void CreateConvolutionBackpropDataOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::ConvolutionBackpropData>& op) {
// 3rd input is an optional output shape
validate_inputs_count(op, {2, 3});
auto inputs = p.GetInputInfo(op);
@ -119,7 +119,7 @@ static void CreateConvolutionBackpropDataOp(Program& p, const std::shared_ptr<ng
// Dimensions order of weights blob is IOYX, but
// the selected format is OIYX by default. So we need to swap (and transpose) I and O dimensions to match the format
// For Constant node on input transpose is not needed, because the data is transposed on const node creation
if ((hasConstantWeights && std::dynamic_pointer_cast<ngraph::op::v0::Constant>(weights_node) == nullptr) || !hasConstantWeights) {
if ((hasConstantWeights && std::dynamic_pointer_cast<ov::op::v0::Constant>(weights_node) == nullptr) || !hasConstantWeights) {
std::string permuteName = layerName + "_cldnn_weights_permute";
auto weights_rank = op->get_input_shape(1).size();
std::vector<uint16_t> permute_order(weights_rank);
@ -173,7 +173,7 @@ static void CreateConvolutionBackpropDataOp(Program& p, const std::shared_ptr<ng
output_padding,
weights_have_group_dim);
if (op->get_input_size() == 3) {
auto output_shape_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(2));
auto output_shape_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2));
if (output_shape_constant) {
auto output_shape = output_shape_constant->cast_vector<int64_t>();
ov::Shape shape(output_shape.begin(), output_shape.end());
@ -187,7 +187,7 @@ static void CreateConvolutionBackpropDataOp(Program& p, const std::shared_ptr<ng
}
}
static void CreateGroupConvolutionBackpropDataOp(Program& p, const std::shared_ptr<ngraph::op::v1::GroupConvolutionBackpropData>& op) {
static void CreateGroupConvolutionBackpropDataOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::GroupConvolutionBackpropData>& op) {
// 3rd input is an optional output shape
validate_inputs_count(op, {2, 3});
auto inputs = p.GetInputInfo(op);
@ -209,7 +209,7 @@ static void CreateGroupConvolutionBackpropDataOp(Program& p, const std::shared_p
// Dimensions order of weights blob is IOYX, but
// the selected format is OIYX by default. So we need to swap I and O dimensions to match the format.
// For Constant node on input transpose is not needed, because the data is transposed on const node creation
if ((hasConstWeights && std::dynamic_pointer_cast<ngraph::op::v0::Constant>(weights_node) == nullptr) || !hasConstWeights) {
if ((hasConstWeights && std::dynamic_pointer_cast<ov::op::v0::Constant>(weights_node) == nullptr) || !hasConstWeights) {
std::string permuteName = layerName + "_cldnn_weights_permute";
auto weights_rank = op->get_input_shape(1).size();
std::vector<uint16_t> permute_order(weights_rank);
@ -264,7 +264,7 @@ static void CreateGroupConvolutionBackpropDataOp(Program& p, const std::shared_p
output_padding,
weights_have_group_dim);
if (op->get_input_size() == 3) {
auto output_shape_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(2));
auto output_shape_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2));
if (output_shape_constant) {
auto output_shape = output_shape_constant->cast_vector<int64_t>();
ov::Shape shape(output_shape.begin(), output_shape.end());
@ -278,8 +278,8 @@ static void CreateGroupConvolutionBackpropDataOp(Program& p, const std::shared_p
}
}
static void DeformableConvolutionImpl(Program& p,
const std::shared_ptr<ngraph::Node>& op,
static void DeformableConvolutionImpl(ProgramBuilder& p,
const std::shared_ptr<ov::Node>& op,
const int64_t groups,
const ov::Strides& strides,
const ov::Strides& dilations,
@ -351,7 +351,7 @@ static void DeformableConvolutionImpl(Program& p,
}
}
static void CreateDeformableConvolutionOp(Program& p, const std::shared_ptr<ngraph::op::v1::DeformableConvolution>& op) {
static void CreateDeformableConvolutionOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::DeformableConvolution>& op) {
validate_inputs_count(op, {3});
auto strides = op->get_strides();
auto pads_begin = op->get_pads_begin();
@ -365,7 +365,7 @@ static void CreateDeformableConvolutionOp(Program& p, const std::shared_ptr<ngra
DeformableConvolutionImpl(p, op, op->get_group(), strides, dilations, pads_begin, op->get_deformable_group());
}
static void CreateDeformableConvolutionOp(Program& p, const std::shared_ptr<ngraph::op::v8::DeformableConvolution>& op) {
static void CreateDeformableConvolutionOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::DeformableConvolution>& op) {
validate_inputs_count(op, {3, 4});
auto strides = op->get_strides();
auto pads_begin = op->get_pads_begin();
@ -386,7 +386,7 @@ static void CreateDeformableConvolutionOp(Program& p, const std::shared_ptr<ngra
op->get_bilinear_interpolation_pad());
}
static void CreateBinaryConvolutionOp(Program& p, const std::shared_ptr<ngraph::op::v1::BinaryConvolution>& op) {
static void CreateBinaryConvolutionOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::BinaryConvolution>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

24
src/plugins/intel_gpu/src/plugin/ops/ctc_greedy_decoder.cpp
View File

@ -2,11 +2,11 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/ctc_greedy_decoder.hpp"
#include "ngraph/op/ctc_greedy_decoder_seq_len.hpp"
#include "openvino/op/ctc_greedy_decoder.hpp"
#include "openvino/op/ctc_greedy_decoder_seq_len.hpp"
#include "intel_gpu/primitives/ctc_greedy_decoder.hpp"
#include "intel_gpu/primitives/reorder.hpp"
@ -18,7 +18,7 @@
namespace ov {
namespace intel_gpu {
static void CreateCommonCTCGreedyDecoderOp(Program& p, const std::shared_ptr<ngraph::Node>& op, bool ctc_merge_repeated) {
static void CreateCommonCTCGreedyDecoderOp(ProgramBuilder& p, const std::shared_ptr<ov::Node>& op, bool ctc_merge_repeated) {
validate_inputs_count(op, {2, 3});
auto inputs = p.GetInputInfo(op);
@ -30,7 +30,7 @@ static void CreateCommonCTCGreedyDecoderOp(Program& p, const std::shared_ptr<ngr
if (inputDataType == cldnn::data_types::i64) {
// GPU primitive supports only i32 data type for 'sequence_length' and 'blank_index' inputs
// so we need additional reorder if it's provided as i64
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + Program::m_preProcessTag;
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + ProgramBuilder::m_preProcessTag;
auto targetFormat = cldnn::format::get_default_format(op->get_input_shape(portIndex).size());
auto preprocessPrim = cldnn::reorder(reorderPrimName,
inputs[portIndex],
@ -45,12 +45,12 @@ static void CreateCommonCTCGreedyDecoderOp(Program& p, const std::shared_ptr<ngr
uint32_t blank_index = static_cast<uint32_t>(op->get_input_shape(0).back() - 1);
if (reordered_inputs.size() == 3) {
auto blank_index_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(2));
auto blank_index_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2));
if (!blank_index_node) {
OPENVINO_THROW("Unsupported blank_index node type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
}
float val;
if (ngraph::shape_size(blank_index_node->get_output_shape(0)) != 1 || !ov::op::util::get_single_value(blank_index_node, val)) {
if (ov::shape_size(blank_index_node->get_output_shape(0)) != 1 || !ov::op::util::get_single_value(blank_index_node, val)) {
OPENVINO_THROW("Unsupported parameter size in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
}
blank_index = static_cast<uint32_t>(val);
@ -62,8 +62,8 @@ static void CreateCommonCTCGreedyDecoderOp(Program& p, const std::shared_ptr<ngr
std::vector<cldnn::memory::ptr> shared_memory;
if (num_output == 2) {
auto mutable_precision = op->get_output_element_type(1);
if (mutable_precision == ngraph::element::i64) {
mutable_precision = ngraph::element::i32;
if (mutable_precision == ov::element::i64) {
mutable_precision = ov::element::i32;
}
cldnn::layout mutableLayout = cldnn::layout(
@ -90,7 +90,7 @@ static void CreateCommonCTCGreedyDecoderOp(Program& p, const std::shared_ptr<ngr
tensor_from_dims(op->get_output_shape(0)));
// GPU primitive supports only i32 as output data type
primitive.output_data_types = {cldnn::element_type_to_data_type(ngraph::element::i32)};
primitive.output_data_types = {cldnn::element_type_to_data_type(ov::element::i32)};
if (num_output == 2) {
primitive.second_output = reordered_inputs.back().pid;
@ -107,11 +107,11 @@ static void CreateCommonCTCGreedyDecoderOp(Program& p, const std::shared_ptr<ngr
}
}
static void CreateCTCGreedyDecoderOp(Program& p, const std::shared_ptr<ngraph::op::v0::CTCGreedyDecoder>& op) {
static void CreateCTCGreedyDecoderOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::CTCGreedyDecoder>& op) {
CreateCommonCTCGreedyDecoderOp(p, op, op->get_ctc_merge_repeated());
}
static void CreateCTCGreedyDecoderSeqLenOp(Program& p, const std::shared_ptr<ngraph::op::v6::CTCGreedyDecoderSeqLen>& op) {
static void CreateCTCGreedyDecoderSeqLenOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v6::CTCGreedyDecoderSeqLen>& op) {
CreateCommonCTCGreedyDecoderOp(p, op, op->get_merge_repeated());
}

8
src/plugins/intel_gpu/src/plugin/ops/ctc_loss.cpp
View File

@ -2,18 +2,16 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/ctc_loss.hpp"
#include "intel_gpu/primitives/ctc_loss.hpp"
#include <ngraph/op/ctc_loss.hpp>
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
namespace ov {
namespace intel_gpu {
namespace {
void CreateCTCLossOp(Program& p, const std::shared_ptr<ngraph::op::v4::CTCLoss>& op) {
void CreateCTCLossOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v4::CTCLoss>& op) {
validate_inputs_count(op, {4, 5});
const cldnn::ctc_loss ctc_loss_prim(layer_type_name_ID(op),

13
src/plugins/intel_gpu/src/plugin/ops/cum_sum.cpp
View File

@ -2,18 +2,19 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "openvino/core/validation_util.hpp"
#include "openvino/op/cum_sum.hpp"
#include "openvino/op/constant.hpp"
#include "ngraph/op/cum_sum.hpp"
#include "ngraph/op/constant.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/primitives/cum_sum.hpp"
namespace ov {
namespace intel_gpu {
static void CreateCumSumOp(Program& p, const std::shared_ptr<ngraph::op::v0::CumSum>& op) {
static void CreateCumSumOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::CumSum>& op) {
validate_inputs_count(op, {1, 2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -23,7 +24,7 @@ static void CreateCumSumOp(Program& p, const std::shared_ptr<ngraph::op::v0::Cum
int64_t axis = 0;
if (op->get_input_size() == 2) {
auto axes_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(1));
auto axes_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
OPENVINO_ASSERT(axes_constant != nullptr, "[GPU] Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
axis = axes_constant->cast_vector<int64_t>()[0];
}

49
src/plugins/intel_gpu/src/plugin/ops/custom.cpp
View File

@ -2,13 +2,12 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "openvino/core/attribute_visitor.hpp"
#include "openvino/core/node.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/plugin/simple_math.hpp"
#include "ngraph/attribute_visitor.hpp"
#include "ngraph/node.hpp"
#include "intel_gpu/primitives/custom_gpu_primitive.hpp"
#include "intel_gpu/primitives/reorder.hpp"
@ -39,57 +38,57 @@ inline std::string vecToString<std::string>(std::vector<std::string> vec) {
return res;
}
class CustomLayerAttributeVisitor : public ngraph::AttributeVisitor {
class CustomLayerAttributeVisitor : public ov::AttributeVisitor {
public:
CustomLayerAttributeVisitor() : m_values({}) { }
void on_adapter(const std::string& name, ngraph::ValueAccessor<void>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<void>& adapter) override {
OPENVINO_THROW("Attribute ", name, " can't be processed\n");
}
// The remaining adapter methods fall back on the void adapter if not implemented
void on_adapter(const std::string& name, ngraph::ValueAccessor<std::string>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<std::string>& adapter) override {
m_values[name] = adapter.get();
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<bool>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<bool>& adapter) override {
m_values[name] = std::to_string(adapter.get());
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<int64_t>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<int64_t>& adapter) override {
m_values[name] = std::to_string(adapter.get());
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<double>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<double>& adapter) override {
m_values[name] = std::to_string(adapter.get());
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<std::vector<std::string>>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<std::string>>& adapter) override {
m_values[name] = vecToString(adapter.get());
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<std::vector<float>>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<float>>& adapter) override {
m_values[name] = vecToString(adapter.get());
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<std::vector<double>>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<double>>& adapter) override {
m_values[name] = vecToString(adapter.get());
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<std::vector<int8_t>>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<int8_t>>& adapter) override {
m_values[name] = vecToString(adapter.get());
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<std::vector<int16_t>>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<int16_t>>& adapter) override {
m_values[name] = vecToString(adapter.get());
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<std::vector<int32_t>>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<int32_t>>& adapter) override {
m_values[name] = vecToString(adapter.get());
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<std::vector<int64_t>>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<int64_t>>& adapter) override {
m_values[name] = vecToString(adapter.get());
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<std::vector<uint8_t>>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<uint8_t>>& adapter) override {
m_values[name] = vecToString(adapter.get());
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<std::vector<uint16_t>>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<uint16_t>>& adapter) override {
m_values[name] = vecToString(adapter.get());
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<std::vector<uint32_t>>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<uint32_t>>& adapter) override {
m_values[name] = vecToString(adapter.get());
}
void on_adapter(const std::string& name, ngraph::ValueAccessor<std::vector<uint64_t>>& adapter) override {
void on_adapter(const std::string& name, ov::ValueAccessor<std::vector<uint64_t>>& adapter) override {
m_values[name] = vecToString(adapter.get());
}
@ -101,7 +100,7 @@ protected:
std::map<std::string, std::string> m_values;
};
void CreateCustomOp(Program& p, const std::shared_ptr<ngraph::Node>& op, CustomLayerPtr customLayer) {
void CreateCustomOp(ProgramBuilder& p, const std::shared_ptr<ov::Node>& op, CustomLayerPtr customLayer) {
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -141,7 +140,7 @@ void CreateCustomOp(Program& p, const std::shared_ptr<ngraph::Node>& op, CustomL
if (param.portIndex < static_cast<int>(inputs.size()) && reordered_inputs[param.portIndex].pid.empty()) {
// todo: add support for multiple reorders of the same input? (read as bfyx for one arg and yxfb for another)
if (param.format != cldnn::format::any) {
auto reorderPrimName = inputs[param.portIndex].pid + "_" + op->get_friendly_name() + Program::m_preCustomLayerTag;
auto reorderPrimName = inputs[param.portIndex].pid + "_" + op->get_friendly_name() + ProgramBuilder::m_preCustomLayerTag;
auto preprocessPrim = cldnn::reorder(
reorderPrimName,
inputs[param.portIndex],
@ -234,7 +233,7 @@ void CreateCustomOp(Program& p, const std::shared_ptr<ngraph::Node>& op, CustomL
auto prevLayerName = genericLayerName;
if (outputLayout.format != cldnn::format::any) {
// Handle output reorder
auto reorderPrimName = genericLayerName + Program::m_postCustomLayerTag;
auto reorderPrimName = genericLayerName + ProgramBuilder::m_postCustomLayerTag;
p.add_primitive(*op, cldnn::reorder(reorderPrimName,
cldnn::input_info(genericLayerName),
cldnn::format::get_default_format(op->get_output_shape(0).size()),

12
src/plugins/intel_gpu/src/plugin/ops/depth_to_space.cpp
View File

@ -2,28 +2,28 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/depth_to_space.hpp"
#include "openvino/op/depth_to_space.hpp"
#include "intel_gpu/primitives/depth_to_space.hpp"
namespace ov {
namespace intel_gpu {
static cldnn::depth_to_space_mode GetDepthMode(ngraph::op::v0::DepthToSpace::DepthToSpaceMode mode) {
static cldnn::depth_to_space_mode GetDepthMode(ov::op::v0::DepthToSpace::DepthToSpaceMode mode) {
switch (mode) {
case ngraph::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST:
case ov::op::v0::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST:
return cldnn::depth_to_space_mode::blocks_first;
case ngraph::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST:
case ov::op::v0::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST:
return cldnn::depth_to_space_mode::depth_first;
default: OPENVINO_THROW("Unsupported DepthToSpaceMode value: ", static_cast<int>(mode));
}
return cldnn::depth_to_space_mode::blocks_first;
}
static void CreateDepthToSpaceOp(Program& p, const std::shared_ptr<ngraph::op::v0::DepthToSpace>& op) {
static void CreateDepthToSpaceOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::DepthToSpace>& op) {
validate_inputs_count(op, {1});
auto inputPrimitives = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

12
src/plugins/intel_gpu/src/plugin/ops/detection_output.cpp
View File

@ -2,10 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/detection_output.hpp"
#include "openvino/op/detection_output.hpp"
#include "intel_gpu/primitives/detection_output.hpp"
@ -27,8 +27,8 @@ static cldnn::prior_box_code_type PriorBoxCodeFromString(const std::string& str)
return cldnn::prior_box_code_type::corner;
}
static void CreateCommonDetectionOutputOp(Program& p,
const std::shared_ptr<ngraph::Node>& op,
static void CreateCommonDetectionOutputOp(ProgramBuilder& p,
const std::shared_ptr<ov::Node>& op,
const ov::op::util::DetectionOutputBase::AttributesBase& attrs,
int num_classes) {
auto inputs = p.GetInputInfo(op);
@ -80,14 +80,14 @@ static void CreateCommonDetectionOutputOp(Program& p,
p.add_primitive(*op, detectionPrim);
}
static void CreateDetectionOutputOp(Program& p, const std::shared_ptr<ngraph::op::v0::DetectionOutput>& op) {
static void CreateDetectionOutputOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::DetectionOutput>& op) {
validate_inputs_count(op, {3});
auto attrs = op->get_attrs();
CreateCommonDetectionOutputOp(p, op, attrs, attrs.num_classes);
}
static void CreateDetectionOutputOp(Program& p, const std::shared_ptr<ngraph::op::v8::DetectionOutput>& op) {
static void CreateDetectionOutputOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::DetectionOutput>& op) {
validate_inputs_count(op, {3});
CreateCommonDetectionOutputOp(p, op, op->get_attrs(), -1);

27
src/plugins/intel_gpu/src/plugin/ops/dft.cpp
View File

@ -2,19 +2,24 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/constant.hpp"
#include "openvino/op/dft.hpp"
#include "openvino/op/idft.hpp"
#include "openvino/op/rdft.hpp"
#include "openvino/op/irdft.hpp"
#include "openvino/core/validation_util.hpp"
#include <intel_gpu/plugin/common_utils.hpp>
#include <intel_gpu/plugin/program.hpp>
#include "intel_gpu/plugin/program_builder.hpp"
#include <intel_gpu/primitives/dft.hpp>
#include <ngraph/op/constant.hpp>
#include <ngraph/op/dft.hpp>
namespace ov {
namespace intel_gpu {
namespace {
void createDft(Program& p,
const std::shared_ptr<ngraph::Node>& op,
void createDft(ProgramBuilder& p,
const std::shared_ptr<ov::Node>& op,
cldnn::dft_direction direction,
cldnn::dft_mode mode) {
validate_inputs_count(op, {2, 3});
@ -24,7 +29,7 @@ void createDft(Program& p,
const auto& friendly_name = op->get_friendly_name();
const auto& out_shape = op->get_output_shape(0);
auto axes_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(1));
auto axes_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
OPENVINO_ASSERT(axes_constant != nullptr, "[GPU] Unsupported parameter nodes type in ", friendly_name, " (", op->get_type_name(), ")");
auto axes = axes_constant->cast_vector<int64_t>();
uint8_t axis_correction = static_cast<uint8_t>(op->get_input_shape(0).size());
@ -37,7 +42,7 @@ void createDft(Program& p,
std::vector<int64_t> signal_size;
if (op->get_input_size() == 3) {
auto signal_size_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(2));
auto signal_size_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2));
OPENVINO_ASSERT(signal_size_constant != nullptr, "[GPU] Unsupported parameter nodes type in ", friendly_name, " (", op->get_type_name(), ")");
signal_size = signal_size_constant->cast_vector<int64_t>();
}
@ -47,19 +52,19 @@ void createDft(Program& p,
p.add_primitive(*op, prim);
}
void CreateDFTOp(Program& p, const std::shared_ptr<ngraph::op::v7::DFT>& op) {
void CreateDFTOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v7::DFT>& op) {
createDft(p, op, cldnn::dft_direction::forward, cldnn::dft_mode::complex);
}
void CreateIDFTOp(Program& p, const std::shared_ptr<ngraph::op::v7::IDFT>& op) {
void CreateIDFTOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v7::IDFT>& op) {
createDft(p, op, cldnn::dft_direction::inverse, cldnn::dft_mode::complex);
}
void CreateRDFTOp(Program& p, const std::shared_ptr<ngraph::op::v9::RDFT>& op) {
void CreateRDFTOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v9::RDFT>& op) {
createDft(p, op, cldnn::dft_direction::forward, cldnn::dft_mode::real);
}
void CreateIRDFTOp(Program& p, const std::shared_ptr<ngraph::op::v9::IRDFT>& op) {
void CreateIRDFTOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v9::IRDFT>& op) {
createDft(p, op, cldnn::dft_direction::inverse, cldnn::dft_mode::real);
}

90
src/plugins/intel_gpu/src/plugin/ops/eltwise.cpp
View File

@ -2,28 +2,28 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "transformations/utils/utils.hpp"
#include "ngraph/op/add.hpp"
#include "ngraph/op/multiply.hpp"
#include "ngraph/op/maximum.hpp"
#include "ngraph/op/minimum.hpp"
#include "ngraph/op/subtract.hpp"
#include "ngraph/op/divide.hpp"
#include "ngraph/op/squared_difference.hpp"
#include "ngraph/op/equal.hpp"
#include "ngraph/op/not_equal.hpp"
#include "ngraph/op/less.hpp"
#include "ngraph/op/less_eq.hpp"
#include "ngraph/op/greater.hpp"
#include "ngraph/op/greater_eq.hpp"
#include "ngraph/op/and.hpp"
#include "ngraph/op/or.hpp"
#include "ngraph/op/xor.hpp"
#include "ngraph/op/power.hpp"
#include "ngraph/op/floor_mod.hpp"
#include "openvino/op/add.hpp"
#include "openvino/op/multiply.hpp"
#include "openvino/op/maximum.hpp"
#include "openvino/op/minimum.hpp"
#include "openvino/op/subtract.hpp"
#include "openvino/op/divide.hpp"
#include "openvino/op/squared_difference.hpp"
#include "openvino/op/equal.hpp"
#include "openvino/op/not_equal.hpp"
#include "openvino/op/less.hpp"
#include "openvino/op/less_eq.hpp"
#include "openvino/op/greater.hpp"
#include "openvino/op/greater_eq.hpp"
#include "openvino/op/logical_and.hpp"
#include "openvino/op/logical_or.hpp"
#include "openvino/op/xor.hpp"
#include "openvino/op/power.hpp"
#include "openvino/op/floor_mod.hpp"
#include "intel_gpu/primitives/activation.hpp"
#include "intel_gpu/primitives/eltwise.hpp"
@ -33,8 +33,8 @@
namespace ov {
namespace intel_gpu {
void CreateElementwiseOp(Program& p,
const std::shared_ptr<ngraph::Node>& op,
void CreateElementwiseOp(ProgramBuilder& p,
const std::shared_ptr<ov::Node>& op,
cldnn::eltwise_mode mode,
std::vector<float> coefficients,
bool pythondiv) {
@ -91,75 +91,75 @@ void CreateElementwiseOp(Program& p,
p.add_primitive(*op, eltwisePrim);
}
static void CreateAddOp(Program& p, const std::shared_ptr<ngraph::op::v1::Add>& op) {
static void CreateAddOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Add>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::sum);
}
static void CreateMultiplyOp(Program& p, const std::shared_ptr<ngraph::op::v1::Multiply>& op) {
static void CreateMultiplyOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Multiply>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::prod);
}
static void CreateMaximumOp(Program& p, const std::shared_ptr<ngraph::op::v1::Maximum>& op) {
static void CreateMaximumOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Maximum>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::max);
}
static void CreateMinimumOp(Program& p, const std::shared_ptr<ngraph::op::v1::Minimum>& op) {
static void CreateMinimumOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Minimum>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::min);
}
static void CreateSubtractOp(Program& p, const std::shared_ptr<ngraph::op::v1::Subtract>& op) {
static void CreateSubtractOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Subtract>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::sub);
}
static void CreateDivideOp(Program& p, const std::shared_ptr<ngraph::op::v1::Divide>& op) {
static void CreateDivideOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Divide>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::div, {}, op->is_pythondiv());
}
static void CreateSquaredDifferenceOp(Program& p, const std::shared_ptr<ngraph::op::v0::SquaredDifference>& op) {
static void CreateSquaredDifferenceOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::SquaredDifference>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::squared_diff);
}
static void CreateEqualOp(Program& p, const std::shared_ptr<ngraph::op::v1::Equal>& op) {
static void CreateEqualOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Equal>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::eq);
}
static void CreateNotEqualOp(Program& p, const std::shared_ptr<ngraph::op::v1::NotEqual>& op) {
static void CreateNotEqualOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::NotEqual>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::ne);
}
static void CreateLessOp(Program& p, const std::shared_ptr<ngraph::op::v1::Less>& op) {
static void CreateLessOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Less>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::lt);
}
static void CreateLessEqualOp(Program& p, const std::shared_ptr<ngraph::op::v1::LessEqual>& op) {
static void CreateLessEqualOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::LessEqual>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::le);
}
static void CreateGreaterOp(Program& p, const std::shared_ptr<ngraph::op::v1::Greater>& op) {
static void CreateGreaterOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Greater>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::gt);
}
static void CreateGreaterEqualOp(Program& p, const std::shared_ptr<ngraph::op::v1::GreaterEqual>& op) {
static void CreateGreaterEqualOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::GreaterEqual>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::ge);
}
static void CreateLogicalAndOp(Program& p, const std::shared_ptr<ngraph::op::v1::LogicalAnd>& op) {
static void CreateLogicalAndOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::LogicalAnd>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::logic_and);
}
static void CreateLogicalOrOp(Program& p, const std::shared_ptr<ngraph::op::v1::LogicalOr>& op) {
static void CreateLogicalOrOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::LogicalOr>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::logic_or);
}
static void CreateLogicalXorOp(Program& p, const std::shared_ptr<ngraph::op::v1::LogicalXor>& op) {
static void CreateLogicalXorOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::LogicalXor>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::logic_xor);
}
static void CreatePowerOp(Program& p, const std::shared_ptr<ngraph::op::v1::Power>& op) {
static void CreatePowerOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Power>& op) {
validate_inputs_count(op, {2});
auto power_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(1));
auto power_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
if (power_node) {
if (ngraph::shape_size(power_node->get_output_shape(0)) == 1) {
if (ov::shape_size(power_node->get_output_shape(0)) == 1) {
float pow;
if (!ov::op::util::get_single_value(power_node, pow))
OPENVINO_THROW("Invalid parameter size in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
@ -170,26 +170,26 @@ static void CreatePowerOp(Program& p, const std::shared_ptr<ngraph::op::v1::Powe
CreateElementwiseOp(p, op, cldnn::eltwise_mode::pow);
}
static void CreateFloorModOp(Program& p, const std::shared_ptr<ngraph::op::v1::FloorMod>& op) {
static void CreateFloorModOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::FloorMod>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::floor_mod);
}
static void CreateModOp(Program& p, const std::shared_ptr<ngraph::op::v1::Mod>& op) {
static void CreateModOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Mod>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::mod);
}
static void CreateIsFiniteOp(Program& p, const std::shared_ptr<ngraph::op::v10::IsFinite>& op) {
static void CreateIsFiniteOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v10::IsFinite>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::is_finite);
}
static void CreateIsInfOp(Program& p, const std::shared_ptr<ngraph::op::v10::IsInf>& op) {
static void CreateIsInfOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v10::IsInf>& op) {
const auto& attributes = op->get_attributes();
const auto detect_negative = static_cast<float>(attributes.detect_negative);
const auto detect_positive = static_cast<float>(attributes.detect_positive);
CreateElementwiseOp(p, op, cldnn::eltwise_mode::is_inf, {detect_negative, detect_positive});
}
static void CreateIsNaNOp(Program& p, const std::shared_ptr<ngraph::op::v10::IsNaN>& op) {
static void CreateIsNaNOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v10::IsNaN>& op) {
CreateElementwiseOp(p, op, cldnn::eltwise_mode::is_nan);
}

28
src/plugins/intel_gpu/src/plugin/ops/embedding_bag.cpp
View File

@ -2,12 +2,12 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/embedding_segments_sum.hpp"
#include "ngraph/op/embeddingbag_offsets_sum.hpp"
#include "ngraph/op/embeddingbag_packedsum.hpp"
#include "openvino/op/embedding_segments_sum.hpp"
#include "openvino/op/embeddingbag_offsets_sum.hpp"
#include "openvino/op/embeddingbag_packedsum.hpp"
#include "intel_gpu/primitives/embedding_bag.hpp"
#include "intel_gpu/primitives/reorder.hpp"
@ -17,18 +17,18 @@
namespace ov {
namespace intel_gpu {
static void CreateEmbeddingBagOffsetsSumOp(Program& p, const std::shared_ptr<ngraph::op::v3::EmbeddingBagOffsetsSum>& op) {
static void CreateEmbeddingBagOffsetsSumOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::EmbeddingBagOffsetsSum>& op) {
validate_inputs_count(op, {3, 4, 5});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
int32_t defaultIndex = -1;
if (inputs.size() > 3) {
auto index_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(3));
auto index_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(3));
OPENVINO_ASSERT(index_node != nullptr, "[GPU] Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
float val;
if (ngraph::shape_size(index_node->get_output_shape(0)) != 1 || !ov::op::util::get_single_value(index_node, val))
if (ov::shape_size(index_node->get_output_shape(0)) != 1 || !ov::op::util::get_single_value(index_node, val))
OPENVINO_THROW("Unsupported parameter size in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
defaultIndex = static_cast<int32_t>(val);
@ -43,7 +43,7 @@ static void CreateEmbeddingBagOffsetsSumOp(Program& p, const std::shared_ptr<ngr
if (((portIndex == 1) || (portIndex == 2)) && (inputDataType == cldnn::data_types::i64)) {
// GPU primitive supports only i32 data type for indices inputs,
// so we need additional reorders if they are provided as i64
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + Program::m_preProcessTag;
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + ProgramBuilder::m_preProcessTag;
auto targetFormat = cldnn::format::get_default_format(op->get_input_shape(portIndex).size());
auto preprocessPrim = cldnn::reorder(reorderPrimName,
inputs[portIndex],
@ -65,7 +65,7 @@ static void CreateEmbeddingBagOffsetsSumOp(Program& p, const std::shared_ptr<ngr
p.add_primitive(*op, embeddingBagPrim);
}
static void CreateEmbeddingBagPackedSumOp(Program& p, const std::shared_ptr<ngraph::op::v3::EmbeddingBagPackedSum>& op) {
static void CreateEmbeddingBagPackedSumOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::EmbeddingBagPackedSum>& op) {
validate_inputs_count(op, {2, 3});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -78,7 +78,7 @@ static void CreateEmbeddingBagPackedSumOp(Program& p, const std::shared_ptr<ngra
if ((portIndex == 1) && (inputDataType == cldnn::data_types::i64)) {
// GPU primitive supports only i32 data type for indices input,
// so we need additional reorder if it's provided as i64
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + Program::m_preProcessTag;
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + ProgramBuilder::m_preProcessTag;
auto targetFormat = cldnn::format::get_default_format(op->get_input_shape(portIndex).size());
auto preprocessPrim = cldnn::reorder(reorderPrimName,
inputs[portIndex],
@ -100,7 +100,7 @@ static void CreateEmbeddingBagPackedSumOp(Program& p, const std::shared_ptr<ngra
p.add_primitive(*op, embeddingBagPrim);
}
static void CreateEmbeddingSegmentsSumOp(Program& p, const std::shared_ptr<ngraph::op::v3::EmbeddingSegmentsSum>& op) {
static void CreateEmbeddingSegmentsSumOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::EmbeddingSegmentsSum>& op) {
validate_inputs_count(op, {4, 5, 6});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -110,11 +110,11 @@ static void CreateEmbeddingSegmentsSumOp(Program& p, const std::shared_ptr<ngrap
int32_t defaultIndex = -1;
// port of default_index is 4 by default, but we removed "num_segments" above, so now it's equal to 3
if (inputs.size() > 3) {
auto index_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(4));
auto index_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(4));
OPENVINO_ASSERT(index_node != nullptr, "[GPU] Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
float val;
if (ngraph::shape_size(index_node->get_output_shape(0)) != 1 || !ov::op::util::get_single_value(index_node, val))
if (ov::shape_size(index_node->get_output_shape(0)) != 1 || !ov::op::util::get_single_value(index_node, val))
OPENVINO_THROW("Unsupported parameter size in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
defaultIndex = static_cast<int32_t>(val);
@ -129,7 +129,7 @@ static void CreateEmbeddingSegmentsSumOp(Program& p, const std::shared_ptr<ngrap
if (((portIndex == 1) || (portIndex == 2)) && (inputDataType == cldnn::data_types::i64)) {
// GPU primitive supports only i32 data type for indices inputs,
// so we need additional reorders if they are provided as i64
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + Program::m_preProcessTag;
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + ProgramBuilder::m_preProcessTag;
auto targetFormat = cldnn::format::get_default_format(op->get_input_shape(portIndex).size());
auto preprocessPrim = cldnn::reorder(reorderPrimName,
inputs[portIndex],

8
src/plugins/intel_gpu/src/plugin/ops/experimental_detectron_detection_output.cpp
View File

@ -2,10 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "ngraph/op/experimental_detectron_detection_output.hpp"
#include "openvino/op/experimental_detectron_detection_output.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/primitives/experimental_detectron_detection_output.hpp"
#include "intel_gpu/primitives/mutable_data.hpp"
@ -13,8 +13,8 @@ namespace ov {
namespace intel_gpu {
static void CreateExperimentalDetectronDetectionOutputOp(
Program& p,
const std::shared_ptr<ngraph::op::v6::ExperimentalDetectronDetectionOutput>& op) {
ProgramBuilder& p,
const std::shared_ptr<ov::op::v6::ExperimentalDetectronDetectionOutput>& op) {
validate_inputs_count(op, {4});
if (op->get_output_size() != 3) {

8
src/plugins/intel_gpu/src/plugin/ops/experimental_detectron_generate_proposals_single_image.cpp
View File

@ -2,10 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/experimental_detectron_generate_proposals.hpp"
#include "openvino/op/experimental_detectron_generate_proposals.hpp"
#include "intel_gpu/primitives/mutable_data.hpp"
#include "intel_gpu/primitives/experimental_detectron_generate_proposals_single_image.hpp"
@ -14,8 +14,8 @@ namespace ov {
namespace intel_gpu {
static void CreateExperimentalDetectronGenerateProposalsSingleImageOp(
Program& p,
const std::shared_ptr<ngraph::op::v6::ExperimentalDetectronGenerateProposalsSingleImage>& op) {
ProgramBuilder& p,
const std::shared_ptr<ov::op::v6::ExperimentalDetectronGenerateProposalsSingleImage>& op) {
validate_inputs_count(op, {4});
if (op->get_output_size() != 2) {
OPENVINO_THROW("ExperimentalDetectronGenerateProposalsSingleImage requires 2 outputs");

8
src/plugins/intel_gpu/src/plugin/ops/experimental_detectron_prior_grid_generator.cpp
View File

@ -3,9 +3,9 @@
//
#include <intel_gpu/plugin/common_utils.hpp>
#include <intel_gpu/plugin/program.hpp>
#include "intel_gpu/plugin/program_builder.hpp"
#include <intel_gpu/primitives/experimental_detectron_prior_grid_generator.hpp>
#include <ngraph/op/experimental_detectron_prior_grid_generator.hpp>
#include "openvino/op/experimental_detectron_prior_grid_generator.hpp"
namespace ov {
namespace intel_gpu {
@ -18,8 +18,8 @@ cldnn::tensor mkTensor(const ov::Shape& shape) {
}
static void CreateExperimentalDetectronPriorGridGeneratorOp(
Program& p,
const std::shared_ptr<ngraph::op::v6::ExperimentalDetectronPriorGridGenerator>& op) {
ProgramBuilder& p,
const std::shared_ptr<ov::op::v6::ExperimentalDetectronPriorGridGenerator>& op) {
validate_inputs_count(op, {3});
cldnn::tensor outTensor = mkTensor(op->get_output_shape(0));
auto outDataType = cldnn::element_type_to_data_type(op->get_output_element_type(0));

7
src/plugins/intel_gpu/src/plugin/ops/experimental_detectron_roi_feature_extractor.cpp
View File

@ -2,10 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/experimental_detectron_roi_feature.hpp"
#include "openvino/op/experimental_detectron_roi_feature.hpp"
#include "intel_gpu/primitives/mutable_data.hpp"
#include "intel_gpu/primitives/experimental_detectron_roi_feature_extractor.hpp"
@ -13,7 +13,8 @@
namespace ov {
namespace intel_gpu {
static void CreateExperimentalDetectronROIFeatureExtractorOp(Program& p, const std::shared_ptr<ngraph::op::v6::ExperimentalDetectronROIFeatureExtractor>& op) {
static void CreateExperimentalDetectronROIFeatureExtractorOp(ProgramBuilder& p,
const std::shared_ptr<ov::op::v6::ExperimentalDetectronROIFeatureExtractor>& op) {
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op) + ".out0";

8
src/plugins/intel_gpu/src/plugin/ops/experimental_detectron_topk_rois.cpp
View File

@ -2,10 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/experimental_detectron_topkrois.hpp"
#include "openvino/op/experimental_detectron_topkrois.hpp"
#include "intel_gpu/primitives/experimental_detectron_topk_rois.hpp"
#include "intel_gpu/primitives/arg_max_min.hpp"
@ -17,8 +17,8 @@ namespace {
using namespace cldnn;
void CreateExperimentalDetectronTopKROIsOp(Program &p,
const std::shared_ptr<ngraph::op::v6::ExperimentalDetectronTopKROIs> &op) {
void CreateExperimentalDetectronTopKROIsOp(ProgramBuilder &p,
const std::shared_ptr<ov::op::v6::ExperimentalDetectronTopKROIs> &op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
auto max_rois = static_cast<uint32_t>(op->get_max_rois());

14
src/plugins/intel_gpu/src/plugin/ops/extract_image_patches.cpp
View File

@ -2,28 +2,28 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/extractimagepatches.hpp"
#include "openvino/op/extractimagepatches.hpp"
#include "intel_gpu/primitives/extract_image_patches.hpp"
namespace ov {
namespace intel_gpu {
static inline std::string PadToString(ngraph::op::PadType pad) {
static inline std::string PadToString(ov::op::PadType pad) {
switch (pad) {
case ngraph::op::PadType::SAME_UPPER: return "same_upper";
case ngraph::op::PadType::SAME_LOWER: return "same_lower";
case ngraph::op::PadType::VALID: return "valid";
case ov::op::PadType::SAME_UPPER: return "same_upper";
case ov::op::PadType::SAME_LOWER: return "same_lower";
case ov::op::PadType::VALID: return "valid";
default: OPENVINO_THROW("Unsupported pad type in ExtractImagePatches primitive ", pad);
}
return "";
}
static void CreateExtractImagePatchesOp(Program& p, const std::shared_ptr<ngraph::op::v3::ExtractImagePatches>& op) {
static void CreateExtractImagePatchesOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::ExtractImagePatches>& op) {
validate_inputs_count(op, {1});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

13
src/plugins/intel_gpu/src/plugin/ops/eye.cpp
View File

@ -2,12 +2,13 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "ngraph/op/eye.hpp"
#include "openvino/op/eye.hpp"
#include "openvino/op/constant.hpp"
#include <memory>
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/primitives/eye.hpp"
#include "intel_gpu/runtime/layout.hpp"
@ -16,19 +17,19 @@ namespace intel_gpu {
namespace {
static void CreateEyeOp(Program& p, const std::shared_ptr<ngraph::op::v9::Eye>& op) {
static void CreateEyeOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v9::Eye>& op) {
validate_inputs_count(op, {3, 4});
const InferenceEngine::SizeVector& output_shapes = op->get_output_shape(0);
const ov::Shape& output_shapes = op->get_output_shape(0);
auto os_sz = output_shapes.size();
OPENVINO_ASSERT(2 <= os_sz && os_sz <= 5, "Incorrect output size: ", os_sz, " in op ", op->get_friendly_name());
size_t dim_size = std::max(os_sz, static_cast<size_t>(4));
InferenceEngine::SizeVector dims(dim_size, 1);
ov::Shape dims(dim_size, 1);
for (size_t i = dim_size, j = os_sz; i > 0 && j > 0; --i, --j) {
dims[i - 1] = output_shapes[j - 1];
}
const ngraph::op::v0::Constant* constant = dynamic_cast<const ngraph::op::v0::Constant*>(op->get_input_node_ptr(2));
const ov::op::v0::Constant* constant = dynamic_cast<ov::op::v0::Constant*>(op->get_input_node_ptr(2));
OPENVINO_ASSERT(constant != nullptr, "Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
int32_t shift{};

6
src/plugins/intel_gpu/src/plugin/ops/fake_quantize.cpp
View File

@ -2,17 +2,17 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/fake_quantize.hpp"
#include "openvino/op/fake_quantize.hpp"
#include "intel_gpu/primitives/quantize.hpp"
namespace ov {
namespace intel_gpu {
static void CreateFakeQuantizeOp(Program& p, const std::shared_ptr<ngraph::op::v0::FakeQuantize>& op) {
static void CreateFakeQuantizeOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::FakeQuantize>& op) {
validate_inputs_count(op, {5});
std::string layerName = layer_type_name_ID(op);
auto inputs = p.GetInputInfo(op);

8
src/plugins/intel_gpu/src/plugin/ops/gather tree.cpp
View File

@ -2,10 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/gather_tree.hpp"
#include "openvino/op/gather_tree.hpp"
#include "intel_gpu/primitives/gather_tree.hpp"
#include "intel_gpu/primitives/reorder.hpp"
@ -13,7 +13,7 @@
namespace ov {
namespace intel_gpu {
static void CreateGatherTreeOp(Program& p, const std::shared_ptr<ngraph::op::v1::GatherTree>& op) {
static void CreateGatherTreeOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::GatherTree>& op) {
validate_inputs_count(op, {4});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -26,7 +26,7 @@ static void CreateGatherTreeOp(Program& p, const std::shared_ptr<ngraph::op::v1:
if (inputDataType == cldnn::data_types::i64) {
// GPU primitive does not support i64 inputs,
// so we need additional reorders to convert them to i32
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + Program::m_preProcessTag;
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + ProgramBuilder::m_preProcessTag;
auto targetFormat = cldnn::format::get_default_format(op->get_input_shape(portIndex).size());
auto preprocessPrim = cldnn::reorder(reorderPrimName,
inputs[portIndex],

25
src/plugins/intel_gpu/src/plugin/ops/gather.cpp
View File

@ -2,23 +2,22 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "transformations/utils/utils.hpp"
#include "ngraph/op/gather.hpp"
#include "openvino/op/gather.hpp"
#include "intel_gpu/primitives/gather.hpp"
#include "intel_gpu/primitives/reorder.hpp"
#include "intel_gpu/primitives/reshape.hpp"
#include "intel_gpu/primitives/crop.hpp"
using namespace InferenceEngine;
namespace ov {
namespace intel_gpu {
template <typename T>
void CreateGatherOpBase(Program& p, const std::shared_ptr<T>& op, const int64_t batch_dim = 0, bool support_neg_ind = false) {
void CreateGatherOpBase(ProgramBuilder& p, const std::shared_ptr<T>& op, const int64_t batch_dim = 0, bool support_neg_ind = false) {
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -32,7 +31,7 @@ void CreateGatherOpBase(Program& p, const std::shared_ptr<T>& op, const int64_t
if (inputDataType == cldnn::data_types::i64) {
// GPU primitive does not support i64 inputs,
// so we need additional reorders to convert them to i32
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + Program::m_preProcessTag;
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + ProgramBuilder::m_preProcessTag;
auto targetFormat = cldnn::format::get_default_format(op->get_input_partial_shape(portIndex).size());
auto preprocessPrim = cldnn::reorder(reorderPrimName,
inputs[portIndex],
@ -100,13 +99,13 @@ void CreateGatherOpBase(Program& p, const std::shared_ptr<T>& op, const int64_t
// Get indices info to calculate offset
const auto& indices_node = indices.get_node_shared_ptr();
auto indices_constant = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(indices_node);
auto indices_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(indices_node);
float result = 0.f;
OPENVINO_ASSERT(ov::op::util::get_single_value(indices_constant, result),
"Unsupported indices node in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
// Set tensors for crop shape and offset
InferenceEngine::SizeVector start_offset(input_shape.size());
ov::Shape start_offset(input_shape.size());
start_offset[0] = static_cast<size_t>(result);
auto offsetTensor = tensor_from_dims(start_offset, 0);
auto outTensor = tensor_from_dims(out_shape, 1);
@ -148,23 +147,23 @@ void CreateGatherOpBase(Program& p, const std::shared_ptr<T>& op, const int64_t
}
}
static void CreateGatherOp(Program& p, const std::shared_ptr<ngraph::op::v1::Gather>& op) {
static void CreateGatherOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Gather>& op) {
validate_inputs_count(op, {2, 3});
CreateGatherOpBase<ngraph::op::v1::Gather>(p, op);
CreateGatherOpBase<ov::op::v1::Gather>(p, op);
}
REGISTER_FACTORY_IMPL(v1, Gather);
static void CreateGatherOp(Program& p, const std::shared_ptr<ngraph::op::v7::Gather>& op) {
static void CreateGatherOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v7::Gather>& op) {
validate_inputs_count(op, {2, 3, 4});
CreateGatherOpBase<ngraph::op::v7::Gather>(p, op, op->get_batch_dims());
CreateGatherOpBase<ov::op::v7::Gather>(p, op, op->get_batch_dims());
}
REGISTER_FACTORY_IMPL(v7, Gather);
static void CreateGatherOp(Program& p, const std::shared_ptr<ngraph::op::v8::Gather>& op) {
static void CreateGatherOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::Gather>& op) {
validate_inputs_count(op, {2, 3, 4});
CreateGatherOpBase<ngraph::op::v8::Gather>(p, op, op->get_batch_dims(), true);
CreateGatherOpBase<ov::op::v8::Gather>(p, op, op->get_batch_dims(), true);
}
REGISTER_FACTORY_IMPL(v8, Gather);

8
src/plugins/intel_gpu/src/plugin/ops/gather_elements.cpp
View File

@ -2,18 +2,18 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/gather_elements.hpp"
#include "ngraph/op/constant.hpp"
#include "openvino/op/gather_elements.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/primitives/gather_elements.hpp"
namespace ov {
namespace intel_gpu {
static void CreateGatherElementsOp(Program& p, const std::shared_ptr<ngraph::op::v6::GatherElements>& op) {
static void CreateGatherElementsOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v6::GatherElements>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

10
src/plugins/intel_gpu/src/plugin/ops/gather_nd.cpp
View File

@ -2,18 +2,18 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/gather_nd.hpp"
#include "ngraph/op/constant.hpp"
#include "openvino/op/gather_nd.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/primitives/gather_nd.hpp"
namespace ov {
namespace intel_gpu {
static void CreateGatherNDOp(Program& p, const std::shared_ptr<ngraph::op::v5::GatherND>& op) {
static void CreateGatherNDOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v5::GatherND>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -34,7 +34,7 @@ static void CreateGatherNDOp(Program& p, const std::shared_ptr<ngraph::op::v5::G
REGISTER_FACTORY_IMPL(v5, GatherND);
static void CreateGatherNDOp(Program& p, const std::shared_ptr<ngraph::op::v8::GatherND>& op) {
static void CreateGatherNDOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::GatherND>& op) {
validate_inputs_count(op, { 2 });
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

4
src/plugins/intel_gpu/src/plugin/ops/generate_proposals.cpp
View File

@ -7,14 +7,14 @@
#include <ov_ops/generate_proposals_ie_internal.hpp>
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/primitives/mutable_data.hpp"
namespace ov {
namespace intel_gpu {
static void CreateGenerateProposalsIEInternalOp(
Program& p,
ProgramBuilder& p,
const std::shared_ptr<ov::op::internal::GenerateProposalsIEInternal>& op) {
validate_inputs_count(op, {4});
if (op->get_output_size() != 3) {

6
src/plugins/intel_gpu/src/plugin/ops/grid_sample.cpp
View File

@ -4,15 +4,15 @@
#include "intel_gpu/primitives/grid_sample.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "ngraph/op/grid_sample.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "openvino/op/grid_sample.hpp"
namespace ov {
namespace intel_gpu {
namespace {
void CreateGridSampleOp(Program& p, const std::shared_ptr<ngraph::op::v9::GridSample>& op) {
void CreateGridSampleOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v9::GridSample>& op) {
validate_inputs_count(op, {2});
const cldnn::grid_sample grid_sample_prim(layer_type_name_ID(op), p.GetInputInfo(op), op->get_attributes());

6
src/plugins/intel_gpu/src/plugin/ops/grn.cpp
View File

@ -2,17 +2,17 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/grn.hpp"
#include "openvino/op/grn.hpp"
#include "intel_gpu/primitives/grn.hpp"
namespace ov {
namespace intel_gpu {
static void CreateGRNOp(Program& p, const std::shared_ptr<ngraph::op::v0::GRN>& op) {
static void CreateGRNOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::GRN>& op) {
validate_inputs_count(op, {1});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

27
src/plugins/intel_gpu/src/plugin/ops/interpolate.cpp
View File

@ -2,13 +2,12 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "openvino/core/validation_util.hpp"
#include "openvino/op/interpolate.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "caseless.hpp"
#include "ngraph/op/interpolate.hpp"
#include "ngraph/op/constant.hpp"
#include "intel_gpu/primitives/resample.hpp"
#include <optional>
@ -19,7 +18,7 @@ static std::vector<int64_t> ExtractAxes(const std::shared_ptr<ov::op::util::Inte
std::vector<int64_t> axes;
auto inputRank = op->get_input_partial_shape(0).size();
if (op->get_input_size() == axes_index + 1) {
auto axes_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(axes_index));
auto axes_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(axes_index));
OPENVINO_ASSERT(axes_constant, "Unsupported parameter node type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
axes = axes_constant->cast_vector<int64_t>();
@ -70,7 +69,7 @@ static void ValidateAxesAndThrowIfError(const std::shared_ptr<ov::op::util::Inte
}
}
static void CreateInterpolateOp(Program& p, const std::shared_ptr<ngraph::op::v4::Interpolate>& op) {
static void CreateInterpolateOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v4::Interpolate>& op) {
validate_inputs_count(op, {3, 4});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -81,10 +80,10 @@ static void CreateInterpolateOp(Program& p, const std::shared_ptr<ngraph::op::v4
auto attrs = op->get_attrs();
auto sizes_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(SIZES_INDEX));
auto sizes_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(SIZES_INDEX));
std::vector<int64_t> sizes = sizes_constant ? sizes_constant->cast_vector<int64_t>() : std::vector<int64_t>{};
auto scales_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(SCALES_INDEX));
auto scales_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(SCALES_INDEX));
std::vector<float> scales = scales_constant ? scales_constant->cast_vector<float>() : std::vector<float>{};
std::vector<int64_t> axes = ExtractAxes(op, AXES_INDEX);
@ -93,7 +92,7 @@ static void CreateInterpolateOp(Program& p, const std::shared_ptr<ngraph::op::v4
OPENVINO_ASSERT(axes.size() == scales.size(), "[GPU] Incorrect axes and scales values for Interpolate operation with id ", op->get_friendly_name());
}
// TODO shouldn't be all this checking done in ngraph::op::v4::Interpolate?
// TODO shouldn't be all this checking done in ov::op::v4::Interpolate?
ValidateAxesAndThrowIfError(op, axes);
std::shared_ptr<cldnn::resample> resamplePrim = nullptr;
@ -148,7 +147,7 @@ static void CreateInterpolateOp(Program& p, const std::shared_ptr<ngraph::op::v4
p.add_primitive(*op, resamplePrim);
}
static void CreateInterpolateOp(Program& p, const std::shared_ptr<ngraph::op::v11::Interpolate>& op) {
static void CreateInterpolateOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v11::Interpolate>& op) {
validate_inputs_count(op, {2, 3});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -161,7 +160,7 @@ static void CreateInterpolateOp(Program& p, const std::shared_ptr<ngraph::op::v1
auto attrs = op->get_attrs();
auto scales_or_sizes_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(eScalesOrSizesIndex));
auto scales_or_sizes_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(eScalesOrSizesIndex));
std::vector<float> scales = scales_or_sizes_constant && attrs.shape_calculation_mode == ov::op::v11::Interpolate::ShapeCalcMode::SCALES ?
scales_or_sizes_constant->cast_vector<float>() : std::vector<float>{};
std::vector<int64_t> sizes = scales_or_sizes_constant && attrs.shape_calculation_mode == ov::op::v11::Interpolate::ShapeCalcMode::SIZES ?
@ -173,7 +172,7 @@ static void CreateInterpolateOp(Program& p, const std::shared_ptr<ngraph::op::v1
OPENVINO_ASSERT(axes.size() == scales.size(), "[GPU] Incorrect axes and scales values for Interpolate operation with id ", op->get_friendly_name());
}
// TODO shouldn't be all this checking done in ngraph::op::v4::Interpolate?
// TODO shouldn't be all this checking done in ov::op::v4::Interpolate?
ValidateAxesAndThrowIfError(op, axes);
std::shared_ptr<cldnn::resample> resamplePrim = nullptr;

29
src/plugins/intel_gpu/src/plugin/ops/loop.cpp
View File

@ -1,17 +1,14 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/plugin/plugin.hpp"
#include <cpp/ie_cnn_network.h>
#include "ngraph/op/loop.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/util/sub_graph_base.hpp"
#include "openvino/op/loop.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/util/sub_graph_base.hpp"
#include "transformations/utils/utils.hpp"
#include "ie_ngraph_utils.hpp"
#include "intel_gpu/primitives/loop.hpp"
#include "intel_gpu/primitives/mutable_data.hpp"
@ -19,23 +16,25 @@
#include "intel_gpu/primitives/reorder.hpp"
#include "intel_gpu/graph/topology.hpp"
#include "ie_ngraph_utils.hpp"
#include <vector>
#include <algorithm>
using Loop = ngraph::op::v5::Loop;
using Loop = ov::op::v5::Loop;
namespace ov {
namespace intel_gpu {
template<class DATA_TYPE>
static DATA_TYPE CreateScalarData(Program &p, const cldnn::primitive_id& id, int64_t num) {
static DATA_TYPE CreateScalarData(ProgramBuilder &p, const cldnn::primitive_id& id, int64_t num) {
auto mem = p.get_engine().allocate_memory({ cldnn::data_types::i64, cldnn::format::bfyx, { 1, 1, 1, 1 } });
cldnn::mem_lock<int64_t> ptr{mem, p.get_engine().get_service_stream()};
*ptr.begin() = num;
return {id, mem};
}
static cldnn::mutable_data CreateAdditionalOutputData(Program &p, const std::shared_ptr<ngraph::Node>& op,
static cldnn::mutable_data CreateAdditionalOutputData(ProgramBuilder &p, const std::shared_ptr<ov::Node>& op,
const cldnn::primitive_id& id, const cldnn::primitive_id& input,
const int32_t output_idx) {
const auto precision = cldnn::element_type_to_data_type(op->get_output_element_type(output_idx));
@ -47,7 +46,7 @@ static cldnn::mutable_data CreateAdditionalOutputData(Program &p, const std::sha
return md;
}
static void CreateLoopOp(Program& p, const std::shared_ptr<Loop>& op) {
static void CreateLoopOp(ProgramBuilder& p, const std::shared_ptr<Loop>& op) {
const std::string layerName = layer_type_name_ID(op);
auto inputs = p.GetInputInfo(op);
const auto& loop_input_descs = op->get_input_descriptions();
@ -58,7 +57,6 @@ static void CreateLoopOp(Program& p, const std::shared_ptr<Loop>& op) {
InferenceEngine::CNNNetwork body_network(op->get_function());
auto networkInputs = body_network.getInputsInfo();
auto networkOutputs = body_network.getOutputsInfo();
// Set special body ports: current_iteration input , execution condition output
auto special_body_ports = op->get_special_body_ports();
@ -82,7 +80,7 @@ static void CreateLoopOp(Program& p, const std::shared_ptr<Loop>& op) {
}
// get body topology from ngraph function
Program body_program(body_network, p.get_engine(), p.get_config(), true);
ProgramBuilder body_program(body_network, p.get_engine(), p.get_config(), true);
auto body_topology = *body_program.GetTopology();
// setup input_primitive_maps/ output_primitive_maps and back_edges
@ -118,11 +116,10 @@ static void CreateLoopOp(Program& p, const std::shared_ptr<Loop>& op) {
cldnn::primitive_id from_id = layer_type_name_ID(from);
// reset output data type because the data types of the outputs of the
// body topology are always FP32 regardless of ngraph data type
// body topology are always FP32 regardless of element type
{
const auto from_prim = body_topology.at(from_id);
const auto& to_ngraph_type = to->get_element_type();
const auto to_cldnn_type = cldnn::element_type_to_data_type(to_ngraph_type);
const auto to_cldnn_type = cldnn::element_type_to_data_type(to->get_element_type());
from_prim->output_data_types = {to_cldnn_type};
}
back_edges.emplace_back(from_id, to_id);

10
src/plugins/intel_gpu/src/plugin/ops/lrn.cpp
View File

@ -2,11 +2,11 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/lrn.hpp"
#include "ngraph/op/constant.hpp"
#include "openvino/op/lrn.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/primitives/lrn.hpp"
@ -21,12 +21,12 @@ static cldnn::lrn_norm_region GetNormRegion(std::vector<int64_t> axis_value) {
}
}
static void CreateLRNOp(Program& p, const std::shared_ptr<ngraph::op::v0::LRN>& op) {
static void CreateLRNOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::LRN>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
auto axis_const = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(1));
auto axis_const = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
OPENVINO_ASSERT(axis_const != nullptr, "[GPU] Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
auto axis_value = axis_const->cast_vector<int64_t>();
auto localSize = static_cast<uint32_t>(op->get_nsize());

26
src/plugins/intel_gpu/src/plugin/ops/matmul.cpp
View File

@ -4,12 +4,12 @@
#include <array>
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/matmul.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/fake_quantize.hpp"
#include "openvino/op/matmul.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/fake_quantize.hpp"
#include "intel_gpu/primitives/gemm.hpp"
#include "intel_gpu/primitives/fully_connected.hpp"
@ -29,7 +29,7 @@ namespace intel_gpu {
static std::tuple<bool, PartialShape, PartialShape> get_aligned_shapes(const PartialShape& shape_a,
const PartialShape& shape_b,
const std::shared_ptr<ngraph::op::v0::MatMul>& matmul) {
const std::shared_ptr<ov::op::v0::MatMul>& matmul) {
PartialShape shape_a_aligned(shape_a), shape_b_aligned(shape_b);
auto rank_a = shape_a_aligned.rank().get_length();
auto rank_b = shape_b_aligned.rank().get_length();
@ -71,7 +71,7 @@ static std::tuple<bool, PartialShape, PartialShape> get_aligned_shapes(const Par
return {true, shape_a_aligned, shape_b_aligned};
}
static void CreateMatMulOp(Program& p, const std::shared_ptr<ngraph::op::v0::MatMul>& op) {
static void CreateMatMulOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::MatMul>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -172,12 +172,12 @@ static void CreateMatMulOp(Program& p, const std::shared_ptr<ngraph::op::v0::Mat
auto transA = op->get_transpose_a();
auto transB = op->get_transpose_b();
std::array<ngraph::PartialShape, 2> inputShapes{
std::array<ov::PartialShape, 2> inputShapes{
op->get_input_partial_shape(0),
op->get_input_partial_shape(1)
};
auto canTransposeInputs = [&] (const std::array<ngraph::PartialShape, 2>& shapes, bool transA, bool transB, ov::element::Type type) -> bool {
auto canTransposeInputs = [&] (const std::array<ov::PartialShape, 2>& shapes, bool transA, bool transB, ov::element::Type type) -> bool {
if (!transA && !transB)
return false;
@ -188,17 +188,17 @@ static void CreateMatMulOp(Program& p, const std::shared_ptr<ngraph::op::v0::Mat
// don't transpose inputs if they're aligned to 16
bool inputsAligned = std::all_of(shapes[0].rbegin(), shapes[0].rbegin() + 2,
[] (const ngraph::Dimension& dim) { return dim.is_static() && dim.get_length() % 16 == 0; }) &&
[] (const ov::Dimension& dim) { return dim.is_static() && dim.get_length() % 16 == 0; }) &&
std::all_of(shapes[1].rbegin(), shapes[1].rbegin() + 2,
[] (const ngraph::Dimension& dim) { return dim.is_static() && dim.get_length() % 16 == 0; });
[] (const ov::Dimension& dim) { return dim.is_static() && dim.get_length() % 16 == 0; });
if (inputsAligned)
return false;
// Heuristic condition for permute and tiled_opt kernel perform better than ref kernel.
bool in0_large = std::all_of(shapes[0].rbegin(), shapes[0].rbegin() + 2,
[] (const ngraph::Dimension& dim) { return dim.is_static() && dim.get_length() >= 64; });
[] (const ov::Dimension& dim) { return dim.is_static() && dim.get_length() >= 64; });
bool in1_large = std::all_of(shapes[1].rbegin(), shapes[1].rbegin() + 2,
[] (const ngraph::Dimension& dim) { return dim.is_static() && dim.get_length() >= 64; });
[] (const ov::Dimension& dim) { return dim.is_static() && dim.get_length() >= 64; });
// Optimized for clDNN
auto is_u8_i8 = (type == ov::element::Type_t::i8 || type == ov::element::Type_t::u8);
bool in0_very_large = tensor_from_dims(shapes[0].to_shape()).count() > 100000;
@ -208,7 +208,7 @@ static void CreateMatMulOp(Program& p, const std::shared_ptr<ngraph::op::v0::Mat
return (in0_large && in1_large) || needs_to_transpose_inputs;
};
auto transposeInput = [] (Program& p, const std::shared_ptr<ngraph::Node>& op, const ngraph::PartialShape& shape,
auto transposeInput = [] (ProgramBuilder& p, const std::shared_ptr<ov::Node>& op, const ov::PartialShape& shape,
const std::string& suffix, const cldnn::primitive_id& primitiveId) -> cldnn::input_info {
std::vector<uint16_t> transposeOrder(shape.size());
std::iota(transposeOrder.begin(), transposeOrder.end(), 0);

15
src/plugins/intel_gpu/src/plugin/ops/matrix_nms.cpp
View File

@ -3,18 +3,19 @@
//
#include "intel_gpu/primitives/matrix_nms.hpp"
#include <memory>
#include <openvino/opsets/opset8.hpp>
#include "openvino/op/matrix_nms.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/primitives/mutable_data.hpp"
#include "ov_ops/nms_static_shape_ie.hpp"
#include <memory>
namespace ov {
namespace op {
namespace internal {
using NmsStaticShapeIE8 = ov::op::internal::NmsStaticShapeIE<ov::opset8::MatrixNms>;
using NmsStaticShapeIE8 = ov::op::internal::NmsStaticShapeIE<ov::op::v8::MatrixNms>;
}
} // namespace op
} // namespace ov
@ -23,14 +24,14 @@ namespace ov {
namespace intel_gpu {
namespace {
void CreateNmsStaticShapeIE8Op(Program& p, const std::shared_ptr<ov::op::internal::NmsStaticShapeIE8>& op) {
void CreateNmsStaticShapeIE8Op(ProgramBuilder& p, const std::shared_ptr<ov::op::internal::NmsStaticShapeIE8>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::vector<cldnn::memory::ptr> shared_memory;
auto outputIndices = op->get_output_shape(0)[0];
cldnn::layout mutableLayoutFirst = cldnn::layout(cldnn::element_type_to_data_type(ngraph::element::i32),
cldnn::layout mutableLayoutFirst = cldnn::layout(cldnn::element_type_to_data_type(ov::element::i32),
cldnn::format::bfyx,
cldnn::tensor(static_cast<int32_t>(outputIndices), 1, 1, 1));
@ -42,7 +43,7 @@ void CreateNmsStaticShapeIE8Op(Program& p, const std::shared_ptr<ov::op::interna
inputs.push_back(cldnn::input_info(matrix_nms_mutable_id_w_first));
auto batches_num = op->get_output_shape(2)[0];
cldnn::layout mutableLayoutSecond = cldnn::layout(cldnn::element_type_to_data_type(ngraph::element::i32),
cldnn::layout mutableLayoutSecond = cldnn::layout(cldnn::element_type_to_data_type(ov::element::i32),
cldnn::format::bfyx,
cldnn::tensor(static_cast<int32_t>(batches_num), 1, 1, 1));

4
src/plugins/intel_gpu/src/plugin/ops/multiclass_nms.cpp
View File

@ -6,7 +6,7 @@
#include "ov_ops/multiclass_nms_ie_internal.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/primitives/multiclass_nms.hpp"
#include "intel_gpu/primitives/mutable_data.hpp"
@ -14,7 +14,7 @@ namespace ov {
namespace intel_gpu {
static void CreateMulticlassNmsIEInternalOp(Program& p, const std::shared_ptr<op::internal::MulticlassNmsIEInternal>& op) {
static void CreateMulticlassNmsIEInternalOp(ProgramBuilder& p, const std::shared_ptr<op::internal::MulticlassNmsIEInternal>& op) {
validate_inputs_count(op, {2, 3});
auto inputs = p.GetInputInfo(op);

20
src/plugins/intel_gpu/src/plugin/ops/mvn.cpp
View File

@ -2,12 +2,12 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "openvino/op/mvn.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/core/validation_util.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/mvn.hpp"
#include "ngraph/op/constant.hpp"
#include "intel_gpu/primitives/mvn.hpp"
#include <algorithm>
@ -15,7 +15,7 @@
namespace ov {
namespace intel_gpu {
static void CreateCommonMVNOp(Program& p, const std::shared_ptr<ngraph::Node>& op,
static void CreateCommonMVNOp(ProgramBuilder& p, const std::shared_ptr<ov::Node>& op,
std::vector<int64_t> axes, bool normalize_variance, float eps, bool eps_inside_sqrt = true) {
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -30,7 +30,7 @@ static void CreateCommonMVNOp(Program& p, const std::shared_ptr<ngraph::Node>& o
p.add_primitive(*op, mvnPrim);
}
static void CreateMVNOp(Program& p, const std::shared_ptr<ngraph::op::v0::MVN>& op) {
static void CreateMVNOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::MVN>& op) {
validate_inputs_count(op, {1});
bool across_channels = op->get_across_channels();
@ -48,10 +48,10 @@ static void CreateMVNOp(Program& p, const std::shared_ptr<ngraph::op::v0::MVN>&
CreateCommonMVNOp(p, op, axes, normalize_variance, eps);
}
static void CreateMVNOp(Program& p, const std::shared_ptr<ngraph::op::v6::MVN>& op) {
static void CreateMVNOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v6::MVN>& op) {
validate_inputs_count(op, {2});
auto inConst = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(1));
auto inConst = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
OPENVINO_ASSERT(inConst != nullptr, "[GPU] Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
std::vector<int64_t> axes = inConst->cast_vector<int64_t>();
@ -61,7 +61,7 @@ static void CreateMVNOp(Program& p, const std::shared_ptr<ngraph::op::v6::MVN>&
bool normalize_variance = op->get_normalize_variance();
float eps = op->get_eps();
bool eps_inside_sqrt = op->get_eps_mode() == ngraph::op::MVNEpsMode::INSIDE_SQRT;
bool eps_inside_sqrt = op->get_eps_mode() == ov::op::MVNEpsMode::INSIDE_SQRT;
CreateCommonMVNOp(p, op, axes, normalize_variance, eps, eps_inside_sqrt);
}

17
src/plugins/intel_gpu/src/plugin/ops/non_max_suppression.cpp
View File

@ -2,11 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/non_max_suppression.hpp"
#include <ngraph/opsets/opset3.hpp>
#include "openvino/op/non_max_suppression.hpp"
#include <ov_ops/nms_ie_internal.hpp>
#include "intel_gpu/primitives/reorder.hpp"
@ -17,7 +16,7 @@
namespace ov {
namespace intel_gpu {
static void CreateNonMaxSuppressionIEInternalOp(Program& p, const std::shared_ptr<ov::op::internal::NonMaxSuppressionIEInternal>& op) {
static void CreateNonMaxSuppressionIEInternalOp(ProgramBuilder& p, const std::shared_ptr<ov::op::internal::NonMaxSuppressionIEInternal>& op) {
validate_inputs_count(op, {2, 3, 4, 5, 6});
auto inputs = p.GetInputInfo(op);
std::vector<cldnn::input_info> reordered_inputs;
@ -28,7 +27,7 @@ static void CreateNonMaxSuppressionIEInternalOp(Program& p, const std::shared_pt
if ((portIndex == 2) && (inputDataType == cldnn::data_types::i64)) {
// GPU primitive supports only i32 data type for 'max_output_boxes_per_class' input
// so we need additional reorder if it's provided as i64
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + Program::m_preProcessTag;
auto reorderPrimName = inputs[portIndex].pid + "_" + op->get_friendly_name() + ProgramBuilder::m_preProcessTag;
auto targetFormat = cldnn::format::get_default_format(op->get_input_partial_shape(portIndex).size());
auto preprocessPrim = cldnn::reorder(reorderPrimName,
inputs[portIndex],
@ -55,8 +54,8 @@ static void CreateNonMaxSuppressionIEInternalOp(Program& p, const std::shared_pt
for (size_t i = 0; i < num_outputs; i++) {
auto type = op->get_output_element_type(i);
// GPU primitive supports only i32 as output data type
if (type == ngraph::element::i64) {
type = ngraph::element::i32;
if (type == ov::element::i64) {
type = ov::element::i32;
}
output_data_types.push_back(cldnn::element_type_to_data_type(type));
}
@ -94,8 +93,8 @@ static void CreateNonMaxSuppressionIEInternalOp(Program& p, const std::shared_pt
switch (num_outputs) {
case 3: {
auto mutable_precision_second = op->get_output_element_type(2);
if (mutable_precision_second == ngraph::element::i64) {
mutable_precision_second = ngraph::element::i32;
if (mutable_precision_second == ov::element::i64) {
mutable_precision_second = ov::element::i32;
}
cldnn::layout mutableLayoutSecond = cldnn::layout(
cldnn::element_type_to_data_type(mutable_precision_second),

6
src/plugins/intel_gpu/src/plugin/ops/non_zero.cpp
View File

@ -2,17 +2,17 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/non_zero.hpp"
#include "openvino/op/non_zero.hpp"
#include "intel_gpu/primitives/non_zero.hpp"
namespace ov {
namespace intel_gpu {
static void CreateNonZeroOp(Program& p, const std::shared_ptr<ngraph::Node>& op) {
static void CreateNonZeroOp(ProgramBuilder& p, const std::shared_ptr<ov::Node>& op) {
validate_inputs_count(op, {1});
auto inputs = p.GetInputInfo(op);
std::string layer_name = layer_type_name_ID(op);

12
src/plugins/intel_gpu/src/plugin/ops/normalize_l2.cpp
View File

@ -2,11 +2,11 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/normalize_l2.hpp"
#include "ngraph/op/constant.hpp"
#include "openvino/op/normalize_l2.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/primitives/normalize.hpp"
#include "intel_gpu/primitives/data.hpp"
@ -14,13 +14,13 @@
namespace ov {
namespace intel_gpu {
static void CreateNormalizeL2Op(Program& p, const std::shared_ptr<ngraph::op::v0::NormalizeL2>& op) {
static void CreateNormalizeL2Op(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::NormalizeL2>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
// params
auto const_axis = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(1));
auto const_axis = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
OPENVINO_ASSERT(const_axis != nullptr, "[GPU] Unsupported axis node type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
auto axis = const_axis->cast_vector<size_t>();
@ -33,7 +33,7 @@ static void CreateNormalizeL2Op(Program& p, const std::shared_ptr<ngraph::op::v0
}
// We create fake scale constant and fill it with ones to keep the same behavior as current primitive
auto scale = std::make_shared<ngraph::op::v0::Constant>(op->get_output_element_type(0), ngraph::Shape{1}, std::vector<float>{1.0});
auto scale = std::make_shared<ov::op::v0::Constant>(op->get_output_element_type(0), ov::Shape{1}, std::vector<float>{1.0});
cldnn::layout constLayout = cldnn::layout(cldnn::element_type_to_data_type(op->get_output_element_type(0)), cldnn::format::bfyx, cldnn::tensor{1});
auto mem = p.get_engine().allocate_memory(constLayout, false);
cldnn::mem_lock<int8_t> tmpPointer{mem, p.get_engine().get_service_stream()};

12
src/plugins/intel_gpu/src/plugin/ops/one_hot.cpp
View File

@ -2,26 +2,26 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "transformations/utils/utils.hpp"
#include "ngraph/op/one_hot.hpp"
#include "openvino/op/one_hot.hpp"
#include "intel_gpu/primitives/one_hot.hpp"
namespace ov {
namespace intel_gpu {
static void CreateOneHotOp(Program& p, const std::shared_ptr<ngraph::op::v1::OneHot>& op) {
static void CreateOneHotOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::OneHot>& op) {
validate_inputs_count(op, {4});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
int64_t axis = op->get_axis();
auto depth_value_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(1));
auto on_value_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(2));
auto off_value_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(3));
auto depth_value_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
auto on_value_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2));
auto off_value_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(3));
OPENVINO_ASSERT(on_value_node != nullptr || off_value_node != nullptr || depth_value_node != nullptr,
"[GPU] Unsupported on/off/depth nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");

12
src/plugins/intel_gpu/src/plugin/ops/pad.cpp
View File

@ -2,18 +2,18 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "transformations/utils/utils.hpp"
#include "ngraph/op/pad.hpp"
#include "openvino/op/pad.hpp"
#include "intel_gpu/primitives/border.hpp"
namespace ov {
namespace intel_gpu {
static void CreatePadOp(Program& p, const std::shared_ptr<ngraph::op::v1::Pad>& op) {
static void CreatePadOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Pad>& op) {
validate_inputs_count(op, {3, 4});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -21,7 +21,7 @@ static void CreatePadOp(Program& p, const std::shared_ptr<ngraph::op::v1::Pad>&
std::vector<cldnn::input_info> non_constant_inputs = {inputs[0]};
int32_t non_constant_input_mask = 0;
auto pads_begin_constant = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->input_value(1).get_node_shared_ptr());
auto pads_begin_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->input_value(1).get_node_shared_ptr());
std::vector<int64_t> pads_begin = std::vector<int64_t>{};
if (pads_begin_constant) {
pads_begin = pads_begin_constant->cast_vector<int64_t>();
@ -30,7 +30,7 @@ static void CreatePadOp(Program& p, const std::shared_ptr<ngraph::op::v1::Pad>&
non_constant_input_mask |= cldnn::border::PAD_NON_CONST_INPUT::BEGIN;
}
auto pads_end_constant = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->input_value(2).get_node_shared_ptr());
auto pads_end_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->input_value(2).get_node_shared_ptr());
std::vector<int64_t> pads_end = std::vector<int64_t>{};
if (pads_end_constant) {
pads_end = pads_end_constant->cast_vector<int64_t>();
@ -42,7 +42,7 @@ static void CreatePadOp(Program& p, const std::shared_ptr<ngraph::op::v1::Pad>&
float pad_value = 0.f;
bool is_value_const = false;
if (op->get_pad_mode() == ov::op::PadMode::CONSTANT && op->get_input_size() == 4) {
auto const_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(3));
auto const_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(3));
if (const_node) {
const bool check_value_range = false; // Allows the usage of infinity value as pad_value
OPENVINO_ASSERT(ov::op::util::get_single_value(const_node, pad_value, check_value_range),

37
src/plugins/intel_gpu/src/plugin/ops/parameter.cpp
View File

@ -2,24 +2,29 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "openvino/runtime/intel_gpu/properties.hpp"
#include "openvino/core/preprocess/input_tensor_info.hpp"
#include "openvino/op/fake_quantize.hpp"
#include "openvino/op/parameter.hpp"
#include "openvino/op/nv12_to_rgb.hpp"
#include "openvino/op/nv12_to_bgr.hpp"
#include "openvino/op/i420_to_rgb.hpp"
#include "openvino/op/i420_to_bgr.hpp"
#include "ngraph/op/parameter.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/primitives/input_layout.hpp"
#include "intel_gpu/primitives/reorder.hpp"
#include "intel_gpu/primitives/data.hpp"
#include "intel_gpu/primitives/concatenation.hpp"
#include "openvino/core/preprocess/input_tensor_info.hpp"
using namespace InferenceEngine;
namespace ov {
namespace intel_gpu {
static void CreateParameterOp(Program& p, const std::shared_ptr<ngraph::op::v0::Parameter>& op) {
static void CreateParameterOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Parameter>& op) {
auto networkInputs = p.GetNetworkInputs();
OPENVINO_ASSERT(networkInputs.find(op->get_friendly_name()) != networkInputs.end(),
"[GPU] Can't find input ", op->get_friendly_name(), " in InputsDataMap");
@ -55,7 +60,7 @@ static void CreateParameterOp(Program& p, const std::shared_ptr<ngraph::op::v0::
cldnn::layout networkInputLayout(input_pshape,
cldnn::element_type_to_data_type(op->get_output_element_type(0)),
inputFormat);
cldnn::primitive_id meanBlobID = inputName + Program::m_meanValuesTag;
cldnn::primitive_id meanBlobID = inputName + ProgramBuilder::m_meanValuesTag;
std::vector<float> meanValues;
if ((meanChannels > 0) &&
@ -132,10 +137,10 @@ static void CreateParameterOp(Program& p, const std::shared_ptr<ngraph::op::v0::
}
auto is_convert_color_type = [](const std::shared_ptr<ov::Node> &node) {
return ngraph::is_type<ngraph::op::v8::NV12toRGB>(node) ||
ngraph::is_type<ngraph::op::v8::NV12toBGR>(node) ||
ngraph::is_type<ngraph::op::v8::I420toRGB>(node) ||
ngraph::is_type<ngraph::op::v8::I420toBGR>(node);
return ov::is_type<ov::op::v8::NV12toRGB>(node) ||
ov::is_type<ov::op::v8::NV12toBGR>(node) ||
ov::is_type<ov::op::v8::I420toRGB>(node) ||
ov::is_type<ov::op::v8::I420toBGR>(node);
};
std::function<bool(const std::shared_ptr<ov::Node>&, size_t)> recursive_search_convert_color =
@ -155,7 +160,7 @@ static void CreateParameterOp(Program& p, const std::shared_ptr<ngraph::op::v0::
if (node->output(0).get_rt_info().count(ov::preprocess::TensorInfoMemoryType::get_type_info_static())) {
std::string mem_type = node->output(0).get_rt_info().at(ov::preprocess::TensorInfoMemoryType::get_type_info_static())
.as<ov::preprocess::TensorInfoMemoryType>().value;
if (mem_type.find(GPU_CONFIG_KEY(SURFACE)) != std::string::npos) {
if (mem_type.find(ov::intel_gpu::memory_type::surface) != std::string::npos) {
surface_input_found = true;
}
}
@ -165,7 +170,7 @@ static void CreateParameterOp(Program& p, const std::shared_ptr<ngraph::op::v0::
std::function<bool(const std::shared_ptr<ov::Node>&)> connected_to_quantize =
[&](const std::shared_ptr<ov::Node> &node) -> bool {
for (auto& user : node->get_users()) {
if (ngraph::is_type<ngraph::op::v0::FakeQuantize>(user))
if (ov::is_type<ov::op::v0::FakeQuantize>(user))
return true;
}
return false;
@ -192,7 +197,7 @@ static void CreateParameterOp(Program& p, const std::shared_ptr<ngraph::op::v0::
auto reorder_layout = networkInputLayout;
reorder_layout.format = cldnn::format::bfyx;
auto preprocessPrimID = "reorder:" + inputName + Program::m_preProcessTag + suffix;
auto preprocessPrimID = "reorder:" + inputName + ProgramBuilder::m_preProcessTag + suffix;
auto reorder = cldnn::reorder(preprocessPrimID,
cldnn::input_info(batched_name),
reorder_layout);
@ -204,7 +209,7 @@ static void CreateParameterOp(Program& p, const std::shared_ptr<ngraph::op::v0::
if (batch > 1 && !is_convert_color_input)
p.add_primitive(*op, cldnn::concatenation(inputName, surfaces_inputs, 0));
else
p.primitive_ids[inputName] = "reorder:" + inputName + Program::m_preProcessTag;
p.primitive_ids[inputName] = "reorder:" + inputName + ProgramBuilder::m_preProcessTag;
} else if (is_convert_color_input) {
networkInputLayout.format = cldnn::format::byxf;
@ -213,7 +218,7 @@ static void CreateParameterOp(Program& p, const std::shared_ptr<ngraph::op::v0::
p.inputLayouts.insert({ inputInfo->name(), networkInputLayout });
p.add_primitive(*op, cldnn::input_layout(inputName, networkInputLayout));
} else {
auto preprocessPrimID = "reorder:" + inputName + Program::m_preProcessTag;
auto preprocessPrimID = "reorder:" + inputName + ProgramBuilder::m_preProcessTag;
cldnn::layout inputLayout(networkInputLayout);
auto network_input_data_type = DataTypeFromPrecision(ip);
inputLayout.data_type = network_input_data_type;

14
src/plugins/intel_gpu/src/plugin/ops/pooling.cpp
View File

@ -2,11 +2,11 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/max_pool.hpp"
#include "ngraph/op/avg_pool.hpp"
#include "openvino/op/max_pool.hpp"
#include "openvino/op/avg_pool.hpp"
#include "intel_gpu/primitives/mutable_data.hpp"
#include "intel_gpu/primitives/pooling.hpp"
@ -14,7 +14,7 @@
namespace ov {
namespace intel_gpu {
static void CreateAvgPoolOp(Program& p, const std::shared_ptr<ngraph::op::v1::AvgPool>& op) {
static void CreateAvgPoolOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::AvgPool>& op) {
validate_inputs_count(op, {1});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -46,7 +46,7 @@ static void CreateAvgPoolOp(Program& p, const std::shared_ptr<ngraph::op::v1::Av
p.add_primitive(*op, pooling_prim);
}
static void CreateMaxPoolOp(Program& p, const std::shared_ptr<ngraph::op::v1::MaxPool>& op) {
static void CreateMaxPoolOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::MaxPool>& op) {
validate_inputs_count(op, {1});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -76,10 +76,10 @@ static void CreateMaxPoolOp(Program& p, const std::shared_ptr<ngraph::op::v1::Ma
p.add_primitive(*op, pooling_prim);
}
static void CreateMaxPoolOp(Program& p, const std::shared_ptr<ngraph::op::v8::MaxPool>& op) {
static void CreateMaxPoolOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::MaxPool>& op) {
validate_inputs_count(op, {1});
if (op->get_output_size() != 2) {
OPENVINO_THROW("[GPU] MaxPool opset 8 requires 2 outputs");
OPENVINO_THROW("[GPU] v8:MaxPool requires 2 outputs");
}
auto inputs = p.GetInputInfo(op);
const auto layer_type_name = layer_type_name_ID(op);

24
src/plugins/intel_gpu/src/plugin/ops/prior_box.cpp
View File

@ -2,18 +2,18 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "openvino/op/prior_box.hpp"
#include "openvino/op/prior_box_clustered.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/prior_box.hpp"
#include "ngraph/op/prior_box_clustered.hpp"
#include "intel_gpu/primitives/prior_box.hpp"
namespace ov {
namespace intel_gpu {
static void CreatePriorBoxClusteredOp(Program& p, const std::shared_ptr<ngraph::op::v0::PriorBoxClustered>& op) {
static void CreatePriorBoxClusteredOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::PriorBoxClustered>& op) {
OPENVINO_ASSERT(false, "[GPU] PriorBoxClustered op is not supported in GPU plugin yet.");
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
@ -86,7 +86,7 @@ static void CreatePriorBoxClusteredOp(Program& p, const std::shared_ptr<ngraph::
}
}
static void CreatePriorBoxOp(Program& p, const std::shared_ptr<ngraph::op::v0::PriorBox>& op) {
static void CreatePriorBoxOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::PriorBox>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -111,8 +111,8 @@ static void CreatePriorBoxOp(Program& p, const std::shared_ptr<ngraph::op::v0::P
OPENVINO_ASSERT(img_pshape.is_static(), "Dynamic shapes are not supported for PriorBox operation yet");
if (!output_pshape.is_dynamic()) {
const auto output_size_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(0));
const auto image_size_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(1));
const auto output_size_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(0));
const auto image_size_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
// output_size should be constant to be static output shape
OPENVINO_ASSERT(output_size_constant,
@ -174,7 +174,7 @@ static void CreatePriorBoxOp(Program& p, const std::shared_ptr<ngraph::op::v0::P
}
}
static void CreatePriorBoxOp(Program& p, const std::shared_ptr<ngraph::op::v8::PriorBox>& op) {
static void CreatePriorBoxOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::PriorBox>& op) {
validate_inputs_count(op, {2});
const auto inputs = p.GetInputInfo(op);
std::string layer_name = layer_type_name_ID(op);
@ -183,8 +183,8 @@ static void CreatePriorBoxOp(Program& p, const std::shared_ptr<ngraph::op::v8::P
auto output_pshape = op->get_output_partial_shape(0);
if (!output_pshape.is_dynamic()) {
const auto output_size_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(0));
const auto image_size_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(1));
const auto output_size_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(0));
const auto image_size_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
// output_size should be constant to be static output shape
OPENVINO_ASSERT(output_size_constant,

15
src/plugins/intel_gpu/src/plugin/ops/proposal.cpp
View File

@ -2,11 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "openvino/op/proposal.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/proposal.hpp"
#include "intel_gpu/primitives/proposal.hpp"
#include "intel_gpu/primitives/mutable_data.hpp"
#include "intel_gpu/runtime/debug_configuration.hpp"
@ -14,7 +13,7 @@
namespace ov {
namespace intel_gpu {
static void CreateProposalOp(Program& p, const std::shared_ptr<ngraph::op::v0::Proposal>& op) {
static void CreateProposalOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Proposal>& op) {
validate_inputs_count(op, {3});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -105,8 +104,8 @@ static void CreateProposalOp(Program& p, const std::shared_ptr<ngraph::op::v0::P
} else {
if (op->get_output_size() == 2) {
auto mutable_precision = op->get_output_element_type(1);
if (mutable_precision == ngraph::element::i64) {
mutable_precision = ngraph::element::i32;
if (mutable_precision == ov::element::i64) {
mutable_precision = ov::element::i32;
}
cldnn::layout mutableLayout = cldnn::layout(cldnn::element_type_to_data_type(mutable_precision),
@ -185,7 +184,7 @@ static void CreateProposalOp(Program& p, const std::shared_ptr<ngraph::op::v0::P
p.add_primitive(*op, proposalPrim);
} else {
IE_THROW() << op->get_friendly_name() << " Incorrect Proposal outputs number";
OPENVINO_THROW(op->get_friendly_name(), " Incorrect Proposal outputs number");
}
}
}

6
src/plugins/intel_gpu/src/plugin/ops/random_uniform.cpp
View File

@ -2,9 +2,9 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/random_uniform.hpp"
#include "openvino/op/random_uniform.hpp"
#include "intel_gpu/primitives/random_uniform.hpp"
@ -13,7 +13,7 @@ namespace intel_gpu {
namespace {
void CreateRandomUniformOp(Program &p, const std::shared_ptr<ngraph::op::v8::RandomUniform> &op) {
void CreateRandomUniformOp(ProgramBuilder &p, const std::shared_ptr<ov::op::v8::RandomUniform> &op) {
auto inputs = p.GetInputInfo(op);
auto input_pshape = op->get_input_partial_shape(0);
auto output_pshape = op->get_output_partial_shape(0);

7
src/plugins/intel_gpu/src/plugin/ops/range.cpp
View File

@ -2,16 +2,15 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <intel_gpu/plugin/program.hpp>
#include "openvino/op/range.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include <intel_gpu/plugin/common_utils.hpp>
#include <intel_gpu/primitives/range.hpp>
#include <ngraph/op/range.hpp>
namespace ov {
namespace intel_gpu {
static void CreateRangeOp(Program &p, const std::shared_ptr<ngraph::op::v4::Range> &op) {
static void CreateRangeOp(ProgramBuilder &p, const std::shared_ptr<ov::op::v4::Range> &op) {
validate_inputs_count(op, { 3 });
auto output_pshape = op->get_output_partial_shape(0);
OPENVINO_ASSERT(output_pshape.rank().get_length() == 1 , "[GPU] range v4 output rank should be 1");

44
src/plugins/intel_gpu/src/plugin/ops/reduce.cpp
View File

@ -2,19 +2,19 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/reduce_sum.hpp"
#include "ngraph/op/reduce_prod.hpp"
#include "ngraph/op/reduce_mean.hpp"
#include "ngraph/op/reduce_logical_or.hpp"
#include "ngraph/op/reduce_logical_and.hpp"
#include "ngraph/op/reduce_l1.hpp"
#include "ngraph/op/reduce_l2.hpp"
#include "ngraph/op/min.hpp"
#include "ngraph/op/max.hpp"
#include "ngraph/op/constant.hpp"
#include "openvino/op/reduce_sum.hpp"
#include "openvino/op/reduce_prod.hpp"
#include "openvino/op/reduce_mean.hpp"
#include "openvino/op/reduce_logical_or.hpp"
#include "openvino/op/reduce_logical_and.hpp"
#include "openvino/op/reduce_l1.hpp"
#include "openvino/op/reduce_l2.hpp"
#include "openvino/op/reduce_min.hpp"
#include "openvino/op/reduce_max.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/primitives/reduce.hpp"
#include "intel_gpu/primitives/reorder.hpp"
@ -23,14 +23,14 @@
namespace ov {
namespace intel_gpu {
static void CreateReduceOp(Program& p, const std::shared_ptr<ngraph::Node>& op, cldnn::reduce_mode mode, bool keep_dims) {
static void CreateReduceOp(ProgramBuilder& p, const std::shared_ptr<ov::Node>& op, cldnn::reduce_mode mode, bool keep_dims) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
auto input_pshape = op->get_input_partial_shape(0);
int64_t rank = input_pshape.size();
auto axes_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(1));
auto axes_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
OPENVINO_ASSERT(axes_constant != nullptr, "[GPU] Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
std::vector<int64_t> axes = axes_constant->cast_vector<int64_t>();
@ -94,39 +94,39 @@ static void CreateReduceOp(Program& p, const std::shared_ptr<ngraph::Node>& op,
}
}
static void CreateReduceMaxOp(Program& p, const std::shared_ptr<ngraph::op::v1::ReduceMax>& op) {
static void CreateReduceMaxOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::ReduceMax>& op) {
CreateReduceOp(p, op, cldnn::reduce_mode::max, op->get_keep_dims());
}
static void CreateReduceLogicalAndOp(Program& p, const std::shared_ptr<ngraph::op::v1::ReduceLogicalAnd>& op) {
static void CreateReduceLogicalAndOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::ReduceLogicalAnd>& op) {
CreateReduceOp(p, op, cldnn::reduce_mode::logical_and, op->get_keep_dims());
}
static void CreateReduceLogicalOrOp(Program& p, const std::shared_ptr<ngraph::op::v1::ReduceLogicalOr>& op) {
static void CreateReduceLogicalOrOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::ReduceLogicalOr>& op) {
CreateReduceOp(p, op, cldnn::reduce_mode::logical_or, op->get_keep_dims());
}
static void CreateReduceMeanOp(Program& p, const std::shared_ptr<ngraph::op::v1::ReduceMean>& op) {
static void CreateReduceMeanOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::ReduceMean>& op) {
CreateReduceOp(p, op, cldnn::reduce_mode::mean, op->get_keep_dims());
}
static void CreateReduceMinOp(Program& p, const std::shared_ptr<ngraph::op::v1::ReduceMin>& op) {
static void CreateReduceMinOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::ReduceMin>& op) {
CreateReduceOp(p, op, cldnn::reduce_mode::min, op->get_keep_dims());
}
static void CreateReduceProdOp(Program& p, const std::shared_ptr<ngraph::op::v1::ReduceProd>& op) {
static void CreateReduceProdOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::ReduceProd>& op) {
CreateReduceOp(p, op, cldnn::reduce_mode::prod, op->get_keep_dims());
}
static void CreateReduceSumOp(Program& p, const std::shared_ptr<ngraph::op::v1::ReduceSum>& op) {
static void CreateReduceSumOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::ReduceSum>& op) {
CreateReduceOp(p, op, cldnn::reduce_mode::sum, op->get_keep_dims());
}
static void CreateReduceL1Op(Program& p, const std::shared_ptr<ngraph::op::v4::ReduceL1>& op) {
static void CreateReduceL1Op(ProgramBuilder& p, const std::shared_ptr<ov::op::v4::ReduceL1>& op) {
CreateReduceOp(p, op, cldnn::reduce_mode::l1, op->get_keep_dims());
}
static void CreateReduceL2Op(Program& p, const std::shared_ptr<ngraph::op::v4::ReduceL2>& op) {
static void CreateReduceL2Op(ProgramBuilder& p, const std::shared_ptr<ov::op::v4::ReduceL2>& op) {
CreateReduceOp(p, op, cldnn::reduce_mode::l2, op->get_keep_dims());
}

6
src/plugins/intel_gpu/src/plugin/ops/region_yolo.cpp
View File

@ -2,17 +2,17 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/region_yolo.hpp"
#include "openvino/op/region_yolo.hpp"
#include "intel_gpu/primitives/region_yolo.hpp"
namespace ov {
namespace intel_gpu {
static void CreateRegionYoloOp(Program& p, const std::shared_ptr<ngraph::op::v0::RegionYolo>& op) {
static void CreateRegionYoloOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::RegionYolo>& op) {
validate_inputs_count(op, {1});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

6
src/plugins/intel_gpu/src/plugin/ops/reorg_yolo.cpp
View File

@ -2,17 +2,17 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/reorg_yolo.hpp"
#include "openvino/op/reorg_yolo.hpp"
#include "intel_gpu/primitives/reorg_yolo.hpp"
namespace ov {
namespace intel_gpu {
static void CreateReorgYoloOp(Program& p, const std::shared_ptr<ngraph::op::v0::ReorgYolo>& op) {
static void CreateReorgYoloOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::ReorgYolo>& op) {
validate_inputs_count(op, {1});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

19
src/plugins/intel_gpu/src/plugin/ops/reshape.cpp
View File

@ -2,12 +2,13 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/reshape.hpp"
#include "ngraph/op/squeeze.hpp"
#include "ngraph/op/unsqueeze.hpp"
#include "openvino/op/reshape.hpp"
#include "openvino/op/squeeze.hpp"
#include "openvino/op/unsqueeze.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/primitives/reshape.hpp"
#include "intel_gpu/primitives/reorder.hpp"
@ -15,7 +16,7 @@
namespace ov {
namespace intel_gpu {
static void CreateCommonReshapeOp(Program& p, const std::shared_ptr<ngraph::Node>& op, cldnn::reshape::reshape_mode mode, bool special_zero = false) {
static void CreateCommonReshapeOp(ProgramBuilder& p, const std::shared_ptr<ov::Node>& op, cldnn::reshape::reshape_mode mode, bool special_zero = false) {
validate_inputs_count(op, {1, 2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -25,7 +26,7 @@ static void CreateCommonReshapeOp(Program& p, const std::shared_ptr<ngraph::Node
if (p.use_new_shape_infer() || op->is_dynamic()) {
std::shared_ptr<cldnn::reshape> reshape_prim = nullptr;
auto second_const_input = op->get_input_size() == 2 ? std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(1)) : nullptr;
auto second_const_input = op->get_input_size() == 2 ? std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1)) : nullptr;
std::vector<int64_t> output_pattern = {};
if (second_const_input != nullptr) {
output_pattern = second_const_input->cast_vector<int64_t>();
@ -82,15 +83,15 @@ static void CreateCommonReshapeOp(Program& p, const std::shared_ptr<ngraph::Node
}
}
static void CreateReshapeOp(Program& p, const std::shared_ptr<ngraph::op::v1::Reshape>& op) {
static void CreateReshapeOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Reshape>& op) {
CreateCommonReshapeOp(p, op, cldnn::reshape::reshape_mode::base, op->get_special_zero());
}
static void CreateSqueezeOp(Program& p, const std::shared_ptr<ngraph::op::v0::Squeeze>& op) {
static void CreateSqueezeOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Squeeze>& op) {
CreateCommonReshapeOp(p, op, cldnn::reshape::reshape_mode::squeeze);
}
static void CreateUnsqueezeOp(Program& p, const std::shared_ptr<ngraph::op::v0::Unsqueeze>& op) {
static void CreateUnsqueezeOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Unsqueeze>& op) {
CreateCommonReshapeOp(p, op, cldnn::reshape::reshape_mode::unsqueeze);
}

21
src/plugins/intel_gpu/src/plugin/ops/result.cpp
View File

@ -2,11 +2,14 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "openvino/op/result.hpp"
#include "openvino/op/nv12_to_rgb.hpp"
#include "openvino/op/nv12_to_bgr.hpp"
#include "openvino/op/i420_to_rgb.hpp"
#include "openvino/op/i420_to_bgr.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/result.hpp"
#include "intel_gpu/primitives/reorder.hpp"
using namespace InferenceEngine;
@ -14,7 +17,7 @@ using namespace InferenceEngine;
namespace ov {
namespace intel_gpu {
static void CreateResultOp(Program& p, const std::shared_ptr<ngraph::op::v0::Result>& op) {
static void CreateResultOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Result>& op) {
OutputsDataMap networkOutputs = p.GetNetworkOutputs();
validate_inputs_count(op, {1});
@ -37,10 +40,10 @@ static void CreateResultOp(Program& p, const std::shared_ptr<ngraph::op::v0::Res
const auto outputDesc = outputData->getTensorDesc();
auto outputlayout = outputDesc.getLayout();
if (ngraph::is_type<ngraph::op::v8::NV12toRGB>(prev) ||
ngraph::is_type<ngraph::op::v8::NV12toBGR>(prev) ||
ngraph::is_type<ngraph::op::v8::I420toRGB>(prev) ||
ngraph::is_type<ngraph::op::v8::I420toBGR>(prev)) {
if (ov::is_type<ov::op::v8::NV12toRGB>(prev) ||
ov::is_type<ov::op::v8::NV12toBGR>(prev) ||
ov::is_type<ov::op::v8::I420toRGB>(prev) ||
ov::is_type<ov::op::v8::I420toBGR>(prev)) {
outputlayout = NHWC;
}

10
src/plugins/intel_gpu/src/plugin/ops/reverse.cpp
View File

@ -2,21 +2,21 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/primitives/reverse.hpp"
#include "openvino/op/reverse.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "ngraph/op/reverse_sequence.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/primitives/reverse.hpp"
namespace ov {
namespace intel_gpu {
static void CreateReverseOp(Program& p, const std::shared_ptr<ngraph::op::v1::Reverse>& op) {
static void CreateReverseOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Reverse>& op) {
validate_inputs_count(op, {2});
const auto inputs = p.GetInputInfo(op);
const auto layer_name = layer_type_name_ID(op);
const auto mode =
op->get_mode() == ngraph::op::v1::Reverse::Mode::INDEX ? cldnn::reverse_mode::index : cldnn::reverse_mode::mask;
op->get_mode() == ov::op::v1::Reverse::Mode::INDEX ? cldnn::reverse_mode::index : cldnn::reverse_mode::mask;
const cldnn::reverse reverse{layer_name, inputs[0], inputs[1], mode};

6
src/plugins/intel_gpu/src/plugin/ops/reverse_sequence.cpp
View File

@ -2,17 +2,17 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/reverse_sequence.hpp"
#include "openvino/op/reverse_sequence.hpp"
#include "intel_gpu/primitives/reverse_sequence.hpp"
namespace ov {
namespace intel_gpu {
static void CreateReverseSequenceOp(Program& p, const std::shared_ptr<ngraph::op::v0::ReverseSequence>& op) {
static void CreateReverseSequenceOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::ReverseSequence>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

12
src/plugins/intel_gpu/src/plugin/ops/rnn.cpp
View File

@ -2,11 +2,11 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/lstm_cell.hpp"
#include "ngraph/op/lstm_sequence.hpp"
#include "openvino/op/lstm_cell.hpp"
#include "openvino/op/lstm_sequence.hpp"
#include "intel_gpu/primitives/reshape.hpp"
#include "intel_gpu/primitives/reorder.hpp"
@ -61,7 +61,7 @@ void GetLSTMActivationParams(const std::shared_ptr<T>& op,
}
}
static void CreateLSTMCellOp(Program& p, const std::shared_ptr<ngraph::op::v4::LSTMCell>& op) {
static void CreateLSTMCellOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v4::LSTMCell>& op) {
validate_inputs_count(op, {6});
int lstm_batch_size, lstm_input_size, lstm_hidden_size;
auto inputs = p.GetInputInfo(op);
@ -156,7 +156,7 @@ static void CreateLSTMCellOp(Program& p, const std::shared_ptr<ngraph::op::v4::L
p.add_primitive(*op, cldnn::reshape(outputCellID, cldnn::input_info(outputCellCropID), outSz));
}
static void CreateLSTMSequenceOp(Program& p, const std::shared_ptr<ngraph::op::v5::LSTMSequence>& op) {
static void CreateLSTMSequenceOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v5::LSTMSequence>& op) {
validate_inputs_count(op, {7});
std::string layerName = layer_type_name_ID(op);
@ -186,7 +186,7 @@ static void CreateLSTMSequenceOp(Program& p, const std::shared_ptr<ngraph::op::v
std::vector<cldnn::activation_additional_params> activation_params;
GetLSTMActivationParams(op, activations, activation_params);
float clip = op->get_clip();
bool isForward = op->get_direction() == ngraph::op::RecurrentSequenceDirection::FORWARD;
bool isForward = op->get_direction() == ov::op::RecurrentSequenceDirection::FORWARD;
// LSTM primitive works with single precision for all in/out/weights tensors
auto lstm_dtype = cldnn::element_type_to_data_type(op->get_output_element_type(0));

16
src/plugins/intel_gpu/src/plugin/ops/roi_align.cpp
View File

@ -1,12 +1,12 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "ngraph/op/roi_align.hpp"
#include "openvino/op/roi_align.hpp"
#include <memory>
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/primitives/roi_align.hpp"
namespace ov {
@ -25,19 +25,19 @@ cldnn::roi_align::PoolingMode from(T mode) {
}
}
cldnn::roi_align::AlignedMode from(ngraph::op::v9::ROIAlign::AlignedMode mode) {
cldnn::roi_align::AlignedMode from(ov::op::v9::ROIAlign::AlignedMode mode) {
switch (mode) {
case ngraph::op::v9::ROIAlign::AlignedMode::HALF_PIXEL_FOR_NN:
case ov::op::v9::ROIAlign::AlignedMode::HALF_PIXEL_FOR_NN:
return cldnn::roi_align::AlignedMode::half_pixel_for_nn;
case ngraph::op::v9::ROIAlign::AlignedMode::HALF_PIXEL:
case ov::op::v9::ROIAlign::AlignedMode::HALF_PIXEL:
return cldnn::roi_align::AlignedMode::half_pixel;
case ngraph::op::v9::ROIAlign::AlignedMode::ASYMMETRIC:
case ov::op::v9::ROIAlign::AlignedMode::ASYMMETRIC:
default:
return cldnn::roi_align::AlignedMode::asymmetric;
}
}
void CreateROIAlignOp(Program& p, const std::shared_ptr<ngraph::op::v3::ROIAlign>& op) {
void CreateROIAlignOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::ROIAlign>& op) {
validate_inputs_count(op, {3});
auto roi_align_prim = cldnn::roi_align(layer_type_name_ID(op),
p.GetInputInfo(op),
@ -50,7 +50,7 @@ void CreateROIAlignOp(Program& p, const std::shared_ptr<ngraph::op::v3::ROIAlign
p.add_primitive(*op, roi_align_prim);
}
void CreateROIAlignOp(Program& p, const std::shared_ptr<ngraph::op::v9::ROIAlign>& op) {
void CreateROIAlignOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v9::ROIAlign>& op) {
validate_inputs_count(op, {3});
auto roi_align_prim = cldnn::roi_align(layer_type_name_ID(op),
p.GetInputInfo(op),

16
src/plugins/intel_gpu/src/plugin/ops/roi_pooling.cpp
View File

@ -2,12 +2,12 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/roi_pooling.hpp"
#include "ngraph/op/psroi_pooling.hpp"
#include "ngraph/op/deformable_psroi_pooling.hpp"
#include "openvino/op/roi_pooling.hpp"
#include "openvino/op/psroi_pooling.hpp"
#include "openvino/op/deformable_psroi_pooling.hpp"
#include "intel_gpu/primitives/roi_pooling.hpp"
@ -25,7 +25,7 @@ static cldnn::pooling_mode GetPoolingMode(std::string method) {
return cldnn::pooling_mode::deformable_bilinear;
}
static void CreateDeformablePSROIPoolingOp(Program& p, const std::shared_ptr<ngraph::op::v1::DeformablePSROIPooling>& op) {
static void CreateDeformablePSROIPoolingOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::DeformablePSROIPooling>& op) {
validate_inputs_count(op, {2, 3});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -62,7 +62,7 @@ static void CreateDeformablePSROIPoolingOp(Program& p, const std::shared_ptr<ngr
p.add_primitive(*op, psROIPoolingPrim);
}
static void CreatePSROIPoolingOp(Program& p, const std::shared_ptr<ngraph::op::v0::PSROIPooling>& op) {
static void CreatePSROIPoolingOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::PSROIPooling>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -89,13 +89,13 @@ static void CreatePSROIPoolingOp(Program& p, const std::shared_ptr<ngraph::op::v
p.add_primitive(*op, psROIPoolingPrim);
}
static void CreateROIPoolingOp(Program& p, const std::shared_ptr<ngraph::op::v0::ROIPooling>& op) {
static void CreateROIPoolingOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::ROIPooling>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
// params
auto out_size = op->get_output_size();
auto out_size = op->get_output_roi();
int pooled_height = static_cast<int>(out_size[0]);
int pooled_width = static_cast<int>(out_size[1]);
float spatial_scale = op->get_spatial_scale();

14
src/plugins/intel_gpu/src/plugin/ops/roll.cpp
View File

@ -2,19 +2,19 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/op/roll.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/primitives/roll.hpp"
#include <ngraph/op/roll.hpp>
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
namespace ov {
namespace intel_gpu {
namespace {
void CreateRollOp(Program& p, const std::shared_ptr<ngraph::op::v7::Roll>& op) {
void CreateRollOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v7::Roll>& op) {
validate_inputs_count(op, {3});
const auto inputs = p.GetInputInfo(op);
@ -27,11 +27,11 @@ void CreateRollOp(Program& p, const std::shared_ptr<ngraph::op::v7::Roll>& op) {
const auto format = cldnn::format::get_default_format(rank);
const auto default_rank = format.dimension();
auto shift_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(1));
auto shift_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
OPENVINO_ASSERT(shift_constant != nullptr, "[GPU] Unsupported parameter nodes type in ", op_friendly_name, " (", op->get_type_name(), ")");
const auto shift_raw = shift_constant->cast_vector<int32_t>();
auto axes_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(2));
auto axes_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2));
OPENVINO_ASSERT(axes_constant != nullptr, "[GPU] Unsupported parameter nodes type in ", op_friendly_name, " (", op->get_type_name(), ")");
auto axes_raw = axes_constant->cast_vector<int32_t>();

14
src/plugins/intel_gpu/src/plugin/ops/scatter_elements_update.cpp
View File

@ -2,23 +2,23 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "openvino/core/validation_util.hpp"
#include "openvino/op/scatter_elements_update.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/scatter_elements_update.hpp"
#include "ngraph/op/constant.hpp"
#include "intel_gpu/primitives/scatter_elements_update.hpp"
namespace ov {
namespace intel_gpu {
static void CreateScatterElementsUpdateOp(Program& p, const std::shared_ptr<ngraph::op::v3::ScatterElementsUpdate>& op) {
static void CreateScatterElementsUpdateOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::ScatterElementsUpdate>& op) {
validate_inputs_count(op, {4});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
auto axes_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(3));
auto axes_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(3));
if (!axes_constant) {
OPENVINO_ASSERT("Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
}

8
src/plugins/intel_gpu/src/plugin/ops/scatter_nd_update.cpp
View File

@ -2,18 +2,18 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/scatter_nd_update.hpp"
#include "ngraph/op/constant.hpp"
#include "openvino/op/scatter_nd_update.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/primitives/scatter_nd_update.hpp"
namespace ov {
namespace intel_gpu {
static void CreateScatterNDUpdateOp(Program& p, const std::shared_ptr<ngraph::op::v3::ScatterNDUpdate>& op) {
static void CreateScatterNDUpdateOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::ScatterNDUpdate>& op) {
validate_inputs_count(op, {3});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

10
src/plugins/intel_gpu/src/plugin/ops/scatter_update.cpp
View File

@ -2,23 +2,23 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/scatter_update.hpp"
#include "ngraph/op/constant.hpp"
#include "openvino/op/scatter_update.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/primitives/scatter_update.hpp"
namespace ov {
namespace intel_gpu {
static void CreateScatterUpdateOp(Program& p, const std::shared_ptr<ngraph::op::v3::ScatterUpdate>& op) {
static void CreateScatterUpdateOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::ScatterUpdate>& op) {
validate_inputs_count(op, {4});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
auto axes_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(3));
auto axes_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(3));
OPENVINO_ASSERT(axes_constant != nullptr, "[GPU] Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
int64_t axis = axes_constant->cast_vector<int64_t>()[0];
auto primitive = cldnn::scatter_update(layerName,

12
src/plugins/intel_gpu/src/plugin/ops/select.cpp
View File

@ -2,10 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/select.hpp"
#include "openvino/op/select.hpp"
#include "intel_gpu/primitives/select.hpp"
#include "intel_gpu/primitives/reorder.hpp"
@ -14,7 +14,7 @@
namespace ov {
namespace intel_gpu {
static void CreateSelectOp(Program& p, const std::shared_ptr<ngraph::op::v1::Select>& op) {
static void CreateSelectOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Select>& op) {
validate_inputs_count(op, {3});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -24,12 +24,12 @@ static void CreateSelectOp(Program& p, const std::shared_ptr<ngraph::op::v1::Sel
auto broadcast_type = op->get_auto_broadcast();
if (broadcast_type.m_type != ngraph::op::AutoBroadcastType::NONE &&
broadcast_type.m_type != ngraph::op::AutoBroadcastType::NUMPY) {
if (broadcast_type.m_type != ov::op::AutoBroadcastType::NONE &&
broadcast_type.m_type != ov::op::AutoBroadcastType::NUMPY) {
OPENVINO_THROW("[GPU] Unsupported broadcast type (", broadcast_type.m_type, ") in layer " + op->get_friendly_name());
}
if (broadcast_type.m_type == ngraph::op::AutoBroadcastType::NUMPY) {
if (broadcast_type.m_type == ov::op::AutoBroadcastType::NUMPY) {
// Preprocess inputs
for (size_t i = 0; i < inputs.size(); ++i) {
auto input_pshape = op->get_input_partial_shape(i);

10
src/plugins/intel_gpu/src/plugin/ops/shape_of.cpp
View File

@ -2,17 +2,17 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/shape_of.hpp"
#include "openvino/op/shape_of.hpp"
#include "intel_gpu/primitives/shape_of.hpp"
namespace ov {
namespace intel_gpu {
static void CreateShapeOfOpCommon(Program& p, const std::shared_ptr<ngraph::Node>& op) {
static void CreateShapeOfOpCommon(ProgramBuilder& p, const std::shared_ptr<ov::Node>& op) {
validate_inputs_count(op, {1, 2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -25,11 +25,11 @@ static void CreateShapeOfOpCommon(Program& p, const std::shared_ptr<ngraph::Node
p.add_primitive(*op, primitive);
}
static void CreateShapeOfOp(Program& p, const std::shared_ptr<ngraph::op::v0::ShapeOf>& op) {
static void CreateShapeOfOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::ShapeOf>& op) {
CreateShapeOfOpCommon(p, op);
}
static void CreateShapeOfOp(Program& p, const std::shared_ptr<ngraph::op::v3::ShapeOf>& op) {
static void CreateShapeOfOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::ShapeOf>& op) {
CreateShapeOfOpCommon(p, op);
}

10
src/plugins/intel_gpu/src/plugin/ops/shuffle_channels.cpp
View File

@ -2,17 +2,17 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "openvino/core/validation_util.hpp"
#include "openvino/op/shuffle_channels.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/shuffle_channels.hpp"
#include "intel_gpu/primitives/shuffle_channels.hpp"
namespace ov {
namespace intel_gpu {
static void CreateShuffleChannelsOp(Program& p, const std::shared_ptr<ngraph::op::v0::ShuffleChannels>& op) {
static void CreateShuffleChannelsOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::ShuffleChannels>& op) {
validate_inputs_count(op, {1, 2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

6
src/plugins/intel_gpu/src/plugin/ops/slice.cpp
View File

@ -2,10 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/slice.hpp"
#include "openvino/op/slice.hpp"
#include "intel_gpu/primitives/slice.hpp"
@ -16,7 +16,7 @@ namespace intel_gpu {
namespace {
static void CreateSliceOp(Program& p, const std::shared_ptr<ngraph::op::v8::Slice>& op) {
static void CreateSliceOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::Slice>& op) {
validate_inputs_count(op, { 4, 5 });
auto inputs = p.GetInputInfo(op);
auto output_shape = tensor_from_dims(op->get_output_shape(0));

16
src/plugins/intel_gpu/src/plugin/ops/softmax.cpp
View File

@ -2,19 +2,19 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "openvino/core/validation_util.hpp"
#include "openvino/op/softmax.hpp"
#include "openvino/op/log_softmax.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/softmax.hpp"
#include "ngraph/op/log_softmax.hpp"
#include "intel_gpu/primitives/softmax.hpp"
#include "intel_gpu/primitives/activation.hpp"
namespace ov {
namespace intel_gpu {
static void CreateSoftmaxOp(Program& p, const std::shared_ptr<ngraph::op::v1::Softmax>& op) {
static void CreateSoftmaxOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Softmax>& op) {
validate_inputs_count(op, {1});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -24,7 +24,7 @@ static void CreateSoftmaxOp(Program& p, const std::shared_ptr<ngraph::op::v1::So
p.add_primitive(*op, softmaxPrim);
}
static void CreateSoftmaxOp(Program& p, const std::shared_ptr<ngraph::op::v8::Softmax>& op) {
static void CreateSoftmaxOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v8::Softmax>& op) {
validate_inputs_count(op, {1});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -39,7 +39,7 @@ static void CreateSoftmaxOp(Program& p, const std::shared_ptr<ngraph::op::v8::So
p.add_primitive(*op, softmaxPrim);
}
static void CreateLogSoftmaxOp(Program& p, const std::shared_ptr<ngraph::op::v5::LogSoftmax>& op) {
static void CreateLogSoftmaxOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v5::LogSoftmax>& op) {
validate_inputs_count(op, {1});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

12
src/plugins/intel_gpu/src/plugin/ops/space_to_batch.cpp
View File

@ -2,18 +2,18 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/space_to_batch.hpp"
#include "ngraph/op/constant.hpp"
#include "openvino/op/space_to_batch.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/primitives/space_to_batch.hpp"
namespace ov {
namespace intel_gpu {
static void CreateSpaceToBatchOp(Program& p, const std::shared_ptr<ngraph::op::v1::SpaceToBatch>& op) {
static void CreateSpaceToBatchOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::SpaceToBatch>& op) {
validate_inputs_count(op, {4});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -26,7 +26,7 @@ static void CreateSpaceToBatchOp(Program& p, const std::shared_ptr<ngraph::op::v
bool non_constant_input = false;
for (size_t i = 1; i < 4; ++i) {
auto inConst = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(i));
auto inConst = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(i));
bool is_const_input = (inConst != nullptr);
OPENVINO_ASSERT((i == 1) || (i >= 2 && non_constant_input != is_const_input),
@ -47,7 +47,7 @@ static void CreateSpaceToBatchOp(Program& p, const std::shared_ptr<ngraph::op::v
p.add_primitive(*op, spaceToBatchPrim);
} else {
for (size_t i = 1; i < 4; ++i) {
auto inConst = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(i));
auto inConst = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(i));
std::vector<int32_t> sizes = inConst->cast_vector<int32_t>();
int32_t default_size = i == 1 ? 1 : 0;

12
src/plugins/intel_gpu/src/plugin/ops/space_to_depth.cpp
View File

@ -2,26 +2,26 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/space_to_depth.hpp"
#include "openvino/op/space_to_depth.hpp"
#include "intel_gpu/primitives/space_to_depth.hpp"
namespace ov {
namespace intel_gpu {
static cldnn::space_to_depth::depth_mode GetDepthMode(ngraph::op::v0::SpaceToDepth::SpaceToDepthMode mode) {
static cldnn::space_to_depth::depth_mode GetDepthMode(ov::op::v0::SpaceToDepth::SpaceToDepthMode mode) {
switch (mode) {
case ngraph::op::v0::SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST: return cldnn::space_to_depth::blocks_first;
case ngraph::op::v0::SpaceToDepth::SpaceToDepthMode::DEPTH_FIRST: return cldnn::space_to_depth::depth_first;
case ov::op::v0::SpaceToDepth::SpaceToDepthMode::BLOCKS_FIRST: return cldnn::space_to_depth::blocks_first;
case ov::op::v0::SpaceToDepth::SpaceToDepthMode::DEPTH_FIRST: return cldnn::space_to_depth::depth_first;
default: OPENVINO_THROW("[GPU] Unsupported SpaceToDepthMode value: ", static_cast<int>(mode));
}
return cldnn::space_to_depth::blocks_first;
}
static void CreateSpaceToDepthOp(Program& p, const std::shared_ptr<ngraph::op::v0::SpaceToDepth>& op) {
static void CreateSpaceToDepthOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::SpaceToDepth>& op) {
validate_inputs_count(op, {1});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);

24
src/plugins/intel_gpu/src/plugin/ops/split.cpp
View File

@ -2,18 +2,18 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/split.hpp"
#include "ngraph/op/variadic_split.hpp"
#include "openvino/op/split.hpp"
#include "openvino/op/variadic_split.hpp"
#include "intel_gpu/primitives/crop.hpp"
namespace ov {
namespace intel_gpu {
static void CreateCommonSplitOp(Program& p, const std::shared_ptr<ngraph::Node>& op) {
static void CreateCommonSplitOp(ProgramBuilder& p, const std::shared_ptr<ov::Node>& op) {
auto get_layer_name = [&](size_t idx)->std::string {
return layer_type_name_ID(op) + ((op->get_output_size() == 1)? "" : ".out" + std::to_string(idx));
};
@ -24,7 +24,7 @@ static void CreateCommonSplitOp(Program& p, const std::shared_ptr<ngraph::Node>&
if (!op->is_dynamic()) {
auto input_pshape = op->get_input_partial_shape(0);
InferenceEngine::SizeVector start_offset(input_pshape.size());
ov::Shape start_offset(input_pshape.size());
for (size_t i = 0; i < op->get_output_size(); i++) {
const auto outPartialShape = op->get_output_partial_shape(i);
auto offsetTensor = tensor_from_dims(start_offset, 0);
@ -40,8 +40,8 @@ static void CreateCommonSplitOp(Program& p, const std::shared_ptr<ngraph::Node>&
cldnn::crop_ngraph_op_mode op_mode = cldnn::crop_ngraph_op_mode::variadic_split;
auto num_splits = static_cast<size_t>(1);
if (ngraph::is_type<ngraph::op::v1::Split>(op)) {
num_splits = ngraph::as_type_ptr<ngraph::op::v1::Split>(op)->get_num_splits();
if (ov::is_type<ov::op::v1::Split>(op)) {
num_splits = ov::as_type_ptr<ov::op::v1::Split>(op)->get_num_splits();
op_mode = cldnn::crop_ngraph_op_mode::split;
}
@ -57,10 +57,10 @@ static void CreateCommonSplitOp(Program& p, const std::shared_ptr<ngraph::Node>&
}
} else {
auto input_pshape = op->get_input_partial_shape(0);
InferenceEngine::SizeVector start_offset(input_pshape.size());
ov::Shape start_offset(input_pshape.size());
for (size_t i = 0; i < op->get_output_size(); i++) {
const auto outPartialShape = op->get_output_partial_shape(i);
NGRAPH_SUPPRESS_DEPRECATED_START
OPENVINO_SUPPRESS_DEPRECATED_START
if (outPartialShape.size() != start_offset.size()) {
OPENVINO_THROW("Invalid dimesions in split layer: ", op->get_friendly_name(),
" output: ", ov::descriptor::get_ov_tensor_legacy_name(op->get_output_tensor(i)));
@ -71,7 +71,7 @@ static void CreateCommonSplitOp(Program& p, const std::shared_ptr<ngraph::Node>&
" output: ", ov::descriptor::get_ov_tensor_legacy_name(op->get_output_tensor(idx)));
}
}
NGRAPH_SUPPRESS_DEPRECATED_END
OPENVINO_SUPPRESS_DEPRECATED_END
auto offsetTensor = tensor_from_dims(start_offset, 0);
auto outTensor = tensor_from_dims(op->get_output_shape(i), 1);
@ -87,12 +87,12 @@ static void CreateCommonSplitOp(Program& p, const std::shared_ptr<ngraph::Node>&
}
}
static void CreateSplitOp(Program& p, const std::shared_ptr<ngraph::op::v1::Split>& op) {
static void CreateSplitOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Split>& op) {
validate_inputs_count(op, {2});
CreateCommonSplitOp(p, op);
}
static void CreateVariadicSplitOp(Program& p, const std::shared_ptr<ngraph::op::v1::VariadicSplit>& op) {
static void CreateVariadicSplitOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::VariadicSplit>& op) {
validate_inputs_count(op, {3});
CreateCommonSplitOp(p, op);
}

18
src/plugins/intel_gpu/src/plugin/ops/strided_slice.cpp
View File

@ -2,11 +2,11 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/strided_slice.hpp"
#include "ngraph/op/constant.hpp"
#include "openvino/op/strided_slice.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/primitives/strided_slice.hpp"
#include "intel_gpu/primitives/reshape.hpp"
@ -15,7 +15,7 @@
namespace ov {
namespace intel_gpu {
static void CreateStridedSliceOp(Program& p, const std::shared_ptr<ngraph::op::v1::StridedSlice>& op) {
static void CreateStridedSliceOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::StridedSlice>& op) {
validate_inputs_count(op, {4});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -23,11 +23,11 @@ static void CreateStridedSliceOp(Program& p, const std::shared_ptr<ngraph::op::v
auto output_pshape = op->get_output_partial_shape(0);
auto input_pshape = op->get_input_partial_shape(0);
auto begin_constant = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->input_value(1).get_node_shared_ptr());
auto begin_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->input_value(1).get_node_shared_ptr());
std::vector<int64_t> begin = begin_constant ? begin_constant->cast_vector<int64_t>() : std::vector<int64_t>{};
auto end_constant = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->input_value(2).get_node_shared_ptr());
auto end_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->input_value(2).get_node_shared_ptr());
std::vector<int64_t> end = end_constant ? end_constant->cast_vector<int64_t>() : std::vector<int64_t>{};
auto stride_constant = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->input_value(3).get_node_shared_ptr());
auto stride_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->input_value(3).get_node_shared_ptr());
std::vector<int64_t> strides = stride_constant ? stride_constant->cast_vector<int64_t>() : std::vector<int64_t>{};
do {
@ -53,7 +53,7 @@ static void CreateStridedSliceOp(Program& p, const std::shared_ptr<ngraph::op::v
break;
auto convert_to_set = [](const std::vector<int64_t> mask) {
ngraph::AxisSet axis_set{};
ov::AxisSet axis_set{};
for (size_t i = 0; i < static_cast<size_t>(mask.size()); ++i) {
if (mask[i] == 1) {
axis_set.emplace(i);
@ -210,7 +210,7 @@ static void CreateStridedSliceOp(Program& p, const std::shared_ptr<ngraph::op::v
offset_tensor[axes[i]] = static_cast<cldnn::tensor::value_type>(offset[i]);
}
ngraph::Shape crop_shape(reshape_pattern);
ov::Shape crop_shape(reshape_pattern);
for (size_t i = 0; i < axes.size(); ++i) {
crop_shape[axes[i]] = dim[i];
}

23
src/plugins/intel_gpu/src/plugin/ops/tensor_iterator.cpp
View File

@ -2,15 +2,15 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "intel_gpu/plugin/plugin.hpp"
#include <cpp/ie_cnn_network.h>
#include "ngraph/op/tensor_iterator.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/op/util/sub_graph_base.hpp"
#include "openvino/op/tensor_iterator.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/util/sub_graph_base.hpp"
#include "intel_gpu/primitives/loop.hpp"
#include "intel_gpu/primitives/mutable_data.hpp"
@ -21,20 +21,20 @@
#include <vector>
#include <algorithm>
using TensorIterator = ngraph::op::v0::TensorIterator;
using TensorIterator = ov::op::v0::TensorIterator;
namespace ov {
namespace intel_gpu {
template<class DATA_TYPE>
static DATA_TYPE CreateScalarData(Program &p, const cldnn::primitive_id& id, int64_t num) {
static DATA_TYPE CreateScalarData(ProgramBuilder &p, const cldnn::primitive_id& id, int64_t num) {
auto mem = p.get_engine().allocate_memory({ cldnn::data_types::i64, cldnn::format::bfyx, { 1, 1, 1, 1 } });
cldnn::mem_lock<int64_t> ptr{mem, p.get_engine().get_service_stream()};
*ptr.begin() = num;
return {id, mem};
}
static cldnn::mutable_data CreateAdditionalOutputData(Program &p, const std::shared_ptr<ngraph::Node>& op,
static cldnn::mutable_data CreateAdditionalOutputData(ProgramBuilder &p, const std::shared_ptr<ov::Node>& op,
const cldnn::primitive_id& id, const cldnn::primitive_id& input,
const int32_t output_idx) {
const auto precision = cldnn::element_type_to_data_type(op->get_output_element_type(output_idx));
@ -46,12 +46,12 @@ static cldnn::mutable_data CreateAdditionalOutputData(Program &p, const std::sha
return md;
}
static void CreateTensorIteratorOp(Program &p, const std::shared_ptr<TensorIterator> &op) {
static void CreateTensorIteratorOp(ProgramBuilder &p, const std::shared_ptr<TensorIterator> &op) {
auto inputs = p.GetInputInfo(op);
// get body topology from ngraph function
InferenceEngine::CNNNetwork body_network(op->get_body());
Program body_program(body_network, p.get_engine(), p.get_config(), true);
ProgramBuilder body_program(body_network, p.get_engine(), p.get_config(), true);
auto body_topology = *body_program.GetTopology();
// setup input_primitive_maps/ output_primitive_maps and back_edges
@ -93,11 +93,10 @@ static void CreateTensorIteratorOp(Program &p, const std::shared_ptr<TensorItera
cldnn::primitive_id from_id = layer_type_name_ID(from);
// reset output data type because the data types of the outputs of the
// body topology are always FP32 regardless of ngraph data type
// body topology are always FP32 regardless of element type
{
const auto from_prim = body_topology.at(from_id);
const auto& to_ngraph_type = to->get_element_type();
const auto to_cldnn_type = cldnn::element_type_to_data_type(to_ngraph_type);
const auto to_cldnn_type = cldnn::element_type_to_data_type(to->get_element_type());
from_prim->output_data_types = {to_cldnn_type};
}
back_edges.emplace_back(from_id, to_id);

12
src/plugins/intel_gpu/src/plugin/ops/tile.cpp
View File

@ -2,22 +2,22 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "openvino/op/tile.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/tile.hpp"
#include "intel_gpu/primitives/tile.hpp"
#include "intel_gpu/primitives/reshape.hpp"
namespace ov {
namespace intel_gpu {
static void CreateTileOp(Program& p, const std::shared_ptr<ngraph::op::v0::Tile>& op) {
static void CreateTileOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Tile>& op) {
validate_inputs_count(op, {2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
if (auto repeats_const = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(1))) {
if (auto repeats_const = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1))) {
std::vector<int64_t> repeats = repeats_const->cast_vector<int64_t>();
// TODO: Remove code below once new shape infer is enabled

18
src/plugins/intel_gpu/src/plugin/ops/topk.cpp
View File

@ -2,10 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/topk.hpp"
#include "openvino/op/topk.hpp"
#include "intel_gpu/primitives/arg_max_min.hpp"
#include "intel_gpu/primitives/mutable_data.hpp"
@ -14,8 +14,8 @@
namespace ov {
namespace intel_gpu {
static void TopKImpl(Program& p,
const std::shared_ptr<ngraph::Node>& op,
static void TopKImpl(ProgramBuilder& p,
const std::shared_ptr<ov::Node>& op,
ov::op::TopKMode mode,
ov::op::TopKSortType stype,
uint32_t top_k,
@ -42,7 +42,7 @@ static void TopKImpl(Program& p,
return output_data_types;
};
auto topk_constant = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->input_value(1).get_node_shared_ptr());
auto topk_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->input_value(1).get_node_shared_ptr());
auto argmaxPrim = cldnn::arg_max_min(layerName,
inputs[0],
inputs[1],
@ -61,8 +61,8 @@ static void TopKImpl(Program& p,
} else {
if (op->get_output_size() == 2) {
auto mutable_precision = op->get_output_element_type(1);
if (mutable_precision == ngraph::element::i64) {
mutable_precision = ngraph::element::i32;
if (mutable_precision == ov::element::i64) {
mutable_precision = ov::element::i32;
}
cldnn::layout mutableLayout = cldnn::layout(cldnn::element_type_to_data_type(mutable_precision),
@ -116,11 +116,11 @@ static void TopKImpl(Program& p,
}
}
static void CreateTopKOp(Program& p, const std::shared_ptr<ngraph::op::v1::TopK>& op) {
static void CreateTopKOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::TopK>& op) {
TopKImpl(p, op, op->get_mode(), op->get_sort_type(), static_cast<uint32_t>(op->get_k()), op->get_axis());
}
static void CreateTopKOp(Program& p, const std::shared_ptr<ngraph::op::v11::TopK>& op) {
static void CreateTopKOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v11::TopK>& op) {
TopKImpl(p, op, op->get_mode(), op->get_sort_type(), static_cast<uint32_t>(op->get_k()), op->get_axis(), op->get_stable());
}

28
src/plugins/intel_gpu/src/plugin/ops/transpose.cpp
View File

@ -2,39 +2,43 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "openvino/op/transpose.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/convert.hpp"
#include "openvino/op/nv12_to_rgb.hpp"
#include "openvino/op/nv12_to_bgr.hpp"
#include "openvino/op/i420_to_rgb.hpp"
#include "openvino/op/i420_to_bgr.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/transpose.hpp"
#include "ngraph/op/constant.hpp"
#include "intel_gpu/primitives/permute.hpp"
#include "intel_gpu/primitives/reorder.hpp"
namespace ov {
namespace intel_gpu {
static void CreateTransposeOp(Program& p, const std::shared_ptr<ngraph::op::v1::Transpose>& op) {
static void CreateTransposeOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::Transpose>& op) {
validate_inputs_count(op, {1, 2});
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
std::vector<uint16_t> order;
if (op->get_input_size() == 2) {
auto order_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(1));
auto order_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
OPENVINO_ASSERT(order_constant != nullptr, "[GPU] Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
order = order_constant->cast_vector<uint16_t>();
}
auto is_convert_color_type_impl = [](const std::shared_ptr<ov::Node> &node) {
return ngraph::is_type<ngraph::op::v8::NV12toRGB>(node) ||
ngraph::is_type<ngraph::op::v8::NV12toBGR>(node) ||
ngraph::is_type<ngraph::op::v8::I420toRGB>(node) ||
ngraph::is_type<ngraph::op::v8::I420toBGR>(node);
return ov::is_type<ov::op::v8::NV12toRGB>(node) ||
ov::is_type<ov::op::v8::NV12toBGR>(node) ||
ov::is_type<ov::op::v8::I420toRGB>(node) ||
ov::is_type<ov::op::v8::I420toBGR>(node);
};
auto is_convert_color_type = [&is_convert_color_type_impl](const std::shared_ptr<ov::Node> &node) {
if (ngraph::is_type<ngraph::op::v0::Convert>(node)) {
if (ngraph::is_type<ov::op::v0::Convert>(node)) {
return is_convert_color_type_impl(node->get_input_node_shared_ptr(0));
}
return is_convert_color_type_impl(node);

178
src/plugins/intel_gpu/src/plugin/ops/unary.cpp
View File

@ -2,51 +2,51 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "transformations/utils/utils.hpp"
#include "ngraph/op/tanh.hpp"
#include "ngraph/op/elu.hpp"
#include "ngraph/op/sigmoid.hpp"
#include "ngraph/op/relu.hpp"
#include "ngraph/op/prelu.hpp"
#include "ngraph/op/clamp.hpp"
#include "ngraph/op/exp.hpp"
#include "ngraph/op/not.hpp"
#include "ngraph/op/asin.hpp"
#include "ngraph/op/asinh.hpp"
#include "ngraph/op/acos.hpp"
#include "ngraph/op/acosh.hpp"
#include "ngraph/op/atan.hpp"
#include "ngraph/op/atanh.hpp"
#include "ngraph/op/abs.hpp"
#include "ngraph/op/floor.hpp"
#include "ngraph/op/ceiling.hpp"
#include "ngraph/op/erf.hpp"
#include "ngraph/op/hard_sigmoid.hpp"
#include "ngraph/op/log.hpp"
#include "ngraph/op/negative.hpp"
#include "ngraph/op/selu.hpp"
#include "ngraph/op/softplus.hpp"
#include "ngraph/op/tan.hpp"
#include "ngraph/op/sin.hpp"
#include "ngraph/op/sinh.hpp"
#include "ngraph/op/cos.hpp"
#include "ngraph/op/cosh.hpp"
#include "ngraph/op/swish.hpp"
#include "ngraph/op/hswish.hpp"
#include "ngraph/op/mish.hpp"
#include "ngraph/op/gelu.hpp"
#include "ngraph/op/sign.hpp"
#include "ngraph/op/hsigmoid.hpp"
#include "ngraph/op/round.hpp"
#include "openvino/op/tanh.hpp"
#include "openvino/op/elu.hpp"
#include "openvino/op/sigmoid.hpp"
#include "openvino/op/relu.hpp"
#include "openvino/op/prelu.hpp"
#include "openvino/op/clamp.hpp"
#include "openvino/op/exp.hpp"
#include "openvino/op/logical_not.hpp"
#include "openvino/op/asin.hpp"
#include "openvino/op/asinh.hpp"
#include "openvino/op/acos.hpp"
#include "openvino/op/acosh.hpp"
#include "openvino/op/atan.hpp"
#include "openvino/op/atanh.hpp"
#include "openvino/op/abs.hpp"
#include "openvino/op/floor.hpp"
#include "openvino/op/ceiling.hpp"
#include "openvino/op/erf.hpp"
#include "openvino/op/hard_sigmoid.hpp"
#include "openvino/op/log.hpp"
#include "openvino/op/negative.hpp"
#include "openvino/op/selu.hpp"
#include "openvino/op/softplus.hpp"
#include "openvino/op/tan.hpp"
#include "openvino/op/sin.hpp"
#include "openvino/op/sinh.hpp"
#include "openvino/op/cos.hpp"
#include "openvino/op/cosh.hpp"
#include "openvino/op/swish.hpp"
#include "openvino/op/hswish.hpp"
#include "openvino/op/mish.hpp"
#include "openvino/op/gelu.hpp"
#include "openvino/op/sign.hpp"
#include "openvino/op/hsigmoid.hpp"
#include "openvino/op/round.hpp"
#include "intel_gpu/primitives/activation.hpp"
namespace ov {
namespace intel_gpu {
void CreateUnaryEltwiseOp(Program& p, const std::shared_ptr<ngraph::Node>& op,
void CreateUnaryEltwiseOp(ProgramBuilder& p, const std::shared_ptr<ov::Node>& op,
cldnn::activation_func func, cldnn::activation_additional_params params) {
auto inputs = p.GetInputInfo(op);
std::string layerName = layer_type_name_ID(op);
@ -54,31 +54,31 @@ void CreateUnaryEltwiseOp(Program& p, const std::shared_ptr<ngraph::Node>& op,
p.add_primitive(*op, activationPrimitive);
}
static void CreateTanhOp(Program& p, const std::shared_ptr<ngraph::op::v0::Tanh>& op) {
static void CreateTanhOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Tanh>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::hyperbolic_tan, {});
}
static void CreateEluOp(Program& p, const std::shared_ptr<ngraph::op::v0::Elu>& op) {
static void CreateEluOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Elu>& op) {
auto alpha = static_cast<float>(op->get_alpha());
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::elu, {alpha});
}
static void CreateSigmoidOp(Program& p, const std::shared_ptr<ngraph::op::v0::Sigmoid>& op) {
static void CreateSigmoidOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Sigmoid>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::logistic, {});
}
static void CreateReluOp(Program& p, const std::shared_ptr<ngraph::op::v0::Relu>& op) {
static void CreateReluOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Relu>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::relu, {});
}
static void CreatePReluOp(Program& p, const std::shared_ptr<ngraph::op::v0::PRelu>& op) {
static void CreatePReluOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::PRelu>& op) {
validate_inputs_count(op, {2});
auto slope_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(1));
auto slope_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
auto slope_shape = op->get_input_partial_shape(1);
auto out_shape = op->get_output_partial_shape(0);
if (slope_node && ngraph::shape_size(slope_shape.to_shape()) == 1) {
if (slope_node && ov::shape_size(slope_shape.to_shape()) == 1) {
float slope;
OPENVINO_ASSERT(ov::op::util::get_single_value(slope_node, slope),
"[GPU] Unsupported parameter size in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
@ -94,7 +94,7 @@ static void CreatePReluOp(Program& p, const std::shared_ptr<ngraph::op::v0::PRel
}
}
static void CreateClampOp(Program& p, const std::shared_ptr<ngraph::op::v0::Clamp>& op) {
static void CreateClampOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Clamp>& op) {
double min = op->get_min();
double max = op->get_max();
if (op->get_output_element_type(0) == ov::element::i32) {
@ -109,68 +109,68 @@ static void CreateClampOp(Program& p, const std::shared_ptr<ngraph::op::v0::Clam
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::clamp, {static_cast<float>(min), static_cast<float>(max)});
}
static void CreateExpOp(Program& p, const std::shared_ptr<ngraph::op::v0::Exp>& op) {
static void CreateExpOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Exp>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::exp, {});
}
static void CreateLogicalNotOp(Program& p, const std::shared_ptr<ngraph::op::v1::LogicalNot>& op) {
static void CreateLogicalNotOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v1::LogicalNot>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::negation, {});
}
static void CreateAsinOp(Program& p, const std::shared_ptr<ngraph::op::v0::Asin>& op) {
static void CreateAsinOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Asin>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::asin, {});
}
static void CreateAsinhOp(Program& p, const std::shared_ptr<ngraph::op::v3::Asinh>& op) {
static void CreateAsinhOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::Asinh>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::asinh, {});
}
static void CreateAcosOp(Program& p, const std::shared_ptr<ngraph::op::v0::Acos>& op) {
static void CreateAcosOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Acos>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::acos, {});
}
static void CreateAcoshOp(Program& p, const std::shared_ptr<ngraph::op::v3::Acosh>& op) {
static void CreateAcoshOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::Acosh>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::acosh, {});
}
static void CreateAtanOp(Program& p, const std::shared_ptr<ngraph::op::v0::Atan>& op) {
static void CreateAtanOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Atan>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::atan, {});
}
static void CreateAtanhOp(Program& p, const std::shared_ptr<ngraph::op::v3::Atanh>& op) {
static void CreateAtanhOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::Atanh>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::atanh, {});
}
static void CreateAbsOp(Program& p, const std::shared_ptr<ngraph::op::v0::Abs>& op) {
static void CreateAbsOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Abs>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::abs, {});
}
static void CreateFloorOp(Program& p, const std::shared_ptr<ngraph::op::v0::Floor>& op) {
static void CreateFloorOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Floor>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::floor, {});
}
static void CreateCeilingOp(Program& p, const std::shared_ptr<ngraph::op::v0::Ceiling>& op) {
static void CreateCeilingOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Ceiling>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::ceil, {});
}
static void CreateSqrtOp(Program& p, const std::shared_ptr<ngraph::op::v0::Sqrt>& op) {
static void CreateSqrtOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Sqrt>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::sqrt, {});
}
static void CreateErfOp(Program& p, const std::shared_ptr<ngraph::op::v0::Erf>& op) {
static void CreateErfOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Erf>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::erf, {});
}
static void CreateHardSigmoidOp(Program& p, const std::shared_ptr<ngraph::op::v0::HardSigmoid>& op) {
static void CreateHardSigmoidOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::HardSigmoid>& op) {
validate_inputs_count(op, {3});
auto alpha_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(1));
auto beta_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(2));
auto alpha_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
auto beta_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2));
if (!alpha_node || !beta_node) {
OPENVINO_THROW("[GPU] Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
}
if (ngraph::shape_size(alpha_node->get_output_shape(0)) == 1 &&
ngraph::shape_size(beta_node->get_output_shape(0)) == 1) {
if (ov::shape_size(alpha_node->get_output_shape(0)) == 1 &&
ov::shape_size(beta_node->get_output_shape(0)) == 1) {
float alpha, beta;
if (!ov::op::util::get_single_value(alpha_node, alpha) || !ov::op::util::get_single_value(beta_node, beta)) {
OPENVINO_THROW("Unsupported parameter size in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
@ -179,24 +179,24 @@ static void CreateHardSigmoidOp(Program& p, const std::shared_ptr<ngraph::op::v0
}
}
static void CreateLogOp(Program& p, const std::shared_ptr<ngraph::op::v0::Log>& op) {
static void CreateLogOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Log>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::log, {});
}
static void CreateNegativeOp(Program& p, const std::shared_ptr<ngraph::op::v0::Negative>& op) {
static void CreateNegativeOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Negative>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::negative, {});
}
static void CreateSeluOp(Program& p, const std::shared_ptr<ngraph::op::v0::Selu>& op) {
static void CreateSeluOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Selu>& op) {
validate_inputs_count(op, {3});
auto alpha_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(1));
auto lambda_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(2));
auto alpha_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
auto lambda_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(2));
if (!alpha_node || !lambda_node) {
OPENVINO_THROW("Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
}
if (ngraph::shape_size(alpha_node->get_output_shape(0)) == 1 &&
ngraph::shape_size(lambda_node->get_output_shape(0)) == 1) {
if (ov::shape_size(alpha_node->get_output_shape(0)) == 1 &&
ov::shape_size(lambda_node->get_output_shape(0)) == 1) {
float alpha, lambda;
if (!ov::op::util::get_single_value(alpha_node, alpha) || !ov::op::util::get_single_value(lambda_node, lambda)) {
OPENVINO_THROW("Unsupported parameter size in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
@ -207,36 +207,36 @@ static void CreateSeluOp(Program& p, const std::shared_ptr<ngraph::op::v0::Selu>
}
}
static void CreateSoftPlusOp(Program& p, const std::shared_ptr<ngraph::op::v4::SoftPlus>& op) {
static void CreateSoftPlusOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v4::SoftPlus>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::softplus, {});
}
static void CreateTanOp(Program& p, const std::shared_ptr<ngraph::op::v0::Tan>& op) {
static void CreateTanOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Tan>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::tan, {});
}
static void CreateSinOp(Program& p, const std::shared_ptr<ngraph::op::v0::Sin>& op) {
static void CreateSinOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Sin>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::sin, {});
}
static void CreateSinhOp(Program& p, const std::shared_ptr<ngraph::op::v0::Sinh>& op) {
static void CreateSinhOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Sinh>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::sinh, {});
}
static void CreateCosOp(Program& p, const std::shared_ptr<ngraph::op::v0::Cos>& op) {
static void CreateCosOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Cos>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::cos, {});
}
static void CreateCoshOp(Program& p, const std::shared_ptr<ngraph::op::v0::Cosh>& op) {
static void CreateCoshOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Cosh>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::cosh, {});
}
static void CreateSwishOp(Program& p, const std::shared_ptr<ngraph::op::v4::Swish>& op) {
static void CreateSwishOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v4::Swish>& op) {
validate_inputs_count(op, {1, 2});
if (op->get_input_size() == 2) {
auto beta_node = std::dynamic_pointer_cast<ngraph::op::v0::Constant>(op->get_input_node_shared_ptr(1));
auto beta_node = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
if (beta_node) {
if (ngraph::shape_size(beta_node->get_output_shape(0)) == 1) {
if (ov::shape_size(beta_node->get_output_shape(0)) == 1) {
float beta;
if (!ov::op::util::get_single_value(beta_node, beta)) {
OPENVINO_THROW("Unsupported parameter size in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
@ -253,42 +253,42 @@ static void CreateSwishOp(Program& p, const std::shared_ptr<ngraph::op::v4::Swis
}
}
static void CreateHSwishOp(Program& p, const std::shared_ptr<ngraph::op::v4::HSwish>& op) {
static void CreateHSwishOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v4::HSwish>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::hswish, {});
}
static void CreateMishOp(Program& p, const std::shared_ptr<ngraph::op::v4::Mish>& op) {
static void CreateMishOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v4::Mish>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::mish, {});
}
static void CreateGeluOp(Program& p, const std::shared_ptr<ngraph::op::v7::Gelu>& op) {
static void CreateGeluOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v7::Gelu>& op) {
cldnn::activation_func activationFunc =
op->get_approximation_mode() == op::GeluApproximationMode::ERF ? cldnn::activation_func::gelu
: cldnn::activation_func::gelu_tanh;
CreateUnaryEltwiseOp(p, op, activationFunc, {});
}
static void CreateSoftSignOp(Program& p, const std::shared_ptr<ngraph::op::v9::SoftSign>& op) {
static void CreateSoftSignOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v9::SoftSign>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::softsign, {});
}
static void CreateGeluOp(Program &p, const std::shared_ptr<ngraph::op::v0::Gelu>& op) {
static void CreateGeluOp(ProgramBuilder &p, const std::shared_ptr<ov::op::v0::Gelu>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::gelu, {});
}
static void CreateSignOp(Program& p, const std::shared_ptr<ngraph::op::v0::Sign>& op) {
static void CreateSignOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v0::Sign>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::sign, {});
}
static void CreateHSigmoidOp(Program& p, const std::shared_ptr<ngraph::op::v5::HSigmoid>& op) {
static void CreateHSigmoidOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v5::HSigmoid>& op) {
CreateUnaryEltwiseOp(p, op, cldnn::activation_func::hsigmoid, {});
}
static void CreateRoundOp(Program& p, const std::shared_ptr<ngraph::op::v5::Round>& op) {
static void CreateRoundOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v5::Round>& op) {
auto func = cldnn::activation_func::none;
switch (op->get_mode()) {
case ngraph::op::v5::Round::RoundMode::HALF_TO_EVEN : func = cldnn::activation_func::round_half_to_even; break;
case ngraph::op::v5::Round::RoundMode::HALF_AWAY_FROM_ZERO : func = cldnn::activation_func::round_half_away_from_zero; break;
case ov::op::v5::Round::RoundMode::HALF_TO_EVEN : func = cldnn::activation_func::round_half_to_even; break;
case ov::op::v5::Round::RoundMode::HALF_AWAY_FROM_ZERO : func = cldnn::activation_func::round_half_away_from_zero; break;
default: OPENVINO_THROW("Unsupported round mode in ", op->get_friendly_name(), ": ", static_cast<int>(op->get_mode()));
}
CreateUnaryEltwiseOp(p, op, func, {});

14
src/plugins/intel_gpu/src/plugin/ops/unique.cpp
View File

@ -2,26 +2,30 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/primitives/unique.hpp"
#include "openvino/core/validation_util.hpp"
#include "openvino/op/unique.hpp"
#include "openvino/op/constant.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "ngraph/op/unique.hpp"
#include "intel_gpu/primitives/unique.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
namespace ov {
namespace intel_gpu {
namespace {
void CreateUniqueOp(Program& p, const std::shared_ptr<ngraph::op::v10::Unique>& op) {
void CreateUniqueOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v10::Unique>& op) {
validate_inputs_count(op, {1, 2});
bool flattened = true;
int64_t axis{};
if (op->get_input_size() == 2) {
auto axis_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(1));
auto axis_constant = std::dynamic_pointer_cast<ov::op::v0::Constant>(op->get_input_node_shared_ptr(1));
OPENVINO_ASSERT(axis_constant != nullptr, "[GPU] Unsupported parameter nodes type in ", op->get_friendly_name(), " (", op->get_type_name(), ")");
axis = axis_constant->cast_vector<int64_t>().at(0);
OPENVINO_SUPPRESS_DEPRECATED_START
axis = ov::normalize_axis(op.get(), axis, op->get_input_partial_shape(0).rank());
OPENVINO_SUPPRESS_DEPRECATED_END
flattened = false;
}

16
src/plugins/intel_gpu/src/plugin/ops/variable.cpp
View File

@ -2,10 +2,10 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/common_utils.hpp"
#include "ngraph/op/assign.hpp"
#include "ngraph/op/read_value.hpp"
#include "openvino/op/assign.hpp"
#include "openvino/op/read_value.hpp"
#include "intel_gpu/primitives/assign.hpp"
#include "intel_gpu/primitives/read_value.hpp"
@ -15,7 +15,7 @@ namespace intel_gpu {
namespace {
template<typename T_PRIMITIVE>
void CreateVariableAccessPrimitive(Program &p, const std::shared_ptr<ngraph::op::Op> &op,
void CreateVariableAccessPrimitive(ProgramBuilder &p, const std::shared_ptr<ov::op::Op> &op,
const std::string &variable_id) {
validate_inputs_count(op, {1});
@ -36,19 +36,19 @@ void CreateVariableAccessPrimitive(Program &p, const std::shared_ptr<ngraph::op:
p.add_primitive(*op, prim);
}
void CreateReadValueOp(Program& p, const std::shared_ptr<ngraph::op::v3::ReadValue>& op) {
void CreateReadValueOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::ReadValue>& op) {
CreateVariableAccessPrimitive<cldnn::read_value>(p, op, op->get_variable_id());
}
void CreateAssignOp(Program& p, const std::shared_ptr<ngraph::op::v3::Assign>& op) {
void CreateAssignOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v3::Assign>& op) {
CreateVariableAccessPrimitive<cldnn::assign>(p, op, op->get_variable_id());
}
void CreateReadValueOp(Program& p, const std::shared_ptr<ngraph::op::v6::ReadValue>& op) {
void CreateReadValueOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v6::ReadValue>& op) {
CreateVariableAccessPrimitive<cldnn::read_value>(p, op, op->get_variable_id());
}
void CreateAssignOp(Program& p, const std::shared_ptr<ngraph::op::v6::Assign>& op) {
void CreateAssignOp(ProgramBuilder& p, const std::shared_ptr<ov::op::v6::Assign>& op) {
CreateVariableAccessPrimitive<cldnn::assign>(p, op, op->get_variable_id());
}

6
src/plugins/intel_gpu/src/plugin/plugin.cpp
View File

@ -302,7 +302,7 @@ QueryNetworkResult Plugin::QueryNetwork(const CNNNetwork& network,
config.set_user_property(preprocess_config(orig_config));
config.apply_user_properties(ctx->get_engine().get_device_info());
Program prog(ctx->get_engine(), config);
ProgramBuilder prog(ctx->get_engine(), config);
bool dyn_shape_batch_found = false;
auto model = network.getFunction();
@ -859,7 +859,7 @@ uint32_t Plugin::get_max_batch_size(const std::map<std::string, Parameter>& opti
auto& engine = get_default_context(device_id)->get_impl()->get_engine();
std::shared_ptr<Program> program;
std::shared_ptr<ProgramBuilder> program;
GPU_DEBUG_IF(debug_config->base_batch_for_memory_estimation > 0) {
size_t user_specified_base_batch_size = debug_config->base_batch_for_memory_estimation;
@ -919,7 +919,7 @@ uint32_t Plugin::get_max_batch_size(const std::map<std::string, Parameter>& opti
auto nGraphFunc = cloned_network.getFunction();
TransformationsPipeline transformations(config, device_info);
transformations.apply(nGraphFunc);
program = std::make_shared<Program>(cloned_network, engine, config, false, true);
program = std::make_shared<ProgramBuilder>(cloned_network, engine, config, false, true);
std::pair<int64_t, int64_t> device_memory_usage = program->GetCompiledProgram(0)->get_estimated_device_mem_usage();
if (device_memory_usage.first == static_cast<int64_t>(-1L) && device_memory_usage.second == static_cast<int64_t>(-1L)) {
return static_cast<uint32_t>(max_batch_size);

100
src/plugins/intel_gpu/src/plugin/program.cpp → src/plugins/intel_gpu/src/plugin/program_builder.cpp
View File

@ -2,14 +2,13 @@
// SPDX-License-Identifier: Apache-2.0
//
#if defined(__unix__) && !defined(__ANDROID__)
#include <malloc.h>
#endif
#include "openvino/core/graph_util.hpp"
#include "openvino/runtime/system_conf.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/split.hpp"
#include "openvino/op/variadic_split.hpp"
#include "intel_gpu/plugin/program.hpp"
#include "intel_gpu/plugin/program_builder.hpp"
#include "intel_gpu/plugin/transformations_pipeline.hpp"
#include "intel_gpu/runtime/itt.hpp"
#include "intel_gpu/runtime/debug_configuration.hpp"
@ -20,39 +19,44 @@
# include <dlfcn.h>
#endif
#if defined(__unix__) && !defined(__ANDROID__)
#include <malloc.h>
#endif
using namespace InferenceEngine;
using namespace InferenceEngine::details;
namespace ov {
namespace intel_gpu {
const cldnn::primitive_id Program::m_preProcessTag("_cldnn_input_preprocess");
const cldnn::primitive_id Program::m_meanValuesTag("_cldnn_mean_values");
const cldnn::primitive_id Program::m_preCustomLayerTag("_cldnn_custom_preprocess");
const cldnn::primitive_id Program::m_postCustomLayerTag("_cldnn_custom_postprocess");
Program::factories_map_t Program::factories_map = {};
std::mutex Program::m_mutex = {};
const cldnn::primitive_id ProgramBuilder::m_preProcessTag("_cldnn_input_preprocess");
const cldnn::primitive_id ProgramBuilder::m_meanValuesTag("_cldnn_mean_values");
const cldnn::primitive_id ProgramBuilder::m_preCustomLayerTag("_cldnn_custom_preprocess");
const cldnn::primitive_id ProgramBuilder::m_postCustomLayerTag("_cldnn_custom_postprocess");
ProgramBuilder::factories_map_t ProgramBuilder::factories_map = {};
std::mutex ProgramBuilder::m_mutex = {};
std::string layer_type_lower(const ngraph::Node* op) {
std::string layer_type_lower(const ov::Node* op) {
std::string layerType = op->get_type_name();
std::transform(layerType.begin(), layerType.end(), layerType.begin(),
[](unsigned char c) -> unsigned char { return std::tolower(c); });
return layerType;
}
std::string layer_type_name_ID(const ngraph::Node* op) {
std::string layer_type_name_ID(const ov::Node* op) {
return layer_type_lower(op) + ":" + op->get_friendly_name();
}
std::string layer_type_lower(const std::shared_ptr<ngraph::Node>& op) {
std::string layer_type_lower(const std::shared_ptr<ov::Node>& op) {
return layer_type_lower(op.get());
}
std::string layer_type_name_ID(const std::shared_ptr<ngraph::Node>& op) {
std::string layer_type_name_ID(const std::shared_ptr<ov::Node>& op) {
return layer_type_name_ID(op.get());
}
void Program::ChangeInputBatch(int batch) {
void ProgramBuilder::ChangeInputBatch(int batch) {
m_curBatch = batch;
}
@ -66,7 +70,7 @@ auto getParamName = [](const std::shared_ptr<ov::Node>& param) -> std::string {
// detect the only supported dynamic shape case -
// exactly one dimension is dynamic in input params with defined min/max interval
bool Program::IsDynBatchModel(const std::shared_ptr<ov::Model>& model,
bool ProgramBuilder::IsDynBatchModel(const std::shared_ptr<ov::Model>& model,
std::map<std::string, ov::PartialShape>& shapes,
std::map<std::string, std::pair<int64_t, int64_t>>& batch_dim) {
for (const auto& param : model->get_parameters()) {
@ -120,7 +124,7 @@ bool Program::IsDynBatchModel(const std::shared_ptr<ov::Model>& model,
return dyn_shape_batch_found;
}
Program::Program(InferenceEngine::CNNNetwork& network, cldnn::engine& engine, const ExecutionConfig& config,
ProgramBuilder::ProgramBuilder(InferenceEngine::CNNNetwork& network, cldnn::engine& engine, const ExecutionConfig& config,
bool createTopologyOnly, bool partialBuild,
InferenceEngine::InputsDataMap* inputs, InferenceEngine::OutputsDataMap* outputs,
std::shared_ptr<ov::threading::IStreamsExecutor> task_executor, bool innerProgram)
@ -173,7 +177,7 @@ Program::Program(InferenceEngine::CNNNetwork& network, cldnn::engine& engine, co
auto ops = func->get_ordered_ops();
bool dyn_shape_batch_found = false;
std::map<std::string, ngraph::PartialShape> shapes;
std::map<std::string, ov::PartialShape> shapes;
std::map<std::string, std::pair<int64_t, int64_t>> batch_dim;
dyn_shape_batch_found = IsDynBatchModel(func, shapes, batch_dim);
@ -199,7 +203,7 @@ Program::Program(InferenceEngine::CNNNetwork& network, cldnn::engine& engine, co
// clone the source model, find the batch dim
// and reshape the model to next batch size
auto new_func = func->clone();
std::map<ov::Output<ov::Node>, ngraph::PartialShape> new_shapes;
std::map<ov::Output<ov::Node>, ov::PartialShape> new_shapes;
for (const auto& param : new_func->get_parameters()) {
ov::PartialShape pshape = param->get_output_partial_shape(0);
@ -248,7 +252,7 @@ Program::Program(InferenceEngine::CNNNetwork& network, cldnn::engine& engine, co
// and store them into internal maps
// same operations as above, but for maximum batch
auto new_func = func->clone();
std::map<ov::Output<ov::Node>, ngraph::PartialShape> new_shapes;
std::map<ov::Output<ov::Node>, ov::PartialShape> new_shapes;
for (const auto& param : new_func->get_parameters()) {
ov::PartialShape pshape = param->get_output_partial_shape(0);
@ -300,7 +304,7 @@ Program::Program(InferenceEngine::CNNNetwork& network, cldnn::engine& engine, co
}
}
Program::Program(cldnn::engine& engine, const ExecutionConfig& config,
ProgramBuilder::ProgramBuilder(cldnn::engine& engine, const ExecutionConfig& config,
InferenceEngine::InputsDataMap* inputs, InferenceEngine::OutputsDataMap* outputs)
: m_max_batch(1)
, m_curBatch(-1)
@ -314,7 +318,7 @@ Program::Program(cldnn::engine& engine, const ExecutionConfig& config,
m_networkOutputs = *outputs;
}
int Program::GetMaxBatchSizeForSingleProgram() {
int ProgramBuilder::GetMaxBatchSizeForSingleProgram() {
auto max_dynamic_batch = m_config.get_property(ov::intel_gpu::max_dynamic_batch);
if (max_dynamic_batch > 1) {
// calculate number of networks necessary based on binary log
@ -333,20 +337,20 @@ int Program::GetMaxBatchSizeForSingleProgram() {
return 0;
}
std::shared_ptr<cldnn::program> Program::GetCompiledProgram(int program_id) {
std::shared_ptr<cldnn::program> ProgramBuilder::GetCompiledProgram(int program_id) {
if (program_id >= static_cast<int32_t>(m_programs.size()))
OPENVINO_THROW("Invalid program ID");
return m_programs[program_id];
}
void Program::PrepareBuild(InferenceEngine::InputsDataMap networkInputs, InferenceEngine::OutputsDataMap networkOutputs) {
void ProgramBuilder::PrepareBuild(InferenceEngine::InputsDataMap networkInputs, InferenceEngine::OutputsDataMap networkOutputs) {
m_topology.reset(new cldnn::topology());
m_networkInputs = networkInputs;
m_networkOutputs = networkOutputs;
}
void Program::CleanupBuild() {
void ProgramBuilder::CleanupBuild() {
m_topology.reset();
m_networkInputs.clear();
m_networkOutputs.clear();
@ -360,11 +364,11 @@ void Program::CleanupBuild() {
#endif
}
std::shared_ptr<cldnn::program> Program::BuildProgram(const std::vector<std::shared_ptr<ngraph::Node>>& ops,
std::shared_ptr<cldnn::program> ProgramBuilder::BuildProgram(const std::vector<std::shared_ptr<ov::Node>>& ops,
InferenceEngine::InputsDataMap networkInputs,
InferenceEngine::OutputsDataMap networkOutputs,
bool createTopologyOnly, bool partialBuild, bool innerProgram) {
OV_ITT_SCOPED_TASK(itt::domains::intel_gpu_plugin, "Program::BuildProgram");
OV_ITT_SCOPED_TASK(itt::domains::intel_gpu_plugin, "ProgramBuilder::BuildProgram");
// std::cout << "BuildProgram " << createTopologyOnly << ", " << partialBuild << ", " << innerProgram << std::endl;
// In the case of inner program, allow_new_shape_infer flag is setted by outside of program.
// So, do not check allow_new_shape_infer for inner program build
@ -393,7 +397,7 @@ std::shared_ptr<cldnn::program> Program::BuildProgram(const std::vector<std::sha
if (createTopologyOnly) {
return {};
} else {
OV_ITT_SCOPED_TASK(itt::domains::intel_gpu_plugin, "Program::CreateProgram");
OV_ITT_SCOPED_TASK(itt::domains::intel_gpu_plugin, "ProgramBuilder::CreateProgram");
cldnn::program::ptr program;
try {
program = cldnn::program::build_program(m_engine, *m_topology, m_config, get_task_executor());
@ -406,8 +410,8 @@ std::shared_ptr<cldnn::program> Program::BuildProgram(const std::vector<std::sha
}
}
bool Program::IsOpSupported(const InferenceEngine::CNNNetwork& network, const std::shared_ptr<ngraph::Node>& op) {
OV_ITT_SCOPED_TASK(itt::domains::intel_gpu_plugin, "Program::IsOpSupported");
bool ProgramBuilder::IsOpSupported(const InferenceEngine::CNNNetwork& network, const std::shared_ptr<ov::Node>& op) {
OV_ITT_SCOPED_TASK(itt::domains::intel_gpu_plugin, "ProgramBuilder::IsOpSupported");
cldnn::topology topology;
try {
// Query mode disables checks that input primitives are created,
@ -434,13 +438,13 @@ bool Program::IsOpSupported(const InferenceEngine::CNNNetwork& network, const st
return true;
}
void Program::CreateSingleLayerPrimitive(cldnn::topology& topology, const std::shared_ptr<ngraph::Node>& op) {
OV_ITT_SCOPED_TASK(itt::domains::intel_gpu_plugin, "Program::CreateSingleLayerPrimitive");
void ProgramBuilder::CreateSingleLayerPrimitive(cldnn::topology& topology, const std::shared_ptr<ov::Node>& op) {
OV_ITT_SCOPED_TASK(itt::domains::intel_gpu_plugin, "ProgramBuilder::CreateSingleLayerPrimitive");
GPU_DEBUG_LOG << "Process " << "op::v" << op->get_type_info().version_id << "::" << op->get_type_name() << " operation "
<< "(friendly_name=" << op->get_friendly_name() << ")" << std::endl;
bool is_created = false;
const ngraph::NodeTypeInfo* op_type_info = &op->get_type_info();
const ov::NodeTypeInfo* op_type_info = &op->get_type_info();
while (op_type_info != nullptr) {
auto customLayer = m_custom_layers.find(op->get_type_name());
if (customLayer != m_custom_layers.end()) {
@ -464,7 +468,7 @@ void Program::CreateSingleLayerPrimitive(cldnn::topology& topology, const std::s
}
}
std::vector<cldnn::input_info> Program::GetInputInfo(const std::shared_ptr<ngraph::Node>& op) const {
std::vector<cldnn::input_info> ProgramBuilder::GetInputInfo(const std::shared_ptr<ov::Node>& op) const {
if (!op) {
return {};
}
@ -477,8 +481,8 @@ std::vector<cldnn::input_info> Program::GetInputInfo(const std::shared_ptr<ngrap
std::string prevName = layer_type_name_ID(prevOp);
bool is_legacy_multiple_outputs = !allow_new_shape_infer
// Note:: Currently Split/Variadic Split are divided to multiple crops
|| ngraph::is_type<ngraph::op::v1::Split>(prevOp)
|| ngraph::is_type<ngraph::op::v1::VariadicSplit>(prevOp);
|| ov::is_type<ov::op::v1::Split>(prevOp)
|| ov::is_type<ov::op::v1::VariadicSplit>(prevOp);
if (prevOp->get_output_size() > 1 && is_legacy_multiple_outputs) {
prevName += ".out" + std::to_string(op->get_input_source_output(i).get_index());
}
@ -496,7 +500,7 @@ std::vector<cldnn::input_info> Program::GetInputInfo(const std::shared_ptr<ngrap
return inputInfo;
}
void Program::init_profile_info(const cldnn::primitive& prim) {
void ProgramBuilder::init_profile_info(const cldnn::primitive& prim) {
perfMap[prim.id].first = prim.id;
auto& perfEntry = perfMap[prim.id].second;
perfEntry.layerType = prim.origin_op_type_name;
@ -506,7 +510,7 @@ void Program::init_profile_info(const cldnn::primitive& prim) {
perfEntry.parentPrimitive = prim.origin_op_name;
}
void Program::AddVariableStateInfo(const std::string& variable_id, const cldnn::layout& layout) {
void ProgramBuilder::AddVariableStateInfo(const std::string& variable_id, const cldnn::layout& layout) {
auto it = m_variablesStateInfo.find(variable_id);
if (it != m_variablesStateInfo.end())
it->second.insert(layout);
@ -514,8 +518,8 @@ void Program::AddVariableStateInfo(const std::string& variable_id, const cldnn::
m_variablesStateInfo.insert({variable_id, { layout }});
}
void Program::add_primitive(const ngraph::Node& op, std::shared_ptr<cldnn::primitive> prim, std::vector<std::string> aliases) {
OPENVINO_ASSERT(m_topology != nullptr, "[GPU] Invalid Program builder state: topology is nullptr");
void ProgramBuilder::add_primitive(const ov::Node& op, std::shared_ptr<cldnn::primitive> prim, std::vector<std::string> aliases) {
OPENVINO_ASSERT(m_topology != nullptr, "[GPU] Invalid ProgramBuilder builder state: topology is nullptr");
prim->origin_op_name = op.get_friendly_name();
prim->origin_op_type_name = op.get_type_name();
@ -547,7 +551,7 @@ void Program::add_primitive(const ngraph::Node& op, std::shared_ptr<cldnn::primi
m_topology->add_primitive(prim);
}
bool Program::requires_new_shape_infer(const ngraph::Node& op) const {
bool ProgramBuilder::requires_new_shape_infer(const ov::Node& op) const {
if (op.is_dynamic()) {
return true;
}
@ -565,14 +569,14 @@ bool Program::requires_new_shape_infer(const ngraph::Node& op) const {
return false;
}
// TODO: Does it make sense to add such method to ngraph core?
bool IsNodeOnConstPath(const std::shared_ptr<ngraph::Node>& node) {
std::set<std::shared_ptr<ngraph::Node>> nodes_processed = {};
std::function<bool(const std::shared_ptr<ngraph::Node>&)> is_const_node = [&nodes_processed, &is_const_node](const std::shared_ptr<ngraph::Node>& node) {
// TODO: Does it make sense to add such method to ov core?
bool IsNodeOnConstPath(const std::shared_ptr<ov::Node>& node) {
std::set<std::shared_ptr<ov::Node>> nodes_processed = {};
std::function<bool(const std::shared_ptr<ov::Node>&)> is_const_node = [&nodes_processed, &is_const_node](const std::shared_ptr<ov::Node>& node) {
if (nodes_processed.count(node)) return true;
nodes_processed.insert(node);
// If input is constant, then drop it from the processing list
if (std::dynamic_pointer_cast<ngraph::op::v0::Constant>(node) != nullptr)
if (std::dynamic_pointer_cast<ov::op::v0::Constant>(node) != nullptr)
return true;
// If the node doesn't have any parents and it's not a constant, then we deal with dynamic path
if (node->get_input_size() == 0)
@ -587,7 +591,7 @@ bool IsNodeOnConstPath(const std::shared_ptr<ngraph::Node>& node) {
return is_const_node(node);
}
void validate_inputs_count(const std::shared_ptr<ngraph::Node>& op, std::vector<size_t> valid_inputs_count) {
void validate_inputs_count(const std::shared_ptr<ov::Node>& op, std::vector<size_t> valid_inputs_count) {
for (auto ic : valid_inputs_count) {
if (op->get_input_size() == ic) {
return;

18
src/plugins/intel_gpu/src/plugin/transformations/convert_pooling_to_reduce.cpp
View File

@ -8,15 +8,17 @@
#include <memory>
#include <vector>
#include <ngraph/opsets/opset9.hpp>
#include <ngraph/pattern/op/wrap_type.hpp>
#include <ngraph/rt_info.hpp>
#include "openvino/op/avg_pool.hpp"
#include "openvino/op/reduce_mean.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "openvino/core/rt_info.hpp"
ov::intel_gpu::ConvertAvgPoolingToReduce::ConvertAvgPoolingToReduce() {
// Check all AvgPool nodes
auto m = std::make_shared<ngraph::pattern::Matcher>(ngraph::pattern::wrap_type<ngraph::opset9::AvgPool>(), "ConvertAvgPoolingToReduce");
register_matcher(m, [&](ngraph::pattern::Matcher& m) {
auto pool = std::dynamic_pointer_cast<ngraph::opset9::AvgPool>(m.get_match_root());
auto m = std::make_shared<ov::pass::pattern::Matcher>(ov::pass::pattern::wrap_type<ov::op::v1::AvgPool>(), "ConvertAvgPoolingToReduce");
register_matcher(m, [&](ov::pass::pattern::Matcher& m) {
auto pool = std::dynamic_pointer_cast<ov::op::v1::AvgPool>(m.get_match_root());
if (!pool || transformation_callback(pool)) {
return false;
}
@ -45,9 +47,9 @@ ov::intel_gpu::ConvertAvgPoolingToReduce::ConvertAvgPoolingToReduce() {
std::vector<int64_t> axes_shape(rank - 2);
std::iota(axes_shape.begin(), axes_shape.end(), 2);
auto reduce = std::make_shared<ngraph::opset9::ReduceMean>(
auto reduce = std::make_shared<ov::op::v1::ReduceMean>(
pool->input_value(0),
ngraph::opset9::Constant::create(ngraph::element::i64, ngraph::Shape{axes_shape.size()}, axes_shape),
ov::op::v0::Constant::create(ov::element::i64, ov::Shape{axes_shape.size()}, axes_shape),
true);
reduce->set_friendly_name(pool->get_friendly_name());

10
src/plugins/intel_gpu/src/plugin/transformations/convert_pooling_to_reduce.hpp
View File

@ -4,17 +4,17 @@
#pragma once
#include <ngraph/pass/graph_rewrite.hpp>
#include <transformations_visibility.hpp>
#include "openvino/pass/graph_rewrite.hpp"
#include "openvino/core/visibility.hpp"
namespace ov {
namespace intel_gpu {
class ConvertAvgPoolingToReduce : public ngraph::pass::MatcherPass {
class ConvertAvgPoolingToReduce : public ov::pass::MatcherPass {
public:
OPENVINO_RTTI("ConvertAvgPoolingToReduce", "0");
ConvertAvgPoolingToReduce();
};
} // namespace pass
} // namespace ngraph
} // namespace intel_gpu
} // namespace ov

19
src/plugins/intel_gpu/src/plugin/transformations/convert_shapeof.cpp
View File

@ -4,29 +4,28 @@
#include "convert_shapeof.hpp"
#include "openvino/op/shape_of.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "openvino/core/rt_info.hpp"
#include <memory>
#include <ngraph/pattern/op/wrap_type.hpp>
#include <ngraph/rt_info.hpp>
#include <openvino/opsets/opset1.hpp>
#include <openvino/opsets/opset3.hpp>
#include <vector>
ov::intel_gpu::ConvertShapeOf1To3::ConvertShapeOf1To3() {
auto shapeof1 = ov::pass::pattern::wrap_type<ov::opset1::ShapeOf>();
auto shapeof1 = ov::pass::pattern::wrap_type<ov::op::v0::ShapeOf>();
matcher_pass_callback callback = [](ov::pass::pattern::Matcher& m) {
auto shapeof1 = std::dynamic_pointer_cast<ov::opset1::ShapeOf>(m.get_match_root());
auto shapeof1 = std::dynamic_pointer_cast<ov::op::v0::ShapeOf>(m.get_match_root());
if (!shapeof1) {
return false;
}
auto new_shapeof3 = std::make_shared<ov::opset3::ShapeOf>(shapeof1->input_value(0));
auto new_shapeof3 = std::make_shared<ov::op::v3::ShapeOf>(shapeof1->input_value(0));
new_shapeof3->set_friendly_name(shapeof1->get_friendly_name());
ngraph::copy_runtime_info(shapeof1, new_shapeof3);
ngraph::replace_node(shapeof1, new_shapeof3);
ov::copy_runtime_info(shapeof1, new_shapeof3);
ov::replace_node(shapeof1, new_shapeof3);
return true;
};
auto m = std::make_shared<ngraph::pattern::Matcher>(shapeof1, "ConvertShapeOf1To3");
auto m = std::make_shared<ov::pass::pattern::Matcher>(shapeof1, "ConvertShapeOf1To3");
register_matcher(m, callback);
}

4
src/plugins/intel_gpu/src/plugin/transformations/convert_shapeof.hpp
View File

@ -4,8 +4,8 @@
#pragma once
#include <ngraph/pass/graph_rewrite.hpp>
#include <transformations_visibility.hpp>
#include "openvino/pass/graph_rewrite.hpp"
#include "openvino/core/visibility.hpp"
namespace ov {
namespace intel_gpu {

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

@ -2,14 +2,21 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "openvino/core/rt_info.hpp"
#include "openvino/op/reduce_sum.hpp"
#include "openvino/op/reduce_mean.hpp"
#include "openvino/op/reduce_prod.hpp"
#include "openvino/op/reduce_min.hpp"
#include "openvino/op/reduce_max.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/reshape.hpp"
#include "decompose_reduce_for_false_keepdims.hpp"
#include <algorithm>
#include <cassert>
#include <memory>
#include <ngraph/opsets/opset10.hpp>
#include <ngraph/pattern/op/wrap_type.hpp>
#include <ngraph/rt_info.hpp>
#include <vector>
namespace ov {
@ -17,17 +24,17 @@ namespace intel_gpu {
DecomposeReduceForFalseKeepDims::DecomposeReduceForFalseKeepDims() {
// Get one MatcherPass for all modes
auto reduce_pattern = ngraph::pattern::wrap_type<ngraph::opset10::ReduceSum,
ngraph::opset10::ReduceMean,
ngraph::opset10::ReduceProd,
ngraph::opset10::ReduceMin,
ngraph::opset10::ReduceMax>(
{ngraph::pattern::any_input(ngraph::pattern::has_static_shape()),
ngraph::pattern::wrap_type<ngraph::opset10::Constant>()},
ngraph::pattern::has_static_shape());
auto reduce_pattern = ov::pass::pattern::wrap_type<ov::op::v1::ReduceSum,
ov::op::v1::ReduceMean,
ov::op::v1::ReduceProd,
ov::op::v1::ReduceMin,
ov::op::v1::ReduceMax>(
{ov::pass::pattern::any_input(ov::pass::pattern::has_static_shape()),
ov::pass::pattern::wrap_type<ov::op::v0::Constant>()},
ov::pass::pattern::has_static_shape());
// register callback
ov::matcher_pass_callback callback = [=](ngraph::pattern::Matcher& m) {
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();
auto reduce =
as_type_ptr<op::util::ArithmeticReductionKeepDims>(pattern_map.at(reduce_pattern).get_node_shared_ptr());
@ -45,23 +52,23 @@ DecomposeReduceForFalseKeepDims::DecomposeReduceForFalseKeepDims() {
if (!reduce->get_keep_dims() &&
need_transformation_for_reordered_axes(axes_vector, input_rank, (input_rank - 2)) &&
input_shape.size() < 6) {
ngraph::NodeVector new_ops;
ov::NodeVector new_ops;
// Reduce
auto reduce_const =
ngraph::opset10::Constant::create(ngraph::element::i64, ngraph::Shape{axes_vector.size()}, axes_vector);
ov::op::v0::Constant::create(ov::element::i64, ov::Shape{axes_vector.size()}, axes_vector);
// Add each reduce mode supported by oneDNN
if (ngraph::is_type<ngraph::opset10::ReduceSum>(reduce))
input = std::make_shared<ngraph::opset10::ReduceSum>(input, reduce_const, true);
else if (ngraph::is_type<ngraph::opset10::ReduceMean>(reduce))
input = std::make_shared<ngraph::opset10::ReduceMean>(input, reduce_const, true);
else if (ngraph::is_type<ngraph::opset10::ReduceMin>(reduce))
input = std::make_shared<ngraph::opset10::ReduceMin>(input, reduce_const, true);
else if (ngraph::is_type<ngraph::opset10::ReduceMax>(reduce))
input = std::make_shared<ngraph::opset10::ReduceMax>(input, reduce_const, true);
else if (ngraph::is_type<ngraph::opset10::ReduceProd>(reduce))
input = std::make_shared<ngraph::opset10::ReduceProd>(input, reduce_const, true);
if (ov::is_type<ov::op::v1::ReduceSum>(reduce))
input = std::make_shared<ov::op::v1::ReduceSum>(input, reduce_const, true);
else if (ov::is_type<ov::op::v1::ReduceMean>(reduce))
input = std::make_shared<ov::op::v1::ReduceMean>(input, reduce_const, true);
else if (ov::is_type<ov::op::v1::ReduceMin>(reduce))
input = std::make_shared<ov::op::v1::ReduceMin>(input, reduce_const, true);
else if (ov::is_type<ov::op::v1::ReduceMax>(reduce))
input = std::make_shared<ov::op::v1::ReduceMax>(input, reduce_const, true);
else if (ov::is_type<ov::op::v1::ReduceProd>(reduce))
input = std::make_shared<ov::op::v1::ReduceProd>(input, reduce_const, true);
else
return false;
@ -69,21 +76,21 @@ DecomposeReduceForFalseKeepDims::DecomposeReduceForFalseKeepDims() {
new_ops.push_back(input.get_node_shared_ptr());
// Reshape
auto reshape_shape = ngraph::Shape((input_rank - axes_vector.size()), 1);
auto reshape_shape = ov::Shape((input_rank - axes_vector.size()), 1);
// Expected that a feature axis is only un-reduced unless a new case for this decomposition is added.
assert(reshape_shape.size() == 1);
reshape_shape[0] = reduce_shape[0];
input = std::make_shared<ngraph::opset10::Reshape>(
input = std::make_shared<ov::op::v1::Reshape>(
input,
ngraph::opset10::Constant::create(ngraph::element::i64,
ngraph::Shape{reshape_shape.size()},
ov::op::v0::Constant::create(ov::element::i64,
ov::Shape{reshape_shape.size()},
reshape_shape),
false);
input.get_node_shared_ptr()->set_friendly_name(reduce->get_friendly_name() + "_reshape_false_keepdims");
new_ops.push_back(input.get_node_shared_ptr());
ngraph::copy_runtime_info(reduce, new_ops);
ov::copy_runtime_info(reduce, new_ops);
reduce->output(0).replace(input);
return true;
}
@ -91,7 +98,7 @@ DecomposeReduceForFalseKeepDims::DecomposeReduceForFalseKeepDims() {
return false;
};
auto m = std::make_shared<ngraph::pattern::Matcher>(reduce_pattern, "DecomposeReduceForFalseKeepDims");
auto m = std::make_shared<ov::pass::pattern::Matcher>(reduce_pattern, "DecomposeReduceForFalseKeepDims");
register_matcher(m, callback);
}

6
src/plugins/intel_gpu/src/plugin/transformations/decompose_reduce_for_false_keepdims.hpp
View File

@ -4,8 +4,8 @@
#pragma once
#include <ngraph/pass/graph_rewrite.hpp>
#include <transformations_visibility.hpp>
#include "openvino/pass/graph_rewrite.hpp"
#include "openvino/core/visibility.hpp"
namespace ov {
namespace intel_gpu {
@ -15,7 +15,7 @@ namespace intel_gpu {
* A clDNN Reduce reorders un-reduced axes of its output tensor to b-f and spatial order when keep_dims is false.
* oneDNN reduction does not allow this. And clDNN execution shows a huge perf drop for blocked formats.
*/
class DecomposeReduceForFalseKeepDims : public ngraph::pass::MatcherPass {
class DecomposeReduceForFalseKeepDims : public ov::pass::MatcherPass {
public:
// Decompose reduce if keep_dims is false and it reduces batch and spatial axes
DecomposeReduceForFalseKeepDims();

186
src/plugins/intel_gpu/src/plugin/transformations/einsum_decomposition.cpp
View File

@ -4,11 +4,19 @@
#include "einsum_decomposition.hpp"
#include <unordered_map>
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "openvino/core/rt_info.hpp"
#include "openvino/op/einsum.hpp"
#include "openvino/op/constant.hpp"
#include "openvino/op/unsqueeze.hpp"
#include "openvino/op/reshape.hpp"
#include "openvino/op/multiply.hpp"
#include "openvino/op/transpose.hpp"
#include "openvino/op/broadcast.hpp"
#include "openvino/op/reduce_sum.hpp"
#include "openvino/op/matmul.hpp"
#include <ngraph/opsets/opset7.hpp>
#include <ngraph/pattern/op/wrap_type.hpp>
#include <ngraph/rt_info.hpp>
#include <unordered_map>
namespace ov {
namespace intel_gpu {
@ -24,7 +32,7 @@ using LabelDimMap = std::unordered_map<std::string, std::vector<size_t>>;
/// \return a vector of pairs with input indices assuming that the intermediate result is
/// appended in the tail
///
std::vector<std::pair<size_t, size_t>> compute_einsum_path(std::shared_ptr<const ngraph::opset7::Einsum> einsum_node) {
std::vector<std::pair<size_t, size_t>> compute_einsum_path(std::shared_ptr<const ov::op::v7::Einsum> einsum_node) {
// TODO: implement algorithm for finding (pseudo-)optimal einsum_path
std::vector<std::pair<size_t, size_t>> einsum_path;
const size_t num_inputs = einsum_node->get_input_size();
@ -111,7 +119,7 @@ std::string generate_grouping_subscript(const std::string& input_subscript, cons
return input_subscript;
}
auto labels = ngraph::opset7::Einsum::extract_labels(input_subscript);
auto labels = ov::op::v7::Einsum::extract_labels(input_subscript);
std::string required_subscript = "";
for (auto index : labels_inds) {
required_subscript += labels[index];
@ -131,8 +139,8 @@ std::string generate_grouping_subscript(const std::string& input_subscript, cons
/// \param new_node New input node to be inserted in the tail
/// \param new_subscript New input subscript to be inserted in the tail
///
void update_operands(ngraph::OutputVector& input_nodes, std::vector<std::string>& input_subscripts, size_t input_ind1, size_t input_ind2,
const ngraph::Output<ngraph::Node>& new_node, const std::string& new_subscript) {
void update_operands(ov::OutputVector& input_nodes, std::vector<std::string>& input_subscripts, size_t input_ind1, size_t input_ind2,
const ov::Output<ov::Node>& new_node, const std::string& new_subscript) {
NGRAPH_CHECK(input_ind1 < input_ind2);
NGRAPH_CHECK(input_ind2 < input_nodes.size());
NGRAPH_CHECK(input_ind2 < input_subscripts.size());
@ -154,12 +162,12 @@ void update_operands(ngraph::OutputVector& input_nodes, std::vector<std::string>
///
/// \return sub-shape
///
ngraph::Shape compute_sub_shape(const ngraph::Shape& input_shape, size_t begin, size_t end, bool is_product = false) {
ov::Shape compute_sub_shape(const ov::Shape& input_shape, size_t begin, size_t end, bool is_product = false) {
NGRAPH_CHECK(end <= input_shape.size());
if (end <= begin) {
return ngraph::Shape();
return ov::Shape();
}
ngraph::Shape sub_shape(input_shape.begin() + begin, input_shape.begin() + end);
ov::Shape sub_shape(input_shape.begin() + begin, input_shape.begin() + end);
if (is_product) {
const auto prod = shape_size(sub_shape);
@ -179,13 +187,13 @@ ngraph::Shape compute_sub_shape(const ngraph::Shape& input_shape, size_t begin,
/// \return Unsqueezed input node if a vector of unsqueezing dimensions is not empty,
/// otherwise, the original input node
///
ngraph::Output<ngraph::Node> unsqueeze_input(const ngraph::Output<ngraph::Node>& input_node, const std::vector<int64_t>& unsqueeze_axes,
ngraph::NodeVector& subgraph_nodes) {
ov::Output<ov::Node> unsqueeze_input(const ov::Output<ov::Node>& input_node, const std::vector<int64_t>& unsqueeze_axes,
ov::NodeVector& subgraph_nodes) {
if (unsqueeze_axes.empty()) {
return input_node;
}
auto unsqueeze_axes_const = ngraph::opset7::Constant::create(ngraph::element::Type_t::i64, ngraph::Shape {unsqueeze_axes.size()}, unsqueeze_axes);
auto unsqueeze = std::make_shared<ngraph::opset7::Unsqueeze>(input_node, unsqueeze_axes_const);
auto unsqueeze_axes_const = ov::op::v0::Constant::create(ov::element::Type_t::i64, ov::Shape {unsqueeze_axes.size()}, unsqueeze_axes);
auto unsqueeze = std::make_shared<ov::op::v0::Unsqueeze>(input_node, unsqueeze_axes_const);
subgraph_nodes.insert(subgraph_nodes.end(), {unsqueeze_axes_const, unsqueeze});
return unsqueeze->output(0);
}
@ -204,16 +212,16 @@ ngraph::Output<ngraph::Node> unsqueeze_input(const ngraph::Output<ngraph::Node>&
///
/// \return Reshaped input node
///
ngraph::Output<ngraph::Node> reshape_input_for_matmul(const ngraph::Output<ngraph::Node>& input_node,
const ngraph::Shape& common_sub_shape,
const ngraph::Shape& separate_sub_shape,
const ngraph::Shape& reduced_sub_shape_prod,
ov::Output<ov::Node> reshape_input_for_matmul(const ov::Output<ov::Node>& input_node,
const ov::Shape& common_sub_shape,
const ov::Shape& separate_sub_shape,
const ov::Shape& reduced_sub_shape_prod,
bool is_separate_first,
ngraph::NodeVector& subgraph_nodes) {
ngraph::Shape new_shape{common_sub_shape.begin(), common_sub_shape.end()};
ov::NodeVector& subgraph_nodes) {
ov::Shape new_shape{common_sub_shape.begin(), common_sub_shape.end()};
// compute a product of a sub-shape for separate labels
ngraph::Shape separate_sub_shape_prod = separate_sub_shape;
ov::Shape separate_sub_shape_prod = separate_sub_shape;
if (!common_sub_shape.empty() && separate_sub_shape_prod.empty()) {
// in this case new dimension corresponding to separate labels must be added
// since MatMul operation is not possible to do without separate dimensions
@ -241,16 +249,16 @@ ngraph::Output<ngraph::Node> reshape_input_for_matmul(const ngraph::Output<ngrap
return input_node;
}
const auto new_shape_const = ngraph::opset7::Constant::create(ngraph::element::Type_t::i64, ngraph::Shape {new_shape.size()}, new_shape);
const auto reshaped_input_op = std::make_shared<ngraph::opset7::Reshape>(input_node, new_shape_const, false);
const auto new_shape_const = ov::op::v0::Constant::create(ov::element::Type_t::i64, ov::Shape {new_shape.size()}, new_shape);
const auto reshaped_input_op = std::make_shared<ov::op::v1::Reshape>(input_node, new_shape_const, false);
subgraph_nodes.insert(subgraph_nodes.end(), {new_shape_const, reshaped_input_op});
return reshaped_input_op->output(0);
}
LabelDimMap compute_label_dim_map(const ngraph::Rank& input_rank,
LabelDimMap compute_label_dim_map(const ov::Rank& input_rank,
const std::string& input_subscript) {
static const std::string ellipsis = "...";
const auto labels = ngraph::opset7::Einsum::extract_labels(input_subscript);
const auto labels = ov::op::v7::Einsum::extract_labels(input_subscript);
const auto static_input_rank = input_rank.is_static();
NGRAPH_CHECK(static_input_rank || (std::find(labels.begin(), labels.end(), ellipsis) == labels.end()),
"Input rank cannot be dynamic in case of ellipsis in input subscript");
@ -292,8 +300,8 @@ LabelDimMap compute_label_dim_map(const ngraph::Rank& input_rank,
/// \param subgraph_nodes A vector of operation nodes that is included into
/// a sub-graph decomposing Einsum that is needed for copy_runtime_info
///
void transpose_input(ngraph::OutputVector& input_nodes, std::vector<std::string>& input_subscripts, const std::string& required_subscript, size_t input_ind,
ngraph::NodeVector& subgraph_nodes) {
void transpose_input(ov::OutputVector& input_nodes, std::vector<std::string>& input_subscripts, const std::string& required_subscript, size_t input_ind,
ov::NodeVector& subgraph_nodes) {
// perform sanity check for arguments
const auto num_inputs = input_nodes.size();
NGRAPH_CHECK(num_inputs == input_subscripts.size(), "Each input must have own subscript.");
@ -312,8 +320,8 @@ void transpose_input(ngraph::OutputVector& input_nodes, std::vector<std::string>
// find permutation that establishes bijection between the input subscript
// and the required one
const auto& input_node = input_nodes[input_ind];
const auto labels = ngraph::opset7::Einsum::extract_labels(input_subscript);
const auto required_labels = ngraph::opset7::Einsum::extract_labels(required_subscript);
const auto labels = ov::op::v7::Einsum::extract_labels(input_subscript);
const auto required_labels = ov::op::v7::Einsum::extract_labels(required_subscript);
NGRAPH_CHECK(labels.size() == required_labels.size());
const auto label_dim_map = compute_label_dim_map(input_node.get_partial_shape().rank(), input_subscript);
for (const auto& required_label : required_labels) {
@ -324,8 +332,8 @@ void transpose_input(ngraph::OutputVector& input_nodes, std::vector<std::string>
}
// create a sub-graph for transposing into the required layout
const auto permutation_const = ngraph::opset7::Constant::create(ngraph::element::Type_t::i64, ngraph::Shape {permutation.size()}, permutation);
const auto transpose = std::make_shared<ngraph::opset7::Transpose>(input_node, permutation_const);
const auto permutation_const = ov::op::v0::Constant::create(ov::element::Type_t::i64, ov::Shape {permutation.size()}, permutation);
const auto transpose = std::make_shared<ov::op::v1::Transpose>(input_node, permutation_const);
// update a vector of inputs and input subscripts
input_nodes[input_ind] = transpose->output(0);
@ -348,8 +356,8 @@ void transpose_input(ngraph::OutputVector& input_nodes, std::vector<std::string>
/// a sub-graph decomposing Einsum that is needed for copy_runtime_info
///
void reduce_input(EinsumDecomposition *einsum_decompose_ptr,
ngraph::OutputVector& input_nodes, std::vector<std::string>& input_subscripts,
const std::string& output_subscript, size_t input_ind, ngraph::NodeVector& subgraph_nodes) {
ov::OutputVector& input_nodes, std::vector<std::string>& input_subscripts,
const std::string& output_subscript, size_t input_ind, ov::NodeVector& subgraph_nodes) {
// perform sanity check for arguments
const auto num_inputs = input_nodes.size();
NGRAPH_CHECK(num_inputs == input_subscripts.size(), "Each input must have own subscript.");
@ -360,7 +368,7 @@ void reduce_input(EinsumDecomposition *einsum_decompose_ptr,
// compute output shape and axes to reduce
std::set<int64_t> reduced_axes;
const auto labels = ngraph::opset7::Einsum::extract_labels(input_subscripts[input_ind]);
const auto labels = ov::op::v7::Einsum::extract_labels(input_subscripts[input_ind]);
auto label_dim_map = compute_label_dim_map(input_node.get_partial_shape().rank(), input_subscript);
std::string new_input_subscript = "";
@ -387,8 +395,8 @@ void reduce_input(EinsumDecomposition *einsum_decompose_ptr,
// reduce by summed up elements along dimension for which label is met just once
const std::vector<int64_t> reduced_axes_vec{reduced_axes.cbegin(), reduced_axes.cend()};
const auto axes_const = ngraph::opset7::Constant::create(ngraph::element::Type_t::i64, ngraph::Shape {reduced_axes.size()}, reduced_axes_vec);
const auto reduce_sum = einsum_decompose_ptr->register_new_node<ngraph::opset7::ReduceSum>(input_node, axes_const, false);
const auto axes_const = ov::op::v0::Constant::create(ov::element::Type_t::i64, ov::Shape {reduced_axes.size()}, reduced_axes_vec);
const auto reduce_sum = einsum_decompose_ptr->register_new_node<ov::op::v1::ReduceSum>(input_node, axes_const, false);
// update a vector of inputs and input subscripts
input_nodes[input_ind] = reduce_sum->output(0);
@ -401,17 +409,17 @@ void reduce_input(EinsumDecomposition *einsum_decompose_ptr,
/// \brief Broadcast input to a new shape. The MatMul operation requires the
/// same shape of both operands in the common (or batch) dimensions.
///
void broadcast_input(ngraph::OutputVector& inputs,
void broadcast_input(ov::OutputVector& inputs,
size_t input_ind,
const ngraph::Shape& new_common_shape,
const ngraph::Shape& separate_shape,
const ngraph::Shape& reduced_shape,
const ov::Shape& new_common_shape,
const ov::Shape& separate_shape,
const ov::Shape& reduced_shape,
bool is_separate_first,
ngraph::NodeVector& subgraph_nodes) {
ov::NodeVector& subgraph_nodes) {
NGRAPH_CHECK(input_ind < inputs.size());
const auto& input = inputs[input_ind];
ngraph::Shape new_shape{new_common_shape.begin(), new_common_shape.end()};
ov::Shape new_shape{new_common_shape.begin(), new_common_shape.end()};
if (is_separate_first) {
new_shape.insert(new_shape.end(), separate_shape.begin(), separate_shape.end());
new_shape.insert(new_shape.end(), reduced_shape.begin(), reduced_shape.end());
@ -420,7 +428,7 @@ void broadcast_input(ngraph::OutputVector& inputs,
new_shape.insert(new_shape.end(), separate_shape.begin(), separate_shape.end());
}
const ngraph::Shape old_shape = input.get_shape();
const ov::Shape old_shape = input.get_shape();
if (old_shape == new_shape) {
return;
}
@ -428,20 +436,20 @@ void broadcast_input(ngraph::OutputVector& inputs,
const auto new_shape_size = new_shape.size();
NGRAPH_CHECK(old_shape_size <= new_shape_size);
const auto new_shape_const = ngraph::opset7::Constant::create(ngraph::element::Type_t::i64, ngraph::Shape {new_shape.size()}, new_shape);
const auto broadcast = std::make_shared<ngraph::opset7::Broadcast>(input, new_shape_const, ngraph::op::BroadcastType::NUMPY);
const auto new_shape_const = ov::op::v0::Constant::create(ov::element::Type_t::i64, ov::Shape {new_shape.size()}, new_shape);
const auto broadcast = std::make_shared<ov::op::v3::Broadcast>(input, new_shape_const, ov::op::BroadcastType::NUMPY);
inputs[input_ind] = broadcast->output(0);
subgraph_nodes.insert(subgraph_nodes.end(), {new_shape_const, broadcast});
}
ngraph::Output<ngraph::Node> build_identity(const ngraph::Output<ngraph::Node>& input_node,
ov::Output<ov::Node> build_identity(const ov::Output<ov::Node>& input_node,
const std::vector<size_t>& repeated_label_dims,
ngraph::NodeVector& subgraph_nodes) {
ov::NodeVector& subgraph_nodes) {
NGRAPH_CHECK(repeated_label_dims.size() > 1);
const auto input_shape = input_node.get_shape();
ngraph::Shape identity_shape(input_shape.size(), 1);
ov::Shape identity_shape(input_shape.size(), 1);
const size_t repeated_label_dim_size = input_shape[repeated_label_dims[0]];
for (const auto dim : repeated_label_dims) {
NGRAPH_CHECK(dim < input_shape.size());
@ -463,16 +471,16 @@ ngraph::Output<ngraph::Node> build_identity(const ngraph::Output<ngraph::Node>&
offset += alpha;
}
}
const auto identity = ngraph::opset7::Constant::create(input_node.get_element_type(), identity_shape, identity_values);
const auto identity = ov::op::v0::Constant::create(input_node.get_element_type(), identity_shape, identity_values);
subgraph_nodes.insert(subgraph_nodes.end(), {identity});
return subgraph_nodes.back();
}
ngraph::Output<ngraph::Node> build_multi_identity(EinsumDecomposition* einsum_decompose_ptr,
const ngraph::Output<ngraph::Node>& input_node,
ov::Output<ov::Node> build_multi_identity(EinsumDecomposition* einsum_decompose_ptr,
const ov::Output<ov::Node>& input_node,
const std::vector<std::string>& repeated_labels,
const LabelDimMap& label_dim_map,
ngraph::NodeVector& subgraph_nodes) {
ov::NodeVector& subgraph_nodes) {
NGRAPH_CHECK(repeated_labels.size() > 0);
const auto get_identity = [&](size_t idx) {
@ -486,7 +494,7 @@ ngraph::Output<ngraph::Node> build_multi_identity(EinsumDecomposition* einsum_de
for (size_t label_ind = 1; label_ind < repeated_labels.size(); ++label_ind) {
const auto identity = get_identity(label_ind);
const auto mul = std::make_shared<ngraph::opset7::Multiply>(multi_identity, identity, ngraph::op::AutoBroadcastType::NUMPY);
const auto mul = std::make_shared<ov::op::v1::Multiply>(multi_identity, identity, ov::op::AutoBroadcastType::NUMPY);
subgraph_nodes.insert(subgraph_nodes.end(), {mul});
}
@ -497,16 +505,16 @@ ngraph::Output<ngraph::Node> build_multi_identity(EinsumDecomposition* einsum_de
/// and subscript, repeated labels, axes to reduce.
///
void prepare_diagonal_extraction_data(
const ngraph::Shape& input_shape,
const ov::Shape& input_shape,
const std::string& input_subscript,
const LabelDimMap& label_dim_map,
ngraph::Shape& result_shape,
ov::Shape& result_shape,
std::string& resultant_subscript,
std::vector<std::string>& repeated_labels,
ngraph::AxisSet& reduced_axes
ov::AxisSet& reduced_axes
) {
static const std::string ellipsis = "...";
const auto labels = ngraph::opset7::Einsum::extract_labels(input_subscript);
const auto labels = ov::op::v7::Einsum::extract_labels(input_subscript);
for (const auto& label : labels) {
if (resultant_subscript.find(label) != std::string::npos) {
@ -538,10 +546,10 @@ void prepare_diagonal_extraction_data(
}
void extract_diagonal(EinsumDecomposition* einsum_decompose_ptr,
ngraph::OutputVector& inputs,
ov::OutputVector& inputs,
std::vector<std::string>& input_subscripts,
size_t input_ind,
ngraph::NodeVector& subgraph_nodes) {
ov::NodeVector& subgraph_nodes) {
// perform sanity check for arguments
const auto num_inputs = inputs.size();
NGRAPH_CHECK(num_inputs == input_subscripts.size(), "Each input must have own subscript.");
@ -552,10 +560,10 @@ void extract_diagonal(EinsumDecomposition* einsum_decompose_ptr,
const auto input_shape = input_node.get_shape();
const auto label_dim_map = compute_label_dim_map(input_node.get_partial_shape().rank(), input_subscript);
ngraph::Shape result_shape;
ov::Shape result_shape;
std::string resultant_subscript;
std::vector<std::string> repeated_labels;
ngraph::AxisSet reduced_axes;
ov::AxisSet reduced_axes;
prepare_diagonal_extraction_data(input_shape, input_subscript, label_dim_map,
result_shape, resultant_subscript, repeated_labels, reduced_axes);
@ -567,19 +575,19 @@ void extract_diagonal(EinsumDecomposition* einsum_decompose_ptr,
const auto multi_identity = build_multi_identity(einsum_decompose_ptr, input_node, repeated_labels, label_dim_map, subgraph_nodes);
// multiply both operands with broadcasting
const auto mul = std::make_shared<ngraph::opset7::Multiply>(input_node, multi_identity, ngraph::op::AutoBroadcastType::NUMPY);
const auto mul = std::make_shared<ov::op::v1::Multiply>(input_node, multi_identity, ov::op::AutoBroadcastType::NUMPY);
subgraph_nodes.insert(subgraph_nodes.end(), {mul});
const std::vector<int64_t> reduced_axes_vec{reduced_axes.cbegin(), reduced_axes.cend()};
const auto axes_const = ngraph::opset7::Constant::create(ngraph::element::Type_t::i64, ngraph::Shape {reduced_axes.size()}, reduced_axes_vec);
const auto reduce_sum = std::make_shared<ngraph::opset7::ReduceSum>(mul->output(0), axes_const, false);
const auto axes_const = ov::op::v0::Constant::create(ov::element::Type_t::i64, ov::Shape {reduced_axes.size()}, reduced_axes_vec);
const auto reduce_sum = std::make_shared<ov::op::v1::ReduceSum>(mul->output(0), axes_const, false);
subgraph_nodes.insert(subgraph_nodes.end(), {axes_const, reduce_sum});
inputs[input_ind] = reduce_sum->output(0);
input_subscripts[input_ind] = resultant_subscript;
}
void compute_ranges(const ngraph::Rank& input_rank,
void compute_ranges(const ov::Rank& input_rank,
const std::string& input_subscript,
const std::vector<std::string>& common_labels,
const std::vector<std::string>& sep_labels,
@ -642,9 +650,9 @@ void compute_ranges(const ngraph::Rank& input_rank,
/// sub-graph decomposing Einsum that is needed for copy_runtime_info
///
void contract_two_inputs(EinsumDecomposition* einsum_decompose_ptr,
ngraph::OutputVector& input_nodes, std::vector<std::string>& input_subscripts,
ov::OutputVector& input_nodes, std::vector<std::string>& input_subscripts,
const std::string& output_subscript, size_t input_ind1,
size_t input_ind2, ngraph::NodeVector& subgraph_nodes) {
size_t input_ind2, ov::NodeVector& subgraph_nodes) {
// assume that input_ind1 < input_ind2 without loss of generality, otherwise, just swap them
if (input_ind2 < input_ind1) {
std::swap(input_ind1, input_ind2);
@ -676,9 +684,9 @@ void contract_two_inputs(EinsumDecomposition* einsum_decompose_ptr,
// neither the output subscript nor the input subscripts for other Einsum inputs excluding
// two given inputs
auto& input_subscript1 = input_subscripts[input_ind1];
auto labels1 = ngraph::opset7::Einsum::extract_labels(input_subscript1);
auto labels1 = ov::op::v7::Einsum::extract_labels(input_subscript1);
auto& input_subscript2 = input_subscripts[input_ind2];
auto labels2 = ngraph::opset7::Einsum::extract_labels(input_subscript2);
auto labels2 = ov::op::v7::Einsum::extract_labels(input_subscript2);
std::string common_part = "";
std::string separate_part1 = "";
std::string separate_part2 = "";
@ -726,8 +734,8 @@ void contract_two_inputs(EinsumDecomposition* einsum_decompose_ptr,
// for further unsqueezing
transpose_input(input_nodes, input_subscripts, convenient_subscript, input_ind2, subgraph_nodes);
const auto separate_labels1 = ngraph::opset7::Einsum::extract_labels(separate_part1);
const auto separate_labels2 = ngraph::opset7::Einsum::extract_labels(separate_part2);
const auto separate_labels1 = ov::op::v7::Einsum::extract_labels(separate_part1);
const auto separate_labels2 = ov::op::v7::Einsum::extract_labels(separate_part2);
auto label_to_dim_map1 = compute_label_dim_map(input_node1.get_partial_shape().rank(), input_subscript1);
auto label_to_dim_map2 = compute_label_dim_map(input_node2.get_partial_shape().rank(), input_subscript2);
@ -758,7 +766,7 @@ void contract_two_inputs(EinsumDecomposition* einsum_decompose_ptr,
auto unsqueeze_output2 = unsqueeze_input(input_node2, unsqueeze_axis2, subgraph_nodes);
// multiply both operands with broadcasting
auto mul = std::make_shared<ngraph::opset7::Multiply>(unsqueeze_output1, unsqueeze_output2, ngraph::op::AutoBroadcastType::NUMPY);
auto mul = std::make_shared<ov::op::v1::Multiply>(unsqueeze_output1, unsqueeze_output2, ov::op::AutoBroadcastType::NUMPY);
// update input operand and input subscript for Einsum operation
update_operands(input_nodes, input_subscripts, input_ind1, input_ind2, mul->output(0), resultant_subscript);
@ -819,15 +827,15 @@ void contract_two_inputs(EinsumDecomposition* einsum_decompose_ptr,
const auto input_shape1 = input_node1.get_shape();
const auto input_shape2 = input_node2.get_shape();
ngraph::PartialShape common_sub_shape1 = compute_sub_shape(input_shape1, common_dims_begin, common_dims_end);
ngraph::PartialShape common_sub_shape2 = compute_sub_shape(input_shape2, common_dims_begin2, common_dims_end2);
ov::PartialShape common_sub_shape1 = compute_sub_shape(input_shape1, common_dims_begin, common_dims_end);
ov::PartialShape common_sub_shape2 = compute_sub_shape(input_shape2, common_dims_begin2, common_dims_end2);
const auto reduced_sub_shape_prod = compute_sub_shape(input_shape1, reduced_dims_begin, reduced_dims_end, true);
const auto reduced_sub_shape = compute_sub_shape(input_shape1, reduced_dims_begin, reduced_dims_end);
const auto separate1_sub_shape = compute_sub_shape(input_shape1, separate1_dims_begin, separate1_dims_end);
const auto separate2_sub_shape = compute_sub_shape(input_shape2, separate2_dims_begin, separate2_dims_end);
// broadcast both inputs to have common sub-shape broadcasted that is needed in case of ellipsis among the common labels
ngraph::PartialShape::broadcast_merge_into(common_sub_shape1, common_sub_shape2, ngraph::op::AutoBroadcastType::NUMPY);
ov::PartialShape::broadcast_merge_into(common_sub_shape1, common_sub_shape2, ov::op::AutoBroadcastType::NUMPY);
const auto common_sub_shape = common_sub_shape1.get_shape();
broadcast_input(input_nodes,
input_ind1,
@ -860,7 +868,7 @@ void contract_two_inputs(EinsumDecomposition* einsum_decompose_ptr,
// step 3. apply MatMul operation for formatted inputs
const bool transpose_a = (is_separate_first1 ? false : true);
const bool transpose_b = (is_separate_first2 ? true : false);
const auto matmul = std::make_shared<ngraph::opset7::MatMul>(matmul_operand1, matmul_operand2, transpose_a, transpose_b);
const auto matmul = std::make_shared<ov::op::v0::MatMul>(matmul_operand1, matmul_operand2, transpose_a, transpose_b);
// step 4. reshape back by unrolling dimensions corresponding to separate labels if needed
// now dimensions corresponding to reduced labels are reduced by the MatMul operation
@ -869,13 +877,13 @@ void contract_two_inputs(EinsumDecomposition* einsum_decompose_ptr,
common_part += common_label;
}
const std::string resultant_subscript = common_part + separate_part1 + separate_part2;
ngraph::Shape back_shape;
ov::Shape back_shape;
back_shape.insert(back_shape.end(), common_sub_shape.begin(), common_sub_shape.end());
back_shape.insert(back_shape.end(), separate1_sub_shape.begin(), separate1_sub_shape.end());
back_shape.insert(back_shape.end(), separate2_sub_shape.begin(), separate2_sub_shape.end());
const auto new_shape_const = ngraph::opset7::Constant::create(ngraph::element::Type_t::i64, ngraph::Shape {back_shape.size()}, back_shape);
const auto reshape_result_op = std::make_shared<ngraph::opset7::Reshape>(matmul->output(0), new_shape_const, false);
const auto new_shape_const = ov::op::v0::Constant::create(ov::element::Type_t::i64, ov::Shape {back_shape.size()}, back_shape);
const auto reshape_result_op = std::make_shared<ov::op::v1::Reshape>(matmul->output(0), new_shape_const, false);
subgraph_nodes.insert(subgraph_nodes.end(), {new_shape_const, reshape_result_op});
// update input operand and input subscript for Einsum operation
@ -887,8 +895,8 @@ void contract_two_inputs(EinsumDecomposition* einsum_decompose_ptr,
} // namespace
EinsumDecomposition::EinsumDecomposition() {
ngraph::matcher_pass_callback callback = [this](ngraph::pattern::Matcher& m) {
auto einsum_node = std::dynamic_pointer_cast<ngraph::opset7::Einsum>(m.get_match_root());
ov::matcher_pass_callback callback = [this](ov::pass::pattern::Matcher& m) {
auto einsum_node = std::dynamic_pointer_cast<ov::op::v7::Einsum>(m.get_match_root());
if (!einsum_node) {
return false;
}
@ -900,12 +908,12 @@ EinsumDecomposition::EinsumDecomposition() {
auto equation = einsum_node->get_equation();
std::vector<std::string> input_subscripts;
std::string output_subscript;
ngraph::opset7::Einsum::parse_equation(equation, input_subscripts, output_subscript);
ov::op::v7::Einsum::parse_equation(equation, input_subscripts, output_subscript);
// create a list of input nodes with preserving their order
// and a vector of sub-graph nodes for copy_runtime_info
ngraph::OutputVector input_nodes = einsum_node->input_values();
ngraph::NodeVector subgraph_nodes;
ov::OutputVector input_nodes = einsum_node->input_values();
ov::NodeVector subgraph_nodes;
// compute einsum path that is used to contract a pair of operands
// in more optimal order
@ -930,13 +938,13 @@ EinsumDecomposition::EinsumDecomposition() {
// preserve the original node name
auto last_node = input_nodes[0].get_node_shared_ptr();
last_node->set_friendly_name(einsum_node->get_friendly_name());
ngraph::copy_runtime_info(einsum_node, subgraph_nodes);
ngraph::replace_node(einsum_node, last_node);
ov::copy_runtime_info(einsum_node, subgraph_nodes);
ov::replace_node(einsum_node, last_node);
return true;
};
const auto einsum = ngraph::pattern::wrap_type<ngraph::opset7::Einsum>();
const auto matcher = std::make_shared<ngraph::pattern::Matcher>(einsum, "EinsumDecompositionGpu");
const auto einsum = ov::pass::pattern::wrap_type<ov::op::v7::Einsum>();
const auto matcher = std::make_shared<ov::pass::pattern::Matcher>(einsum, "EinsumDecompositionGpu");
register_matcher(matcher, callback);
}

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