/* * 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 #include #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_ */