ExecutionBuilder Class Reference

#include <ExecutionBuilder.h>

Public Member Functions
	ExecutionBuilder (const ModelBuilder *)
int	setInput (uint32_t index, const ANeuralNetworksOperandType *type, const void *buffer, size_t length)
int	setInputFromMemory (uint32_t index, const ANeuralNetworksOperandType *type, const Memory *memory, size_t offset, size_t length)
int	setOutput (uint32_t index, const ANeuralNetworksOperandType *type, void *buffer, size_t length)
int	setOutputFromMemory (uint32_t index, const ANeuralNetworksOperandType *type, const Memory *memory, size_t offset, size_t length)
int	startCompute (void)

Detailed Description

Definition at line 32 of file ExecutionBuilder.h.

Constructor & Destructor Documentation

ExecutionBuilder()

ExecutionBuilder::ExecutionBuilder

(

const ModelBuilder *

model

)

Definition at line 59 of file ExecutionBuilder.cpp.

    : mModel(model), mInputs(mModel->inputCount()), mOutputs(mModel->outputCount())
{
  VLOG(EXECUTION) << "ExecutionBuilder::ExecutionBuilder";
}

References VLOG.

Member Function Documentation

setInput()

int ExecutionBuilder::setInput	(	uint32_t	index,
		const ANeuralNetworksOperandType *	type,
		const void *	buffer,
		size_t	length
	)

Definition at line 65 of file ExecutionBuilder.cpp.

{
  uint32_t count = static_cast<uint32_t>(mInputs.size());
  if (index >= count)
  {
    LOG(ERROR) << "ANeuralNetworksExecution_setInput bad index " << index << " " << count;
    return ANEURALNETWORKS_BAD_DATA;
  }
  if (type != nullptr)
  {
    int n = validateOperandType(*type, "ANeuralNetworksExecution_setInput", false);
    if (n != ANEURALNETWORKS_NO_ERROR)
    {
      return n;
    }
  }
  if (length > 0xFFFFFFFF)
  {
    LOG(ERROR) << "ANeuralNetworksExecution_setInput input exceeds max length " << length;
    return ANEURALNETWORKS_BAD_DATA;
  }
  uint32_t l = static_cast<uint32_t>(length);
  return mInputs[index].setFromPointer(mModel->getInputOperand(index), type,
                                       const_cast<void *>(buffer), l);
}

References ANEURALNETWORKS_BAD_DATA, ANEURALNETWORKS_NO_ERROR, ModelBuilder::getInputOperand(), LOG, and validateOperandType().

setInputFromMemory()

int ExecutionBuilder::setInputFromMemory	(	uint32_t	index,
		const ANeuralNetworksOperandType *	type,
		const Memory *	memory,
		size_t	offset,
		size_t	length
	)

Definition at line 92 of file ExecutionBuilder.cpp.

{
  uint32_t count = static_cast<uint32_t>(mInputs.size());
  if (index >= count)
  {
    LOG(ERROR) << "ANeuralNetworksExecution_setInputFromMemory bad index " << index << " " << count;
    return ANEURALNETWORKS_BAD_DATA;
  }
  if (!memory->validateSize(offset, length))
  {
    return ANEURALNETWORKS_BAD_DATA;
  }
  uint32_t poolIndex = mMemories.add(memory);
  return mInputs[index].setFromMemory(mModel->getInputOperand(index), type, poolIndex, offset,
                                      length);
}

References MemoryTracker::add(), ANEURALNETWORKS_BAD_DATA, ModelBuilder::getInputOperand(), LOG, offset(), and Memory::validateSize().

setOutput()

int ExecutionBuilder::setOutput	(	uint32_t	index,
		const ANeuralNetworksOperandType *	type,
		void *	buffer,
		size_t	length
	)

Definition at line 110 of file ExecutionBuilder.cpp.

