nnkit::support::onnx::Runner Class Reference

#include <Runner.h>

Public Member Functions
	Runner (const std::string &path)
	~Runner (void)
void	prepareInputs (void)
void	prepareOutputs (void)
TensorSet &	inputs (void)
TensorSet &	outputs (void)
void	run (void)
	Runner (const Runner &)=delete
Runner &	operator= (const Runner &)=delete

Detailed Description

Definition at line 34 of file Runner.h.

Constructor & Destructor Documentation

Runner() [1/2]

nnkit::support::onnx::Runner::Runner

(

const std::string &

path

)

Definition at line 30 of file Runner.cpp.

                                    : _allocator(std::make_unique<Allocator>())
{
  Status status;
 
  status = OrtCreateEnv(ORT_LOGGING_LEVEL_WARNING, "nnkit", &_env);
  assert(!status.isError());
 
  status = OrtCreateSession(_env, path.c_str(), nullptr, &_session);
  assert(!status.isError());
}

References nnkit::support::onnx::Status::isError().

~Runner()

nnkit::support::onnx::Runner::~Runner

(

void

)

Definition at line 41 of file Runner.cpp.

{
  if (_session)
  {
    OrtReleaseSession(_session);
  }
 
  if (_env)
  {
    OrtReleaseEnv(_env);
  }
}

Runner() [2/2]

nnkit::support::onnx::Runner::Runner ( const Runner &  )

delete

Member Function Documentation

inputs()

TensorSet & nnkit::support::onnx::Runner::inputs ( void  )

inline

Definition at line 43 of file Runner.h.

{ return *_inputs; }

Referenced by validate_onnx2circle.OnnxRunner::feed_random_inputs(), nnkit::support::onnx::Backend::prepare(), and package.infer.session::set_inputs().

operator=()

Runner & nnkit::support::onnx::Runner::operator= ( const Runner &  )

delete

outputs()

TensorSet & nnkit::support::onnx::Runner::outputs ( void  )

inline

Definition at line 44 of file Runner.h.

{ return *_outputs; }

Referenced by validate_onnx2circle.OnnxRunner::get_outputs(), package.infer.session::inference(), package.infer.session::set_outputs(), and nnkit::support::onnx::Backend::teardown().

prepareInputs()

void nnkit::support::onnx::Runner::prepareInputs

(

void

)

Definition at line 54 of file Runner.cpp.

{
  Status status;
 
  assert(_inputs == nullptr);
 
  size_t num_input_nodes;
  status = OrtSessionGetInputCount(_session, &num_input_nodes);
  status.throwOnError();
 
  _inputs = std::make_unique<TensorSet>(_allocator.get(), num_input_nodes);
 
  for (size_t i = 0; i < num_input_nodes; ++i)
  {
    char *input_name;
    status = OrtSessionGetInputName(_session, i, _allocator.get(), &input_name);
    status.throwOnError();
 
    assert(input_name != nullptr);
 
    std::string name{input_name};
    _allocator->Free(input_name);
 
    OrtTypeInfo *typeinfo;
    status = OrtSessionGetInputTypeInfo(_session, i, &typeinfo);
    status.throwOnError();
 
    const OrtTensorTypeAndShapeInfo *tensor_info = OrtCastTypeInfoToTensorInfo(typeinfo);
    ONNXTensorElementDataType type = OrtGetTensorElementType(tensor_info);
 
    uint32_t num_dims = OrtGetNumOfDimensions(tensor_info);
    std::vector<size_t> dims(num_dims);
    OrtGetDimensions(tensor_info, (int64_t *)dims.data(), num_dims);
 
    // NOTE To run OnnxRuntime, the total size of input tensor must be fixed.
    //      In the present code, the unknown shape that is -1 is arbitrarily changed to 1.
    //
    // TODO Add user argument related to unknown shape
    //
    for (uint32_t j = 0; j < num_dims; ++j)
    {
      if (dims[j] == -1)
      {
        dims[j] = 1;
      }
    }
    OrtReleaseTypeInfo(typeinfo);
 
    _inputs->set(i, name, type, dims);
  }
}

References nnkit::support::onnx::Status::throwOnError().

Referenced by nnkit::support::onnx::Backend::prepare().

prepareOutputs()

void nnkit::support::onnx::Runner::prepareOutputs

(

void

)

Definition at line 106 of file Runner.cpp.

{
  Status status;
 
  assert(_outputs == nullptr);
 
  size_t num_output_nodes;
  status = OrtSessionGetOutputCount(_session, &num_output_nodes);
  status.throwOnError();
 
  _outputs = std::make_unique<TensorSet>(_allocator.get(), num_output_nodes);
 
  for (size_t i = 0; i < num_output_nodes; ++i)
  {
    char *output_name;
    status = OrtSessionGetOutputName(_session, i, _allocator.get(), &output_name);
    status.throwOnError();
 
    assert(output_name != nullptr);
 
    std::string name{output_name};
    _allocator->Free(output_name);
 
    OrtTypeInfo *typeinfo;
    status = OrtSessionGetOutputTypeInfo(_session, i, &typeinfo);
    status.throwOnError();
 
    const OrtTensorTypeAndShapeInfo *tensor_info = OrtCastTypeInfoToTensorInfo(typeinfo);
    ONNXTensorElementDataType type = OrtGetTensorElementType(tensor_info);
 
    uint32_t num_dims = OrtGetNumOfDimensions(tensor_info);
    std::vector<size_t> dims(num_dims);
    OrtGetDimensions(tensor_info, (int64_t *)dims.data(), num_dims);
 
    // NOTE To run OnnxRuntime, the total size of output tensor must be fixed.
    //      In the present code, the unknown shape that is -1 is arbitrarily changed to 1.
    //
    // TODO Add user argument related to unknown shape
    //
    for (uint32_t j = 0; j < num_dims; ++j)
    {
      if (dims[j] == -1)
      {
        dims[j] = 1;
      }
    }
    OrtReleaseTypeInfo(typeinfo);
 
    _outputs->set(i, name, type, dims);
  }
}

References nnkit::support::onnx::Status::throwOnError().

Referenced by nnkit::support::onnx::Backend::prepare().

run()

void nnkit::support::onnx::Runner::run

(

void

)

Definition at line 158 of file Runner.cpp.

{
  Status status;
 
  auto pinput_names = _inputs->names();
  std::vector<const char *> input_names(pinput_names.size());
  for (size_t i = 0; i < pinput_names.size(); ++i)
  {
    input_names[i] = pinput_names[i].c_str();
  }
 
  auto poutput_names = _outputs->names();
  std::vector<const char *> output_names(poutput_names.size());
  for (size_t i = 0; i < poutput_names.size(); ++i)
  {
    output_names[i] = poutput_names[i].c_str();
  }
 
  status = OrtRun(_session, NULL, input_names.data(), _inputs->tensors().data(), _inputs->size(),
                  output_names.data(), _outputs->size(), _outputs->mutable_tensors().data());
  status.throwOnError();
}

References nnkit::support::onnx::Status::throwOnError().

Referenced by package.infer.session::inference(), and nnkit::support::onnx::Backend::run().

---

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

• compiler/nnkit-onnxrt/support/include/nnkit/support/onnx/Runner.h
• compiler/nnkit-onnxrt/support/src/Runner.cpp