//============================================================================== // // Copyright (c) 2019-2021 Qualcomm Technologies, Inc. // All Rights Reserved. // Confidential and Proprietary - Qualcomm Technologies, Inc. // //============================================================================== #ifndef SNPE_UDO_BASE_H #define SNPE_UDO_BASE_H #include // Provide values to use for API version. #define API_VERSION_MAJOR 1 #define API_VERSION_MINOR 6 #define API_VERSION_TEENY 0 /** @addtogroup c_plus_plus_apis C++ @{ */ // Defines a bitmask of enum values. typedef uint32_t SnpeUdo_Bitmask_t; typedef SnpeUdo_Bitmask_t Udo_Bitmask_t; // A string of characters, rather than an array of bytes. // Assumed to be UTF-8. typedef char* SnpeUdo_String_t; typedef SnpeUdo_String_t Udo_String_t; // The maximum allowable length of a SnpeUdo_String_t in bytes, // including null terminator. SNPE will truncate strings longer // than this. #define SNPE_UDO_MAX_STRING_SIZE 1024 /** * An enum which holds the various error types. * The error types are divided to classes : * 0 - 99 : generic errors * 100 - 200 : errors related to configuration * */ typedef enum { /// No Error SNPE_UDO_NO_ERROR = 0, UDO_NO_ERROR = 0, /// Unsupported value for core type SNPE_UDO_WRONG_CORE = 1, UDO_WRONG_CORE = 1, /// Invalid attribute/argument passed into UDO API SNPE_UDO_INVALID_ARGUMENT = 2, UDO_INVALID_ARGUMENT = 2, /// Unsupported feature error SNPE_UDO_UNSUPPORTED_FEATURE = 3, UDO_UNSUPPORTED_FEATURE = 3, /// Error relating to memory allocation SNPE_UDO_MEM_ALLOC_ERROR = 4, UDO_MEM_ALLOC_ERROR = 4, /* Configuration Specific errors */ /// No op with given attributes available in library SNPE_UDO_WRONG_OPERATION = 100, UDO_WRONG_OPERATION = 100, /// Unsupported value for core type in UDO configuration SNPE_UDO_WRONG_CORE_TYPE = 101, UDO_WRONG_CORE_TYPE = 101, /// Wrong number of params in UDO definition SNPE_UDO_WRONG_NUM_OF_PARAMS = 102, UDO_WRONG_NUM_OF_PARAMS = 102, /// Wrong number of dimensions for tensor(s) in UDO definition SNPE_UDO_WRONG_NUM_OF_DIMENSIONS = 103, UDO_WRONG_NUM_OF_DIMENSIONS = 103, /// Wrong number of input tensors in UDO definition SNPE_UDO_WRONG_NUM_OF_INPUTS = 104, UDO_WRONG_NUM_OF_INPUTS = 104, /// Wrong number of output tensors in UDO definition SNPE_UDO_WRONG_NUM_OF_OUTPUTS = 105, UDO_WRONG_NUM_OF_OUTPUTS = 105, SNPE_UDO_PROGRAM_CACHE_NOT_FOUND = 106, UDO_PROGRAM_CACHE_NOT_FOUND = 106, SNPE_UDO_UNKNOWN_ERROR = 0xFFFFFFFF, UDO_UNKNOWN_ERROR = 0xFFFFFFFF } SnpeUdo_ErrorType_t; typedef SnpeUdo_ErrorType_t Udo_ErrorType_t; /** * An enum which holds the various data types. * Designed to be used as single values or combined into a bitfield parameter * (0x1, 0x2, 0x4, etc) * \n FIXED_XX types are targeted for data in tensors. * \n UINT / INT types are targeted for scalar params */ typedef enum { /// data type: 16-bit floating point SNPE_UDO_DATATYPE_FLOAT_16 = 0x01, UDO_DATATYPE_FLOAT_16 = 0x01, /// data type: 32-bit floating point SNPE_UDO_DATATYPE_FLOAT_32 = 0x02, UDO_DATATYPE_FLOAT_32 = 0x02, /// data type: 4-bit fixed point SNPE_UDO_DATATYPE_FIXED_4 = 0x04, UDO_DATATYPE_FIXED_4 = 0x04, /// data type: 8-bit fixed point SNPE_UDO_DATATYPE_FIXED_8 = 0x08, UDO_DATATYPE_FIXED_8 = 0x08, /// data type: 16-bit fixed point SNPE_UDO_DATATYPE_FIXED_16 = 0x10, UDO_DATATYPE_FIXED_16 = 0x10, /// data type: 32-bit fixed point SNPE_UDO_DATATYPE_FIXED_32 = 0x20, UDO_DATATYPE_FIXED_32 = 0x20, /// data type: 8-bit unsigned integer SNPE_UDO_DATATYPE_UINT_8 = 0x100, UDO_DATATYPE_UINT_8 = 0x100, /// data type: 16-bit unsigned integer SNPE_UDO_DATATYPE_UINT_16 = 0x200, UDO_DATATYPE_UINT_16 = 0x200, /// data type: 32-bit unsigned integer SNPE_UDO_DATATYPE_UINT_32 = 0x400, UDO_DATATYPE_UINT_32 = 0x400, /// data type: 8-bit signed integer SNPE_UDO_DATATYPE_INT_8 = 0x1000, UDO_DATATYPE_INT_8 = 0x1000, /// data type: 16-bit signed integer SNPE_UDO_DATATYPE_INT_16 = 0x2000, UDO_DATATYPE_INT_16 = 0x2000, /// data type: 32-bit signed integer SNPE_UDO_DATATYPE_INT_32 = 0x4000, UDO_DATATYPE_INT_32 = 0x4000, SNPE_UDO_DATATYPE_LAST = 0xFFFFFFFF, UDO_DATATYPE_LAST = 0xFFFFFFFF } SnpeUdo_DataType_t; typedef SnpeUdo_DataType_t Udo_DataType_t; /** * An enum which holds the various layouts. * Designed to be used as single values or combined into a bitfield parameter * (0x1, 0x2, 0x4, etc) */ typedef enum { /// data layout (4D): NHWC (batch-height-width-channel) SNPE_UDO_LAYOUT_NHWC = 0x01, UDO_LAYOUT_NHWC = 0x01, /// data layout (4D): NCHW (batch-channel-height-width) SNPE_UDO_LAYOUT_NCHW = 0x02, UDO_LAYOUT_NCHW = 0x02, /// data layout (5D): NDHWC (batch-dimension-height-width-channel) SNPE_UDO_LAYOUT_NDHWC = 0x04, UDO_LAYOUT_NDHWC = 0x04, SNPE_UDO_LAYOUT_GPU_OPTIMAL1 = 0x08, UDO_LAYOUT_GPU_OPTIMAL1 = 0x08, SNPE_UDO_LAYOUT_GPU_OPTIMAL2 = 0x10, UDO_LAYOUT_GPU_OPTIMAL2 = 0x10, SNPE_UDO_LAYOUT_DSP_OPTIMAL1 = 0x11, UDO_LAYOUT_DSP_OPTIMAL1 = 0x11, SNPE_UDO_LAYOUT_DSP_OPTIMAL2 = 0x12, UDO_LAYOUT_DSP_OPTIMAL2 = 0x12, // Indicates no data will be allocated for this tensor. // Used to specify optional inputs/outputs positionally. SNPE_UDO_LAYOUT_NULL = 0x13, UDO_LAYOUT_NULL = 0x13, SNPE_UDO_LAYOUT_LAST = 0xFFFFFFFF, UDO_LAYOUT_LAST = 0xFFFFFFFF } SnpeUdo_TensorLayout_t; typedef SnpeUdo_TensorLayout_t Udo_TensorLayout_t; /** * An enum which holds the UDO library Core type . * Designed to be used as single values or combined into a bitfield parameter * (0x1, 0x2, 0x4, etc) */ typedef enum { /// Library target IP Core is undefined SNPE_UDO_CORETYPE_UNDEFINED = 0x00, UDO_CORETYPE_UNDEFINED = 0x00, /// Library target IP Core is CPU SNPE_UDO_CORETYPE_CPU = 0x01, UDO_CORETYPE_CPU = 0x01, /// Library target IP Core is GPU SNPE_UDO_CORETYPE_GPU = 0x02, UDO_CORETYPE_GPU = 0x02, /// Library target IP Core is DSP SNPE_UDO_CORETYPE_DSP = 0x04, UDO_CORETYPE_DSP = 0x04, SNPE_UDO_CORETYPE_LAST = 0xFFFFFFFF, UDO_CORETYPE_LAST = 0xFFFFFFFF } SnpeUdo_CoreType_t; typedef SnpeUdo_CoreType_t Udo_CoreType_t; /** * An enum to specify the parameter type : Scalar or Tensor */ typedef enum { /// UDO static param type: scalar SNPE_UDO_PARAMTYPE_SCALAR = 0x00, UDO_PARAMTYPE_SCALAR = 0x00, /// UDO static param type: string SNPE_UDO_PARAMTYPE_STRING = 0x01, UDO_PARAMTYPE_STRING = 0x01, /// UDO static param type: tensor SNPE_UDO_PARAMTYPE_TENSOR = 0x02, UDO_PARAMTYPE_TENSOR = 0x02, SNPE_UDO_PARAMTYPE_LAST = 0xFFFFFFFF, UDO_PARAMTYPE_LAST = 0xFFFFFFFF } SnpeUdo_ParamType_t; typedef SnpeUdo_ParamType_t Udo_ParamType_t; /** * An enum to specify quantization type */ typedef enum { /// Tensor Quantization type: NONE. Signifies unquantized tensor data SNPE_UDO_QUANTIZATION_NONE = 0x00, UDO_QUANTIZATION_NONE = 0x00, /// Tensor Quantization type: Tensorflow-style SNPE_UDO_QUANTIZATION_TF = 0x01, UDO_QUANTIZATION_TF = 0x01, SNPE_UDO_QUANTIZATION_QMN = 0x02, UDO_QUANTIZATION_QMN = 0x02, SNPE_UDO_QUANTIZATION_LAST = 0xFFFFFFFF, UDO_QUANTIZATION_LAST = 0xFFFFFFFF } SnpeUdo_QuantizationType_t; typedef SnpeUdo_QuantizationType_t Udo_QuantizationType_t; /** * @brief A struct which is used to provide a version number using 3 values : major, minor, teeny * */ typedef struct { /// version field: major - for backward-incompatible changes uint32_t major; /// version field: minor - for backward-compatible feature updates uint32_t minor; /// version field: teeny - for minor bug-fixes and clean-up uint32_t teeny; } SnpeUdo_Version_t; typedef SnpeUdo_Version_t Udo_Version_t; /** * @brief A struct returned from version query, contains the Library version and API version * */ typedef struct { /// Version of UDO library. Controlled by users SnpeUdo_Version_t libVersion; /// Version of SNPE UDO API used in compiling library. Determined by SNPE SnpeUdo_Version_t apiVersion; } SnpeUdo_LibVersion_t; /** * @brief A struct returned from version query, contains the package version * */ typedef struct { /// Version of UDO API used in package. Udo_Version_t apiVersion; } Udo_PkgVersion_t; /** * @brief A union to hold the value of a generic type. Allows defining a parameter struct * in a generic way, with a "value" location that holds the data regardless of the type. * */ typedef union { /// value type: float float floatValue; /// value type: unsigned 32-bit integer uint32_t uint32Value; /// value type: signed 32-bit integer int32_t int32Value; /// value type: unsigned 16-bit integer uint16_t uint16Value; /// value type: signed 16-bit integer int16_t int16Value; /// value type: unsigned 8-bit integer uint8_t uint8Value; /// value type: signed 8-bit integer int8_t int8Value; } SnpeUdo_Value_t; typedef SnpeUdo_Value_t Udo_Value_t; /** * @brief A struct which defines a scalar parameter : name, data type, and union of values * */ typedef struct { /// The parameter data type : float, int, etc. SnpeUdo_DataType_t dataType; /// a union of specified type which holds the data SnpeUdo_Value_t dataValue; } SnpeUdo_ScalarParam_t; typedef SnpeUdo_ScalarParam_t Udo_ScalarParam_t; /** * @brief A struct which defines the quantization parameters in case of Tensorflow style quantization * */ typedef struct { /// minimum value of the quantization range of data float minValue; /// maximum value of the quantization range of data float maxValue; } SnpeUdo_TFQuantize_t; typedef SnpeUdo_TFQuantize_t Udo_TFQuantize_t; /** * @brief A struct which defines the quantization type, and union of supported quantization structs * */ typedef struct { /// quantization type (only TF-style currently supported) SnpeUdo_QuantizationType_t quantizeType; union { /// TF-style min-max quantization ranges SnpeUdo_TFQuantize_t TFParams; }; } SnpeUdo_QuantizeParams_t; typedef SnpeUdo_QuantizeParams_t Udo_QuantizeParams_t; /** * @brief A struct which defines the datatype associated with a specified core-type * This should be used to denote the datatypes for a single tensor info, depending * on the intended execution core. * */ typedef struct { /// The IP Core SnpeUdo_CoreType_t coreType; /// The associated datatype for this coreType SnpeUdo_DataType_t dataType; } SnpeUdo_PerCoreDatatype_t; typedef SnpeUdo_PerCoreDatatype_t Udo_PerCoreDatatype_t; /** * @brief A struct which defines a tensor parameter : name, data type, layout, quantization, more. * Also holds a pointer to the tensor data. * */ typedef struct { /// The maximum allowable dimensions of the tensor. The memory held in /// _tensorData_ is guaranteed to be large enough for this. uint32_t* maxDimensions; /// The current dimensions of the tensor. An operation may modify the current /// dimensions of its output, to indicate cases where the output has been /// "resized". /// Note that for static parameters, the current and max dimensions must /// match. uint32_t* currDimensions; /// Quantization params applicable to the tensor. Currently only supports /// Tensorflow quantization style. SnpeUdo_QuantizeParams_t quantizeParams; /// Number of dimensions to the tensor: 3D, 4D, etc. uint32_t tensorRank; /// The parameter data type: float, int, etc. SnpeUdo_DataType_t dataType; /// The tensor layout type: NCHW, NHWC, etc. SnpeUdo_TensorLayout_t layout; /// Opaque pointer to tensor data. User may be required to re-interpret the pointer /// based on core-specific definitions. void* tensorData; } SnpeUdo_TensorParam_t; typedef SnpeUdo_TensorParam_t Udo_TensorParam_t; /** * @brief A struct which defines tensor information for activation tensors only * * It describes an activation tensor object using its name, the intended layout and the datatype * it will take depending on the intended runtime core. The repeated field indicates that * that the tensor info describes several input/output activation tensors, which all share the * aforementioned properties. */ typedef struct { /// The tensor name SnpeUdo_String_t tensorName; /// The tensor layout type: NCHW, NHWC, etc. SnpeUdo_TensorLayout_t layout; /// The per core datatype: {SNPE_UDO_DATATYPE, SNPE_UDO_CORE_TYPE} SnpeUdo_PerCoreDatatype_t* perCoreDatatype; /// A boolean field indicating that this tensorinfo will be repeated e.x for ops such as Concat or Split bool repeated; /// A boolean field indicating whether input is static or not. bool isStatic; } SnpeUdo_TensorInfo_t; typedef SnpeUdo_TensorInfo_t Udo_TensorInfo_t; /** * @brief struct which defines a UDO parameter - a union of scalar, tensor and string parameters * */ typedef struct { /// Type is scalar or tensor SnpeUdo_ParamType_t paramType; /// The param name, for example : "offset", "activation_type" SnpeUdo_String_t paramName; union { /// scalar param value SnpeUdo_ScalarParam_t scalarParam; /// tensor param value SnpeUdo_TensorParam_t tensorParam; /// string param value SnpeUdo_String_t stringParam; }; } SnpeUdo_Param_t; typedef SnpeUdo_Param_t Udo_Param_t; /** * @brief A struct which defines Operation information which is specific for IP core (CPU, GPU, DSP ...) * */ typedef struct { /// The IP Core SnpeUdo_CoreType_t udoCoreType; /// Bitmask, defines supported internal calculation types (like FLOAT_32, etc) /// Based on SnpeUdo_DataType SnpeUdo_Bitmask_t operationCalculationTypes; } SnpeUdo_OpCoreInfo_t; typedef SnpeUdo_OpCoreInfo_t Udo_OpCoreInfo_t; /** * @brief A struct which defines the common and core-specific Operation information * */ typedef struct { /// Operation type SnpeUdo_String_t operationType; /// A bitmask describing which IP Cores (CPU, GPU, DSP ...) support this operation /// Translated based on SnpeUdo_CoreType SnpeUdo_Bitmask_t supportedByCores; /// Number of static parameters defined by the op uint32_t numOfStaticParams; /// Array of static parameters. Can be scalar or tensor params SnpeUdo_Param_t* staticParams; /// Number of input tensors this op receives uint32_t numOfInputs; /// Array of input tensor names to this operation SnpeUdo_String_t* inputNames; /// Number of output tensors this op receives uint32_t numOfOutputs; /// Array of output tensor names to this operation SnpeUdo_String_t* outputNames; /// Number of cores that the op can execute on uint32_t numOfCoreInfo; /// Array of per-core information entries SnpeUdo_OpCoreInfo_t* opPerCoreInfo; /// Array of input tensor infos for this operation SnpeUdo_TensorInfo_t* inputInfos; /// Array of output tensor infos for this operation SnpeUdo_TensorInfo_t* outputInfos; } SnpeUdo_OperationInfo_t; typedef SnpeUdo_OperationInfo_t Udo_OperationInfo_t; /** * @brief A struct which provides the implementation library info : type, name * */ typedef struct { /// Defines the IP Core that this implementation library is targeting SnpeUdo_CoreType_t udoCoreType; /// library name. will be looked at in the standard library path SnpeUdo_String_t libraryName; } SnpeUdo_LibraryInfo_t; typedef SnpeUdo_LibraryInfo_t Udo_LibraryInfo_t; /** * @brief A struct returned by the registration library and contains information on the UDO package : * name, operations, libraries, etc. * */ typedef struct { /// A string containing the package name SnpeUdo_String_t packageName; /// A bitmask describing supported IP cores (CPU, GPU, DSP ...) /// Translated based on SnpeUdo_CoreType SnpeUdo_Bitmask_t supportedCoreTypes; /// The number of implementation libraries in the package uint32_t numOfImplementationLib; /// Array of implementation libraries names/types SnpeUdo_LibraryInfo_t* implementationLib; /// A string containing all operation types separated by space SnpeUdo_String_t operationsString; /// Number of supported operations uint32_t numOfOperations; /// Array of Operation info structs. Each entry describes one /// Operation (name, params, inputs, outputs) SnpeUdo_OperationInfo_t* operationsInfo; } SnpeUdo_RegInfo_t; typedef SnpeUdo_RegInfo_t Udo_RegInfo_t; /** * @brief A struct returned by the implementation library and contains information on the * specific library: name, IP Core, operations, etc. * */ typedef struct { /// Defines the IP Core that this implementation library is targeting SnpeUdo_CoreType_t udoCoreType; /// A string containing the package name SnpeUdo_String_t packageName; /// A string containing all operation types separated by space SnpeUdo_String_t operationsString; /// Number of supported operations uint32_t numOfOperations; } SnpeUdo_ImpInfo_t; typedef SnpeUdo_ImpInfo_t Udo_ImpInfo_t; /** * @brief This struct defines an operation. It is used for validation * or creation of an operation. * In case of using it for creation, the static params which are tensors * contain pointers to the real data (weights, for example), and input/output * tensors also include pointers to the buffers used. */ typedef struct { /// The IP Core that the operation is defined for - CPU, GPU, DSP... SnpeUdo_CoreType_t udoCoreType; /// Operation type SnpeUdo_String_t operationType; /// The number of static parameters provided in the staticParams array. /// this number has to match the number provided by the UDO Registration library information uint32_t numOfStaticParams; /// Array of static parameters SnpeUdo_Param_t* staticParams; /// The number of input parameters provided in inputs array. /// this number has to match the number provided by the UDO Registration library information uint32_t numOfInputs; /// Array of input tensors, providing layout, data type, sizes, etc /// When used to create an operation, also contains the initial location of the data SnpeUdo_TensorParam_t* inputs; /// The number of output parameters provided in inputs array. /// this number has to match the number provided by the UDO Registration library information uint32_t numOfOutputs; /// Array of output tensors, providing layout, data type, sizes, etc /// When used to create an operation, also contains the initial location of the data SnpeUdo_TensorParam_t* outputs; } SnpeUdo_OpDefinition_t; typedef SnpeUdo_OpDefinition_t Udo_OpDefinition_t; /** @} */ /* end_addtogroup c_plus_plus_apis C++ */ #endif //SNPE_UDO_BASE_H