1 /*
2 * Copyright (c) 2018-2020 Arm Limited.
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to
8 * deal in the Software without restriction, including without limitation the
9 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10 * sell copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in all
14 * copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24 #include "src/core/NEON/kernels/NECopyKernel.h"
25
26 #include "arm_compute/core/Error.h"
27 #include "arm_compute/core/Helpers.h"
28 #include "arm_compute/core/ITensor.h"
29 #include "arm_compute/core/TensorInfo.h"
30 #include "arm_compute/core/Validate.h"
31 #include "arm_compute/core/Window.h"
32 #include "arm_compute/core/utils/misc/ShapeCalculator.h"
33 #include "src/core/helpers/AutoConfiguration.h"
34 #include "src/core/helpers/WindowHelpers.h"
35
36 namespace arm_compute
37 {
38 namespace
39 {
validate_arguments(const ITensorInfo * input,const ITensorInfo * output,const PaddingList & padding=PaddingList ())40 Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output, const PaddingList &padding = PaddingList())
41 {
42 ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output);
43 ARM_COMPUTE_RETURN_ERROR_ON(input->data_type() == DataType::UNKNOWN);
44 ARM_COMPUTE_RETURN_ERROR_ON(padding.size() > 4);
45
46 // Validate output if initialized
47 if(output->total_size() != 0)
48 {
49 ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DIMENSIONS(misc::shape_calculator::compute_padded_shape(input->tensor_shape(), padding), output->tensor_shape());
50 ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, output);
51 }
52
53 return Status{};
54 }
55
validate_and_configure_window(ITensorInfo * input,ITensorInfo * output)56 std::pair<Status, Window> validate_and_configure_window(ITensorInfo *input, ITensorInfo *output)
57 {
58 // Output auto inizialitation if not yet initialized
59 auto_init_if_empty(*output, *input);
60 return std::make_pair(Status{}, calculate_max_window(*output));
61 }
62
validate_and_configure_window_with_padding(ITensorInfo * input,ITensorInfo * output,const PaddingList & padding)63 std::pair<Status, Window> validate_and_configure_window_with_padding(ITensorInfo *input, ITensorInfo *output, const PaddingList &padding)
64 {
65 const TensorShape input_shape = input->tensor_shape();
66 const TensorShape padded_shape = misc::shape_calculator::compute_padded_shape(input_shape, padding);
67 auto_init_if_empty(*output, input->clone()->set_tensor_shape(padded_shape));
68 // Configure window
69 const Window win = calculate_max_window(*output, output->dimension(0));
70 return std::make_pair(Status{}, win);
71 }
72
73 } // namespace
74
NECopyKernel()75 NECopyKernel::NECopyKernel()
76 : _input(nullptr), _output(nullptr), _padding()
77 {
78 }
79
configure(const ITensor * input,ITensor * output,const PaddingList & padding)80 void NECopyKernel::configure(const ITensor *input, ITensor *output, const PaddingList &padding)
81 {
82 ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
83 ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(input->info(), output->info(), padding));
84
85 _input = input;
86 _output = output;
87 _padding = padding;
88
89 std::pair<Status, Window> win_config;
90
91 if(padding.empty())
92 {
93 win_config = validate_and_configure_window(input->info(), output->info());
94 }
95 else
96 {
97 win_config = validate_and_configure_window_with_padding(input->info(), output->info(), padding);
98 }
99
100 ARM_COMPUTE_ERROR_THROW_ON(win_config.first);
101 INEKernel::configure(win_config.second);
102 }
103
validate(const arm_compute::ITensorInfo * input,const arm_compute::ITensorInfo * output,const PaddingList & padding)104 Status NECopyKernel::validate(const arm_compute::ITensorInfo *input, const arm_compute::ITensorInfo *output, const PaddingList &padding)
105 {
106 ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, output, padding));
107
108 if(padding.empty())
109 {
110 ARM_COMPUTE_RETURN_ON_ERROR(validate_and_configure_window(input->clone().get(), output->clone().get()).first);
111 }
112 else
113 {
114 ARM_COMPUTE_RETURN_ON_ERROR(validate_and_configure_window_with_padding(input->clone().get(), output->clone().get(), padding).first);
115 }
116
117 return Status{};
118 }
119
run(const Window & window,const ThreadInfo & info)120 void NECopyKernel::run(const Window &window, const ThreadInfo &info)
121 {
122 ARM_COMPUTE_UNUSED(info);
123 ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
124 ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(INEKernel::window(), window);
125
126 if(_padding.empty())
127 {
128 Window output_window{ window };
129 output_window.set(Window::DimX, Window::Dimension(output_window.x().start(), output_window.x().end(), _input->info()->dimension(0)));
130 Window out_slice = output_window.first_slice_window_1D();
131 do
132 {
133 Iterator input_it(_input, out_slice);
134 Iterator output_it(_output, out_slice);
135
136 execute_window_loop(out_slice, [&](const Coordinates &)
137 {
138 memcpy(output_it.ptr(), input_it.ptr(), _output->info()->dimension(0) * _output->info()->element_size());
139 },
140 input_it, output_it);
141 }
142 while(output_window.slide_window_slice_1D(out_slice));
143 }
144 else
145 {
146 Window input_window{ window };
147 input_window.set(Window::DimX, Window::Dimension(0, window.x().end() - _padding[0].first, _input->info()->dimension(0)));
148
149 Iterator input_it(_input, input_window);
150 Iterator output_it(_output, window);
151 const size_t row_size_in_bytes = _input->info()->dimension(0) * _input->info()->element_size();
152 execute_window_loop(window, [&](const Coordinates &)
153 {
154 auto dst_ptr = output_it.ptr() + _padding[0].first * _output->info()->element_size();
155 std::memcpy(dst_ptr, input_it.ptr(), row_size_in_bytes);
156 },
157 input_it, output_it);
158 }
159 }
160 } // namespace arm_compute
161