From c65023e01d8e5c8f5af15dd8e2ca4fae3c4889f9 Mon Sep 17 00:00:00 2001 From: Sheri Zhang Date: Wed, 3 Nov 2021 21:24:00 +0000 Subject: Refine code for graph level fusion Partially resolves: COMPMID-4701 Signed-off-by: Sheri Zhang Change-Id: I11fb89bd31ef5a98ad9a2d6bb5fd0c1e8371b52f Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/6572 Comments-Addressed: Arm Jenkins Reviewed-by: Gunes Bayir Reviewed-by: SiCong Li Tested-by: Arm Jenkins --- arm_compute/graph/INode.h | 28 +- arm_compute/graph/backends/FunctionHelpers.h | 1 + .../graph/nodes/FusedConvolutionWithPostOpNode.h | 23 +- arm_compute/graph/printers/DotGraphPrinter.h | 23 -- src/graph/INode.cpp | 13 +- src/graph/mutators/NodeFusionMutator.cpp | 450 ++++++++++++--------- src/graph/nodes/FusedConvolutionWithPostOpNode.cpp | 13 +- 7 files changed, 289 insertions(+), 262 deletions(-) diff --git a/arm_compute/graph/INode.h b/arm_compute/graph/INode.h index b92003464c..becd672d90 100644 --- a/arm_compute/graph/INode.h +++ b/arm_compute/graph/INode.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018-2019 Arm Limited. + * Copyright (c) 2018-2019,2021 Arm Limited. * * SPDX-License-Identifier: MIT * @@ -29,6 +29,7 @@ #include "arm_compute/graph/TensorDescriptor.h" #include "arm_compute/graph/Types.h" +#include #include namespace arm_compute @@ -240,18 +241,29 @@ public: * @return Assigned target of this node */ Target assigned_target() const; + /** Post operator info list + * + * @return Post operator info list + */ + const std::list> &post_op_info_list() const; + /** Post operator info list + * + * @return Post operator info list + */ + std::list> &post_op_info_list(); protected: friend class Graph; protected: - Graph *_graph; /**< Backward reference to graph owning the node */ - NodeID _id; /**< Node ID */ - NodeParams _common_params; /**< Node common params */ - std::vector _outputs; /**< Output of the node */ - std::vector _input_edges; /**< Inputs edge set */ - std::set _output_edges; /**< Output edge set */ - Target _assigned_target; /**< Assigned target by the Graph executor */ + Graph *_graph; /**< Backward reference to graph owning the node */ + NodeID _id; /**< Node ID */ + NodeParams _common_params; /**< Node common params */ + std::vector _outputs; /**< Output of the node */ + std::vector _input_edges; /**< Inputs edge set */ + std::set _output_edges; /**< Output edge set */ + Target _assigned_target; /**< Assigned target by the Graph executor */ + std::list> _post_op_info_list; /**< Post operator info list */ }; } // namespace graph } // namespace arm_compute diff --git a/arm_compute/graph/backends/FunctionHelpers.h b/arm_compute/graph/backends/FunctionHelpers.h index 6bec66a6ff..6aec3f6590 100644 --- a/arm_compute/graph/backends/FunctionHelpers.h +++ b/arm_compute/graph/backends/FunctionHelpers.h @@ -602,6 +602,7 @@ std::unique_ptr create_fused_convolution_with_post_op(FusedConvolutio std::unique_ptr func; std::string func_name; + // Fuse convolution with post ops is only supported for conv1x1, which is only implemented as gemmconv2d std::tie(func, func_name) = create_named_memory_managed_function( std::string("GEMMConvolutionLayer"), mm, input, weights, biases, output, conv_info, diff --git a/arm_compute/graph/nodes/FusedConvolutionWithPostOpNode.h b/arm_compute/graph/nodes/FusedConvolutionWithPostOpNode.h index 0bb3d1b7ef..6048994b02 100644 --- a/arm_compute/graph/nodes/FusedConvolutionWithPostOpNode.h +++ b/arm_compute/graph/nodes/FusedConvolutionWithPostOpNode.h @@ -72,16 +72,6 @@ public: * @return Fast math hint to be used by the node */ FastMathHint fast_math_hint() const; - /** Post operator info list - * - * @return Post operator info list - */ - const std::list> &post_op_info_list() const; - /** Post operator info list - * - * @return Post operator info list - */ - std::list> &post_op_info_list(); /** Convolution metadata accessor * * @return Convolution information @@ -129,13 +119,12 @@ public: static constexpr NodeType node_type = NodeType::FusedConvolutionWithPostOp; private: - PadStrideInfo _info; - unsigned int _num_groups; - ConvolutionMethod _method; - FastMathHint _fast_math_hint; - QuantizationInfo _out_quant_info; - ActivationLayerInfo _fused_activation; - std::list> _post_op_info_list; + PadStrideInfo _info; + unsigned int _num_groups; + ConvolutionMethod _method; + FastMathHint _fast_math_hint; + QuantizationInfo _out_quant_info; + ActivationLayerInfo _fused_activation; }; } // namespace graph } // namespace arm_compute diff --git a/arm_compute/graph/printers/DotGraphPrinter.h b/arm_compute/graph/printers/DotGraphPrinter.h index 41607e831a..42a20678fe 100644 --- a/arm_compute/graph/printers/DotGraphPrinter.h +++ b/arm_compute/graph/printers/DotGraphPrinter.h @@ -1,26 +1,3 @@ -/* - * Copyright (c) 2021 Arm Limited. - * - * SPDX-License-Identifier: MIT - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to - * deal in the Software without restriction, including without limitation the - * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or - * sell copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ /* * Copyright (c) 2018-2019,2021 Arm Limited. * diff --git a/src/graph/INode.cpp b/src/graph/INode.cpp index 93f085404a..e5b4adda26 100644 --- a/src/graph/INode.cpp +++ b/src/graph/INode.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2018 Arm Limited. + * Copyright (c) 2018,2021 Arm Limited. * * SPDX-License-Identifier: MIT * @@ -37,6 +37,7 @@ namespace graph INode::INode() : _graph(nullptr), _id(EmptyNodeID), _common_params({ "", Target::UNSPECIFIED}), _outputs(), _input_edges(), _output_edges(), _assigned_target(Target::UNSPECIFIED) + ,_post_op_info_list(std::list> {}) { } // clang-format on @@ -199,5 +200,15 @@ Target INode::assigned_target() const { return _assigned_target; } + +const std::list> &INode::post_op_info_list() const +{ + return _post_op_info_list; +} + +std::list> &INode::post_op_info_list() +{ + return _post_op_info_list; +} } // namespace graph } // namespace arm_compute \ No newline at end of file diff --git a/src/graph/mutators/NodeFusionMutator.cpp b/src/graph/mutators/NodeFusionMutator.cpp index 463d1cd8f6..3f979e48ee 100644 --- a/src/graph/mutators/NodeFusionMutator.cpp +++ b/src/graph/mutators/NodeFusionMutator.cpp @@ -44,6 +44,40 @@ namespace graph { namespace detail { +void transfer_driving_nodes_and_remove_old_node(Graph &g, INode *new_node, INode *old_node, bool add_output_tensor) +{ + if(new_node == nullptr || old_node == nullptr) + { + return; + } + + // Get driving nodes of last fusable node + std::vector last_driving_nodes = get_driving_nodes(*old_node); + + // Extract last fusable node accessor if any + if(old_node->output(0) == nullptr) + { + return; + } + auto old_node_accessor = old_node->output(0)->extract_accessor(); + + // Remove node + g.remove_node(old_node->id()); + + // Update fused node outputs + for(auto &driving_node : last_driving_nodes) + { + g.add_connection(new_node->id(), 0, driving_node.node_id, driving_node.index); + if(add_output_tensor) + { + configure_tensor(new_node->output(0)); + } + } + + // Update accessor to fused node + new_node->output(0)->set_accessor(std::move(old_node_accessor)); +} + void fuse_convolution_with_batch_normalization(Graph &g, const Edge *output_edge) { ARM_COMPUTE_ERROR_ON(output_edge == nullptr); @@ -107,24 +141,11 @@ void fuse_convolution_with_batch_normalization(Graph &g, const Edge *output_edge g.add_connection(bn_gamma_id, 0, fused_id, 6); } - auto fused_node = g.node(fused_id); - std::vector bn_driving_nodes = get_driving_nodes(*bn_node); - - // Extract batch normalization node accessor if any - auto bn_node_accessor = bn_node->output(0)->extract_accessor(); - auto bn_node_name = bn_node->name(); + auto fused_node = g.node(fused_id); + auto bn_node_name = bn_node->name(); - // Remove batch normalization node - g.remove_node(bn_node->id()); + transfer_driving_nodes_and_remove_old_node(g, fused_node, bn_node, true); - // Get driving nodes of batch normalization node - for(auto &driving_node : bn_driving_nodes) - { - g.add_connection(fused_id, 0, driving_node.node_id, driving_node.index); - configure_tensor(fused_node->output(0)); - } - // Update fused node outputs - fused_node->output(0)->set_accessor(std::move(bn_node_accessor)); fused_node->set_assigned_target(assigned_target); fused_node->set_common_node_parameters(NodeParams{ conv_node->name() + "+" + bn_node_name, assigned_target }); @@ -184,24 +205,11 @@ void fuse_depthwise_convolution_with_batch_normalization(Graph &g, const Edge *o g.add_connection(bn_beta_id, 0, fused_id, 5); g.add_connection(bn_gamma_id, 0, fused_id, 6); - auto fused_node = g.node(fused_id); - std::vector bn_driving_nodes = get_driving_nodes(*bn_node); - - // Extract batch normalization node accessor if any - auto bn_node_accessor = bn_node->output(0)->extract_accessor(); - auto bn_node_name = bn_node->name(); + auto fused_node = g.node(fused_id); + auto bn_node_name = bn_node->name(); - // Remove batch normalization node - g.remove_node(bn_node->id()); + transfer_driving_nodes_and_remove_old_node(g, fused_node, bn_node, true); - // Get driving nodes of batch normalization node - for(auto &driving_node : bn_driving_nodes) - { - g.add_connection(fused_id, 0, driving_node.node_id, driving_node.index); - configure_tensor(fused_node->output(0)); - } - // Update fused node outputs - fused_node->output(0)->set_accessor(std::move(bn_node_accessor)); fused_node->set_assigned_target(assigned_target); fused_node->set_common_node_parameters(NodeParams{ depth_conv_node->name() + "+" + bn_node_name, assigned_target }); @@ -242,26 +250,10 @@ void fuse_node_with_activation(Graph &g, const Edge *output_edge, const std::set // Prevent fusion if fused node has an output accessor if(n_node->output(0)->accessor() == nullptr) { - // Get driving nodes of activation node - std::vector act_driving_nodes = get_driving_nodes(*act_node); - // Set activation info to fused node n_node->set_fused_activation(act_node->activation_info()); - // Extract activation node accessor if any - auto act_node_accessor = act_node->output(0)->extract_accessor(); - - // Remove activation node - g.remove_node(act_node->id()); - - // Update fused node outputs - for(auto &driving_node : act_driving_nodes) - { - g.add_connection(n_node->id(), 0, driving_node.node_id, driving_node.index); - } - - // Update accessor to fused node - n_node->output(0)->set_accessor(std::move(act_node_accessor)); + transfer_driving_nodes_and_remove_old_node(g, n_node, act_node, false); } else { @@ -339,7 +331,7 @@ void fuse_layer(Graph &g, std::function const &prec, const F fuse } } -/** Fuse below operators: +/** Check valid combinations: * * | Main operator | Post operators | * |:--------------|:---------------------------| @@ -348,136 +340,246 @@ void fuse_layer(Graph &g, std::function const &prec, const F fuse * |conv | add + act | * |conv | act + add + act | * - * Notes: currently, only GEMM supports fusion with post operator */ -template -void fuse_convolution(Graph &g, const Edge *output_edge, int conv_node_id, const std::set &supported_fused_activations) +#define MAX_VALIDE_COMBINATION 4 +#define MAX_POST_OP_NUM 3 +NodeType valide_post_op_type[MAX_VALIDE_COMBINATION][MAX_POST_OP_NUM] = { { EltwiseLayerNode::node_type }, + { EltwiseLayerNode::node_type, ActivationLayerNode::node_type }, + { ActivationLayerNode::node_type, EltwiseLayerNode::node_type }, + { ActivationLayerNode::node_type, EltwiseLayerNode::node_type, ActivationLayerNode::node_type } +}; + +bool check_post_op_type(NodeType *post_op_type, int len) { - ARM_COMPUTE_ERROR_ON(output_edge == nullptr); + if(len > MAX_POST_OP_NUM || len <= 0) + { + return false; + } - auto *conv_node = arm_compute::utils::cast::polymorphic_downcast(output_edge->producer()); - ARM_COMPUTE_ERROR_ON(conv_node->output(0) == nullptr); - // Prevent fusion if fused node has an output accessor - if(conv_node->output(0)->accessor() == nullptr) + bool found = false; + for(int i = 0; i < MAX_VALIDE_COMBINATION; ++i) { - // If data type is FP32/FP16, data layout is NHWC, and filter size if 1x1, fuse convolution with post op, as Conv1x1 always leads to GEMM. - const Edge *input_edge = conv_node->input_edge(1); - if(input_edge != nullptr && input_edge->tensor() != nullptr) + for(int j = 0; j < len; ++j) { - const DataLayout data_layout = input_edge->tensor()->desc().layout; - const DataType data_type = input_edge->tensor()->desc().data_type; - const TensorShape tensor_shape = input_edge->tensor()->desc().shape; - if(data_layout != DataLayout::NHWC || is_data_type_float(data_type) == false || tensor_shape.y() != 1 || tensor_shape.z() != 1) + if(post_op_type[j] != valide_post_op_type[i][j]) { - ARM_COMPUTE_LOG_GRAPH_VERBOSE("Prevented fusion of convolution node with post ops due to non GEMM convolution\n"); - return; + found = false; + break; + } + found = true; + } + if(found) + break; + } + + return found; +} + +void fuse_convolution_with_post_op(Graph &g, INode *fused_node, std::list post_op_node_list, int prev_op_dst_pos) +{ + unsigned int op_idx = 0; + // Fuse post operators with conv + for(const auto &post_op : post_op_node_list) + { + switch(post_op->type()) + { + case EltwiseLayerNode::node_type: + { + auto *eltwise_node = arm_compute::utils::cast::polymorphic_downcast(post_op); + ARM_COMPUTE_ERROR_ON(eltwise_node->output(0) == nullptr); + + fused_node->post_op_info_list().push_back(std::make_unique(prev_op_dst_pos, eltwise_node->convert_policy())); + ARM_COMPUTE_LOG_GRAPH_VERBOSE(" with Elementwise Layer node with ID : " << post_op->id()); + break; } + case ActivationLayerNode::node_type: + { + auto *act_node = arm_compute::utils::cast::polymorphic_downcast(post_op); + ARM_COMPUTE_ERROR_ON(act_node->output(0) == nullptr); + + fused_node->post_op_info_list().push_back(std::make_unique(act_node->activation_info())); + ARM_COMPUTE_LOG_GRAPH_VERBOSE(" with Activation Layer node with ID : " << post_op->id()); + break; + } + default: + { + break; + } + } + + if(op_idx == post_op_node_list.size() - 1) // last fusable node + { + transfer_driving_nodes_and_remove_old_node(g, fused_node, post_op, true); } else { - return; + // Remove node + g.remove_node(post_op->id()); } + op_idx++; + } +} - std::list post_op_node_list = {}; - int eltwise_adden_input_id = 0; - int prev_op_dst_pos = 0; // Previous operator dst's postion in current operator - NodeID prev_op_dst_id = conv_node->id(); - for(unsigned int i = conv_node_id + 1; i < g.nodes().size(); ++i) +std::list get_post_op_list(Graph &g, int &eltwise_operand_id, int &prev_op_dst_pos, int conv_node_id, const std::set &supported_fused_activations) +{ + std::list post_op_node_list = {}; + NodeID prev_op_dst_id = conv_node_id; + NodeType post_op_type_list[3] = { NodeType::Dummy, NodeType::Dummy, NodeType::Dummy }; + int post_op_idx = 0; + for(unsigned int i = conv_node_id + 1; i < g.nodes().size(); ++i) + { + auto post_op_node = g.node(i); + bool fusable_post_op = false; + if(post_op_node != nullptr && post_op_node->output_edges().size() > 0) { - auto post_op_node = g.node(i); - bool fusable_post_op = false; - if(post_op_node != nullptr && post_op_node->output_edges().size() > 0) - { - const auto post_op_output_edge_id = *post_op_node->output_edges().begin(); - const auto post_op_output_edge = g.edge(post_op_output_edge_id); + const auto post_op_output_edge_id = *post_op_node->output_edges().begin(); + const auto post_op_output_edge = g.edge(post_op_output_edge_id); - if(post_op_output_edge != nullptr) + if(post_op_output_edge != nullptr) + { + switch(post_op_output_edge->producer()->type()) { - switch(post_op_output_edge->producer()->type()) + case EltwiseLayerNode::node_type: { - case EltwiseLayerNode::node_type: + auto *eltwise_node = arm_compute::utils::cast::polymorphic_downcast(post_op_output_edge->producer()); + ARM_COMPUTE_ERROR_ON(eltwise_node->output(0) == nullptr); + if(eltwise_node->output(0)->accessor() == nullptr) { - auto *eltwise_node = arm_compute::utils::cast::polymorphic_downcast(post_op_output_edge->producer()); - ARM_COMPUTE_ERROR_ON(eltwise_node->output(0) == nullptr); - if(eltwise_node->output(0)->accessor() == nullptr) + post_op_node_list.push_back(post_op_output_edge->producer()); + fusable_post_op = true; + post_op_type_list[post_op_idx++] = eltwise_node->type(); + + // Extract elementwise inputs + const auto eltwise_input_id_0 = eltwise_node->input_edge(0)->producer_id(); + const auto eltwise_input_id_1 = eltwise_node->input_edge(1)->producer_id(); + if(eltwise_input_id_0 == prev_op_dst_id) { - post_op_node_list.push_back(post_op_output_edge->producer()); - fusable_post_op = true; - - // Extract elementwise inputs - const auto eltwise_input_id_0 = eltwise_node->input_edge(0)->producer_id(); - const auto eltwise_input_id_1 = eltwise_node->input_edge(1)->producer_id(); - if(eltwise_input_id_0 == prev_op_dst_id) - { - eltwise_adden_input_id = eltwise_input_id_1; - prev_op_dst_pos = 0; - } - else if(eltwise_input_id_1 == prev_op_dst_id) - { - eltwise_adden_input_id = eltwise_input_id_0; - prev_op_dst_pos = 1; - } + eltwise_operand_id = eltwise_input_id_1; + prev_op_dst_pos = 0; } - else + else if(eltwise_input_id_1 == prev_op_dst_id) { - ARM_COMPUTE_LOG_GRAPH_VERBOSE("Prevented fusion of convolution node with elementwise due to the presence of an output accessor\n"); + eltwise_operand_id = eltwise_input_id_0; + prev_op_dst_pos = 1; } - break; } - case ActivationLayerNode::node_type: + else { - auto *act_node = arm_compute::utils::cast::polymorphic_downcast(post_op_output_edge->producer()); - ARM_COMPUTE_ERROR_ON(act_node->output(0) == nullptr); - // Check if activation is supported for fusion - if(supported_fused_activations.count(act_node->activation_info().activation()) == 0) - { - break; - } - if(act_node->output(0)->accessor() == nullptr) - { - post_op_node_list.push_back(post_op_output_edge->producer()); - fusable_post_op = true; - prev_op_dst_id = act_node->id(); - } - else - { - ARM_COMPUTE_LOG_GRAPH_VERBOSE("Prevented fusion of convolution node with activation due to the presence of an output accessor\n"); - } - break; + ARM_COMPUTE_LOG_GRAPH_VERBOSE("Prevented fusion of convolution node with elementwise due to the presence of an output accessor\n"); } - default: + break; + } + case ActivationLayerNode::node_type: + { + auto *act_node = arm_compute::utils::cast::polymorphic_downcast(post_op_output_edge->producer()); + ARM_COMPUTE_ERROR_ON(act_node->output(0) == nullptr); + // Check if activation is supported for fusion + if(supported_fused_activations.count(act_node->activation_info().activation()) == 0) + { break; + } + if(act_node->output(0)->accessor() == nullptr) + { + post_op_node_list.push_back(post_op_output_edge->producer()); + fusable_post_op = true; + post_op_type_list[post_op_idx++] = act_node->type(); + prev_op_dst_id = act_node->id(); + } + else + { + ARM_COMPUTE_LOG_GRAPH_VERBOSE("Prevented fusion of convolution node with activation due to the presence of an output accessor\n"); + } + break; + } + default: + { + break; } } + } - // Check if the node is not a branching node and current node is fusable - if(post_op_node->output_edges().size() == 1 && fusable_post_op == true) - { - continue; - } - else - { - break; - } + // Check if the node is not a branching node and current node is fusable + if(post_op_node->output_edges().size() == 1 && fusable_post_op == true && post_op_node_list.size() < 3) + { + continue; + } + else + { + break; } } + } - if(post_op_node_list.size() == 0) + // Check whether it's valid post op list + if(post_op_node_list.size() > 0) + { + bool fuse_with_post_op = check_post_op_type(post_op_type_list, post_op_node_list.size()); + if(!fuse_with_post_op) { - return; + post_op_node_list.clear(); } - else if(post_op_node_list.size() == 1) // Use fusion without post op if post op only contains one activation operator + } + + return post_op_node_list; +} + +/** Fuse below operators: + * + * | Main operator | Post operators | + * |:--------------|:---------------------------| + * |conv | add | + * |conv | act + add | + * |conv | add + act | + * |conv | act + add + act | + * + * Notes: currently, only GEMM supports fusion with post operator +*/ +template +void fuse_convolution(Graph &g, const Edge *output_edge, int conv_node_id, const std::set &supported_fused_activations) +{ + ARM_COMPUTE_ERROR_ON(output_edge == nullptr); + + auto *conv_node = arm_compute::utils::cast::polymorphic_downcast(output_edge->producer()); + ARM_COMPUTE_ERROR_ON(conv_node->output(0) == nullptr); + + const ConvolutionMethod conv_algorithm = conv_node->convolution_method(); + if(conv_algorithm != ConvolutionMethod::GEMM) + { + ARM_COMPUTE_LOG_GRAPH_VERBOSE("Prevented fusion of convolution node with post ops due to non GEMM convolution\n"); + return; + } + + // Prevent fusion if fused node has an output accessor + if(conv_node->output(0)->accessor() == nullptr) + { + // If data type is FP32/FP16, data layout is NHWC, and filter size if 1x1, fuse convolution with post op, as Conv1x1 always leads to GEMM. + const Edge *input_edge = conv_node->input_edge(1); + if(input_edge != nullptr && input_edge->tensor() != nullptr) { - for(const auto &post_op : post_op_node_list) + const DataLayout data_layout = input_edge->tensor()->desc().layout; + const DataType data_type = input_edge->tensor()->desc().data_type; + const TensorShape tensor_shape = input_edge->tensor()->desc().shape; + if(data_layout != DataLayout::NHWC || is_data_type_float(data_type) == false || tensor_shape.y() != 1 || tensor_shape.z() != 1) { - if(post_op->type() == ActivationLayerNode::node_type) - { - post_op_node_list.clear(); - return; - } + ARM_COMPUTE_LOG_GRAPH_VERBOSE("Prevented fusion of convolution node with post ops due to non GEMM convolution\n"); + return; } } - else // Use fusion with post op if there're two or more operators + else + { + return; + } + + // Get post op list + int eltwise_operand_id = 0; + int prev_op_dst_pos = 0; // Previous operator dst's postion in current operator + std::list post_op_node_list = get_post_op_list(g, eltwise_operand_id, prev_op_dst_pos, conv_node_id, supported_fused_activations); + + if(post_op_node_list.size() == 0) + { + return; + } + else // Do convolution fusion with post op if there're one(elementwise), two or more operators { const Target assigned_target = conv_node->assigned_target(); @@ -501,70 +603,16 @@ void fuse_convolution(Graph &g, const Edge *output_edge, int conv_node_id, const auto conv_bias_id = conv_node->input_edge(2)->producer_id(); g.add_connection(conv_bias_id, 0, fused_id, 2); } - g.add_connection(eltwise_adden_input_id, 0, fused_id, 3); + g.add_connection(eltwise_operand_id, 0, fused_id, 3); g.remove_node(conv_node->id()); // Update fused node outputs - auto fused_node = g.node(fused_id); - auto *fused_conv_node = arm_compute::utils::cast::polymorphic_downcast(fused_node); + auto fused_node = g.node(fused_id); fused_node->set_assigned_target(assigned_target); - unsigned int op_idx = 0; - // Fuse post operators with conv - for(const auto &post_op : post_op_node_list) - { - switch(post_op->type()) - { - case EltwiseLayerNode::node_type: - { - auto *eltwise_node = arm_compute::utils::cast::polymorphic_downcast(post_op); - ARM_COMPUTE_ERROR_ON(eltwise_node->output(0) == nullptr); - - fused_conv_node->post_op_info_list().push_back(std::make_unique(prev_op_dst_pos, eltwise_node->convert_policy())); - ARM_COMPUTE_LOG_GRAPH_VERBOSE(" with Elementwise Layer node with ID : " << post_op->id()); - break; - } - case ActivationLayerNode::node_type: - { - auto *act_node = arm_compute::utils::cast::polymorphic_downcast(post_op); - ARM_COMPUTE_ERROR_ON(act_node->output(0) == nullptr); - - fused_conv_node->post_op_info_list().push_back(std::make_unique(act_node->activation_info())); - ARM_COMPUTE_LOG_GRAPH_VERBOSE(" with Activation Layer node with ID : " << post_op->id()); - break; - } - default: - break; - } - - if(op_idx == post_op_node_list.size() - 1) // last fusable node - { - // Get driving nodes of last fusable node - std::vector last_driving_nodes = get_driving_nodes(*post_op); - - // Extract last fusable node accessor if any - auto last_node_accessor = post_op->output(0)->extract_accessor(); - - // Remove node - g.remove_node(post_op->id()); - - // Update fused node outputs - for(auto &driving_node : last_driving_nodes) - { - g.add_connection(fused_id, 0, driving_node.node_id, driving_node.index); - configure_tensor(fused_node->output(0)); - } + // Fuse convolution with post op + fuse_convolution_with_post_op(g, fused_node, post_op_node_list, prev_op_dst_pos); - // Update accessor to fused node - fused_node->output(0)->set_accessor(std::move(last_node_accessor)); - } - else - { - // Remove node - g.remove_node(post_op->id()); - } - op_idx++; - } post_op_node_list.clear(); ARM_COMPUTE_LOG_GRAPH_VERBOSE(std::endl); } diff --git a/src/graph/nodes/FusedConvolutionWithPostOpNode.cpp b/src/graph/nodes/FusedConvolutionWithPostOpNode.cpp index c7ca59d863..63341e2760 100644 --- a/src/graph/nodes/FusedConvolutionWithPostOpNode.cpp +++ b/src/graph/nodes/FusedConvolutionWithPostOpNode.cpp @@ -37,8 +37,7 @@ FusedConvolutionWithPostOpNode::FusedConvolutionWithPostOpNode(PadStrideInfo ConvolutionMethod method, FastMathHint fast_math_hint, QuantizationInfo out_quant_info) - : _info(std::move(info)), _num_groups(num_groups), _method(method), _fast_math_hint(fast_math_hint), _out_quant_info(std::move(out_quant_info)), _fused_activation(), - _post_op_info_list(std::list> {}) + : _info(std::move(info)), _num_groups(num_groups), _method(method), _fast_math_hint(fast_math_hint), _out_quant_info(std::move(out_quant_info)), _fused_activation() { _input_edges.resize(4, EmptyEdgeID); _outputs.resize(1, NullTensorID); @@ -64,16 +63,6 @@ FastMathHint FusedConvolutionWithPostOpNode::fast_math_hint() const return _fast_math_hint; } -const std::list> &FusedConvolutionWithPostOpNode::post_op_info_list() const -{ - return _post_op_info_list; -} - -std::list> &FusedConvolutionWithPostOpNode::post_op_info_list() -{ - return _post_op_info_list; -} - PadStrideInfo FusedConvolutionWithPostOpNode::convolution_info() const { return _info; -- cgit v1.2.1