1 /*
2 * Copyright (c) 2019-2022 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/NEMeanStdDevNormalizationKernel.h"
25
26 #include "arm_compute/core/Helpers.h"
27 #include "arm_compute/core/ITensor.h"
28 #include "arm_compute/core/TensorInfo.h"
29 #include "arm_compute/core/Types.h"
30 #include "arm_compute/core/Window.h"
31 #include "src/core/CPP/Validate.h"
32 #include "src/core/NEON/NEMath.h"
33 #include "src/core/NEON/wrapper/wrapper.h"
34 #include "src/core/common/Registrars.h"
35 #include "src/core/helpers/AutoConfiguration.h"
36 #include "src/core/helpers/WindowHelpers.h"
37 #include "src/cpu/kernels/meanstddevnorm/list.h"
38
39 namespace arm_compute
40 {
41 namespace
42 {
43 struct MeanStdDevNormSelectorData
44 {
45 DataType dt;
46 };
47
48 using MeanStdDevNormSelctorPtr = std::add_pointer<bool(const MeanStdDevNormSelectorData &data)>::type;
49 using MeanStdDevNormUKernelPtr = std::add_pointer<void(ITensor *input, ITensor *output, float epsilon, const Window &window)>::type;
50
51 struct MeanStdDevNormKernel
52 {
53 const char *name;
54 const MeanStdDevNormSelctorPtr is_selected;
55 MeanStdDevNormUKernelPtr ukernel;
56 };
57
58 static const std::vector<MeanStdDevNormKernel> available_kernels =
59 {
60 {
61 "fp32_neon_meanstddevnorm",
__anon9bfaead00202() 62 [](const MeanStdDevNormSelectorData & data) { return data.dt == DataType::F32; },
63 REGISTER_FP32_NEON(arm_compute::cpu::neon_fp32_meanstddevnorm)
64 },
65 #ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
66 {
67 "fp16_neon_meanstddevnorm",
__anon9bfaead00302() 68 [](const MeanStdDevNormSelectorData & data) { return data.dt == DataType::F16; },
69 REGISTER_FP16_NEON(arm_compute::cpu::neon_fp16_meanstddevnorm)
70 },
71 #endif // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC
72 {
73 "qasymm8_neon_meanstddevnorm",
__anon9bfaead00402() 74 [](const MeanStdDevNormSelectorData & data) { return data.dt == DataType::QASYMM8; },
75 REGISTER_QASYMM8_NEON(arm_compute::cpu::neon_qasymm8_meanstddevnorm)
76 },
77 };
78
79 /** Micro-kernel selector
80 *
81 * @param[in] data Selection data passed to help pick the appropriate micro-kernel
82 *
83 * @return A matching micro-kernel else nullptr
84 */
get_implementation(const MeanStdDevNormSelectorData & data)85 const MeanStdDevNormKernel *get_implementation(const MeanStdDevNormSelectorData &data)
86 {
87 for(const auto &uk : available_kernels)
88 {
89 if(uk.is_selected(data))
90 {
91 return &uk;
92 }
93 }
94 return nullptr;
95 }
96
validate_arguments(const ITensorInfo * input,const ITensorInfo * output,float epsilon)97 Status validate_arguments(const ITensorInfo *input, const ITensorInfo *output, float epsilon)
98 {
99 ARM_COMPUTE_UNUSED(epsilon);
100 ARM_COMPUTE_RETURN_ERROR_ON_CPU_F16_UNSUPPORTED(input);
101 ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input);
102 ARM_COMPUTE_RETURN_ERROR_ON_MSG(input->num_dimensions() > 2, "Input tensor cannot have more than 2 dimensions");
103 ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(input, 1, DataType::F16, DataType::F32, DataType::QASYMM8);
104
105 // Checks performed when output is configured
106 if((output != nullptr) && (output->total_size() != 0))
107 {
108 ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_SHAPES(input, output);
109 ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(input, output);
110 }
111 return Status{};
112 }
113
validate_and_configure_window(ITensorInfo * input,ITensorInfo * output)114 std::pair<Status, Window> validate_and_configure_window(ITensorInfo *input, ITensorInfo *output)
115 {
116 if(output != nullptr)
117 {
118 ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
119 // Output auto inizialitation if not yet initialized
120 auto_init_if_empty(*output, *input);
121 }
122
123 // This kernel doesn't need padding. A left-over for loop on dimension X, we cannot have any read or write out of memory
124 // For this reason num_elems_processed_per_iteration is set to 1
125 Window win = calculate_max_window(*input, Steps());
126
127 return std::make_pair(Status{}, win);
128 }
129 } // namespace
130
NEMeanStdDevNormalizationKernel()131 NEMeanStdDevNormalizationKernel::NEMeanStdDevNormalizationKernel()
132 : _input(nullptr), _output(nullptr), _epsilon(1e-8f)
133 {
134 }
135
configure(ITensor * input,ITensor * output,float epsilon)136 void NEMeanStdDevNormalizationKernel::configure(ITensor *input, ITensor *output, float epsilon)
137 {
138 ARM_COMPUTE_ERROR_ON_NULLPTR(input);
139
140 ARM_COMPUTE_ERROR_THROW_ON(NEMeanStdDevNormalizationKernel::validate(input->info(), (output != nullptr) ? output->info() : nullptr, epsilon));
141
142 _input = input;
143 _output = (output == nullptr) ? input : output;
144 _epsilon = epsilon;
145
146 // Configure kernel window
147 auto win_config = validate_and_configure_window(input->info(), (output == nullptr) ? nullptr : output->info());
148 ARM_COMPUTE_ERROR_THROW_ON(win_config.first);
149 ICPPKernel::configure(win_config.second);
150 }
151
validate(const ITensorInfo * input,const ITensorInfo * output,float epsilon)152 Status NEMeanStdDevNormalizationKernel::validate(const ITensorInfo *input, const ITensorInfo *output, float epsilon)
153 {
154 ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(input, output, epsilon));
155 ARM_COMPUTE_RETURN_ON_ERROR(validate_and_configure_window(input->clone().get(), (output != nullptr) ? output->clone().get() : nullptr).first);
156 return Status{};
157 }
158
run(const Window & window,const ThreadInfo & info)159 void NEMeanStdDevNormalizationKernel::run(const Window &window, const ThreadInfo &info)
160 {
161 ARM_COMPUTE_UNUSED(info);
162 ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
163 ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(IKernel::window(), window);
164
165 const auto *uk = get_implementation(MeanStdDevNormSelectorData{ _output->info()->data_type() });
166 ARM_COMPUTE_ERROR_ON(uk == nullptr || uk->ukernel == nullptr);
167
168 uk->ukernel(_input, _output, _epsilon, window);
169 }
170 } // namespace arm_compute
171