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/CL/kernels/CLElementWiseUnaryLayerKernel.h"
25
26 #include "arm_compute/core/CL/CLHelpers.h"
27 #include "arm_compute/core/CL/ICLTensor.h"
28 #include "src/core/CL/CLValidate.h"
29 #include "src/core/helpers/WindowHelpers.h"
30 #include "support/Cast.h"
31 #include "support/StringSupport.h"
32
33 namespace arm_compute
34 {
35 namespace
36 {
validate_arguments(const ITensorInfo & input,const ITensorInfo & output,const ElementWiseUnary op)37 Status validate_arguments(const ITensorInfo &input, const ITensorInfo &output, const ElementWiseUnary op)
38 {
39 ARM_COMPUTE_RETURN_ERROR_ON_F16_UNSUPPORTED(&input);
40 if(op == ElementWiseUnary::LOGICAL_NOT)
41 {
42 ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&input, 1, DataType::U8);
43 }
44 else
45 {
46 ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&input, 1, DataType::F16, DataType::F32);
47 }
48
49 // Validate in case of configured output
50 if(output.total_size() > 0)
51 {
52 ARM_COMPUTE_RETURN_ERROR_ON_F16_UNSUPPORTED(&output);
53 if(op == ElementWiseUnary::LOGICAL_NOT)
54 {
55 ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&input, 1, DataType::U8);
56 }
57 else
58 {
59 ARM_COMPUTE_RETURN_ERROR_ON_DATA_TYPE_CHANNEL_NOT_IN(&output, 1, DataType::F16, DataType::F32);
60 }
61 ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_DATA_TYPES(&input, &output);
62 ARM_COMPUTE_RETURN_ERROR_ON_MISMATCHING_SHAPES(&input, &output);
63 }
64
65 return Status{};
66 }
67 } // namespace
68
configure(const ITensorInfo * input,ITensorInfo * output,const ElementWiseUnary & op)69 void CLElementWiseUnaryLayerKernel::configure(const ITensorInfo *input, ITensorInfo *output, const ElementWiseUnary &op)
70 {
71 configure(CLKernelLibrary::get().get_compile_context(), input, output, op);
72 }
73
configure(const CLCompileContext & compile_context,const ITensorInfo * input,ITensorInfo * output,const ElementWiseUnary & op)74 void CLElementWiseUnaryLayerKernel::configure(const CLCompileContext &compile_context, const ITensorInfo *input, ITensorInfo *output, const ElementWiseUnary &op)
75 {
76 ARM_COMPUTE_ERROR_ON_NULLPTR(input, output);
77
78 auto padding_info = get_padding_info({ input, output });
79
80 ARM_COMPUTE_ERROR_THROW_ON(validate_arguments(*input, *output, op));
81
82 const std::string kernel_name = "elementwise_unary";
83 const int vec_size_x = 16 / output->element_size();
84 const int output_width_x = output->tensor_shape().x();
85 const bool multi_access_x = (output_width_x / vec_size_x > 0);
86
87 // Set kernel build options
88 CLBuildOptions build_opts;
89 build_opts.add_option("-DDATA_TYPE=" + get_cl_type_from_data_type(input->data_type()));
90 build_opts.add_option_if(multi_access_x, "-DVEC_SIZE=" + support::cpp11::to_string(vec_size_x));
91 build_opts.add_option_if(multi_access_x, "-DLAST_ACCESSED_X=" + support::cpp11::to_string(std::max<int>(output_width_x - vec_size_x, 0)));
92 switch(op)
93 {
94 case ElementWiseUnary::RSQRT:
95 build_opts.add_option("-DOPERATION=rsqrt_op");
96 break;
97 case ElementWiseUnary::EXP:
98 build_opts.add_option("-DOPERATION=exp_op");
99 break;
100 case ElementWiseUnary::NEG:
101 build_opts.add_option("-DOPERATION=neg_op");
102 break;
103 case ElementWiseUnary::SIN:
104 build_opts.add_option("-DOPERATION=sin_op");
105 break;
106 case ElementWiseUnary::ABS:
107 build_opts.add_option("-DOPERATION=fabs_op");
108 break;
109 case ElementWiseUnary::LOG:
110 build_opts.add_option("-DOPERATION=natural_log_op");
111 break;
112 case ElementWiseUnary::ROUND:
113 build_opts.add_option("-DOPERATION=round_op");
114 break;
115 case ElementWiseUnary::LOGICAL_NOT:
116 build_opts.add_option("-DOPERATION=logical_not_op");
117 break;
118 default:
119 ARM_COMPUTE_ERROR("Not implemented");
120 }
121
122 // Create kernel
123 _kernel = create_kernel(compile_context, kernel_name, build_opts.options());
124
125 // Configure kernel window
126 Window win = calculate_max_window(*output);
127 if(multi_access_x)
128 {
129 win.set(Window::DimX,
130 Window::Dimension(win.x().start(), ceil_to_multiple(win.x().end(), vec_size_x), vec_size_x));
131 }
132 ICLKernel::configure_internal(win);
133
134 ARM_COMPUTE_ERROR_ON(has_padding_changed(padding_info));
135 }
136
validate(const ITensorInfo * input,const ITensorInfo * output,const ElementWiseUnary & op)137 Status CLElementWiseUnaryLayerKernel::validate(const ITensorInfo *input, const ITensorInfo *output, const ElementWiseUnary &op)
138 {
139 ARM_COMPUTE_UNUSED(op);
140 ARM_COMPUTE_RETURN_ERROR_ON_NULLPTR(input, output);
141 ARM_COMPUTE_RETURN_ON_ERROR(validate_arguments(*input, *output, op));
142
143 return Status{};
144 }
145
run_op(ITensorPack & tensors,const Window & window,cl::CommandQueue & queue)146 void CLElementWiseUnaryLayerKernel::run_op(ITensorPack &tensors, const Window &window, cl::CommandQueue &queue)
147 {
148 ARM_COMPUTE_ERROR_ON_UNCONFIGURED_KERNEL(this);
149 ARM_COMPUTE_ERROR_ON_INVALID_SUBWINDOW(ICLKernel::window(), window);
150
151 Window collapsed = window.collapse_if_possible(ICLKernel::window(), Window::DimZ);
152 Window slice = collapsed.first_slice_window_3D();
153
154 const auto src = utils::cast::polymorphic_downcast<const ICLTensor *>(tensors.get_const_tensor(TensorType::ACL_SRC));
155 auto dst = utils::cast::polymorphic_downcast<ICLTensor *>(tensors.get_tensor(TensorType::ACL_DST));
156
157 do
158 {
159 unsigned int idx = 0;
160 add_3D_tensor_argument(idx, src, slice);
161 add_3D_tensor_argument(idx, dst, slice);
162 enqueue(queue, *this, slice, lws_hint());
163 }
164 while(collapsed.slide_window_slice_3D(slice));
165 }
166 } // namespace arm_compute
167