Compute Library
 22.08
KernelDescriptors.h
Go to the documentation of this file.
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 #ifndef ARM_COMPUTE_CORE_KERNEL_DESCRIPTORS_H
25 #define ARM_COMPUTE_CORE_KERNEL_DESCRIPTORS_H
26 
28 #include "arm_compute/core/Types.h"
30 
31 namespace arm_compute
32 {
33 /** Descriptor for FFT scale kernels */
35 {
36  float scale{ 0.f }; /**< Axis to perform the kernel on. */
37  bool conjugate{ true }; /**< Flag to conjugate the output/ */
38 };
39 
40 /** Descriptor for FFT digit reverse kernels */
42 {
43  unsigned int axis{ 0 }; /**< Axis to perform the kernel on. */
44  bool conjugate{ false }; /**< Flag to conjugate the output/ */
45 };
46 
47 /** Descriptor used by the FFT core kernels */
49 {
50  unsigned int axis{ 0 }; /**< Axis to run the kernel on. */
51  unsigned int radix{ 0 }; /**< Radix to use. */
52  unsigned int Nx{ 0 }; /**< Nx coefficient. */
53  bool is_first_stage{ false }; /**< Flags if the FFT kernels is the first stage of a decomposed FFT. */
54 };
55 
56 class ITensorInfo;
57 /** Descriptor used by the GEMM kernels */
59 {
60  GEMMKernelInfo() = default;
62  unsigned int im,
63  unsigned int in,
64  unsigned int ik,
65  unsigned int idepth_output_gemm3d,
66  bool ireinterpret_input_as_3d,
67  bool ibroadcast_bias,
68  bool ifp_mixed_precision,
69  bool ihas_pad_y,
70  ActivationLayerInfo iactivation_info,
71  int inmult_transpose1xW_width,
72  int imult_interleave4x4_height,
73  GEMMLHSMatrixInfo ilhs_info,
74  GEMMRHSMatrixInfo irhs_info,
75  int32_t ina_offset,
76  int32_t inb_offset,
78  : m(im), n(in), k(ik), depth_output_gemm3d(idepth_output_gemm3d), reinterpret_input_as_3d(ireinterpret_input_as_3d), broadcast_bias(ibroadcast_bias), fp_mixed_precision(ifp_mixed_precision),
79  has_pad_y(ihas_pad_y), activation_info(iactivation_info), mult_transpose1xW_width(inmult_transpose1xW_width), mult_interleave4x4_height(imult_interleave4x4_height), lhs_info(ilhs_info),
80  rhs_info(irhs_info), a_offset(ina_offset), b_offset(inb_offset), post_ops(ipost_ops)
81  {
82  }
83 
84  unsigned int m{ 0 }; /**< Number of LHS rows*/
85  unsigned int n{ 0 }; /**< Number of RHS columns*/
86  unsigned int k{ 0 }; /**< Number of LHS columns or RHS rows */
87  unsigned int depth_output_gemm3d{ 0 }; /**< Depth of the output tensor in case is reinterpreted as 3D */
88  bool reinterpret_input_as_3d{ false }; /**< Flag used to reinterpret the input as 3D */
89  bool broadcast_bias{ false }; /**< Flag used to broadcast the bias addition */
90  bool fp_mixed_precision{ false }; /**< Flag used to indicate wider accumulators (32 bit instead of 16 for FP16). */
91  bool has_pad_y{ false }; /**< Flag used to indicate if the input/output tensors have internal pad on the y direction */
92  ActivationLayerInfo activation_info{}; /**< Activation function to perform after the matrix multiplication */
93  int mult_transpose1xW_width{ 1 }; /**< Multiplication factor for the width of the 1xW transposed block */
94  int mult_interleave4x4_height{ 1 }; /**< Multiplication factor for the height of the 4x4 interleaved block */
95  GEMMLHSMatrixInfo lhs_info{}; /**< LHS matrix information used to retrieve the number of rows processed by each thread */
96  GEMMRHSMatrixInfo rhs_info{}; /**< RHS matrix information used for reshaping the RHS matrix */
97  int32_t a_offset{ 0 }; /**< Offset to be added to each element of the matrix A */
98  int32_t b_offset{ 0 }; /**< Offset to be added to each element of the matrix B */
99  GEMMLowpOutputStageInfo output_stage{}; /**< GEMMLowp output stage information */
100  experimental::PostOpList<ITensorInfo *> post_ops{}; /**< (EXPERIMENTAL_POST_OPS) Specifies a list of post ops to be fused after the main op. Note unsupported post ops would not be executed.
101  * If specified, automatically disable the @ref activation_info */
102 };
103 
104 /** Compute descriptor used by the depthwise convolution native kernel */
106 {
107  unsigned int n0{ 0 }; /**< Number of columns processed by each thread */
108  unsigned int m0{ 0 }; /**< Number of rows processed by each thread */
109  bool export_weights_to_cl_image{ false }; /**< Export the weights to cl_image */
110 };
111 
112 /** Compute descriptor used by the direct convolution kernel */
114 {
115  int32_t m0{ 1 }; /**< Number of rows to be processed by the kernel */
116  int32_t n0{ 1 }; /**< Number of columns to be processed by the kernel */
117  int32_t k0{ 1 }; /**< Number of partial accumulations to be processed in a single iteration by the kernel */
118  bool export_weights_to_cl_image{ false }; /**< Flag to export the weights to cl_image */
119 };
120 
121 /** Descriptor used by the softmax kernels */
123 {
124  float beta{ 1.f }; /**< A scaling factor for the exponent with default value 1.0 */
125  bool is_log{ false }; /**< Flag used to perform Log Softmax operation */
126  DataType input_data_type{ DataType::UNKNOWN }; /**< Input tensor data type */
127  int32_t axis{ 0 }; /**< The dimension in which to apply softmax. */
128 };
129 
130 /** Descriptor used by the direct convolution layer output stage kernels */
132 {
133  int32_t result_fixedpoint_multiplier{ 0 }; /**< Result output stage multiplier used for quantizing */
134  int32_t result_shift{ 0 }; /**< Result output stage shift used for quantizing */
135  int32_t result_offset_after_shift{ 0 }; /**< Result offset used for quantizing */
136  DataType output_data_type{ DataType::UNKNOWN }; /**< Output tensor data type to use if the output is not initialized */
137 };
138 
140 {
141  /** Default constructor */
143  : InstanceNormalizationLayerKernelInfo(1.f, 0.f, 1e-12, true)
144  {
145  }
146  /** Constructor
147  *
148  * @param[in] gamma The scale scalar value applied to the normalized tensor.
149  * @param[in] beta The offset scalar value applied to the normalized tensor
150  * @param[in] epsilon Lower bound value for the normalization.
151  * @param[in] use_mixed_precision Use mixed precision in case of FP16 execution.
152  */
153  InstanceNormalizationLayerKernelInfo(float gamma, float beta, float epsilon, bool use_mixed_precision)
154  : gamma(gamma), beta(beta), epsilon(epsilon), use_mixed_precision(use_mixed_precision)
155  {
156  }
157 
158  float gamma; /**< The scale scalar value applied to the normalized tensor. Defaults to 1.0 */
159  float beta; /**< The offset scalar value applied to the normalized tensor. Defaults to 0.0 */
160  float epsilon; /**< Lower bound value for the normalization. Defaults to 1e-12 */
161  bool use_mixed_precision; /**< Use mixed precision in case of FP16 execution. Defaults to true */
162 };
163 
165 {
166  /** Default constructor */
167  GEMMLowpReductionKernelInfo() = default;
168  /** Constructor
169  *
170  * @param[in] k Number of matrix columns/rows.
171  * @param[in] is_reshaped True if the input tensor has been reshaped.
172  * @param[in] scalar Scalar value to multiply each reduced column/row by.
173  * @param[in] mul_by_scalar True if each column/row reduction has to be multiplied by a scalar value.
174  */
175  GEMMLowpReductionKernelInfo(int32_t k, bool is_reshaped, int32_t scalar, bool mul_by_scalar)
176  : k(k), is_reshaped(is_reshaped), scalar(scalar), mul_by_scalar(mul_by_scalar)
177  {
178  }
179 
180  int32_t k{ 0 }; /**< Number of matrix columns/rows */
181  bool is_reshaped{ false }; /**< True if the input tensor has been reshaped */
182  int32_t scalar{ 0 }; /**< Scalar value to multiply each reduced column/row by */
183  bool mul_by_scalar{ false }; /**< True if each column/row reduction has to be multiplied by a scalar value */
184 };
185 
187 {
188  /** Constructor
189  *
190  * @param[in] interpolation_policy Interpolation type to use
191  * @param[in] border_mode Border mode policy
192  * @param[in] constant_border_value (Optional) Constant value to use for borders if border_mode is set to CONSTANT and use_padding is set to false. Defaults to default @ref PixelValue
193  * @param[in] sampling_policy (Optional) Sampling policy used by the interpolation. Defaults to @ref SamplingPolicy::CENTER
194  * @param[in] use_padding (Optional) Is padding in use or not. Defaults to true.
195  * @param[in] align_corners (Optional) Align corners of input and output, only affecting bilinear policy with TOP_LEFT sampling policy. Defaults to false.
196  * @param[in] data_layout (Optional) Data layout used by the layer. Defaults to @ref DataLayout::UNKNOWN
197  */
199  BorderMode border_mode,
200  PixelValue constant_border_value = PixelValue(),
202  bool use_padding = true,
203  bool align_corners = false,
205  : interpolation_policy{ interpolation_policy },
206  border_mode{ border_mode },
207  constant_border_value{ constant_border_value },
209  use_padding{ use_padding },
210  align_corners{ align_corners },
212  {
213  }
214 
215  InterpolationPolicy interpolation_policy; /**< Interpolation type to use */
216  BorderMode border_mode; /**< Border mode policy */
217  PixelValue constant_border_value; /**< Constant value to use for constant border mode policy */
218  SamplingPolicy sampling_policy; /**< Sampling policy used by the interpolation. */
219  bool use_padding; /**< Indication of using padding */
220  bool align_corners; /**< Align corners of input and output */
221  DataLayout data_layout; /**< Data layout to use */
222 };
223 } // namespace arm_compute
224 #endif /* ARM_COMPUTE_CORE_KERNEL_DESCRIPTORS_H */
BorderMode
Methods available to handle borders.
Definition: Types.h:274
BorderMode border_mode
Border mode policy.
Class describing the value of a pixel for any image format.
Definition: PixelValue.h:34
InterpolationPolicy
Interpolation method.
Definition: Types.h:411
experimental::PostOpList< ITensorInfo * > post_ops
bool export_weights_to_cl_image(const ITensorInfo *tensor)
Definition: CLHelpers.cpp:444
Descriptor used by the GEMM kernels.
InterpolationPolicy interpolation_policy
Interpolation type to use.
GEMMKernelInfo(unsigned int im, unsigned int in, unsigned int ik, unsigned int idepth_output_gemm3d, bool ireinterpret_input_as_3d, bool ibroadcast_bias, bool ifp_mixed_precision, bool ihas_pad_y, ActivationLayerInfo iactivation_info, int inmult_transpose1xW_width, int imult_interleave4x4_height, GEMMLHSMatrixInfo ilhs_info, GEMMRHSMatrixInfo irhs_info, int32_t ina_offset, int32_t inb_offset, const experimental::PostOpList< ITensorInfo *> &ipost_ops=experimental::PostOpList< ITensorInfo *> {})
InstanceNormalizationLayerKernelInfo(float gamma, float beta, float epsilon, bool use_mixed_precision)
Constructor.
bool align_corners
Align corners of input and output.
GEMM LHS (Left Hand Side) matrix information.
Definition: Types.h:2236
Store the tensor&#39;s metadata.
Definition: ITensorInfo.h:40
bool use_padding
Indication of using padding.
Activation Layer Information class.
Definition: Types.h:1625
Copyright (c) 2017-2022 Arm Limited.
Samples are taken at pixel center.
bool use_mixed_precision
Use mixed precision in case of FP16 execution.
const OutputStage & output_stage
GEMMLowpReductionKernelInfo(int32_t k, bool is_reshaped, int32_t scalar, bool mul_by_scalar)
Constructor.
SamplingPolicy sampling_policy
Sampling policy used by the interpolation.
GEMM RHS (Right Hand Side) matrix information.
Definition: Types.h:2251
Descriptor used by the FFT core kernels.
Descriptor for FFT scale kernels.
GEMMLowp output stage info.
Definition: Types.h:2220
Compute descriptor used by the direct convolution kernel.
Compute descriptor used by the depthwise convolution native kernel.
ScaleKernelInfo(InterpolationPolicy interpolation_policy, BorderMode border_mode, PixelValue constant_border_value=PixelValue(), SamplingPolicy sampling_policy=SamplingPolicy::CENTER, bool use_padding=true, bool align_corners=false, DataLayout data_layout=DataLayout::UNKNOWN) noexcept
Constructor.
float epsilon
Lower bound value for the normalization.
Descriptor for FFT digit reverse kernels.
float gamma
The scale scalar value applied to the normalized tensor.
PixelValue constant_border_value
Constant value to use for constant border mode policy.
float scale
Axis to perform the kernel on.
Descriptor used by the softmax kernels.
DataLayout data_layout
Data layout to use.
DataType
Available data types.
Definition: Types.h:79
DataLayout
[DataLayout enum definition]
Definition: Types.h:113
A sequence of PostOps that can be appended to the end of other operators.
Definition: IPostOp.h:119
float beta
The offset scalar value applied to the normalized tensor.
Descriptor used by the direct convolution layer output stage kernels.
bool conjugate
Flag to conjugate the output/.
SamplingPolicy
Available Sampling Policies.
Definition: Types.h:104