{
  uint32_t count = static_cast<uint32_t>(mOutputs.size());
  if (index >= count)
  {
    LOG(ERROR) << "ANeuralNetworksExecution_setOutput bad index " << index << " " << count;
    return ANEURALNETWORKS_BAD_DATA;
  }
  if (type != nullptr)
  {
    int n = validateOperandType(*type, "ANeuralNetworksExecution_setOutput", false);
    if (n != ANEURALNETWORKS_NO_ERROR)
    {
      return n;
    }
  }
  if (length > 0xFFFFFFFF)
  {
    LOG(ERROR) << "ANeuralNetworksExecution_setOutput input exceeds max length " << length;
    return ANEURALNETWORKS_BAD_DATA;
  }
  uint32_t l = static_cast<uint32_t>(length);
  return mOutputs[index].setFromPointer(mModel->getOutputOperand(index), type, buffer, l);
}

References ANEURALNETWORKS_BAD_DATA, ANEURALNETWORKS_NO_ERROR, ModelBuilder::getOutputOperand(), LOG, and validateOperandType().

setOutputFromMemory()

int ExecutionBuilder::setOutputFromMemory	(	uint32_t	index,
		const ANeuralNetworksOperandType *	type,
		const Memory *	memory,
		size_t	offset,
		size_t	length
	)

Definition at line 136 of file ExecutionBuilder.cpp.

{
  // Should be similar to StepExecutor::setInputOrOutputFromTemporaryMemory()
 
  uint32_t count = static_cast<uint32_t>(mOutputs.size());
  if (index >= count)
  {
    LOG(ERROR) << "ANeuralNetworksExecution_setOutputFromMemory bad index " << index << " "
               << count;
    return ANEURALNETWORKS_BAD_DATA;
  }
  if (!memory->validateSize(offset, length))
  {
    return ANEURALNETWORKS_BAD_DATA;
  }
  // TODO validate the rest
  uint32_t poolIndex = mMemories.add(memory);
  return mOutputs[index].setFromMemory(mModel->getOutputOperand(index), type, poolIndex, offset,
                                       length);
}

References MemoryTracker::add(), ANEURALNETWORKS_BAD_DATA, ModelBuilder::getOutputOperand(), LOG, offset(), and Memory::validateSize().

startCompute()

int ExecutionBuilder::startCompute

(

void

)

Definition at line 158 of file ExecutionBuilder.cpp.

{
  Model model;
  mModel->publish(&model);
 
  // modelPoolInfo holds the infomation of pre-allocated memory pools during model construction
  std::vector<RunTimePoolInfo> modelPoolInfos;
  if (!setRunTimePoolInfosFromMemories(&modelPoolInfos, model.pools))
  {
    return ANEURALNETWORKS_UNMAPPABLE;
  }
 
  std::vector<RunTimePoolInfo> requestPoolInfos;
  uint32_t count = mMemories.size();
  requestPoolInfos.resize(count);
  // Create as many pools as there are input / output
  auto fixPointerArguments = [&requestPoolInfos](std::vector<ModelArgumentInfo> &argumentInfos) {
    for (ModelArgumentInfo &argumentInfo : argumentInfos)
    {
      if (argumentInfo.state == ModelArgumentInfo::POINTER)
      {
        RunTimePoolInfo runTimeInfo;
        runTimeInfo.buffer = static_cast<uint8_t *>(argumentInfo.buffer);
        argumentInfo.locationAndLength.poolIndex = static_cast<uint32_t>(requestPoolInfos.size());
        argumentInfo.locationAndLength.offset = 0;
        requestPoolInfos.push_back(runTimeInfo);
      }
    }
  };
  fixPointerArguments(mInputs);
  fixPointerArguments(mOutputs);
 
  Request request;
  setRequestArgumentArray(mInputs, &request.inputs);
  setRequestArgumentArray(mOutputs, &request.outputs);
 
  Executor executor;
  return executor.run(model, request, modelPoolInfos, requestPoolInfos);
}

References ANEURALNETWORKS_UNMAPPABLE, RunTimePoolInfo::buffer, Request::inputs, Request::outputs, ModelArgumentInfo::POINTER, ModelBuilder::publish(), Executor::run(), setRunTimePoolInfosFromMemories(), and MemoryTracker::size().

---

The documentation for this class was generated from the following files:

• compiler/ann-ref/src/ExecutionBuilder.h
• compiler/ann-ref/src/ExecutionBuilder.cpp