| /* |
| * Copyright (c) 2019-2023 Arm Limited. |
| * |
| * SPDX-License-Identifier: MIT |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in all |
| * copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| * SOFTWARE. |
| */ |
| #ifndef ACL_ARM_COMPUTE_CORE_KERNELDESCRIPTORS_H |
| #define ACL_ARM_COMPUTE_CORE_KERNELDESCRIPTORS_H |
| |
| #include "arm_compute/core/PixelValue.h" |
| #include "arm_compute/core/Types.h" |
| #include "arm_compute/function_info/ActivationLayerInfo.h" |
| |
| namespace arm_compute |
| { |
| /** Descriptor for FFT scale kernels */ |
| struct FFTScaleKernelInfo |
| { |
| float scale{0.f}; /**< Axis to perform the kernel on. */ |
| bool conjugate{true}; /**< Flag to conjugate the output/ */ |
| }; |
| |
| /** Descriptor for FFT digit reverse kernels */ |
| struct FFTDigitReverseKernelInfo |
| { |
| unsigned int axis{0}; /**< Axis to perform the kernel on. */ |
| bool conjugate{false}; /**< Flag to conjugate the output/ */ |
| }; |
| |
| /** Descriptor used by the FFT core kernels */ |
| struct FFTRadixStageKernelInfo |
| { |
| unsigned int axis{0}; /**< Axis to run the kernel on. */ |
| unsigned int radix{0}; /**< Radix to use. */ |
| unsigned int Nx{0}; /**< Nx coefficient. */ |
| bool is_first_stage{false}; /**< Flags if the FFT kernels is the first stage of a decomposed FFT. */ |
| }; |
| |
| class ITensorInfo; |
| /** Descriptor used by the GEMM kernels */ |
| struct GEMMKernelInfo |
| { |
| GEMMKernelInfo() = default; |
| 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) |
| : 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), |
| 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), |
| rhs_info(irhs_info), |
| a_offset(ina_offset), |
| b_offset(inb_offset) |
| { |
| } |
| |
| unsigned int m{0}; /**< Number of LHS rows*/ |
| unsigned int n{0}; /**< Number of RHS columns*/ |
| unsigned int k{0}; /**< Number of LHS columns or RHS rows */ |
| unsigned int depth_output_gemm3d{0}; /**< Depth of the output tensor in case is reinterpreted as 3D */ |
| bool reinterpret_input_as_3d{false}; /**< Flag used to reinterpret the input as 3D */ |
| bool broadcast_bias{false}; /**< Flag used to broadcast the bias addition */ |
| bool fp_mixed_precision{false}; /**< Flag used to indicate wider accumulators (32 bit instead of 16 for FP16). */ |
| bool has_pad_y{ |
| false}; /**< Flag used to indicate if the input/output tensors have internal pad on the y direction */ |
| ActivationLayerInfo activation_info{}; /**< Activation function to perform after the matrix multiplication */ |
| int mult_transpose1xW_width{1}; /**< Multiplication factor for the width of the 1xW transposed block */ |
| int mult_interleave4x4_height{1}; /**< Multiplication factor for the height of the 4x4 interleaved block */ |
| GEMMLHSMatrixInfo |
| lhs_info{}; /**< LHS matrix information used to retrieve the number of rows processed by each thread */ |
| GEMMRHSMatrixInfo rhs_info{}; /**< RHS matrix information used for reshaping the RHS matrix */ |
| int32_t a_offset{0}; /**< Offset to be added to each element of the matrix A */ |
| int32_t b_offset{0}; /**< Offset to be added to each element of the matrix B */ |
| GEMMLowpOutputStageInfo output_stage{}; /**< GEMMLowp output stage information */ |
| }; |
| |
| /** Compute descriptor used by the depthwise convolution native kernel */ |
| struct DWCComputeKernelInfo |
| { |
| unsigned int n0{1}; /**< Number of columns processed by each thread */ |
| unsigned int m0{1}; /**< Number of rows processed by each thread */ |
| bool export_input_to_cl_image{false}; /**< Export input to cl_image */ |
| bool export_weights_to_cl_image{false}; /**< Export the weights to cl_image */ |
| }; |
| |
| /** Compute descriptor used by the direct convolution kernel */ |
| struct DirectConvComputeKernelInfo |
| { |
| int32_t m0{1}; /**< Number of rows to be processed by the kernel */ |
| int32_t n0{1}; /**< Number of columns to be processed by the kernel */ |
| int32_t k0{1}; /**< Number of partial accumulations to be processed in a single iteration by the kernel */ |
| bool export_weights_to_cl_image{false}; /**< Flag to export the weights to cl_image */ |
| bool export_output_to_cl_image{false}; /**< Flag to export the output to cl_image */ |
| bool export_input_to_cl_image{false}; /**< Flag to export the input to cl_image */ |
| }; |
| |
| /** Descriptor used by the softmax kernels */ |
| struct SoftmaxKernelInfo |
| { |
| float beta{1.f}; /**< A scaling factor for the exponent with default value 1.0 */ |
| bool is_log{false}; /**< Flag used to perform Log Softmax operation */ |
| DataType input_data_type{DataType::UNKNOWN}; /**< Input tensor data type */ |
| int32_t axis{0}; /**< The dimension in which to apply softmax. */ |
| }; |
| |
| /** Descriptor used by the direct convolution layer output stage kernels */ |
| struct DirectConvolutionLayerOutputStageKernelInfo |
| { |
| int32_t result_fixedpoint_multiplier{0}; /**< Result output stage multiplier used for quantizing */ |
| int32_t result_shift{0}; /**< Result output stage shift used for quantizing */ |
| int32_t result_offset_after_shift{0}; /**< Result offset used for quantizing */ |
| DataType output_data_type{ |
| DataType::UNKNOWN}; /**< Output tensor data type to use if the output is not initialized */ |
| }; |
| |
| struct InstanceNormalizationLayerKernelInfo |
| { |
| /** Default constructor */ |
| InstanceNormalizationLayerKernelInfo() : InstanceNormalizationLayerKernelInfo(1.f, 0.f, 1e-12, true) |
| { |
| } |
| /** Constructor |
| * |
| * @param[in] gamma The scale scalar value applied to the normalized tensor. |
| * @param[in] beta The offset scalar value applied to the normalized tensor |
| * @param[in] epsilon Lower bound value for the normalization. |
| * @param[in] use_mixed_precision Use mixed precision in case of FP16 execution. |
| */ |
| InstanceNormalizationLayerKernelInfo(float gamma, float beta, float epsilon, bool use_mixed_precision) |
| : gamma(gamma), beta(beta), epsilon(epsilon), use_mixed_precision(use_mixed_precision) |
| { |
| } |
| |
| float gamma; /**< The scale scalar value applied to the normalized tensor. Defaults to 1.0 */ |
| float beta; /**< The offset scalar value applied to the normalized tensor. Defaults to 0.0 */ |
| float epsilon; /**< Lower bound value for the normalization. Defaults to 1e-12 */ |
| bool use_mixed_precision; /**< Use mixed precision in case of FP16 execution. Defaults to true */ |
| }; |
| |
| struct GEMMLowpReductionKernelInfo |
| { |
| /** Default constructor */ |
| GEMMLowpReductionKernelInfo() = default; |
| /** Constructor |
| * |
| * @param[in] k Number of matrix columns/rows. |
| * @param[in] is_reshaped True if the input tensor has been reshaped. |
| * @param[in] scalar Scalar value to multiply each reduced column/row by. |
| * @param[in] mul_by_scalar True if each column/row reduction has to be multiplied by a scalar value. |
| */ |
| GEMMLowpReductionKernelInfo(int32_t k, bool is_reshaped, int32_t scalar, bool mul_by_scalar) |
| : k(k), is_reshaped(is_reshaped), scalar(scalar), mul_by_scalar(mul_by_scalar) |
| { |
| } |
| |
| int32_t k{0}; /**< Number of matrix columns/rows */ |
| bool is_reshaped{false}; /**< True if the input tensor has been reshaped */ |
| int32_t scalar{0}; /**< Scalar value to multiply each reduced column/row by */ |
| bool mul_by_scalar{false}; /**< True if each column/row reduction has to be multiplied by a scalar value */ |
| }; |
| |
| struct ScaleKernelInfo |
| { |
| /** Constructor |
| * |
| * @param[in] interpolation_policy Interpolation type to use |
| * @param[in] border_mode Border mode policy |
| * @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 |
| * @param[in] sampling_policy (Optional) Sampling policy used by the interpolation. Defaults to @ref SamplingPolicy::CENTER |
| * @param[in] use_padding (Optional) Is padding in use or not. Defaults to true. |
| * @param[in] align_corners (Optional) Align corners of input and output, only affecting bilinear policy with TOP_LEFT sampling policy. Defaults to false. |
| * @param[in] data_layout (Optional) Data layout used by the layer. Defaults to @ref DataLayout::UNKNOWN |
| */ |
| 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 |
| : interpolation_policy{interpolation_policy}, |
| border_mode{border_mode}, |
| constant_border_value{constant_border_value}, |
| sampling_policy{sampling_policy}, |
| use_padding{use_padding}, |
| align_corners{align_corners}, |
| data_layout{data_layout} |
| { |
| } |
| |
| InterpolationPolicy interpolation_policy; /**< Interpolation type to use */ |
| BorderMode border_mode; /**< Border mode policy */ |
| PixelValue constant_border_value; /**< Constant value to use for constant border mode policy */ |
| SamplingPolicy sampling_policy; /**< Sampling policy used by the interpolation. */ |
| bool use_padding; /**< Indication of using padding */ |
| bool align_corners; /**< Align corners of input and output */ |
| DataLayout data_layout; /**< Data layout to use */ |
| }; |
| |
| struct MatMulKernelInfo |
| { |
| MatMulKernelInfo() = default; |
| MatMulKernelInfo( |
| bool adj_lhs, bool adj_rhs, int m0 = 1, int n0 = 1, int k0 = 1, bool export_rhs_to_cl_image = false) |
| : adj_lhs{adj_lhs}, adj_rhs{adj_rhs}, m0{m0}, n0{n0}, k0{k0}, export_rhs_to_cl_image{export_rhs_to_cl_image} |
| { |
| } |
| bool adj_lhs{false}; /**< Get Adjoint LHS flag value */ |
| bool adj_rhs{false}; /**< Get Adjoint RHS flag value */ |
| int m0{1}; /**< Number of output rows processed by each work-item*/ |
| int n0{1}; /**< Number of output columns processed by each work-item*/ |
| int k0{1}; /**< Number of inner accumulations */ |
| bool export_rhs_to_cl_image{false}; /**< Flag to know whether the RHS tensor should be exported to cl_image*/ |
| }; |
| } // namespace arm_compute |
| #endif // ACL_ARM_COMPUTE_CORE_KERNELDESCRIPTORS_H |