#include <ModelArgumentInfo.h>

Collaboration diagram for ModelArgumentInfo:

Public Types
enum	{ POINTER , MEMORY , HAS_NO_VALUE , UNSPECIFIED }

Public Member Functions
int	setFromPointer (const Operand &operand, const ANeuralNetworksOperandType type, void buffer, uint32_t length)

int	setFromMemory (const Operand &operand, const ANeuralNetworksOperandType *type, uint32_t poolIndex, uint32_t offset, uint32_t length)

int	updateDimensionInfo (const Operand &operand, const ANeuralNetworksOperandType *newType)

Data Fields
enum ModelArgumentInfo:: { ... }	state = UNSPECIFIED

DataLocation	locationAndLength

std::vector< uint32_t >	dimensions

void *	buffer

Detailed Description

Definition at line 27 of file ModelArgumentInfo.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
POINTER
MEMORY
HAS_NO_VALUE
UNSPECIFIED

Definition at line 38 of file ModelArgumentInfo.h.

  {
    POINTER,
    MEMORY,
    HAS_NO_VALUE,
    UNSPECIFIED
  } state = UNSPECIFIED;

Member Function Documentation

◆ setFromMemory()

int ModelArgumentInfo::setFromMemory	(	const Operand &	operand,
		const ANeuralNetworksOperandType *	type,
		uint32_t	poolIndex,
		uint32_t	offset,
		uint32_t	length
	)

Definition at line 59 of file ModelArgumentInfo.cpp.

{
  int n = updateDimensionInfo(operand, type);
  if (n != ANEURALNETWORKS_NO_ERROR)
  {
    return n;
  }
  uint32_t neededLength = sizeOfData(operand.type, dimensions);
  if (neededLength != length)
  {
    LOG(ERROR) << "Setting argument with invalid length: " << length
               << ", expected length: " << neededLength;
    return ANEURALNETWORKS_BAD_DATA;
  }
 
  state = ModelArgumentInfo::MEMORY;
  locationAndLength = {.poolIndex = poolIndex, .offset = offset, .length = length};
  buffer = nullptr;
  return ANEURALNETWORKS_NO_ERROR;
}

References ANEURALNETWORKS_BAD_DATA, ANEURALNETWORKS_NO_ERROR, buffer, dimensions, locationAndLength, LOG, MEMORY, offset(), DataLocation::poolIndex, sizeOfData(), state, Operand::type, type, and updateDimensionInfo().

◆ setFromPointer()

int ModelArgumentInfo::setFromPointer	(	const Operand &	operand,
		const ANeuralNetworksOperandType *	type,
		void *	buffer,
		uint32_t	length
	)

Definition at line 24 of file ModelArgumentInfo.cpp.

{
  if ((data == nullptr) != (length == 0))
  {
    LOG(ERROR) << "Data pointer must be nullptr if and only if length is zero (data = " << data
               << ", length = " << length << ")";
    return ANEURALNETWORKS_BAD_DATA;
  }
  if (data == nullptr)
  {
    state = ModelArgumentInfo::HAS_NO_VALUE;
  }
  else
  {
    int n = updateDimensionInfo(operand, type);
    if (n != ANEURALNETWORKS_NO_ERROR)
    {
      return n;
    }
    uint32_t neededLength = sizeOfData(operand.type, dimensions);
    if (neededLength != length)
    {
      LOG(ERROR) << "Setting argument with invalid length: " << length
                 << ", expected length: " << neededLength;
      return ANEURALNETWORKS_BAD_DATA;
    }
    state = ModelArgumentInfo::POINTER;
  }
  buffer = data;
  locationAndLength = {.poolIndex = 0, .offset = 0, .length = length};
  return ANEURALNETWORKS_NO_ERROR;
}

References ANEURALNETWORKS_BAD_DATA, ANEURALNETWORKS_NO_ERROR, buffer, dimensions, HAS_NO_VALUE, locationAndLength, LOG, POINTER, DataLocation::poolIndex, sizeOfData(), state, Operand::type, type, and updateDimensionInfo().

◆ updateDimensionInfo()

int ModelArgumentInfo::updateDimensionInfo	(	const Operand &	operand,
		const ANeuralNetworksOperandType *	newType
	)

Definition at line 81 of file ModelArgumentInfo.cpp.

{
  ASSERT(dimensions.empty());
  if (newType == nullptr)
  {
    for (auto i : operand.dimensions)
    {
      if (i == 0)
      {
        LOG(ERROR) << "Setting input/output with unspecified dimensions";
        return ANEURALNETWORKS_BAD_DATA;
      }
    }
    dimensions = operand.dimensions;
  }
  else
  {
    uint32_t count = newType->dimensionCount;
    if (static_cast<OperandType>(newType->type) != operand.type ||
        count != operand.dimensions.size())
    {
      LOG(ERROR) << "Setting input/output with incompatible types";
      return ANEURALNETWORKS_BAD_DATA;
    }
    dimensions = std::vector<uint32_t>(count);
    for (uint32_t i = 0; i < count; i++)
    {
      if (operand.dimensions[i] != 0 && operand.dimensions[i] != newType->dimensions[i])
      {
        LOG(ERROR) << "Overriding a fully specified dimension is disallowed";
        return ANEURALNETWORKS_BAD_DATA;
      }
      else
      {
        dimensions[i] = newType->dimensions[i];
      }
    }
  }
  return ANEURALNETWORKS_NO_ERROR;
}