/* * Copyright (c) 2016-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_CORETYPES #define ACL_ARM_COMPUTE_CORE_CORETYPES #include "arm_compute/core/Strides.h" #include "support/Half.h" /** CoreTypes.h groups together essential small types that are used across functions */ namespace arm_compute { /** 16-bit floating point type */ using half = half_float::half; /** Permutation vector */ using PermutationVector = Strides; /** Available channels */ enum class Channel { UNKNOWN, /** Unknown channel format */ C0, /**< First channel (used by formats with unknown channel types). */ C1, /**< Second channel (used by formats with unknown channel types). */ C2, /**< Third channel (used by formats with unknown channel types). */ C3, /**< Fourth channel (used by formats with unknown channel types). */ R, /**< Red channel. */ G, /**< Green channel. */ B, /**< Blue channel. */ A, /**< Alpha channel. */ Y, /**< Luma channel. */ U, /**< Cb/U channel. */ V /**< Cr/V/Value channel. */ }; /** Image colour formats */ enum class Format { UNKNOWN, /**< Unknown image format */ U8, /**< 1 channel, 1 U8 per channel */ S16, /**< 1 channel, 1 S16 per channel */ U16, /**< 1 channel, 1 U16 per channel */ S32, /**< 1 channel, 1 S32 per channel */ U32, /**< 1 channel, 1 U32 per channel */ S64, /**< 1 channel, 1 S64 per channel */ U64, /**< 1 channel, 1 U64 per channel */ BFLOAT16, /**< 16-bit brain floating-point number */ F16, /**< 1 channel, 1 F16 per channel */ F32, /**< 1 channel, 1 F32 per channel */ UV88, /**< 2 channel, 1 U8 per channel */ RGB888, /**< 3 channels, 1 U8 per channel */ RGBA8888, /**< 4 channels, 1 U8 per channel */ YUV444, /**< A 3 plane of 8 bit 4:4:4 sampled Y, U, V planes */ YUYV422, /**< A single plane of 32-bit macro pixel of Y0, U0, Y1, V0 bytes */ NV12, /**< A 2 plane YUV format of Luma (Y) and interleaved UV data at 4:2:0 sampling */ NV21, /**< A 2 plane YUV format of Luma (Y) and interleaved VU data at 4:2:0 sampling */ IYUV, /**< A 3 plane of 8-bit 4:2:0 sampled Y, U, V planes */ UYVY422 /**< A single plane of 32-bit macro pixel of U0, Y0, V0, Y1 byte */ }; /** Available data types */ enum class DataType { UNKNOWN, /**< Unknown data type */ U8, /**< unsigned 8-bit number */ S8, /**< signed 8-bit number */ QSYMM8, /**< quantized, symmetric fixed-point 8-bit number */ QASYMM8, /**< quantized, asymmetric fixed-point 8-bit number unsigned */ QASYMM8_SIGNED, /**< quantized, asymmetric fixed-point 8-bit number signed */ QSYMM8_PER_CHANNEL, /**< quantized, symmetric per channel fixed-point 8-bit number */ U16, /**< unsigned 16-bit number */ S16, /**< signed 16-bit number */ QSYMM16, /**< quantized, symmetric fixed-point 16-bit number */ QASYMM16, /**< quantized, asymmetric fixed-point 16-bit number */ U32, /**< unsigned 32-bit number */ S32, /**< signed 32-bit number */ U64, /**< unsigned 64-bit number */ S64, /**< signed 64-bit number */ BFLOAT16, /**< 16-bit brain floating-point number */ F16, /**< 16-bit floating-point number */ F32, /**< 32-bit floating-point number */ F64, /**< 64-bit floating-point number */ SIZET /**< size_t */ }; /** [DataLayout enum definition] **/ /** Supported tensor data layouts */ enum class DataLayout { UNKNOWN, /**< Unknown data layout */ NCHW, /**< Num samples, channels, height, width */ NHWC, /**< Num samples, height, width, channels */ NCDHW, /**< Num samples, channels, depth, height, width */ NDHWC /**< Num samples, depth, height, width, channels */ }; /** [DataLayout enum definition] **/ /** Supported tensor data layout dimensions */ enum class DataLayoutDimension { CHANNEL, /**< channel */ HEIGHT, /**< height */ WIDTH, /**< width */ DEPTH, /**< depth */ BATCHES /**< batches */ }; /** Dimension rounding type when down-scaling on CNNs * @note Used in pooling and convolution layer */ enum class DimensionRoundingType { FLOOR, /**< Floor rounding */ CEIL /**< Ceil rounding */ }; class PadStrideInfo { public: /** Constructor * * @param[in] stride_x (Optional) Stride, in elements, across x. Defaults to 1. * @param[in] stride_y (Optional) Stride, in elements, across y. Defaults to 1. * @param[in] pad_x (Optional) Padding, in elements, across x. Defaults to 0. * @param[in] pad_y (Optional) Padding, in elements, across y. Defaults to 0. * @param[in] round (Optional) Dimensions rounding. Defaults to @ref DimensionRoundingType::FLOOR. */ PadStrideInfo(unsigned int stride_x = 1, unsigned int stride_y = 1, unsigned int pad_x = 0, unsigned int pad_y = 0, DimensionRoundingType round = DimensionRoundingType::FLOOR) : _stride(std::make_pair(stride_x, stride_y)), _pad_left(pad_x), _pad_top(pad_y), _pad_right(pad_x), _pad_bottom(pad_y), _round_type(round) { } /** Constructor * * @param[in] stride_x Stride, in elements, across x. * @param[in] stride_y Stride, in elements, across y. * @param[in] pad_left Padding across x on the left, in elements. * @param[in] pad_right Padding across x on the right, in elements. * @param[in] pad_top Padding across y on the top, in elements. * @param[in] pad_bottom Padding across y on the bottom, in elements. * @param[in] round Dimensions rounding. */ PadStrideInfo(unsigned int stride_x, unsigned int stride_y, unsigned int pad_left, unsigned int pad_right, unsigned int pad_top, unsigned int pad_bottom, DimensionRoundingType round) : _stride(std::make_pair(stride_x, stride_y)), _pad_left(pad_left), _pad_top(pad_top), _pad_right(pad_right), _pad_bottom(pad_bottom), _round_type(round) { } /** Get the stride. * * @return a pair: stride x, stride y. */ std::pair stride() const { return _stride; } /** Check whether the padding is symmetric. * * @return True if the padding is symmetric. */ bool padding_is_symmetric() const { return (_pad_left == _pad_right) && (_pad_top == _pad_bottom); } /** Get the padding. * * @note This should only be used when the padding is symmetric. * * @return a pair: padding left/right, padding top/bottom */ std::pair pad() const { //this accessor should be used only when padding is symmetric ARM_COMPUTE_ERROR_ON(!padding_is_symmetric()); return std::make_pair(_pad_left, _pad_top); } /** Get the left padding */ unsigned int pad_left() const { return _pad_left; } /** Get the right padding */ unsigned int pad_right() const { return _pad_right; } /** Get the top padding */ unsigned int pad_top() const { return _pad_top; } /** Get the bottom padding */ unsigned int pad_bottom() const { return _pad_bottom; } /** Get the rounding type */ DimensionRoundingType round() const { return _round_type; } /** Check whether this has any padding */ bool has_padding() const { return (_pad_left != 0 || _pad_top != 0 || _pad_right != 0 || _pad_bottom != 0); } private: std::pair _stride; unsigned int _pad_left; unsigned int _pad_top; unsigned int _pad_right; unsigned int _pad_bottom; DimensionRoundingType _round_type; }; /** Memory layouts for the weights tensor. * * * UNSPECIFIED is used to select kernels that do not run in * variable weights mode. * * * ANY is used to query the kernel database to retrieve any of the * kernels that runs in variable weights mode. Once a kernel is * found, the specific format expected by the kernel can be * retrieved by the user for reordering the weights tensor * accordingly. * * The other values OHWIo{interleave_by}i{block_by} describe the * memory layout of a 4D tensor with layout OHWI that has been * transformed into a 4D tensor with dimensions O'HWI' where: * * O' = first multiple of {interleave_by} s.t. O<=O' * I' = first multiple of {block_by} s.t. I<=I' * * The total size of the dst tensor is O' x H x W x I' * * The access function of the tensor with layout * OHWIo{interleave_by}i{block_by} and size O'HWI' is a 6-parameter * access function, where the 6 parameters are computed as follows: * * x5 = floor(o/{interleave_by}) RANGE [0, O'/{interleave_by} -1] SIZE: O'/{interleave_by} * * x4 = h RANGE [0, H-1] SIZE: H * x3 = w RANGE [0, W-1] SIZE: W * x2 = floor(i/{block_by}) RANGE [0, I'/{block_by} -1] SIZE: I'/{block_by} * x1 = o%{interleave_by} RANGE [0, {interleave_by} -1] SIZE: {interleave_by} * x0 = i%{block_by} RANGE [0, {block_by} -1] SIZE: {block_by} * TOTAL SIZE: O' * H * W * I' * * 4D 6D * ----------------- ----------------------------------- * value(o, h, w, i) = x5 * H * W * I' * {interleave_by} * + x4 * W * I' * {interleave_by} * + x3 * I' * {interleave_by} * + x2 * {interleave_by} * {block_by} * + x1 * {block_by} * + x0 * * Notice that in arm_gemm the 4D tensor of dimension O'HWI' created * for the OHWIo{interleave_by}i{block_by} format is in reality seen * as a 2D tensor, where the number of rows is O'/{interleave_by} * and the number of columns is {interleave_by} * H * W * I'. * * The postfix *_bf16 is for the memory layout needed for the * fast-mode kernels, in which the weights are passed in bfloat16 * format. */ enum class WeightFormat { UNSPECIFIED = 0x1, ANY = 0x2, OHWI = 0x100100, OHWIo2 = 0x100200, OHWIo4 = 0x100400, OHWIo8 = 0x100800, OHWIo16 = 0x101000, OHWIo32 = 0x102000, OHWIo64 = 0x104000, OHWIo128 = 0x108000, OHWIo4i2 = 0x200400, OHWIo4i2_bf16 = 0x200410, OHWIo8i2 = 0x200800, OHWIo8i2_bf16 = 0x200810, OHWIo16i2 = 0x201000, OHWIo16i2_bf16 = 0x201010, OHWIo32i2 = 0x202000, OHWIo32i2_bf16 = 0x202010, OHWIo64i2 = 0x204000, OHWIo64i2_bf16 = 0x204010, OHWIo4i4 = 0x400400, OHWIo4i4_bf16 = 0x400410, OHWIo8i4 = 0x400800, OHWIo8i4_bf16 = 0x400810, OHWIo16i4 = 0x401000, OHWIo16i4_bf16 = 0x401010, OHWIo32i4 = 0x402000, OHWIo32i4_bf16 = 0x402010, OHWIo64i4 = 0x404000, OHWIo64i4_bf16 = 0x404010, OHWIo2i8 = 0x800200, OHWIo4i8 = 0x800400, OHWIo8i8 = 0x800800, OHWIo16i8 = 0x801000, OHWIo32i8 = 0x802000, OHWIo64i8 = 0x804000 }; } // namespace arm_compute #endif /* ACL_ARM_COMPUTE_CORE_CORETYPES */