From 6cb26ce7ff35e0c9b634160603560feeb23b0cee Mon Sep 17 00:00:00 2001 From: Georgios Pinitas Date: Wed, 24 Jun 2020 17:20:23 +0100 Subject: COMPMID-3150: Remove padding from NEL2NormalizationLayerKernel Signed-off-by: Georgios Pinitas Change-Id: I7ae0d56f1c1f55c7049509b1f80cc07bdc54c8ec Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/3457 Tested-by: Arm Jenkins Reviewed-by: Michele Di Giorgio Comments-Addressed: Arm Jenkins --- src/core/NEON/kernels/NEL2NormalizeLayerKernel.cpp | 221 ++++++++------------- tests/validation/NEON/L2NormalizeLayer.cpp | 6 +- 2 files changed, 86 insertions(+), 141 deletions(-) diff --git a/src/core/NEON/kernels/NEL2NormalizeLayerKernel.cpp b/src/core/NEON/kernels/NEL2NormalizeLayerKernel.cpp index 9900446218..226d6e0c9c 100644 --- a/src/core/NEON/kernels/NEL2NormalizeLayerKernel.cpp +++ b/src/core/NEON/kernels/NEL2NormalizeLayerKernel.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2019 ARM Limited. + * Copyright (c) 2017-2020 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -45,102 +45,87 @@ constexpr int max_input_tensor_dim = 3; template void l2_normalize_X(const ITensor *in, const ITensor *sum, ITensor *out, float epsilon, const Window &window) { - /** NEON vector tag type. */ using ExactTagType = typename wrapper::traits::neon_vector::tag_type; - Window window_sum(window); - window_sum.set(Window::DimX, Window::Dimension(0, 0, 0)); + const int window_step_x = 16 / data_size_from_type(in->info()->data_type()); + const auto window_start_x = static_cast(window.x().start()); + const auto window_end_x = static_cast(window.x().end()); - Window in_slice = window.first_slice_window_1D(); - Window sum_slice = window_sum.first_slice_window_1D(); + Window win_collapsed = window.collapse_if_possible(window, Window::DimZ); + win_collapsed.set(Window::DimX, Window::Dimension(0, 1, 1)); - do + Iterator input_it(in, win_collapsed); + Iterator sum_it(sum, win_collapsed); + Iterator output_it(out, win_collapsed); + + execute_window_loop(win_collapsed, [&](const Coordinates &) { - Iterator input_it(in, in_slice); - Iterator sum_it(sum, sum_slice); - Iterator output_it(out, in_slice); + const auto in_ptr = reinterpret_cast(input_it.ptr()); + const auto out_ptr = reinterpret_cast(output_it.ptr()); - const auto sum_value = *reinterpret_cast(sum_it.ptr()); - const auto vec_normalize_value = wrapper::vdup_n(static_cast(1.f / std::sqrt(std::max(sum_value, static_cast(epsilon)))), ExactTagType{}); + const T sum_value = *reinterpret_cast(sum_it.ptr()); + const T norm_value = static_cast(1.f) / std::sqrt(std::max(sum_value, static_cast(epsilon))); + const auto vec_norm_value = wrapper::vdup_n(norm_value, ExactTagType{}); - execute_window_loop(in_slice, [&](const Coordinates &) + // Compute elements over vector steps + int x = window_start_x; + for(; x <= (window_end_x - window_step_x); x += window_step_x) { - const auto in_ptr = reinterpret_cast(input_it.ptr()); - const auto out_ptr = reinterpret_cast(output_it.ptr()); + wrapper::vstore(out_ptr + x, wrapper::vmul(wrapper::vloadq(in_ptr + x), vec_norm_value)); + } - wrapper::vstore(out_ptr, wrapper::vmul(wrapper::vloadq(in_ptr), vec_normalize_value)); - }, - input_it, output_it); - } - while(window.slide_window_slice_1D(in_slice) && window.slide_window_slice_1D(sum_slice)); + // Compute left-over elements + for(; x < window_end_x; ++x) + { + out_ptr[x] = in_ptr[x] * norm_value; + } + }, + input_it, sum_it, output_it); } template -void l2_normalize_Y(const ITensor *in, const ITensor *sum, ITensor *out, float epsilon, const Window &window) +void l2_normalize_YZ(const ITensor *in, const ITensor *sum, ITensor *out, float epsilon, const Window &window, size_t axis) { - /** NEON vector tag type. */ using ExactTagType = typename wrapper::traits::neon_vector::tag_type; - Window window_sum(window); - window_sum.set(Window::DimY, Window::Dimension(0, 0, 0)); - - Window in_slice = window.first_slice_window_2D(); - Window sum_slice = window_sum.first_slice_window_2D(); - - do - { - Iterator input_it(in, in_slice); - Iterator sum_it(sum, sum_slice); - Iterator output_it(out, in_slice); - - auto eps = wrapper::vdup_n(static_cast(epsilon), ExactTagType{}); + const int window_step_x = 16 / data_size_from_type(in->info()->data_type()); + const auto window_start_x = static_cast(window.x().start()); + const auto window_end_x = static_cast(window.x().end()); - execute_window_loop(in_slice, [&](const Coordinates &) - { - const auto in_ptr = reinterpret_cast(input_it.ptr()); - const auto sum_ptr = reinterpret_cast(sum_it.ptr()); - const auto out_ptr = reinterpret_cast(output_it.ptr()); - - const auto vec_normalize_value = wrapper::vinvsqrt(wrapper::vmax(wrapper::vloadq(sum_ptr), eps)); - wrapper::vstore(out_ptr, wrapper::vmul(wrapper::vloadq(in_ptr), vec_normalize_value)); - }, - input_it, sum_it, output_it); - } - while(window.slide_window_slice_2D(in_slice) && window.slide_window_slice_2D(sum_slice)); -} + Window win = window; + win.set(Window::DimX, Window::Dimension(0, 1, 1)); -template -void l2_normalize_Z(const ITensor *in, const ITensor *sum, ITensor *out, float epsilon, const Window &window) -{ - /** NEON vector tag type. */ - using ExactTagType = typename wrapper::traits::neon_vector::tag_type; + Window window_sum(win); + window_sum.set(axis, Window::Dimension(0, 0, 0)); - Window window_sum(window); - window_sum.set(Window::DimZ, Window::Dimension(0, 0, 0)); + Iterator input_it(in, win); + Iterator sum_it(sum, window_sum); + Iterator output_it(out, win); - Window in_slice = window.first_slice_window_3D(); - Window sum_slice = window_sum.first_slice_window_3D(); + const auto vec_eps = wrapper::vdup_n(static_cast(epsilon), ExactTagType{}); - do + execute_window_loop(win, [&](const Coordinates &) { - Iterator input_it(in, in_slice); - Iterator sum_it(sum, sum_slice); - Iterator output_it(out, in_slice); + const auto in_ptr = reinterpret_cast(input_it.ptr()); + const auto sum_ptr = reinterpret_cast(sum_it.ptr()); + const auto out_ptr = reinterpret_cast(output_it.ptr()); - auto eps = wrapper::vdup_n(static_cast(epsilon), ExactTagType{}); + // Compute elements over vector steps + int x = window_start_x; + for(; x <= (window_end_x - window_step_x); x += window_step_x) + { + const auto vec_norm_value = wrapper::vinvsqrt(wrapper::vmax(wrapper::vloadq(sum_ptr + x), vec_eps)); + wrapper::vstore(out_ptr + x, wrapper::vmul(wrapper::vloadq(in_ptr + x), vec_norm_value)); + } - execute_window_loop(in_slice, [&](const Coordinates &) + // Compute left-over elements + for(; x < window_end_x; ++x) { - const auto in_ptr = reinterpret_cast(input_it.ptr()); - const auto sum_ptr = reinterpret_cast(sum_it.ptr()); - const auto out_ptr = reinterpret_cast(output_it.ptr()); - - const auto vec_normalize_value = wrapper::vinvsqrt(wrapper::vmax(wrapper::vloadq(sum_ptr), eps)); - wrapper::vstore(out_ptr, wrapper::vmul(wrapper::vloadq(in_ptr), vec_normalize_value)); - }, - input_it, sum_it, output_it); - } - while(window.slide_window_slice_3D(in_slice) && window.slide_window_slice_3D(sum_slice)); + const T norm_value = static_cast(1.f) / std::sqrt(std::max(sum_ptr[x], static_cast(epsilon))); + out_ptr[x] = in_ptr[x] * norm_value; + } + }, + input_it, sum_it, output_it); } Status validate_arguments(const ITensorInfo *input, const ITensorInfo *sum, const ITensorInfo *output, int axis, float epsilon) @@ -170,27 +155,19 @@ Status validate_arguments(const ITensorInfo *input, const ITensorInfo *sum, cons return Status{}; } -std::tuple validate_and_configure_window(ITensorInfo *input, ITensorInfo *sum, ITensorInfo *output, int axis) +std::tuple validate_and_configure_window(ITensorInfo *input, ITensorInfo *output) { - const uint32_t actual_axis = wrap_around(axis, max_input_tensor_dim); - const unsigned int num_elems_processed_per_iteration = 16 / data_size_from_type(input->data_type()); - const unsigned int num_elems_processed_per_iteration_sum = (actual_axis == 0) ? 1 : num_elems_processed_per_iteration; - - Window win = calculate_max_window(*input, Steps(num_elems_processed_per_iteration)); + Window win = calculate_max_window(*input, Steps()); // Output auto initialization if not yet initialized auto_init_if_empty(*output, input->tensor_shape(), 1, input->data_type()); - AccessWindowHorizontal input_access(input, 0, num_elems_processed_per_iteration); - AccessWindowHorizontal sum_access(sum, 0, num_elems_processed_per_iteration_sum); - AccessWindowHorizontal output_access(output, 0, num_elems_processed_per_iteration); - - bool window_changed = update_window_and_padding(win, input_access, sum_access, output_access); - output_access.set_valid_region(win, input->valid_region()); + // NEL2NormalizeLayerKernel doesn't need padding so update_window_and_padding() can be skipped + Coordinates coord; + coord.set_num_dimensions(output->num_dimensions()); + output->set_valid_region(ValidRegion(coord, output->tensor_shape())); - Status err = (window_changed) ? ARM_COMPUTE_CREATE_ERROR(ErrorCode::RUNTIME_ERROR, "Insufficient Padding!") : Status{}; - - return std::make_tuple(err, win); + return std::make_tuple(Status{}, win); } } // namespace @@ -204,14 +181,14 @@ void NEL2NormalizeLayerKernel::configure(const ITensor *input, const ITensor *su ARM_COMPUTE_ERROR_ON_NULLPTR(input, sum, output); ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input->info(), sum->info(), output->info(), axis, epsilon)); - _input = input; - _sum = sum; - _output = output; - _actual_axis = wrap_around(axis, max_input_tensor_dim); - _epsilon = epsilon; + _input = input; + _sum = sum; + _output = output; + _actual_axis = wrap_around(axis, max_input_tensor_dim); + _epsilon = epsilon; // Configure kernel window - auto win_config = validate_and_configure_window(_input->info(), _sum->info(), _output->info(), axis); + auto win_config = validate_and_configure_window(_input->info(), _output->info()); ARM_COMPUTE_ERROR_THROW_ON(std::get<0>(win_config)); INEKernel::configure(std::get<1>(win_config)); @@ -220,7 +197,7 @@ void NEL2NormalizeLayerKernel::configure(const ITensor *input, const ITensor *su Status NEL2NormalizeLayerKernel::validate(const ITensorInfo *input, const ITensorInfo *sum, const ITensorInfo *output, int axis, float epsilon) { ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, sum, output, axis, epsilon)); - ARM_COMPUTE_RETURN_ON_ERROR(std::get<0>(validate_and_configure_window(input->clone().get(), sum->clone().get(), output->clone().get(), axis))); + ARM_COMPUTE_RETURN_ON_ERROR(std::get<0>(validate_and_configure_window(input->clone().get(), output->clone().get()))); return Status{}; } @@ -231,55 +208,23 @@ void NEL2NormalizeLayerKernel::run(const Window &window, const ThreadInfo &info) ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this); ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(INEKernel::window(), window); - switch(_actual_axis) + if(_actual_axis > 2) { - case 0: - switch(_input->info()->data_type()) - { - case DataType::F32: - l2_normalize_X(_input, _sum, _output, _epsilon, window); - break; -#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC - case DataType::F16: - l2_normalize_X(_input, _sum, _output, _epsilon, window); - break; -#endif // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC - default: - ARM_COMPUTE_ERROR("Not implemented"); - } + ARM_COMPUTE_ERROR("Unsupported normalization axis"); + } + + switch(_input->info()->data_type()) + { + case DataType::F32: + (_actual_axis == Window::DimX) ? l2_normalize_X(_input, _sum, _output, _epsilon, window) : l2_normalize_YZ(_input, _sum, _output, _epsilon, window, _actual_axis); break; - case 1: - switch(_input->info()->data_type()) - { - case DataType::F32: - l2_normalize_Y(_input, _sum, _output, _epsilon, window); - break; #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC - case DataType::F16: - l2_normalize_Y(_input, _sum, _output, _epsilon, window); -#endif // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC - break; - default: - ARM_COMPUTE_ERROR("Not implemented"); - } + case DataType::F16: + (_actual_axis == Window::DimX) ? l2_normalize_X(_input, _sum, _output, _epsilon, window) : l2_normalize_YZ(_input, _sum, _output, _epsilon, window, _actual_axis); break; - case 2: - switch(_input->info()->data_type()) - { - case DataType::F32: - l2_normalize_Z(_input, _sum, _output, _epsilon, window); - break; -#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC - case DataType::F16: - l2_normalize_Z(_input, _sum, _output, _epsilon, window); - break; #endif // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC - default: - ARM_COMPUTE_ERROR("Not implemented"); - } - break; default: - ARM_COMPUTE_ERROR("Unsupported normalization axis"); + ARM_COMPUTE_ERROR("Not implemented"); } } } // namespace arm_compute diff --git a/tests/validation/NEON/L2NormalizeLayer.cpp b/tests/validation/NEON/L2NormalizeLayer.cpp index 17147c1d50..0bbbf2acad 100644 --- a/tests/validation/NEON/L2NormalizeLayer.cpp +++ b/tests/validation/NEON/L2NormalizeLayer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2019 ARM Limited. + * Copyright (c) 2017-2020 ARM Limited. * * SPDX-License-Identifier: MIT * @@ -99,7 +99,7 @@ using NEL2NormalizeLayerFixture = L2NormalizeLayerValidationFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F32)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), - framework::dataset::make("Axis", { -1, 0, 2 })), + framework::dataset::make("Axis", { -1, 0, 1, 2 })), framework::dataset::make("Epsilon", { 1e-12 }))) { // Validate output @@ -120,7 +120,7 @@ TEST_SUITE_END() // FP32 TEST_SUITE(FP16) FIXTURE_DATA_TEST_CASE(RunSmall, NEL2NormalizeLayerFixture, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(), framework::dataset::make("DataType", DataType::F16)), framework::dataset::make("DataLayout", { DataLayout::NCHW, DataLayout::NHWC })), - framework::dataset::make("Axis", { -1, 0, 2 })), + framework::dataset::make("Axis", { -1, 0, 1, 2 })), framework::dataset::make("Epsilon", { 1e-12 }))) { // Validate output -- cgit v1.2.1