From 233e977ad1be36399beccd2e2df23b4ade56aa41 Mon Sep 17 00:00:00 2001 From: Sergei Barannikov/AI Tools Lab /SRR/Engineer/Samsung Electronics Date: Thu, 21 Nov 2019 09:58:07 +0300 Subject: [PATCH] [neurun] Simplify code using Operand::asVector (#9038) Simplify code using newly introduced `Operand::asVector`. Signed-off-by: Sergei Barannikov --- runtime/neurun/backend/acl_cl/KernelGenerator.cc | 6 +- runtime/neurun/backend/acl_neon/KernelGenerator.cc | 227 ++++++--------------- 2 files changed, 62 insertions(+), 171 deletions(-) diff --git a/runtime/neurun/backend/acl_cl/KernelGenerator.cc b/runtime/neurun/backend/acl_cl/KernelGenerator.cc index b4112b1..d0bdacd 100644 --- a/runtime/neurun/backend/acl_cl/KernelGenerator.cc +++ b/runtime/neurun/backend/acl_cl/KernelGenerator.cc @@ -533,7 +533,7 @@ void KernelGenerator::visit(const model::operation::ReduceSum &node) // Convert to ACL axes taking into account negative values and possible duplicates. std::set acl_axes; - const auto input_rank = _ctx.at(input_index).shape().rank(); + const int input_rank = _ctx.at(input_index).shape().rank(); for (int axis : axes) { if (axis < 0) @@ -1809,7 +1809,7 @@ void KernelGenerator::visit(const model::operation::Mean &node) // Convert to ACL axes taking into account negative values and possible duplicates. std::set acl_axes; const int ifm_rank = _ctx.at(ifm_index).shape().rank(); - for (auto axis : axes) + for (int axis : axes) { if (axis < 0) axis += ifm_rank; @@ -1891,7 +1891,7 @@ void KernelGenerator::visit(const model::operation::ReduceMin &node) // Convert to ACL axes taking into account negative values and possible duplicates. std::set acl_axes; - const auto ifm_rank = _ctx.at(ifm_index).shape().rank(); + const int ifm_rank = _ctx.at(ifm_index).shape().rank(); for (int axis : axes) { if (axis < 0) diff --git a/runtime/neurun/backend/acl_neon/KernelGenerator.cc b/runtime/neurun/backend/acl_neon/KernelGenerator.cc index 4cace9c..89251d8 100644 --- a/runtime/neurun/backend/acl_neon/KernelGenerator.cc +++ b/runtime/neurun/backend/acl_neon/KernelGenerator.cc @@ -433,64 +433,29 @@ void KernelGenerator::visit(const model::operation::Mean &node) { const auto ofm_index{node.getOutputs().at(0)}; const auto ifm_index{node.getInputs().at(model::operation::Mean::Input::INPUT)}; - - const auto axis_index{node.param().axis_index}; + const auto &axes{_ctx.at(node.param().axis_index).asVector()}; const auto keep_dims{node.param().keep_dims}; - const auto ifm_shape = _ctx.at(ifm_index).shape(); - auto ofm_alloc = _tensor_builder->at(ofm_index).get(); auto ifm_alloc = _tensor_builder->at(ifm_index).get(); - std::set axes; + const auto frontend_layout = _current_subg_layout; + const auto backend_layout = ifm_alloc->layout(); + + // Convert to ACL axes taking into account negative values and possible duplicates. + std::set acl_axes; + const int ifm_rank = _ctx.at(ifm_index).shape().rank(); + for (int axis : axes) { - const auto ifm_rank = ifm_shape.rank(); - const auto frontend_layout = _current_subg_layout; - const auto backend_layout = ifm_alloc->layout(); - const auto axis_shape = _ctx.at(axis_index).shape(); - switch (axis_shape.rank()) - { - case 0: // scalar - { - auto axis_value = _ctx.at(axis_index).asScalar(); - if (axis_value < 0) - { - axis_value += ifm_rank; - } - axes.insert(::neurun::backend::acl_common::ToARMComputeAxis(ifm_rank, axis_value, - frontend_layout, backend_layout) - .value()); - break; - } - case 1: // vector - { - const auto axis_base = _ctx.at(axis_index).data().base(); - const int axis_size = axis_shape.num_elements(); - - // If axis's data does not exist as constant values and can be gotten as input data, we have - // to find a way to infer output shape when sinking output. - assert(axis_base != nullptr); - for (int32_t n = 0; n < axis_size; ++n) - { - int32_t axis_value = *(reinterpret_cast(axis_base) + n); - if (axis_value < 0) - { - axis_value += ifm_rank; - } - axes.insert(::neurun::backend::acl_common::ToARMComputeAxis( - ifm_rank, axis_value, frontend_layout, backend_layout) - .value()); - } - break; - } - default: - throw std::runtime_error("Not supported"); - } + if (axis < 0) + axis += ifm_rank; + acl_axes.insert( + acl_common::ToARMComputeAxis(ifm_rank, axis, frontend_layout, backend_layout).value()); } arm_compute::Coordinates fixed_axis; - for (auto a : axes) + for (const auto axis : acl_axes) { - fixed_axis.set(fixed_axis.num_dimensions(), a); + fixed_axis.set(fixed_axis.num_dimensions(), axis); } // NOTE NEReduceMean has a bug that does not support NHWC layout @@ -1284,64 +1249,30 @@ void KernelGenerator::visit(const model::operation::ReduceMax &node) { const auto ofm_index{node.getOutputs().at(0)}; const auto ifm_index{node.getInputs().at(model::operation::ReduceMax::Input::INPUT)}; - const auto axis_index{node.param().axis_index}; + const auto &axes{_ctx.at(node.param().axis_index).asVector()}; - auto ifm_shape = _ctx.at(ifm_index).shape(); - auto ofm_shape = _ctx.at(ofm_index).shape(); - auto axis_shape = _ctx.at(axis_index).shape(); - - const auto ifm_rank = ifm_shape.rank(); auto ofm_alloc = _tensor_builder->at(ofm_index).get(); auto ifm_alloc = _tensor_builder->at(ifm_index).get(); - std::set axes; + const auto frontend_layout = _current_subg_layout; + const auto backend_layout = ifm_alloc->layout(); + + // Convert to ACL axes taking into account negative values and possible duplicates. + std::set acl_axes; + const int ifm_rank = _ctx.at(ifm_index).shape().rank(); + for (int axis : axes) { - const auto frontend_layout = _current_subg_layout; - const auto backend_layout = ifm_alloc->layout(); - switch (axis_shape.rank()) - { - case 0: // scalar - { - auto axis_value = _ctx.at(axis_index).asScalar(); - if (axis_value < 0) - { - axis_value += ifm_rank; - } - axes.insert(::neurun::backend::acl_common::ToARMComputeAxis(ifm_rank, axis_value, - frontend_layout, backend_layout) - .value()); - break; - } - case 1: // vector - { - const auto axis_base = _ctx.at(axis_index).data().base(); - const int axis_size = axis_shape.num_elements(); - - // If axis's data does not exist as constant values and can be gotten as input data, we have - // to find a way to infer output shape when sinking output. - assert(axis_base != nullptr); - for (int32_t n = 0; n < axis_size; ++n) - { - int32_t axis_value = *(reinterpret_cast(axis_base) + n); - if (axis_value < 0) - { - axis_value += ifm_rank; - } - axes.insert(::neurun::backend::acl_common::ToARMComputeAxis( - ifm_rank, axis_value, frontend_layout, backend_layout) - .value()); - } - break; - } - default: - throw std::runtime_error("Not supported"); - break; - } + if (axis < 0) + axis += ifm_rank; + acl_axes.insert( + acl_common::ToARMComputeAxis(ifm_rank, axis, frontend_layout, backend_layout).value()); } + arm_compute::Coordinates reduce_axes; - for (const auto &a : axes) + for (const auto axis : acl_axes) { - reduce_axes.set(reduce_axes.num_dimensions(), a); + reduce_axes.set(reduce_axes.num_dimensions(), axis); } + auto fn = nnfw::cpp14::make_unique<::arm_compute::NEReduceOperation>(); fn->configure(ifm_alloc->handle(), reduce_axes, false, ofm_alloc->handle(), @@ -1356,64 +1287,30 @@ void KernelGenerator::visit(const model::operation::ReduceMin &node) { const auto ofm_index{node.getOutputs().at(0)}; const auto ifm_index{node.getInputs().at(model::operation::ReduceMin::Input::INPUT)}; - const auto axis_index{node.param().axis_index}; - - auto ifm_shape = _ctx.at(ifm_index).shape(); - auto ofm_shape = _ctx.at(ofm_index).shape(); - auto axis_shape = _ctx.at(axis_index).shape(); + const auto &axes{_ctx.at(node.param().axis_index).asVector()}; - const auto ifm_rank = ifm_shape.rank(); auto ofm_alloc = _tensor_builder->at(ofm_index).get(); auto ifm_alloc = _tensor_builder->at(ifm_index).get(); - std::set axes; + const auto frontend_layout = _current_subg_layout; + const auto backend_layout = ifm_alloc->layout(); + + // Convert to ACL axes taking into account negative values and possible duplicates. + std::set acl_axes; + const int ifm_rank = _ctx.at(ifm_index).shape().rank(); + for (int axis : axes) { - const auto frontend_layout = _current_subg_layout; - const auto backend_layout = ifm_alloc->layout(); - switch (axis_shape.rank()) - { - case 0: // scalar - { - auto axis_value = _ctx.at(axis_index).asScalar(); - if (axis_value < 0) - { - axis_value += ifm_rank; - } - axes.insert(::neurun::backend::acl_common::ToARMComputeAxis(ifm_rank, axis_value, - frontend_layout, backend_layout) - .value()); - break; - } - case 1: // vector - { - const auto axis_base = _ctx.at(axis_index).data().base(); - const int axis_size = axis_shape.num_elements(); - - // If axis's data does not exist as constant values and can be gotten as input data, we have - // to find a way to infer output shape when sinking output. - assert(axis_base != nullptr); - for (int32_t n = 0; n < axis_size; ++n) - { - int32_t axis_value = *(reinterpret_cast(axis_base) + n); - if (axis_value < 0) - { - axis_value += ifm_rank; - } - axes.insert(::neurun::backend::acl_common::ToARMComputeAxis( - ifm_rank, axis_value, frontend_layout, backend_layout) - .value()); - } - break; - } - default: - throw std::runtime_error("Not supported"); - break; - } + if (axis < 0) + axis += ifm_rank; + acl_axes.insert( + acl_common::ToARMComputeAxis(ifm_rank, axis, frontend_layout, backend_layout).value()); } + arm_compute::Coordinates reduce_axes; - for (const auto &a : axes) + for (const auto axis : acl_axes) { - reduce_axes.set(reduce_axes.num_dimensions(), a); + reduce_axes.set(reduce_axes.num_dimensions(), axis); } + auto fn = nnfw::cpp14::make_unique<::arm_compute::NEReduceOperation>(); fn->configure(ifm_alloc->handle(), reduce_axes, false, ofm_alloc->handle(), @@ -1428,34 +1325,28 @@ void KernelGenerator::visit(const model::operation::ReduceSum &node) { const auto output_index{node.getOutputs().at(0)}; const auto input_index{node.getInputs().at(model::operation::ReduceSum::Input::INPUT)}; - const auto axis_index{node.param().axis_index}; - - const auto axis_base = _ctx.at(axis_index).data().base(); - const auto axis_size = _ctx.at(axis_index).shape().num_elements(); - const auto input_rank = _ctx.at(input_index).shape().rank(); + const auto &axes{_ctx.at(node.param().axis_index).asVector()}; auto output_alloc = _tensor_builder->at(output_index).get(); auto input_alloc = _tensor_builder->at(input_index).get(); const auto frontend_layout = _current_subg_layout; const auto backend_layout = input_alloc->layout(); - // The axis's data must exist as constant values - assert(axis_base != nullptr); - std::set axes; - for (size_t n = 0; n < axis_size; ++n) + + // Convert to ACL axes taking into account negative values and possible duplicates. + std::set acl_axes; + const int input_rank = _ctx.at(input_index).shape().rank(); + for (int axis : axes) { - int32_t axis_value = *(reinterpret_cast(axis_base) + n); - if (axis_value < 0) - { - axis_value += input_rank; - } - axes.insert(::neurun::backend::acl_common::ToARMComputeAxis(input_rank, axis_value, - frontend_layout, backend_layout) - .value()); + if (axis < 0) + axis += input_rank; + acl_axes.insert( + acl_common::ToARMComputeAxis(input_rank, axis, frontend_layout, backend_layout).value()); } + arm_compute::Coordinates fixed_axes; - for (const auto &a : axes) + for (const auto axis : acl_axes) { - fixed_axes.set(fixed_axes.num_dimensions(), a); + fixed_axes.set(fixed_axes.num_dimensions(), axis); } auto fn = nnfw::cpp14::make_unique<::arm_compute::NEReduceSum>(); -- 2.7.4