| /* |
| * Copyright (c) 2021 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 ARM_COMPUTE_ACL_TYPES_H_ |
| #define ARM_COMPUTE_ACL_TYPES_H_ |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| |
| #ifdef __cplusplus |
| extern "C" |
| { |
| #endif /* __cplusplus */ |
| |
| /**< Opaque Context object */ |
| typedef struct AclContext_ *AclContext; |
| /**< Opaque Queue object */ |
| typedef struct AclQueue_ *AclQueue; |
| /**< Opaque Tensor object */ |
| typedef struct AclTensor_ *AclTensor; |
| /**< Opaque Tensor pack object */ |
| typedef struct AclTensorPack_ *AclTensorPack; |
| /**< Opaque Operator object */ |
| typedef struct AclOperator_ *AclOperator; |
| |
| // Capabilities bitfield (Note: if multiple are enabled ComputeLibrary will pick the best possible) |
| typedef uint64_t AclTargetCapabilities; |
| |
| /**< Error codes returned by the public entry-points */ |
| typedef enum AclStatus : int32_t |
| { |
| AclSuccess = 0, /**< Call succeeded, leading to valid state for all involved objects/data */ |
| AclRuntimeError = 1, /**< Call failed during execution */ |
| AclOutOfMemory = 2, /**< Call failed due to failure to allocate resources */ |
| AclUnimplemented = 3, /**< Call failed as requested capability is not implemented */ |
| AclUnsupportedTarget = 4, /**< Call failed as an invalid backend was requested */ |
| AclInvalidTarget = 5, /**< Call failed as invalid argument was passed */ |
| AclInvalidArgument = 6, /**< Call failed as invalid argument was passed */ |
| AclUnsupportedConfig = 7, /**< Call failed as configuration is unsupported */ |
| AclInvalidObjectState = 8, /**< Call failed as an object has invalid state */ |
| } AclStatus; |
| |
| /**< Supported CPU targets */ |
| typedef enum AclTarget |
| { |
| AclCpu = 0, /**< Cpu target that uses SIMD extensions */ |
| AclGpuOcl = 1, /**< OpenCL target for GPU */ |
| } AclTarget; |
| |
| /** Execution mode types */ |
| typedef enum AclExecutionMode |
| { |
| AclPreferFastRerun = 0, /**< Prioritize performance when multiple iterations are performed */ |
| AclPreferFastStart = 1, /**< Prioritize performance when a single iterations is expected to be performed */ |
| } AclExecutionMode; |
| |
| /** Available CPU capabilities */ |
| typedef enum AclCpuCapabilities |
| { |
| AclCpuCapabilitiesAuto = 0, /**< Automatic discovery of capabilities */ |
| |
| AclCpuCapabilitiesNeon = (1 << 0), /**< Enable NEON optimized paths */ |
| AclCpuCapabilitiesSve = (1 << 1), /**< Enable SVE optimized paths */ |
| AclCpuCapabilitiesSve2 = (1 << 2), /**< Enable SVE2 optimized paths */ |
| // Reserve 3, 4, 5, 6 |
| |
| AclCpuCapabilitiesFp16 = (1 << 7), /**< Enable float16 data-type support */ |
| AclCpuCapabilitiesBf16 = (1 << 8), /**< Enable bfloat16 data-type support */ |
| // Reserve 9, 10, 11, 12 |
| |
| AclCpuCapabilitiesDot = (1 << 13), /**< Enable paths that use the udot/sdot instructions */ |
| AclCpuCapabilitiesMmlaInt8 = (1 << 14), /**< Enable paths that use the mmla integer instructions */ |
| AclCpuCapabilitiesMmlaFp = (1 << 15), /**< Enable paths that use the mmla float instructions */ |
| |
| AclCpuCapabilitiesAll = ~0 /**< Enable all paths */ |
| } AclCpuCapabilities; |
| |
| /**< Allocator interface that can be passed to a context */ |
| typedef struct AclAllocator |
| { |
| /** Allocate a block of size bytes of memory. |
| * |
| * @param[in] user_data User provided data that can be used by the allocator |
| * @param[in] size Size of the allocation |
| * |
| * @return A pointer to the allocated block if successfull else NULL |
| */ |
| void *(*alloc)(void *user_data, size_t size); |
| /** Release a block of size bytes of memory. |
| * |
| * @param[in] user_data User provided data that can be used by the allocator |
| * @param[in] size Size of the allocation |
| */ |
| void (*free)(void *user_data, void *ptr); |
| /** Allocate a block of size bytes of memory. |
| * |
| * @param[in] user_data User provided data that can be used by the allocator |
| * @param[in] size Size of the allocation |
| * |
| * @return A pointer to the allocated block if successfull else NULL |
| */ |
| void *(*aligned_alloc)(void *user_data, size_t size, size_t alignment); |
| /** Allocate a block of size bytes of memory. |
| * |
| * @param[in] user_data User provided data that can be used by the allocator |
| * @param[in] size Size of the allocation |
| */ |
| void (*aligned_free)(void *user_data, void *ptr); |
| |
| /**< User provided information */ |
| void *user_data; |
| } AclAllocator; |
| |
| /**< Context options */ |
| typedef struct AclContextOptions |
| { |
| AclExecutionMode mode; /**< Execution mode to use */ |
| AclTargetCapabilities capabilities; /**< Target capabilities */ |
| bool enable_fast_math; /**< Allow precision loss */ |
| const char *kernel_config_file; /**< Kernel cofiguration file */ |
| int32_t max_compute_units; /**< Max compute units that can be used by a queue created from the context. |
| If <=0 the system will use the hw concurency insted */ |
| AclAllocator *allocator; /**< Allocator to be used by all the memory internally */ |
| } AclContextOptions; |
| |
| /**< Supported tuning modes */ |
| typedef enum |
| { |
| AclTuningModeNone = 0, /**< No tuning */ |
| AclRapid = 1, /**< Fast tuning mode, testing a small portion of the tuning space */ |
| AclNormal = 2, /**< Normal tuning mode, gives a good balance between tuning mode and performance */ |
| AclExhaustive = 3, /**< Exhaustive tuning mode, increased tuning time but with best results */ |
| } AclTuningMode; |
| |
| /**< Queue options */ |
| typedef struct |
| { |
| AclTuningMode mode; /**< Tuning mode */ |
| int32_t compute_units; /**< Compute Units that the queue will deploy */ |
| } AclQueueOptions; |
| |
| /**< Supported data types */ |
| typedef enum AclDataType |
| { |
| AclDataTypeUnknown = 0, /**< Unknown data type */ |
| AclUInt8 = 1, /**< 8-bit unsigned integer */ |
| AclInt8 = 2, /**< 8-bit signed integer */ |
| AclUInt16 = 3, /**< 16-bit unsigned integer */ |
| AclInt16 = 4, /**< 16-bit signed integer */ |
| AclUint32 = 5, /**< 32-bit unsigned integer */ |
| AclInt32 = 6, /**< 32-bit signed integer */ |
| AclFloat16 = 7, /**< 16-bit floating point */ |
| AclBFloat16 = 8, /**< 16-bit brain floating point */ |
| AclFloat32 = 9, /**< 32-bit floating point */ |
| } AclDataType; |
| |
| /**< Supported data layouts for operations */ |
| typedef enum AclDataLayout |
| { |
| AclDataLayoutUnknown = 0, /**< Unknown data layout */ |
| AclNhwc = 1, /**< Native, performant, Compute Library data layout */ |
| AclNchw = 2, /**< Data layout where width is the fastest changing dimension */ |
| } AclDataLayout; |
| |
| /** Type of memory to be imported */ |
| typedef enum AclImportMemoryType |
| { |
| AclHostPtr = 0 /**< Host allocated memory */ |
| } AclImportMemoryType; |
| |
| /**< Tensor Descriptor */ |
| typedef struct AclTensorDescriptor |
| { |
| int32_t ndims; /**< Number or dimensions */ |
| int32_t *shape; /**< Tensor Shape */ |
| AclDataType data_type; /**< Tensor Data type */ |
| int64_t *strides; /**< Strides on each dimension. Linear memory is assumed if nullptr */ |
| int64_t boffset; /**< Offset in terms of bytes for the first element */ |
| } AclTensorDescriptor; |
| |
| /**< Slot type of a tensor */ |
| typedef enum |
| { |
| AclSlotUnknown = -1, |
| AclSrc = 0, |
| AclSrc0 = 0, |
| AclSrc1 = 1, |
| AclDst = 30, |
| AclSrcVec = 256, |
| } AclTensorSlot; |
| |
| #ifdef __cplusplus |
| } |
| #endif /* __cplusplus */ |
| #endif /* ARM_COMPUTE_ACL_TYPES_H_ */ |