Move NNAPI type information to types.spec (14c1f985) · Commits · e / os / android_hardware_interfaces

neuralnetworks/1.0/types.t

+10 −346

Original line number	Diff line number	Diff line
		@@ -63,361 +63,25 @@ enum FusedActivationFunc : int32_t {
		RELU6 = 3,
		};

		/**
		* How an operand is used.
		*/
		enum OperandLifeTime : int32_t {
		/**
		* The operand is internal to the model. It's created by an operation and
		* consumed by other operations. It must be an output operand of
		* exactly one operation.
		*/
		TEMPORARY_VARIABLE,

		/**
		* The operand is an input of the model. It must not be an output
		* operand of any operation.
		*
		* An operand can't be both input and output of a model.
		*/
		MODEL_INPUT,

		/**
		* The operand is an output of the model. It must be an output
		* operand of exactly one operation.
		*
		* An operand can't be both input and output of a model.
		*/
		MODEL_OUTPUT,

		/**
		* The operand is a constant found in Model.operandValues. It must
		* not be an output operand of any operation.
		*/
		CONSTANT_COPY,

		/**
		* The operand is a constant that was specified via a Memory
		* object. It must not be an output operand of any operation.
		*/
		CONSTANT_REFERENCE,

		/**
		* The operand does not have a value. This is valid only for optional
		* arguments of operations.
		*/
		NO_VALUE,
		};

		/**
		* Status of a device.
		*/
		enum DeviceStatus : int32_t {
		AVAILABLE,
		BUSY,
		OFFLINE,
		UNKNOWN,
		};

		/**
		* Performance information for the reference workload.
		*
		* Used by a driver to report its performance characteristics.
		*/
		struct PerformanceInfo {
		/**
		* Ratio of the time taken by the driver to execute the
		* workload compared to the time the CPU would take for the
		* same workload. A lower number is better.
		*/
		float execTime;

		/**
		* Ratio of the energy used by the driver compared to what
		* the CPU would use for doing the same workload. A lower number
		* is better.
		*/
		float powerUsage;
		};

		/**
		* The capabilities of a driver.
		*/
		struct Capabilities {
		/**
		* Driver performance when operating on float32 data.
		*/
		PerformanceInfo float32Performance;

		/**
		* Driver performance when operating on asymmetric 8-bit quantized data.
		*/
		PerformanceInfo quantized8Performance;
		};

		/**
		* Describes the location of a data object.
		*/
		struct DataLocation {
		/**
		* The index of the memory pool where this location is found.
		*/
		uint32_t poolIndex;

		/**
		* Offset in bytes from the start of the pool.
		*/
		uint32_t offset;

		/**
		* The length of the data in bytes.
		*/
		uint32_t length;
		};

		/**
		* Describes one operand of the model's graph.
		*/
		struct Operand {
		/**
		* Data type of the operand.
		*/
		OperandType type;

		/**
		* Dimensions of the operand.
		*
		* For a scalar operand, dimensions.size() must be 0.
		*
		* For a tensor operand, dimensions.size() must be at least 1;
		* however, any of the dimensions may be unspecified.
		*
		* A tensor operand with all dimensions specified has "fully
		* specified" dimensions. Whenever possible (i.e., whenever the
		* dimensions are known at model construction time), a tensor
		* operand should have (but is not required to have) fully
		* specified dimensions, in order to enable the best possible
		* performance.
		*
		* If a tensor operand's dimensions are not fully specified, the
		* dimensions of the operand are deduced from the operand
		* dimensions and values of the operation for which that operand
		* is an output.
		*
		* In the following situations, a tensor operand's dimensions must
		* be fully specified:
		*
		* . The operand has lifetime CONSTANT_COPY or
		* CONSTANT_REFERENCE.
		*
		* . The operand has lifetime MODEL_INPUT or MODEL_OUTPUT. Fully
		* specified dimensions must either be present in the
		* Operand or they must be provided in the corresponding
		* RequestArgument.
		* EXCEPTION: If the input or output is optional and omitted
		* (by setting the hasNoValue field of the corresponding
		* RequestArgument to true) then it need not have fully
		* specified dimensions.
		*
		* A tensor operand with some number of unspecified dimensions is
		* represented by setting each unspecified dimension to 0.
		*/
		vec<uint32_t> dimensions;

		/**
		* The number of times this operand appears as an operation input.
		*
		* (For example, if this operand appears once in one operation's
		* input list, and three times in another operation's input list,
		* then numberOfConsumers = 4.)
		*/
		uint32_t numberOfConsumers;

		/**
		* Quantized scale of the operand.
		*
		* Only applicable if the operand is of type TENSOR_QUANT8_ASYMM or
		* TENSOR_INT32.
		*/
		float scale;

		/**
		* Quantized zero-point offset of the operand.
		*
		* Only applicable if the operand is of type TENSOR_QUANT8_ASYMM.
		*/
		int32_t zeroPoint;

		/**
		* How the operand is used.
		*/
		OperandLifeTime lifetime;

		/**
		* Where to find the data for this operand.
		* If the lifetime is TEMPORARY_VARIABLE, MODEL_INPUT, MODEL_OUTPUT, or
		* NO_VALUE:
		* - All the fields must be 0.
		* If the lifetime is CONSTANT_COPY:
		* - location.poolIndex is 0.
		* - location.offset is the offset in bytes into Model.operandValues.
		* - location.length is set.
		* If the lifetime is CONSTANT_REFERENCE:
		* - location.poolIndex is set.
		* - location.offset is the offset in bytes into the specified pool.
		* - location.length is set.
		*/
		DataLocation location;
		};

		/**
		* Describes one operation of the model's graph.
		*/
		struct Operation {
		/**
		* The operation type.
		*/
		OperationType type;

		/**
		* Describes the table that contains the indexes of the inputs of the
		* operation. The offset is the index in the operandIndexes table.
		*/
		vec<uint32_t> inputs;

		/**
		* Describes the table that contains the indexes of the outputs of the
		* operation. The offset is the index in the operandIndexes table.
		*/
		vec<uint32_t> outputs;
		};

		/**
		* A Neural Network Model.
		*
		* This includes not only the execution graph, but also constant data such as
		* weights or scalars added at construction time. The only information that
		* might not be known is the shape of the input tensors.
		*/
		struct Model {
		/**
		* All operands included in the model.
		*/
		vec<Operand> operands;

		/**
		* All operations included in the model.
		*
		* The operations are sorted into execution order. Every operand
		* with lifetime MODEL_OUTPUT or TEMPORARY_VARIABLE must be
		* written before it is read.
		*/
		vec<Operation> operations;
		%insert OperandLifeTime

		/**
		* Input indexes of the model. There must be at least one.
		*
		* Each value corresponds to the index of the operand in "operands".
		*/
		vec<uint32_t> inputIndexes;
		%insert DeviceStatus

		/**
		* Output indexes of the model. There must be at least one.
		*
		* Each value corresponds to the index of the operand in "operands".
		*/
		vec<uint32_t> outputIndexes;
		%insert PerformanceInfo

		/**
		* A byte buffer containing operand data that were copied into the model.
		*
		* An operand's value must be located here if and only if Operand::lifetime
		* equals OperandLifeTime::CONSTANT_COPY.
		*/
		vec<uint8_t> operandValues;
		%insert Capabilities

		/**
		* A collection of shared memory pools containing operand values.
		*
		* An operand's value must be located here if and only if Operand::lifetime
		* equals OperandLifeTime::CONSTANT_REFERENCE.
		*/
		vec<memory> pools;
		};
		%insert DataLocation

		/**
		* Metadata information specifying the location of the input or output data and
		* any updates to the input or output operand.
		*/
		struct RequestArgument {
		/**
		* If true, the argument does not have a value. This can be used for
		* operations that take optional arguments. If true, the fields of location
		* are set to 0 and the dimensions vector is left empty.
		*/
		bool hasNoValue;

		/**
		* The location within one of the memory pools passed in the Request.
		*/
		DataLocation location;
		%insert Operand

		/**
		* Updated dimension information.
		*
		* If dimensions.size() > 0, dimension information was provided
		* along with the argument. This can be the case for models that
		* accept inputs of varying size. This can't change the rank, just
		* the value of the dimensions that were unspecified in the
		* model. If dimensions.size() > 0, then all dimensions must be
		* specified here; and any dimension that was specified in the
		* model must have the same value here.
		*
		* If the dimensions in the model are not fully specified, then
		* they must be fully specified here, unless hasNoValue is set to
		* true. If the dimensions in the model are fully specified, then
		* either dimensions.size() may be 0, or the dimensions in the
		* model must be identical to the dimensions here.
		*/
		vec<uint32_t> dimensions;
		};
		%insert Operation

		/**
		* Inputs to be sent to and outputs to be retrieved from a prepared model.
		*
		* A Request serves two primary tasks:
		* 1) Provides the input and output data to be used when executing the model.
		* 2) Specifies any updates to the input operand metadata that were left
		* unspecified at model preparation time.
		*
		* An output must not overlap with any other output, with an input, or
		* with an operand of lifetime CONSTANT_REFERENCE.
		*/
		struct Request {
		/**
		* Input data and information to be used in the execution of a prepared
		* model.
		*
		* The index of the input corresponds to the index in Model.inputIndexes.
		* E.g., input[i] corresponds to Model.inputIndexes[i].
		*/
		vec<RequestArgument> inputs;
		%insert Model

		/**
		* Output data and information to be used in the execution of a prepared
		* model.
		*
		* The index of the output corresponds to the index in Model.outputIndexes.
		* E.g., output[i] corresponds to Model.outputIndexes[i].
		*/
		vec<RequestArgument> outputs;
		%insert RequestArgument

		/**
		* A collection of shared memory pools containing operand data for both the
		* inputs and the outputs to a model.
		*/
		vec<memory> pools;
		};
		%insert Request

		/**
		* Return status of a function.

neuralnetworks/1.1/types.t

+4 −122

Original line number	Diff line number	Diff line
		@@ -31,128 +31,10 @@ enum OperationType : @1.0::OperationType {
		%insert Operation_1.1
		};

		/**
		* The capabilities of a driver.
		*/
		struct Capabilities {
		/**
		* Driver performance when operating on float32 data.
		*/
		PerformanceInfo float32Performance;

		/**
		* Driver performance when operating on asymmetric 8-bit quantized data.
		*/
		PerformanceInfo quantized8Performance;

		/**
		* Driver performance when operating on float32 data but performing
		* calculations with range and/or precision as low as that of the IEEE
		* 754 16-bit floating-point format.
		*/
		PerformanceInfo relaxedFloat32toFloat16Performance;
		};

		/**
		* Describes one operation of the model's graph.
		*/
		struct Operation {
		/**
		* The operation type.
		*/
		OperationType type;

		/**
		* Describes the table that contains the indexes of the inputs of the
		* operation. The offset is the index in the operandIndexes table.
		*/
		vec<uint32_t> inputs;

		/**
		* Describes the table that contains the indexes of the outputs of the
		* operation. The offset is the index in the operandIndexes table.
		*/
		vec<uint32_t> outputs;
		};

		/**
		* A Neural Network Model.
		*
		* This includes not only the execution graph, but also constant data such as
		* weights or scalars added at construction time. The only information that
		* may not be known is the shape of the input tensors.
		*/
		struct Model {
		/**
		* All operands included in the model.
		*/
		vec<Operand> operands;

		/**
		* All operations included in the model.
		*
		* The operations are sorted into execution order. Every operand
		* with lifetime MODEL_OUTPUT or TEMPORARY_VARIABLE must be
		* written before it is read.
		*/
		vec<Operation> operations;

		/**
		* Input indexes of the model. There must be at least one.
		*
		* Each value corresponds to the index of the operand in "operands".
		*/
		vec<uint32_t> inputIndexes;

		/**
		* Output indexes of the model. There must be at least one.
		*
		* Each value corresponds to the index of the operand in "operands".
		*/
		vec<uint32_t> outputIndexes;

		/**
		* A byte buffer containing operand data that were copied into the model.
		*
		* An operand's value must be located here if and only if Operand::lifetime
		* equals OperandLifeTime::CONSTANT_COPY.
		*/
		vec<uint8_t> operandValues;
		%insert Capabilities

		/**
		* A collection of shared memory pools containing operand values.
		*
		* An operand's value must be located here if and only if Operand::lifetime
		* equals OperandLifeTime::CONSTANT_REFERENCE.
		*/
		vec<memory> pools;
		%insert Operation

		/**
		* 'true' indicates TENSOR_FLOAT32 may be calculated with range and/or
		* precision as low as that of the IEEE 754 16-bit floating-point format.
		* 'false' indicates TENSOR_FLOAT32 must be calculated using at least the
		* range and precision of the IEEE 754 32-bit floating-point format.
		*/
		bool relaxComputationFloat32toFloat16;
		};
		%insert Model

		/**
		* Execution preferences.
		*/
		enum ExecutionPreference : int32_t {
		/**
		* Prefer executing in a way that minimizes battery drain.
		* This is desirable for compilations that will be executed often.
		*/
		LOW_POWER = 0,
		/**
		* Prefer returning a single answer as fast as possible, even if this causes
		* more power consumption.
		*/
		FAST_SINGLE_ANSWER = 1,
		/**
		* Prefer maximizing the throughput of successive frames, for example when
		* processing successive frames coming from the camera.
		*/
		SUSTAINED_SPEED = 2,
		};
		%insert ExecutionPreference

neuralnetworks/1.2/types.t

+10 −408

File changed.

Preview size limit exceeded, changes collapsed.

neuralnetworks/1.3/types.t

+10 −444

File changed.

Preview size limit exceeded, changes collapsed.