You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
537 lines
20 KiB
537 lines
20 KiB
//==============================================================================
|
|
//
|
|
// 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 <stdint.h>
|
|
|
|
// 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
|
|
|