onert::api::Session Struct Reference

#include <Session.h>

Public Member Functions
	~Session ()
NNFW_STATUS	load_model_from_path (const char *path)
NNFW_STATUS	prepare ()
NNFW_STATUS	run ()
NNFW_STATUS	run_async ()
NNFW_STATUS	await ()
NNFW_STATUS	set_input (uint32_t index, NNFW_TYPE type, const void *buffer, size_t length)
NNFW_STATUS	set_output (uint32_t index, NNFW_TYPE type, void *buffer, size_t length)
NNFW_STATUS	input_size (uint32_t *number)
NNFW_STATUS	output_size (uint32_t *number)
NNFW_STATUS	set_input_layout (uint32_t index, NNFW_LAYOUT layout)
NNFW_STATUS	set_output_layout (uint32_t index, NNFW_LAYOUT layout)
NNFW_STATUS	set_input_type (uint32_t index, NNFW_TYPE type)
NNFW_STATUS	set_output_type (uint32_t index, NNFW_TYPE type)
NNFW_STATUS	set_input_tensorinfo (uint32_t index, const nnfw_tensorinfo *ti)
NNFW_STATUS	input_tensorinfo (uint32_t index, nnfw_tensorinfo *ti)
NNFW_STATUS	output_tensorinfo (uint32_t index, nnfw_tensorinfo *ti)
NNFW_STATUS	set_available_backends (const char *backends)
NNFW_STATUS	set_workspace (const char *dir)
NNFW_STATUS	configure_signature (const char *signature)
NNFW_STATUS	set_signature_run (const char *signature)
NNFW_STATUS	get_last_error_message (char *buffer, size_t length) const
NNFW_STATUS	deprecated (const char *msg)
NNFW_STATUS	set_config (const char *key, const char *value)
NNFW_STATUS	get_config (const char *key, char *value, size_t value_size)
NNFW_STATUS	load_circle_from_buffer (uint8_t *buffer, size_t size)
NNFW_STATUS	get_output (uint32_t index, nnfw_tensorinfo *out_info, const void **out_buffer)
NNFW_STATUS	register_custom_operation (const std::string &id, nnfw_custom_eval eval_func)
NNFW_STATUS	input_tensorindex (const char *tensorname, uint32_t *index)
NNFW_STATUS	output_tensorindex (const char *tensorname, uint32_t *index)
NNFW_STATUS	run_with_auto_compilation (const char *target, NNFW_CODEGEN_PREF pref)
NNFW_STATUS	set_odc_param_minmax_records_count (int minmax_records_count)
NNFW_STATUS	delete_odc_minmax_file ()
NNFW_STATUS	set_backends_per_operation (const char *backend_settings)
	Set backends with string-encoded mapping from operation index to backend type (cpu, acl_cl)
NNFW_STATUS	train_get_traininfo (nnfw_train_info *info)
NNFW_STATUS	train_set_traininfo (const nnfw_train_info *info)
NNFW_STATUS	train_prepare ()
NNFW_STATUS	train_input_tensorinfo (uint32_t index, nnfw_tensorinfo *ti)
NNFW_STATUS	train_expected_tensorinfo (uint32_t index, nnfw_tensorinfo *ti)
NNFW_STATUS	train_set_input (uint32_t index, const void *input, const nnfw_tensorinfo *input_tensorinfo)
NNFW_STATUS	train_set_expected (uint32_t index, const void *expected, const nnfw_tensorinfo *expected_tensorinfo)
NNFW_STATUS	train_set_output (uint32_t index, NNFW_TYPE type, void *buffer, size_t length)
NNFW_STATUS	train_run (bool update_weights)
NNFW_STATUS	train_get_loss (uint32_t index, float *loss)
NNFW_STATUS	train_export_circle (const char *path)
NNFW_STATUS	train_export_circleplus (const char *path)
NNFW_STATUS	train_import_checkpoint (const char *path)
NNFW_STATUS	train_export_checkpoint (const char *path)
NNFW_STATUS	set_quantization_type (NNFW_QUANTIZE_TYPE qtype)
NNFW_STATUS	set_quantized_model_path (const char *path)
NNFW_STATUS	quantize ()
NNFW_STATUS	set_codegen_model_path (const char *path)
NNFW_STATUS	codegen (const char *target, NNFW_CODEGEN_PREF pref)
NNFW_STATUS	set_prepare_config (const NNFW_PREPARE_CONFIG key, const char *value)
NNFW_STATUS	reset_prepare_config ()
NNFW_STATUS	set_execute_config (const NNFW_RUN_CONFIG key, const char *value)
NNFW_STATUS	reset_execute_config ()

Static Public Member Functions
static NNFW_STATUS	create (Session **session)
	Factory method. It creates and initialize Session.

Detailed Description

Definition at line 41 of file Session.h.

Constructor & Destructor Documentation

~Session()

onert::api::Session::~Session ( )

default

Member Function Documentation

await()

NNFW_STATUS onert::api::Session::await

(

)

Definition at line 522 of file Session.cc.

{
  if (!isStateRunning())
  {
    setLastErrorMessage(
      "Error during Session::run_await : run_await should be called after run_async");
    return NNFW_STATUS_ERROR;
  }
 
  _execution->waitFinish();
 
  _state = State::FINISHED_RUN;
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, and NNFW_STATUS_NO_ERROR.

codegen()

NNFW_STATUS onert::api::Session::codegen	(	const char *	target,
		NNFW_CODEGEN_PREF	pref
	)

Definition at line 2235 of file Session.cc.

{
  try
  {
    if (isStateInitialized() || isStateRunning())
    {
      setLastErrorMessage("Error during Session::codegen : Invalid state");
      return NNFW_STATUS_INVALID_STATE;
    }
 
    std::string target_str{target};
    if (target_str.empty() || target_str.size() < 5 ||
        target_str.substr(target_str.size() - 4) != "-gen")
    {
      setLastErrorMessage("Error during Session::codegen : Invalid target");
      return NNFW_STATUS_ERROR;
    }
 
    onert::odc::CodegenPreference codegen_pref;
    switch (pref)
    {
      case NNFW_CODEGEN_PREF_DEFAULT:
        codegen_pref = onert::odc::CodegenPreference::CODEGEN_PREF_DEFAULT;
        break;
      case NNFW_CODEGEN_PREF_PERFORMANCE_FIRST:
        codegen_pref = onert::odc::CodegenPreference::CODEGEN_PREF_PERFORMANCE_FIRST;
        break;
      case NNFW_CODEGEN_PREF_MEMORY_FIRST:
        codegen_pref = onert::odc::CodegenPreference::CODEGEN_PREF_MEMORY_FIRST;
        break;
      case NNFW_CODEGEN_PREF_COMPILE_TIME_FIRST:
        codegen_pref = onert::odc::CodegenPreference::CODEGEN_PREF_COMPILE_TIME_FIRST;
        break;
      default:
        setLastErrorMessage("Error during Session::codegen : Invalid preference");
        return NNFW_STATUS_ERROR;
    }
 
    assert(_codegen_manager != nullptr);
    auto export_model_path = std::filesystem::path(_codegen_manager->exportModelPath());
    const auto model_type = target_str.substr(0, target_str.size() - 4);
    // If the export_model_path is not set, it generates a compiled model path
    // automatically.
    if (export_model_path.empty())
    {
      // The compiled model path is the same directory of the original model/package with
      // target backend extension.
      export_model_path = _model_path.replace_extension(model_type);
      _codegen_manager->exportModelPath(export_model_path.string());
    }
 
    _codegen_manager->codegen(_model_path, target, codegen_pref);
 
    // Replace model
    // TODO Support buffer replace, not file reload
    return loadModelFile(export_model_path, model_type);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::codegen : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
}

References onert::odc::CODEGEN_PREF_COMPILE_TIME_FIRST, onert::odc::CODEGEN_PREF_DEFAULT, onert::odc::CODEGEN_PREF_MEMORY_FIRST, onert::odc::CODEGEN_PREF_PERFORMANCE_FIRST, NNFW_CODEGEN_PREF_COMPILE_TIME_FIRST, NNFW_CODEGEN_PREF_DEFAULT, NNFW_CODEGEN_PREF_MEMORY_FIRST, NNFW_CODEGEN_PREF_PERFORMANCE_FIRST, NNFW_STATUS_ERROR, and NNFW_STATUS_INVALID_STATE.

configure_signature()

NNFW_STATUS onert::api::Session::configure_signature

(

const char *

signature

)

Definition at line 1073 of file Session.cc.

{
  if (!signature)
  {
    setLastErrorMessage("Error during Session::configure_signature : signature is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!isStateModelLoaded())
  {
    setLastErrorMessage("Error during Session::configure_signature : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  for (const auto &[subg_idx, sig_str] : _signature_map)
  {
    if (sig_str == std::string(signature))
    {
      _selected_signature = subg_idx;
 
      return NNFW_STATUS_NO_ERROR;
    }
  }
 
  setLastErrorMessage("Error during Session::configure_signature : Cannot find signature \"" +
                      std::string(signature) + "\"");
  return NNFW_STATUS_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

create()

NNFW_STATUS onert::api::Session::create ( Session **  session )

static

Factory method. It creates and initialize Session.

Note

Use factory instead of constructor to get status

Definition at line 231 of file Session.cc.

{
  if (session == nullptr)
    return NNFW_STATUS_UNEXPECTED_NULL;
  try
  {
    auto new_session = std::unique_ptr<Session>(new Session());
    new_session->_kernel_registry = std::make_shared<onert::api::CustomKernelRegistry>();
    *session = new_session.release();
  }
  catch (const std::bad_alloc &e)
  {
    // TODO: Do not write to std::cerr in library code
    std::cerr << "Error during session creation" << std::endl;
    *session = nullptr; // Set nullptr on error to keep the old behavior
    return NNFW_STATUS_OUT_OF_MEMORY;
  }
  catch (const std::exception &e)
  {
    // TODO: Do not write to std::cerr in library code
    std::cerr << "Error during session initialization : " << e.what() << std::endl;
    *session = nullptr; // Set nullptr on error to keep the old behavior
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_NO_ERROR, NNFW_STATUS_OUT_OF_MEMORY, and NNFW_STATUS_UNEXPECTED_NULL.

Referenced by nnfw_create_session().

delete_odc_minmax_file()

NNFW_STATUS onert::api::Session::delete_odc_minmax_file

(

)

Definition at line 2398 of file Session.cc.

{
  if (isStateRunning())
  {
    setLastErrorMessage("Error during Session::delete_odc_minmax_file : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (_quant_manager->deleteMinMaxFile())
    return NNFW_STATUS_NO_ERROR;
 
  setLastErrorMessage("Error during Session::delete_odc_minmax_file : Could not delete file");
  return NNFW_STATUS_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

deprecated()

NNFW_STATUS onert::api::Session::deprecated

(

const char *

msg

)

Definition at line 1145 of file Session.cc.

{
  setLastErrorMessage(msg);
  return NNFW_STATUS_DEPRECATED_API;
}

References NNFW_STATUS_DEPRECATED_API.

get_config()

NNFW_STATUS onert::api::Session::get_config	(	const char *	key,
		char *	value,
		size_t	value_size
	)

Definition at line 1281 of file Session.cc.

{
  if (!isStateModelLoaded())
  {
    setLastErrorMessage("Error during Session::get_config : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (!key)
  {
    setLastErrorMessage("Error during Session::get_config : key is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!value)
  {
    setLastErrorMessage("Error during Session::get_config : value is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  auto check_boundary = [](size_t dest_size, std::string &src) {
    if (dest_size < src.length() + 1 /* for '\0' */)
      return false;
    return true;
  };
 
  const std::string skey = key;
 
  if (skey == onert::util::config::BACKENDS)
  {
    if (_coptions->backend_list.size() == 0)
      return NNFW_STATUS_NO_ERROR; // no setting backend is not an error of get_config_str()
 
    auto str =
      nnfw::misc::join(_coptions->backend_list.begin(), _coptions->backend_list.end(), ";");
 
    if (!check_boundary(value_size, str))
    {
      setLastErrorMessage(
        "Error during Session::get_config : Buffer is too small to copy backends");
      return NNFW_STATUS_ERROR;
    }
 
    strncpy(value, str.c_str(), value_size);
  }
  else if (skey == onert::util::config::EXECUTOR)
  {
    if (!check_boundary(value_size, _coptions->executor))
    {
      setLastErrorMessage(
        "Error during Session::get_config : Buffer is too small to copy executor");
      return NNFW_STATUS_ERROR;
    }
 
    strncpy(value, _coptions->executor.c_str(), _coptions->executor.length());
  }
  else
  {
    setLastErrorMessage("Error during Session::get_config : Unknown config key");
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References nnfw::misc::join(), NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

get_last_error_message()

NNFW_STATUS onert::api::Session::get_last_error_message	(	char *	buffer,
		size_t	length
	)		const

Definition at line 1131 of file Session.cc.

{
  if (!buffer)
  {
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
  if (length < _last_error_message.size() + 1)
  {
    return NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE;
  }
  strncpy(buffer, _last_error_message.c_str(), length);
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

get_output()

NNFW_STATUS onert::api::Session::get_output	(	uint32_t	index,
		nnfw_tensorinfo *	out_info,
		const void **	out_buffer
	)

Definition at line 963 of file Session.cc.

{
  if (ti == nullptr)
  {
    setLastErrorMessage("Error during Session::get_output : tensorinfo is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (out_buffer == nullptr)
  {
    setLastErrorMessage("Error during Session::get_output : output buffer is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!isStateFinishedRun())
  {
    setLastErrorMessage("Error during Session::get_output : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    if (index >= getOutputSize())
    {
      setLastErrorMessage("Error during Session::get_output : index is out of range : " +
                          std::to_string(index) + " >= " + std::to_string(getOutputSize()));
      return NNFW_STATUS_ERROR;
    }
 
    if (!_coptions->internal_output_alloc)
    {
      setLastErrorMessage(
        "Error during Session::get_output : internal output allocation is not enabled : Call "
        "nnfw_set_prepare_config(session, NNFW_PREPARE_CONFIG_ENABLE_INTERNAL_OUTPUT_ALLOC, "
        "\"true\") before nnfw_prepare()");
      return NNFW_STATUS_ERROR;
    }
 
    auto io_index = onert::ir::IOIndex{index};
    const auto &info = _execution->outputInfo(io_index);
    const auto &shape = info.shape();
    const auto &dtype = info.typeInfo().type();
    fillTensorInfo(ti, shape, dtype);
 
    *out_buffer = _execution->outputBuffer(io_index);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::get_output : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References info, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

input_size()

NNFW_STATUS onert::api::Session::input_size

(

uint32_t *

number

)

Definition at line 590 of file Session.cc.

{
  if (isStateInitialized())
  {
    setLastErrorMessage("Error during Session::input_size : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (number == nullptr)
  {
    setLastErrorMessage("Error during Session::input_size : number is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  try
  {
    *number = getInputSize();
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::input_size : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

input_tensorindex()

NNFW_STATUS onert::api::Session::input_tensorindex	(	const char *	tensorname,
		uint32_t *	index
	)

Definition at line 1447 of file Session.cc.

{
  return getTensorIndexImpl(*primary_subgraph(), tensorname, index, true);
}

input_tensorinfo()

NNFW_STATUS onert::api::Session::input_tensorinfo	(	uint32_t	index,
		nnfw_tensorinfo *	ti
	)

Definition at line 869 of file Session.cc.

{
  if (isStateInitialized())
  {
    setLastErrorMessage("Error during Session::input_tensorinfo : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    if (ti == nullptr)
    {
      setLastErrorMessage("Error during Session::input_tensorinfo : tensorinfo is NULL");
      return NNFW_STATUS_UNEXPECTED_NULL;
    }
 
    if (index >= getInputSize())
    {
      setLastErrorMessage("Error during Session::input_tensorinfo : index is out of range");
      return NNFW_STATUS_ERROR;
    }
 
    const auto input_index = onert::ir::IOIndex{index};
    if (isStateModelLoaded())
    {
      const auto &info = _selected_signature.valid() ? _nnpkg->inputInfo(_selected_signature, index)
                                                     : _nnpkg->inputInfo(input_index);
      fillTensorInfo(ti, info.shape(), info.typeInfo().type());
    }
    else
    {
      const auto &info = _execution->inputInfo(input_index);
      fillTensorInfo(ti, info.shape(), info.typeInfo().type());
    }
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::input_tensorinfo : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References info, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

load_circle_from_buffer()

NNFW_STATUS onert::api::Session::load_circle_from_buffer	(	uint8_t *	buffer,
		size_t	size
	)

Definition at line 260 of file Session.cc.

{
  if (!isStateInitialized())
  {
    setLastErrorMessage("Invalid state : " + std::to_string(static_cast<int>(_state)));
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (!buffer)
  {
    setLastErrorMessage("Invalid argument : buffer is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (size == 0)
  {
    setLastErrorMessage("Invalid argument : size is 0");
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    auto model = onert::loader::loadCircleModel(buffer, size);
    // TODO: Update _model_path if necessary
    _nnpkg = std::make_unique<onert::ir::NNPkg>(std::move(model));
    _train_info = loadTrainingInfo(_nnpkg->primary_model());
    _state = State::MODEL_LOADED;
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during model loading : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References onert::loader::loadCircleModel(), NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, and size.

load_model_from_path()

NNFW_STATUS onert::api::Session::load_model_from_path

(

const char *

path

)

Definition at line 296 of file Session.cc.

{
  if (!isStateInitialized())
  {
    setLastErrorMessage("Invalid state : " + std::to_string(static_cast<int>(_state)));
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (!path)
  {
    setLastErrorMessage("Invalid argument : path is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!null_terminating(path, MAX_PATH_LENGTH))
  {
    setLastErrorMessage("Invalid argument : path is too long");
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    std::filesystem::path filename{path};
    if (!std::filesystem::is_directory(filename))
    {
      std::string model_type = inferModelType(filename);
      if (model_type.empty())
      {
        setLastErrorMessage("Cannot determine model type from file name extension '" +
                            filename.string() + "'");
        return NNFW_STATUS_ERROR;
      }
      else
        return loadModelFile(filename, model_type);
    }
 
    const auto &package_dir = filename;
 
    // TODO : add support for zipped package file load
    if (!std::filesystem::is_directory(package_dir))
    {
      setLastErrorMessage("Invalid argument : path '" + package_dir.string() +
                          "' is not a directory");
      return NNFW_STATUS_ERROR;
    }
 
    const auto manifest_file_name = package_dir / "metadata/MANIFEST";
    std::ifstream mfs(manifest_file_name);
 
    // extract the filename of the first(index 0) model
    // e.g. In MANIFEST file, { "models" : [ "firstmodel.tflite", "2nd.tflite" ] }
    Json::Value root;
    mfs >> root;
    const Json::Value &models = root["models"];
    const Json::Value &model_types = root["model-types"];
    const Json::Value &configs = root["configs"];
 
    if (!configs.empty() && !configs[0].empty())
    {
      const auto filepath = package_dir / "metadata" / configs[0].asString();
 
      onert::util::CfgKeyValues keyValues;
      if (loadConfigure(filepath.string(), keyValues))
      {
        onert::util::setConfigKeyValues(keyValues);
      }
    }
    _nnpkg = std::make_unique<onert::ir::NNPkg>();
    auto num_models = models.size();
    if (num_models == 0 || (num_models - 1) > onert::ir::ModelIndex::max())
    {
      setLastErrorMessage("Invalid model size : " + std::to_string(num_models));
      return NNFW_STATUS_ERROR;
    }
 
    // Not support backend mapping to operator index for multiple models yet
    // TODO Support this
    if (num_models > 1 && _coptions->manual_scheduler_options.index_to_backend.size() != 0)
    {
      setLastErrorMessage("Cannot set backend to operator index for multiple models");
      return NNFW_STATUS_ERROR;
    }
 
    for (uint16_t i = 0; i < num_models; ++i)
    {
      const auto model_file_name = std::filesystem::path(models[i].asString());
      const auto model_file_path = package_dir / model_file_name;
      std::string model_type;
 
      // Use model-types if available and not empty, otherwise infer from file extension
      if (!model_types.empty() && i < model_types.size())
        model_type = model_types[i].asString();
      else
        model_type = inferModelType(model_file_name);
      if (model_type.empty())
      {
        setLastErrorMessage(
          "Cannot determine model type for '" + models[i].asString() +
          "' : Please specify model-types in MANIFEST or use a file with valid extension");
        return NNFW_STATUS_ERROR;
      }
 
      auto model = loadModel(model_file_path.string(), model_type);
      _model_path = model_file_path; // TODO Support multiple models
      model->bindKernelBuilder(_kernel_registry->getBuilder());
      _nnpkg->push(onert::ir::ModelIndex{i}, std::move(model));
    }
 
    _train_info = loadTrainingInfo(_nnpkg->primary_model());
 
    auto toIODesc = [](std::string str) {
      auto indices = nnfw::misc::split(str, ':');
      if (indices.size() != 3)
      {
        // TODO: Do not write to std::cerr in library code
        std::cerr << "IODesc should be 3-tuple." << std::endl;
        return onert::ir::IODesc{};
      }
      auto model_idx = static_cast<uint32_t>(std::stoi(indices.at(0)));
      auto subgraph_idx = static_cast<uint32_t>(std::stoi(indices.at(1)));
      auto operand_idx = static_cast<uint32_t>(std::stoi(indices.at(2)));
      return onert::ir::IODesc{model_idx, subgraph_idx, operand_idx};
    };
    // read pkg-inputs and pkg-outputs
    const Json::Value &pkg_inputs = root["pkg-inputs"];
    for (uint32_t i = 0; i < pkg_inputs.size(); ++i)
      _nnpkg->addInput(toIODesc(pkg_inputs[i].asString()));
    const Json::Value &pkg_outputs = root["pkg-outputs"];
    for (uint32_t i = 0; i < pkg_outputs.size(); ++i)
      _nnpkg->addOutput(toIODesc(pkg_outputs[i].asString()));
    // read model-connect
    const Json::Value &fromtos = root["model-connect"];
    for (uint32_t i = 0; i < fromtos.size(); ++i)
    {
      const Json::Value &tos = fromtos[i]["to"];
      for (uint32_t j = 0; j < tos.size(); ++j)
        _nnpkg->addEdge(toIODesc(fromtos[i]["from"].asString()), toIODesc(tos[j].asString()));
    }
 
    _nnpkg->verify();
    _state = State::MODEL_LOADED;
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Failed to load model : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References onert::util::Index< uint16_t, ModelIndexTag >::max(), MAX_PATH_LENGTH, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, onert::util::setConfigKeyValues(), and nnfw::misc::split().

output_size()

NNFW_STATUS onert::api::Session::output_size

(

uint32_t *

number

)

Definition at line 616 of file Session.cc.

{
  if (isStateInitialized())
  {
    setLastErrorMessage("Error during Session::output_size : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (number == nullptr)
  {
    setLastErrorMessage("Error during Session::output_size : number is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  try
  {
    *number = getOutputSize();
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::output_size : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

output_tensorindex()

NNFW_STATUS onert::api::Session::output_tensorindex	(	const char *	tensorname,
		uint32_t *	index
	)

Definition at line 1452 of file Session.cc.

{
  return getTensorIndexImpl(*primary_subgraph(), tensorname, index, false);
}

output_tensorinfo()

NNFW_STATUS onert::api::Session::output_tensorinfo	(	uint32_t	index,
		nnfw_tensorinfo *	ti
	)

Definition at line 912 of file Session.cc.

{
  if (isStateInitialized())
  {
    setLastErrorMessage("Error during Session::output_tensorinfo : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (ti == nullptr)
  {
    setLastErrorMessage("Error during Session::output_tensorinfo : tensorinfo is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  try
  {
    if (index >= getOutputSize())
    {
      setLastErrorMessage("Error during Session::output_tensorinfo : index is out of range");
      return NNFW_STATUS_ERROR;
    }
 
    const auto output_index = onert::ir::IOIndex{index};
    if (isStateModelLoaded())
    {
      const auto &info = _selected_signature.valid()
                           ? _nnpkg->outputInfo(_selected_signature, index)
                           : _nnpkg->outputInfo(output_index);
      fillTensorInfo(ti, info.shape(), info.typeInfo().type());
    }
    else
    {
      auto info = _execution->outputInfo(output_index);
      fillTensorInfo(ti, info.shape(), info.typeInfo().type());
    }
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::output_tensorinfo : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References info, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

prepare()

NNFW_STATUS onert::api::Session::prepare

(

)

Definition at line 446 of file Session.cc.

{
  // NOTE. If users want to run prepare() more than one time, this could be removed.
  if (!isStateModelLoaded())
  {
    if (isStateInitialized())
    {
      setLastErrorMessage("Error during Session::prepare : prepare should be called once");
    }
    else
    {
      setLastErrorMessage("Error during Session::prepare : Invalid state");
    }
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    auto compiler =
      onert::compiler::CompilerFactory::get().create(std::move(_nnpkg), _coptions.get());
    _compiler_artifact = compiler->compile();
    _execution = std::make_unique<onert::exec::Execution>(_compiler_artifact->_executors);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::prepare : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  _state = State::PREPARED;
  return NNFW_STATUS_NO_ERROR;
}

References onert::compiler::CompilerFactory::create(), onert::compiler::CompilerFactory::get(), NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

quantize()

NNFW_STATUS onert::api::Session::quantize

(

)

Definition at line 2185 of file Session.cc.

{
  try
  {
    if (isStateInitialized() || isStateRunning())
    {
      setLastErrorMessage("Error during Session::quantize : Invalid state");
      return NNFW_STATUS_INVALID_STATE;
    }
 
    auto result = _quant_manager->quantize(_model_path.string());
    if (!result)
    {
      setLastErrorMessage("Error during Session::quantize : Quantization failed");
      return NNFW_STATUS_INVALID_STATE;
    }
 
    // Replace model
    // TODO Support buffer replace, not file reload
    return loadModelFile(_quant_manager->exportModelPath(), "circle");
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::quantize : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
}

References NNFW_STATUS_ERROR, and NNFW_STATUS_INVALID_STATE.

register_custom_operation()

NNFW_STATUS onert::api::Session::register_custom_operation	(	const std::string &	id,
		nnfw_custom_eval	eval_func
	)

Definition at line 957 of file Session.cc.

{
  _kernel_registry->registerKernel(id, eval_func);
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_NO_ERROR.

reset_execute_config()

NNFW_STATUS onert::api::Session::reset_execute_config

(

)

Definition at line 2367 of file Session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    setLastErrorMessage("Error during Session::set_execution_config : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  _execution->executionOptions().dump_minmax = false;
  _execution->executionOptions().trace = false;
  _execution->executionOptions().profile = false;
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

reset_prepare_config()

NNFW_STATUS onert::api::Session::reset_prepare_config

(

)

Definition at line 2323 of file Session.cc.

{
  if (!isStateModelLoaded())
  {
    setLastErrorMessage("Error during Session::reset_prepare_config : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  _coptions->he_profiling_mode = false;
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

run()

NNFW_STATUS onert::api::Session::run

(

)

Definition at line 479 of file Session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    setLastErrorMessage("Error during Session::run : run should be called after prepare");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    _execution->execute();
  }
  catch (const onert::InsufficientBufferSizeException &e)
  {
    // Currently insufficient buffer always means output buffer.
    setLastErrorMessage("Error during Session::run : " + std::string(e.what()));
    return NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE;
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::run : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  _state = State::FINISHED_RUN;
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and onert::Exception::what().

run_async()

NNFW_STATUS onert::api::Session::run_async

(

)

Definition at line 507 of file Session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    setLastErrorMessage(
      "Error during Session::run_async : run_async should be called after prepare");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  _execution->startExecute();
 
  _state = State::RUNNING;
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

run_with_auto_compilation()

NNFW_STATUS onert::api::Session::run_with_auto_compilation	(	const char *	target,
		NNFW_CODEGEN_PREF	pref
	)

Definition at line 2414 of file Session.cc.

{
 
  if (!isStatePreparedOrFinishedRun())
  {
    setLastErrorMessage("Error during Session::run_with_auto_compilation : Run should be after "
                        "preparation");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  // Check quantization and code-generation parameters
  std::string target_str{target};
  if (_quant_manager->exportModelPath().empty() || _codegen_manager->exportModelPath().empty() ||
      target_str.empty() || target_str.substr(target_str.size() - 4) != "-gen")
  {
    setLastErrorMessage("Error during Session::run_with_auto_compilation : Quantization and "
                        "code generation parameters should be set");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  // Odc: auto compilation with hidden switching mechanizm
  // Check is model already quantized or compiled
  std::ifstream file_quantized_model(_quant_manager->exportModelPath());
  std::ifstream file_compiled_model(_codegen_manager->exportModelPath());
 
  if (!file_quantized_model.good() && !file_compiled_model.good())
  {
    // Run float model and try to quantize it
    {
      // Save execution options
      auto saved_options = _execution->executionOptions();
      // turn on minmax recording
      _execution->executionOptions().dump_minmax = true;
 
      try
      {
        _execution->execute();
      }
      catch (const onert::InsufficientBufferSizeException &e)
      {
        // Currently insufficient buffer always means output buffer.
        setLastErrorMessage("Error during Session::run_with_auto_compilation : " +
                            std::string(e.what()));
        return NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE;
      }
      catch (const std::exception &e)
      {
        setLastErrorMessage("Error during Session::run_with_auto_compilation : " +
                            std::string(e.what()));
        return NNFW_STATUS_ERROR;
      }
 
      _state = State::FINISHED_RUN;
 
      // restore min_max option to user defined state
      _execution->executionOptions().dump_minmax = saved_options.dump_minmax;
 
      // if enough statistics are collected, then run the quantization
      if (_quant_manager->readyForQuantize())
      {
        try
        {
          if (isStateInitialized() || isStateRunning())
          {
            setLastErrorMessage("Error during Session::run_with_auto_compilation : Invalid state");
            return NNFW_STATUS_INVALID_STATE;
          }
 
          auto result = _quant_manager->quantize(_model_path);
          if (!result)
          {
            setLastErrorMessage(
              "Error during Session::run_with_auto_compilation : Quantization failed");
            return NNFW_STATUS_INVALID_STATE;
          }
 
          // remove minmax file
          result = _quant_manager->deleteMinMaxFile();
          if (!result)
          {
            setLastErrorMessage(
              "Error during Session::run_with_auto_compilation : Could not delete minmax file");
            return NNFW_STATUS_INVALID_STATE;
          }
        }
        catch (const std::exception &e)
        {
          setLastErrorMessage("Error during Session::run_with_auto_compilation : " +
                              std::string(e.what()));
          return NNFW_STATUS_ERROR;
        }
      }
    }
  }
  else
  {
    // run compiled or quantized model
    NNFW_STATUS status;
 
    // turn off minmax recording
    _execution->executionOptions().dump_minmax = false;
 
    // save initial buffers if quantized model or compiled model is not loaded
    if (_autoCompilationState == Session::AutoCompilationState::INITIAL_STATE)
    {
      auto dotidx = _codegen_manager->exportModelPath().rfind('.');
      if (dotidx == std::string::npos)
      {
        setLastErrorMessage("Error during Session::run_with_auto_compilation : Invalid compiled "
                            "model path. Please use a path that includes the extension.");
        return NNFW_STATUS_ERROR;
      }
 
      std::string compiled_model_type =
        _codegen_manager->exportModelPath().substr(dotidx + 1); // + 1 to exclude dot
 
      dotidx = _quant_manager->exportModelPath().rfind('.');
      if (dotidx == std::string::npos)
      {
        setLastErrorMessage("Error during Session::run_with_auto_compilation : Invalid quantized "
                            "model path. Please use a path that includes the extension.");
        return NNFW_STATUS_ERROR;
      }
      std::string quantized_model_type =
        _quant_manager->exportModelPath().substr(dotidx + 1); // + 1 to exclude dot
 
      // Save initial (float) input and output buffers
      auto input_size = _execution->inputSize();
      auto output_size = _execution->outputSize();
 
      std::vector<const void *> _input_buffers;
      std::vector<void *> _output_buffers;
 
      using namespace onert::ir;
      // Copy execution context for backup: I/O buffer, shape, and execution options
      const onert::exec::ExecutionContext ctx_backup = _execution->context();
 
      // Set compile option to use float type
      for (auto input_index = IOIndex{0}; input_index < IOIndex{input_size}; input_index++)
        _coptions->input_type.insert_or_assign(IODesc{ModelIndex{0}, SubgraphIndex{0}, input_index},
                                               TypeInfo(DataType::FLOAT32));
 
      // Save Outputs buffers
      for (auto output_index = IOIndex{0}; output_index < IOIndex{output_size}; output_index++)
        _coptions->output_type.insert_or_assign(
          IODesc{ModelIndex{0}, SubgraphIndex{0}, output_index}, TypeInfo(DataType::FLOAT32));
 
      // if there is compiled model - try to load it
      if (file_compiled_model.good())
      {
        // load compiled model
        status = loadModelFile(_codegen_manager->exportModelPath(), compiled_model_type);
        if (status == NNFW_STATUS_NO_ERROR)
        {
          _autoCompilationState = Session::AutoCompilationState::COMPILED_MODEL_LOADED;
        }
      }
      else // there is no compiled model - try to compile and load it
      {
 
        // avoiding code duplication use existing "codegen" function. Set up _model_path for the
        // codegen function.
        // TODO: change it if codegen function will be generalized
        _model_path = _quant_manager->exportModelPath();
 
        // try to compile and load compiled model
        status = codegen(target, pref);
        if (status == NNFW_STATUS_NO_ERROR)
        {
          _autoCompilationState = Session::AutoCompilationState::COMPILED_MODEL_LOADED;
          // TODO delete quantized model
        }
      }
 
      // loading compiled model is fail - try to load quantized model
      if (_autoCompilationState != Session::AutoCompilationState::COMPILED_MODEL_LOADED)
      {
        // load quantized model
        status = loadModelFile(_quant_manager->exportModelPath(), quantized_model_type);
        if (status != NNFW_STATUS_NO_ERROR)
          return status;
        else
          _autoCompilationState = Session::AutoCompilationState::QUANTIZED_MODEL_LOADED;
      }
 
      status = prepare();
      if (status != NNFW_STATUS_NO_ERROR)
        return status;
 
      // Restore execution context: I/O buffer, shape, and execution options
      _execution->restoreContext(ctx_backup);
    }
 
    // Run quantized model
    if (!isStatePreparedOrFinishedRun())
    {
      setLastErrorMessage("Error during Session::run_with_auto_compilation : Run should be after "
                          "preparation");
      return NNFW_STATUS_INVALID_STATE;
    }
 
    try
    {
      _execution->execute();
    }
    catch (const onert::InsufficientBufferSizeException &e)
    {
      // Currently insufficient buffer always means output buffer.
      setLastErrorMessage("Error during Session::run_with_auto_compilation : " +
                          std::string(e.what()));
      return NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE;
    }
    catch (const std::exception &e)
    {
      setLastErrorMessage("Error during Session::run_with_auto_compilation : " +
                          std::string(e.what()));
      return NNFW_STATUS_ERROR;
    }
 
    _state = State::FINISHED_RUN;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE, NNFW_STATUS_INVALID_STATE, and onert::Exception::what().

set_available_backends()

NNFW_STATUS onert::api::Session::set_available_backends

(

const char *

backends

)

Definition at line 1018 of file Session.cc.

{
  if (!isStateModelLoaded())
  {
    setLastErrorMessage("Error during Session::set_available_backends : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (!backends)
  {
    setLastErrorMessage("Error during Session::set_available_backends : backends is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (null_terminating(backends, MAX_BACKEND_NAME_LENGTH) == false)
  {
    setLastErrorMessage("Error during Session::set_available_backends : backends is too long");
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    using namespace onert::util;
 
    _coptions->backend_list = nnfw::misc::split(std::string{backends}, ';');
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::set_available_backends : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References MAX_BACKEND_NAME_LENGTH, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, and nnfw::misc::split().

set_backends_per_operation()

NNFW_STATUS onert::api::Session::set_backends_per_operation

(

const char *

backend_settings

)

Set backends with string-encoded mapping from operation index to backend type (cpu, acl_cl)

Definition at line 1457 of file Session.cc.

{
  if (backend_settings == NULL)
  {
    setLastErrorMessage(
      "Error during Session::set_backends_per_operation : backend_settings is NULL");
    return NNFW_STATUS_ERROR;
  }
 
  if (!isStateModelLoaded())
  {
    setLastErrorMessage("Error during Session::set_backends_per_operation : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  // Not supported multiple model
  // TODO Support this
  if (_nnpkg->model_count() > 1)
  {
    setLastErrorMessage(
      "Error during Session::set_backends_per_operation : Multiple model is not supported");
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    // Backend for all
    auto &ms_options = _coptions->manual_scheduler_options;
    ms_options.setBackendMap(std::string{backend_settings});
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::set_backends_per_operation : " +
                        std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_codegen_model_path()

NNFW_STATUS onert::api::Session::set_codegen_model_path

(

const char *

path

)

Definition at line 2213 of file Session.cc.

{
  try
  {
    if (isStateInitialized() || isStateRunning())
    {
      setLastErrorMessage("Error during Session::set_codegen_model_path : Invalid state");
      return NNFW_STATUS_INVALID_STATE;
    }
 
    assert(_codegen_manager != nullptr);
    _codegen_manager->exportModelPath(std::string(path));
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::set_codegen_model_path : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_config()

NNFW_STATUS onert::api::Session::set_config	(	const char *	key,
		const char *	value
	)

Definition at line 1151 of file Session.cc.

{
  if (!isStateModelLoaded())
  {
    setLastErrorMessage("Error during Session::set_config : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (!key)
  {
    setLastErrorMessage("Error during Session::set_config : key is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
  if (!value)
  {
    setLastErrorMessage("Error during Session::set_config : value is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  using namespace onert::util;
 
  const std::string skey = key;
 
  if (skey == config::GRAPH_DOT_DUMP)
  {
    _coptions->graph_dump_level = toInt(value);
  }
  else if (skey == config::EXECUTOR)
  {
    _coptions->executor = value;
  }
  else if (skey == config::USE_SCHEDULER)
  {
    _coptions->he_scheduler = toBool(value);
  }
  else if (skey == config::PROFILING_MODE)
  {
    _coptions->he_profiling_mode = toBool(value);
  }
  else if (skey == config::ENABLE_LOG || skey == config::NUM_THREADS)
  {
    onert::util::CfgKeyValues keyValues;
    keyValues[skey] = std::string(value);
    onert::util::setConfigKeyValues(keyValues);
 
    if (skey == config::ENABLE_LOG)
    {
      UPDATE_VERBOSE_CONFIG();
    }
  }
  else
  {
    setLastErrorMessage("Error during Session::set_config : Unknown config key");
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, onert::util::setConfigKeyValues(), and UPDATE_VERBOSE_CONFIG.

set_execute_config()

NNFW_STATUS onert::api::Session::set_execute_config	(	const NNFW_RUN_CONFIG	key,
		const char *	value
	)

Definition at line 2336 of file Session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    setLastErrorMessage("Error during Session::set_execute_config : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  switch (key)
  {
    case NNFW_RUN_CONFIG_DUMP_MINMAX:
      if (_coptions->workspace_dir.empty())
        return NNFW_STATUS_ERROR;
      _execution->executionOptions().dump_minmax = true;
      break;
    case NNFW_RUN_CONFIG_TRACE:
      if (_coptions->workspace_dir.empty())
        return NNFW_STATUS_ERROR;
      _execution->executionOptions().trace = true;
      break;
    case NNFW_RUN_CONFIG_PROFILE:
      _execution->executionOptions().profile = true;
      break;
    default:
      setLastErrorMessage("Error during Session::set_execute_config : Invalid config key");
      return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_RUN_CONFIG_DUMP_MINMAX, NNFW_RUN_CONFIG_PROFILE, NNFW_RUN_CONFIG_TRACE, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_input()

NNFW_STATUS onert::api::Session::set_input	(	uint32_t	index,
		NNFW_TYPE	type,
		const void *	buffer,
		size_t	length
	)

Definition at line 537 of file Session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    setLastErrorMessage("Error during Session::set_input : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (!buffer && length != 0)
  {
    setLastErrorMessage("Error during Session::set_input : buffer is NULL but the length is not 0");
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    _execution->setInput(onert::ir::IOIndex(index), buffer, length);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::set_input : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_input_layout()

NNFW_STATUS onert::api::Session::set_input_layout	(	uint32_t	index,
		NNFW_LAYOUT	layout
	)

Definition at line 642 of file Session.cc.

{
  if (!isStateModelLoaded())
  {
    setLastErrorMessage("Error during Session::set_input_layout : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    if (layout != NNFW_LAYOUT_NONE && layout != NNFW_LAYOUT_CHANNELS_FIRST &&
        layout != NNFW_LAYOUT_CHANNELS_LAST)
    {
      setLastErrorMessage("Error during Session::set_input_layout : Not supported layout");
      return NNFW_STATUS_ERROR;
    }
 
    if (_selected_signature.valid())
    {
      // TODO Support this
      setLastErrorMessage("Error during Session::set_input_layout : set_input_layout after "
                          "signature selection is not supported yet");
      return NNFW_STATUS_ERROR;
    }
 
    const auto io_index = onert::ir::IOIndex{index};
    // Signature is supported on single model only
    assert(!_selected_signature.valid() || _nnpkg->model_count() != 1);
    const auto io_desc =
      _selected_signature.valid()
        ? onert::ir::IODesc{onert::ir::ModelIndex{0}, _selected_signature, io_index}
        : _nnpkg->input(io_index);
    // Insert if not exists, otherwise update the value
    _coptions->input_layout[io_desc] = convertLayout(layout);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::set_input_layout : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_LAYOUT_CHANNELS_FIRST, NNFW_LAYOUT_CHANNELS_LAST, NNFW_LAYOUT_NONE, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_input_tensorinfo()

NNFW_STATUS onert::api::Session::set_input_tensorinfo	(	uint32_t	index,
		const nnfw_tensorinfo *	ti
	)

Definition at line 817 of file Session.cc.

{
  // sanity check
  {
    if (isStateInitialized())
    {
      setLastErrorMessage("Error during Session::set_input_tensorinfo : Model is not loaded");
      return NNFW_STATUS_INVALID_STATE;
    }
 
    if (ti == nullptr)
    {
      setLastErrorMessage("Error during Session::set_input_tensorinfo : tensorinfo is NULL");
      return NNFW_STATUS_UNEXPECTED_NULL;
    }
 
    if (ti->rank < 0 || ti->rank > NNFW_MAX_RANK)
    {
      setLastErrorMessage("Error during Session::set_input_tensorinfo : Unsupported rank : " +
                          std::to_string(ti->rank));
      return NNFW_STATUS_ERROR;
    }
 
    for (int32_t i = 0; i < ti->rank; ++i)
    {
      if (ti->dims[i] <= 0)
      {
        setLastErrorMessage(
          "Error during Session::set_input_tensorinfo : dim must be positive integer but was " +
          std::to_string(ti->dims[i]));
        return NNFW_STATUS_ERROR;
      }
    }
  }
 
  onert::ir::Shape new_shape(ti->rank);
  for (int32_t i = 0; i < ti->rank; i++)
    new_shape.dim(i) = ti->dims[i];
 
  const auto input_index = onert::ir::IOIndex(index);
  if (!isStatePreparedOrFinishedRun())
  {
    // In this case, if we apply input shape, it will propagate after compilation and excution
    _selected_signature.valid() ? _nnpkg->changeInputShape(_selected_signature, index, new_shape)
                                : _nnpkg->changeInputShape(input_index, new_shape);
  }
  else // when called after Session::prepare()
    _execution->changeInputShape(input_index, new_shape);
 
  return NNFW_STATUS_NO_ERROR;
}

References nnfw_tensorinfo::dims, NNFW_MAX_RANK, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, and nnfw_tensorinfo::rank.

set_input_type()

NNFW_STATUS onert::api::Session::set_input_type	(	uint32_t	index,
		NNFW_TYPE	type
	)

Definition at line 729 of file Session.cc.

{
  if (!isStateModelLoaded())
  {
    setLastErrorMessage("Error during Session::set_input_type : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    if (type != NNFW_TYPE_TENSOR_FLOAT32)
    {
      setLastErrorMessage("Error during Session::set_input_type : Not supported type");
      return NNFW_STATUS_ERROR;
    }
 
    if (_selected_signature.valid())
    {
      // TODO Support this
      setLastErrorMessage("Error during Session::set_input_type : set_input_type after signature "
                          "selection is not supported yet");
      return NNFW_STATUS_ERROR;
    }
 
    const auto io_index = onert::ir::IOIndex{index};
    // Signature is supported on single model only
    assert(!_selected_signature.valid() || _nnpkg->model_count() != 1);
    const auto io_desc =
      _selected_signature.valid()
        ? onert::ir::IODesc{onert::ir::ModelIndex{0}, _selected_signature, io_index}
        : _nnpkg->input(io_index);
    // Insert if not exists, otherwise update the value
    _coptions->input_type.insert_or_assign(io_desc,
                                           onert::ir::TypeInfo(onert::ir::DataType::FLOAT32));
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::set_input_type : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_TYPE_TENSOR_FLOAT32, and type.

set_odc_param_minmax_records_count()

NNFW_STATUS onert::api::Session::set_odc_param_minmax_records_count

(

int

minmax_records_count

)

Definition at line 2382 of file Session.cc.

{
  if (isStateInitialized() || isStateRunning())
  {
    setLastErrorMessage("Error during Session::set_odc_param_minmax_records_count : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (_quant_manager->setMinMaxRecordsThreshold(minmax_records_count))
    return NNFW_STATUS_NO_ERROR;
 
  setLastErrorMessage(
    "Error during Session::set_odc_param_minmax_records_count : Could not set value");
  return NNFW_STATUS_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_output()

NNFW_STATUS onert::api::Session::set_output	(	uint32_t	index,
		NNFW_TYPE	type,
		void *	buffer,
		size_t	length
	)

Definition at line 563 of file Session.cc.

{
  if (!isStatePreparedOrFinishedRun())
  {
    setLastErrorMessage("Error during Session::set_output : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (!buffer && length != 0)
  {
    setLastErrorMessage(
      "Error during Session::set_output : buffer is NULL but the length is not 0");
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    _execution->setOutput(onert::ir::IOIndex(index), buffer, length);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::set_output : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_output_layout()

NNFW_STATUS onert::api::Session::set_output_layout	(	uint32_t	index,
		NNFW_LAYOUT	layout
	)

Definition at line 685 of file Session.cc.

{
  if (!isStateModelLoaded())
  {
    setLastErrorMessage("Error during Session::set_output_layout : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    if (layout != NNFW_LAYOUT_NONE && layout != NNFW_LAYOUT_CHANNELS_FIRST &&
        layout != NNFW_LAYOUT_CHANNELS_LAST)
    {
      setLastErrorMessage("Error during Session::set_output_layout : Not supported layout");
      return NNFW_STATUS_ERROR;
    }
 
    if (_selected_signature.valid())
    {
      // TODO Support this
      setLastErrorMessage("Error during Session::set_output_layout : set_output_layout after "
                          "signature selection is not supported yet");
      return NNFW_STATUS_ERROR;
    }
 
    const auto io_index = onert::ir::IOIndex{index};
    // Signature is supported on single model only
    assert(!_selected_signature.valid() || _nnpkg->model_count() != 1);
    const auto io_desc =
      _selected_signature.valid()
        ? onert::ir::IODesc{onert::ir::ModelIndex{0}, _selected_signature, io_index}
        : _nnpkg->output(io_index);
 
    // Insert if not exists, otherwise update the value
    _coptions->output_layout[io_desc] = convertLayout(layout);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::set_output_layout : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_LAYOUT_CHANNELS_FIRST, NNFW_LAYOUT_CHANNELS_LAST, NNFW_LAYOUT_NONE, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_output_type()

NNFW_STATUS onert::api::Session::set_output_type	(	uint32_t	index,
		NNFW_TYPE	type
	)

Definition at line 773 of file Session.cc.

{
  if (!isStateModelLoaded())
  {
    setLastErrorMessage("Error during Session::set_output_type : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    if (type != NNFW_TYPE_TENSOR_FLOAT32)
    {
      setLastErrorMessage("Error during Session::set_output_type : Not supported type");
      return NNFW_STATUS_ERROR;
    }
 
    if (_selected_signature.valid())
    {
      // TODO Support this
      setLastErrorMessage("Error during Session::set_output_type : set_output_type after signature "
                          "selection is not supported yet");
      return NNFW_STATUS_ERROR;
    }
 
    const auto io_index = onert::ir::IOIndex{index};
    // Signature is supported on single model only
    assert(!_selected_signature.valid() || _nnpkg->model_count() != 1);
    const auto io_desc =
      _selected_signature.valid()
        ? onert::ir::IODesc{onert::ir::ModelIndex{0}, _selected_signature, io_index}
        : _nnpkg->output(io_index);
    // Insert if not exists, otherwise update the value
    _coptions->output_type.insert_or_assign(io_desc,
                                            onert::ir::TypeInfo(onert::ir::DataType::FLOAT32));
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::set_output_type : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_TYPE_TENSOR_FLOAT32, and type.

set_prepare_config()

NNFW_STATUS onert::api::Session::set_prepare_config	(	const NNFW_PREPARE_CONFIG	key,
		const char *	value
	)

Definition at line 2299 of file Session.cc.

{
  if (!isStateModelLoaded())
  {
    setLastErrorMessage("Error during Session::set_prepare_config : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  switch (key)
  {
    case NNFW_PREPARE_CONFIG_PROFILE:
      _coptions->he_profiling_mode = true;
      break;
    case NNFW_ENABLE_INTERNAL_OUTPUT_ALLOC:
      _coptions->internal_output_alloc = true;
      break;
    default:
      setLastErrorMessage("Error during Session::set_prepare_config : Invalid config key");
      return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_ENABLE_INTERNAL_OUTPUT_ALLOC, NNFW_PREPARE_CONFIG_PROFILE, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_quantization_type()

NNFW_STATUS onert::api::Session::set_quantization_type

(

NNFW_QUANTIZE_TYPE

qtype

)

Definition at line 2121 of file Session.cc.

{
  using onert::odc::QuantizeType;
  try
  {
    if (isStateInitialized() || isStateRunning())
    {
      setLastErrorMessage("Error during Session::set_quantization_type : Invalid state");
      return NNFW_STATUS_INVALID_STATE;
    }
 
    QuantizeType odc_qtype = onert::odc::ODC_QTYPE_NOT_SET;
    switch (qtype)
    {
      case NNFW_QUANTIZE_TYPE_U8_ASYM:
        odc_qtype = onert::odc::ODC_QTYPE_U8_ASYM;
        break;
      case NNFW_QUANTIZE_TYPE_I16_SYM:
        odc_qtype = onert::odc::ODC_QTYPE_I16_SYM;
        break;
      case NNFW_QUANTIZE_TYPE_WO_I8_SYM:
        odc_qtype = onert::odc::ODC_QTYPE_WO_I8_SYM;
        break;
      case NNFW_QUANTIZE_TYPE_WO_I16_SYM:
        odc_qtype = onert::odc::ODC_QTYPE_WO_I16_SYM;
        break;
      default:
        setLastErrorMessage(
          "Error during Session::set_quantization_type : Invalid quantization type");
        return NNFW_STATUS_INVALID_STATE;
    }
    _quant_manager->quantizeType(odc_qtype);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::set_quantization_type : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_QUANTIZE_TYPE_I16_SYM, NNFW_QUANTIZE_TYPE_U8_ASYM, NNFW_QUANTIZE_TYPE_WO_I16_SYM, NNFW_QUANTIZE_TYPE_WO_I8_SYM, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, onert::odc::ODC_QTYPE_I16_SYM, onert::odc::ODC_QTYPE_NOT_SET, onert::odc::ODC_QTYPE_U8_ASYM, onert::odc::ODC_QTYPE_WO_I16_SYM, and onert::odc::ODC_QTYPE_WO_I8_SYM.

set_quantized_model_path()

NNFW_STATUS onert::api::Session::set_quantized_model_path

(

const char *

path

)

Definition at line 2163 of file Session.cc.

{
  try
  {
    if (isStateInitialized() || isStateRunning())
    {
      setLastErrorMessage("Error during Session::set_quantized_model_path : Invalid state");
      return NNFW_STATUS_INVALID_STATE;
    }
 
    _quant_manager->exportModelPath(std::string(path));
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::set_quantized_model_path : " +
                        std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

set_signature_run()

NNFW_STATUS onert::api::Session::set_signature_run

(

const char *

signature

)

Definition at line 1102 of file Session.cc.

{
  if (!signature)
  {
    setLastErrorMessage("Error during Session::set_signature_run : signature is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!isStatePreparedOrFinishedRun())
  {
    setLastErrorMessage("Error during Session::set_signature_run : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  for (const auto &[subg_idx, sig_str] : _signature_map)
  {
    if (sig_str == std::string(signature))
    {
      _execution =
        std::make_unique<onert::exec::Execution>(_compiler_artifact->_executors, subg_idx);
      return NNFW_STATUS_NO_ERROR;
    }
  }
 
  setLastErrorMessage("Error during Session::set_signature_run : Cannot find signature \"" +
                      std::string(signature) + "\"");
  return NNFW_STATUS_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

set_workspace()

NNFW_STATUS onert::api::Session::set_workspace

(

const char *

dir

)

Definition at line 1052 of file Session.cc.

{
  // TODO Check dir read & write permission
 
  if (!dir)
  {
    setLastErrorMessage("Error during Session::set_workspace : dir is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!isStateInitialized())
  {
    setLastErrorMessage("Error during Session::set_workspace : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  _coptions->workspace_dir = std::string(dir);
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

train_expected_tensorinfo()

NNFW_STATUS onert::api::Session::train_expected_tensorinfo	(	uint32_t	index,
		nnfw_tensorinfo *	ti
	)

Definition at line 1774 of file Session.cc.

{
  if (!isStatePreparedOrFinishedTraining())
  {
    setLastErrorMessage("Error during Session::train_expected_tensorinfo : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  // Check index is valid: [0, getExpectedSize())
 
  // NYI
  (void)index;
  (void)ti;
  setLastErrorMessage("Error during Session::train_expected_tensorinfo : Not implemented yet");
  return NNFW_STATUS_ERROR;
}

References NNFW_STATUS_ERROR, and NNFW_STATUS_INVALID_STATE.

train_export_checkpoint()

NNFW_STATUS onert::api::Session::train_export_checkpoint

(

const char *

path

)

Definition at line 2064 of file Session.cc.

{
  if (path == nullptr)
  {
    setLastErrorMessage("Error during Session::train_export_checkpoint : path is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  // Check training mode is enabled
  if (!isStateFinishedTraining())
  {
    setLastErrorMessage("Error during Session::train_export_checkpoint : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    onert::exporter::train::exportCheckpoint(path, _train_info, _execution);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::train_export_checkpoint : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References onert::exporter::train::exportCheckpoint(), NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

train_export_circle()

NNFW_STATUS onert::api::Session::train_export_circle

(

const char *

path

)

Definition at line 1979 of file Session.cc.

{
  if (path == nullptr)
  {
    setLastErrorMessage("Error during Session::train_export_circle : path is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  // Check training mode is enabled
  if (!isStateFinishedTraining())
  {
    setLastErrorMessage("Error during Session::train_export_circle : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    onert::exporter::CircleExporter exporter(_model_path.string(), std::string{path});
    exporter.updateWeight(_execution);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::train_export_circle : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, and onert::exporter::CircleExporter::updateWeight().

train_export_circleplus()

NNFW_STATUS onert::api::Session::train_export_circleplus

(

const char *

path

)

Definition at line 2008 of file Session.cc.

{
  if (path == nullptr)
  {
    setLastErrorMessage("Error during Session::train_export_circleplus : path is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!isStatePreparedOrFinishedTraining())
  {
    setLastErrorMessage("Error during Session::train_export_circleplus : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    onert::exporter::CircleExporter exporter(_model_path.string(), std::string{path});
    exporter.updateWeight(_execution);
    exporter.updateMetadata(_train_info);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::train_export_circleplus : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, onert::exporter::CircleExporter::updateMetadata(), and onert::exporter::CircleExporter::updateWeight().

train_get_loss()

NNFW_STATUS onert::api::Session::train_get_loss	(	uint32_t	index,
		float *	loss
	)

Definition at line 1945 of file Session.cc.

{
  if (loss == nullptr)
  {
    setLastErrorMessage("Error during Session::train_get_loss : loss is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!isStateFinishedTraining())
  {
    setLastErrorMessage("Error during Session::train_get_loss : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (index >= getOutputSize())
  {
    setLastErrorMessage("Error during Session::train_get_loss : index is out of range");
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    auto ind = onert::ir::IOIndex(index);
    *loss = _execution->getLoss(ind);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::train_get_loss : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

train_get_traininfo()

NNFW_STATUS onert::api::Session::train_get_traininfo

(

nnfw_train_info *

info

)

Definition at line 1497 of file Session.cc.

{
  if (isStateInitialized())
  {
    // There is no _train_info in INITIALIZED, since _train_info is set when a model loaded
    setLastErrorMessage("Error during Session::train_get_traininfo : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (info == nullptr)
  {
    setLastErrorMessage("Error during Session::train_get_traininfo : info is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  // after model loaded, it ensures that _train_info is not nullptr
  assert(_train_info != nullptr);
 
  auto convertLossCode = [](const onert::ir::train::LossCode &code) -> NNFW_TRAIN_LOSS {
    switch (code)
    {
      case onert::ir::train::LossCode::Undefined:
        return NNFW_TRAIN_LOSS_UNDEFINED;
      case onert::ir::train::LossCode::MeanSquaredError:
        return NNFW_TRAIN_LOSS_MEAN_SQUARED_ERROR;
      case onert::ir::train::LossCode::CategoricalCrossentropy:
        return NNFW_TRAIN_LOSS_CATEGORICAL_CROSSENTROPY;
      default:
        throw std::runtime_error{"fail to convert ir::train::LossCode"};
    }
  };
 
  auto convertLossReduction =
    [](const onert::ir::train::LossReductionType &type) -> NNFW_TRAIN_LOSS_REDUCTION {
    switch (type)
    {
      case onert::ir::train::LossReductionType::Undefined:
        return NNFW_TRAIN_LOSS_REDUCTION_UNDEFINED;
      case onert::ir::train::LossReductionType::SumOverBatchSize:
        return NNFW_TRAIN_LOSS_REDUCTION_SUM_OVER_BATCH_SIZE;
      case onert::ir::train::LossReductionType::Sum:
        return NNFW_TRAIN_LOSS_REDUCTION_SUM;
      default:
        throw std::runtime_error{"fail to convert from ir::train::LossReductionType"};
        break;
    }
  };
 
  auto convertOptimizerCode =
    [](const onert::ir::train::OptimizerCode &code) -> NNFW_TRAIN_OPTIMIZER {
    switch (code)
    {
      case onert::ir::train::OptimizerCode::Undefined:
        return NNFW_TRAIN_OPTIMIZER_UNDEFINED;
      case onert::ir::train::OptimizerCode::SGD:
        return NNFW_TRAIN_OPTIMIZER_SGD;
      case onert::ir::train::OptimizerCode::Adam:
        return NNFW_TRAIN_OPTIMIZER_ADAM;
      default:
        throw std::runtime_error{"fail to convert from ir::train::OptimizerCode"};
    }
  };
 
  const auto &loss = _train_info->lossInfo();
  const auto &optim = _train_info->optimizerInfo();
 
  try
  {
    info->learning_rate = optim.learning_rate;
    info->batch_size = _train_info->batchSize();
    info->loss_info.loss = convertLossCode(loss.loss_code);
    info->loss_info.reduction_type = convertLossReduction(loss.reduction_type);
    info->opt = convertOptimizerCode(optim.optim_code);
 
    if (_train_info->getTrainableOps().size() > 0)
    {
      const uint32_t first_trainable_idx = _train_info->getTrainableOps().cbegin()->value();
      const uint32_t last_trainable_idx = _train_info->getTrainableOps().crbegin()->value();
      const uint32_t ops_size = primary_subgraph()->operations().size();
      const uint32_t trainable_indexes_range = last_trainable_idx - first_trainable_idx + 1;
 
      // check if trainable ops set contains continuous indexes on the back of the set
      if (last_trainable_idx == ops_size - 1 &&
          trainable_indexes_range == _train_info->getTrainableOps().size())
      {
        // check if all ops are trainable
        if (0 == first_trainable_idx)
        {
          info->num_of_trainable_ops = NNFW_TRAIN_TRAINABLE_ALL;
        }
        else
        {
          info->num_of_trainable_ops = trainable_indexes_range;
        }
      }
      else
      {
        info->num_of_trainable_ops = NNFW_TRAIN_TRAINABLE_INCORRECT_STATE;
        setLastErrorMessage("Error during Session::train_get_traininfo : Conversion from set of "
                            "trainable ops to num_of_trainable_ops is impossible");
        return NNFW_STATUS_INVALID_STATE;
      }
    }
    else
    {
      // no layer will be trained
      info->num_of_trainable_ops = NNFW_TRAIN_TRAINABLE_NONE;
    }
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::train_get_traininfo : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References onert::ir::train::Adam, onert::ir::train::CategoricalCrossentropy, info, onert::ir::train::MeanSquaredError, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, NNFW_TRAIN_LOSS_CATEGORICAL_CROSSENTROPY, NNFW_TRAIN_LOSS_MEAN_SQUARED_ERROR, NNFW_TRAIN_LOSS_REDUCTION_SUM, NNFW_TRAIN_LOSS_REDUCTION_SUM_OVER_BATCH_SIZE, NNFW_TRAIN_LOSS_REDUCTION_UNDEFINED, NNFW_TRAIN_LOSS_UNDEFINED, NNFW_TRAIN_OPTIMIZER_ADAM, NNFW_TRAIN_OPTIMIZER_SGD, NNFW_TRAIN_OPTIMIZER_UNDEFINED, NNFW_TRAIN_TRAINABLE_ALL, NNFW_TRAIN_TRAINABLE_INCORRECT_STATE, NNFW_TRAIN_TRAINABLE_NONE, onert::ir::train::SGD, onert::ir::train::Sum, onert::ir::train::SumOverBatchSize, type, and onert::ir::train::Undefined.

train_import_checkpoint()

NNFW_STATUS onert::api::Session::train_import_checkpoint

(

const char *

path

)

Definition at line 2037 of file Session.cc.

{
  if (path == nullptr)
  {
    setLastErrorMessage("Error during Session::train_import_checkpoint : path is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!isStatePreparedOrFinishedTraining())
  {
    setLastErrorMessage("Error during Session::train_import_checkpoint : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    onert::loader::train::loadCheckpoint(path, _train_info, _execution);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::train_import_checkpoint : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References onert::loader::train::loadCheckpoint(), NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and NNFW_STATUS_UNEXPECTED_NULL.

train_input_tensorinfo()

NNFW_STATUS onert::api::Session::train_input_tensorinfo	(	uint32_t	index,
		nnfw_tensorinfo *	ti
	)

Definition at line 1757 of file Session.cc.

{
  if (!isStatePreparedOrFinishedTraining())
  {
    setLastErrorMessage("Error during Session::train_input_tensorinfo : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  // Check index is valid: [0, getInputSize())
 
  // NYI
  (void)index;
  (void)ti;
  setLastErrorMessage("Error during Session::train_input_tensorinfo : Not implemented yet");
  return NNFW_STATUS_ERROR;
}

References NNFW_STATUS_ERROR, and NNFW_STATUS_INVALID_STATE.

train_prepare()

NNFW_STATUS onert::api::Session::train_prepare

(

)

Definition at line 1719 of file Session.cc.

{
  // We may need different state to represent training model is loaded
  if (!isStateModelLoaded())
  {
    if (_state == State::PREPARED_TRAINING)
      setLastErrorMessage("Error during Session::train_prepare : Training is already prepared");
    else
      setLastErrorMessage("Error during Session::train_prepare : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  // after model loaded, it ensures that _train_info is not nullptr
  assert(_train_info != nullptr);
 
  try
  {
    if (not _train_info->isValid())
      throw std::runtime_error{"training info is not valid"};
 
    // initialize trainingStep count
    _train_info->trainingStep() = 0;
 
    auto compiler = onert::compiler::CompilerFactory::get().create(
      std::move(_nnpkg), _coptions.get(), _train_info.get());
    _compiler_artifact = compiler->compile();
    _execution = std::make_unique<onert::exec::Execution>(_compiler_artifact->_executors);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::train_prepare : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  _state = State::PREPARED_TRAINING;
  return NNFW_STATUS_NO_ERROR;
}

References onert::compiler::CompilerFactory::create(), onert::compiler::CompilerFactory::get(), NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

train_run()

NNFW_STATUS onert::api::Session::train_run

(

bool

update_weights

)

Definition at line 1911 of file Session.cc.

{
  if (!isStatePreparedOrFinishedTraining())
  {
    setLastErrorMessage("Error during Session::train_run : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  try
  {
    if (update_weights)
    {
      auto &training_step = _train_info->trainingStep();
      _execution->train(training_step++);
    }
    else
      _execution->execute();
  }
  catch (const onert::InsufficientBufferSizeException &e)
  {
    // Currently insufficient buffer always means output buffer.
    setLastErrorMessage("Error during Session::train_run : " + std::string(e.what()));
    return NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE;
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::train_run : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  _state = State::FINISHED_TRAINING;
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, and onert::Exception::what().

train_set_expected()

NNFW_STATUS onert::api::Session::train_set_expected	(	uint32_t	index,
		const void *	expected,
		const nnfw_tensorinfo *	expected_tensorinfo
	)

Definition at line 1834 of file Session.cc.

{
  if (expected == nullptr)
  {
    setLastErrorMessage("Error during Session::train_set_expected : expected is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!isStatePreparedOrFinishedTraining())
  {
    setLastErrorMessage("Error during Session::train_set_expected : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (index >= getOutputSize())
  {
    setLastErrorMessage("Error during Session::train_set_expected : index is out of range");
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    const auto ind = onert::ir::IOIndex{index};
    auto size = _execution->outputInfo(ind).total_size();
    if (expected_tensorinfo && getBufSize(expected_tensorinfo) != size)
    {
      setLastErrorMessage(
        "Error during Session::train_set_expected : Changing tensorinfo is not supported");
      return NNFW_STATUS_ERROR;
    }
 
    // NOTE Find the loss input index
    // Input is added as many as the number of outputs.
    // The loss index is calculated from the value obtained by subtracting the
    // total output(added loss input) from the total input size.
    auto input_index = getInputSize() - getOutputSize() + index;
    auto input_ind = onert::ir::IOIndex(input_index);
    _execution->setInput(input_ind, expected, size);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::train_set_expected : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, and size.

train_set_input()

NNFW_STATUS onert::api::Session::train_set_input	(	uint32_t	index,
		const void *	input,
		const nnfw_tensorinfo *	input_tensorinfo
	)

Definition at line 1791 of file Session.cc.

{
  if (input == nullptr)
  {
    setLastErrorMessage("Error during Session::train_set_input : input is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  if (!isStatePreparedOrFinishedTraining())
  {
    setLastErrorMessage("Error during Session::train_set_input : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (index >= getInputSize())
  {
    setLastErrorMessage("Error during Session::train_set_input : index is out of range");
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    auto ind = onert::ir::IOIndex(index);
    auto size = _execution->inputInfo(ind).total_size();
    if (input_tensorinfo && getBufSize(input_tensorinfo) != size)
    {
      setLastErrorMessage(
        "Error during Session::train_set_input : Changing tensorinfo is not supported");
      return NNFW_STATUS_ERROR;
    }
 
    _execution->setInput(ind, input, size);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::train_set_input : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, and size.

train_set_output()

NNFW_STATUS onert::api::Session::train_set_output	(	uint32_t	index,
		NNFW_TYPE	type,
		void *	buffer,
		size_t	length
	)

Definition at line 1883 of file Session.cc.

{
  if (!isStatePreparedOrFinishedTraining())
  {
    setLastErrorMessage("Error during Session::train_set_output : Invalid state");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (!buffer && length != 0)
  {
    setLastErrorMessage(
      "Error during Session::train_set_output : buffer is NULL but the length is not 0");
    return NNFW_STATUS_ERROR;
  }
 
  try
  {
    _execution->setOutput(onert::ir::IOIndex(index), buffer, length);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::train_set_output : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
  return NNFW_STATUS_NO_ERROR;
}

References NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, and NNFW_STATUS_NO_ERROR.

train_set_traininfo()

NNFW_STATUS onert::api::Session::train_set_traininfo

(

const nnfw_train_info *

info

)

Definition at line 1615 of file Session.cc.

{
  if (!isStateModelLoaded())
  {
    setLastErrorMessage("Error during Session::train_set_traininfo : Model is not loaded");
    return NNFW_STATUS_INVALID_STATE;
  }
 
  if (info == nullptr)
  {
    setLastErrorMessage("Error during Session::train_set_traininfo : info is NULL");
    return NNFW_STATUS_UNEXPECTED_NULL;
  }
 
  // after model loaded, it ensures that _train_info is not nullptr
  assert(_train_info != nullptr);
 
  auto convertLossType = [](const int &type) {
    if (type == NNFW_TRAIN_LOSS_MEAN_SQUARED_ERROR)
      return onert::ir::train::LossCode::MeanSquaredError;
    else if (type == NNFW_TRAIN_LOSS_CATEGORICAL_CROSSENTROPY)
      return onert::ir::train::LossCode::CategoricalCrossentropy;
    else
      throw std::runtime_error("not supported loss type");
  };
 
  auto convertLossReductionType = [](const int &type) {
    if (type == NNFW_TRAIN_LOSS_REDUCTION_SUM_OVER_BATCH_SIZE)
      return onert::ir::train::LossReductionType::SumOverBatchSize;
    else if (type == NNFW_TRAIN_LOSS_REDUCTION_SUM)
      return onert::ir::train::LossReductionType::Sum;
    else
      throw std::runtime_error("not supported loss reduction type");
  };
 
  auto convertOptType = [](const int &type) {
    if (type == NNFW_TRAIN_OPTIMIZER_SGD)
      return onert::ir::train::OptimizerCode::SGD;
    else if (type == NNFW_TRAIN_OPTIMIZER_ADAM)
      return onert::ir::train::OptimizerCode::Adam;
    else
      throw std::runtime_error("not supported optimizer type");
  };
 
  try
  {
    onert::ir::train::LossInfo loss_info;
    loss_info.loss_code = convertLossType(info->loss_info.loss);
    loss_info.reduction_type = convertLossReductionType(info->loss_info.reduction_type);
 
    onert::ir::train::OptimizerInfo opt_info;
    opt_info.learning_rate = info->learning_rate;
    opt_info.optim_code = convertOptType(info->opt);
 
    _train_info->setBatchSize(info->batch_size);
    _train_info->setLossInfo(loss_info);
    _train_info->setOptimizerInfo(opt_info);
 
    if (info->num_of_trainable_ops < -1)
    {
      setLastErrorMessage(
        "Error during Session::train_set_traininfo : Provided num_of_trainable_ops "
        "has incorrect value : " +
        std::to_string(info->num_of_trainable_ops));
      return NNFW_STATUS_ERROR;
    }
 
    const uint32_t ops_size = primary_subgraph()->operations().size();
    std::set<onert::ir::OperationIndex> trainable_ops;
 
    if (NNFW_TRAIN_TRAINABLE_ALL == info->num_of_trainable_ops)
    {
      for (uint32_t idx = 0; idx < ops_size; ++idx)
      {
        trainable_ops.emplace(idx);
      }
    }
    else
    {
      if (static_cast<uint32_t>(info->num_of_trainable_ops) > ops_size)
      {
        setLastErrorMessage(
          "Error during Session::train_set_traininfo : Provided num_of_trainable_ops "
          "is out of operators range : " +
          std::to_string(info->num_of_trainable_ops) + " > " + std::to_string(ops_size));
        return NNFW_STATUS_ERROR;
      }
      for (uint32_t i = 1; i <= static_cast<uint32_t>(info->num_of_trainable_ops); ++i)
      {
        trainable_ops.emplace(ops_size - i);
      }
    }
    // Note that possible setting an empty trainable_ops set (for NNFW_TRAIN_TRAINABLE_NONE value)
    _train_info->setTrainableOps(trainable_ops);
  }
  catch (const std::exception &e)
  {
    setLastErrorMessage("Error during Session::train_set_traininfo : " + std::string(e.what()));
    return NNFW_STATUS_ERROR;
  }
 
  return NNFW_STATUS_NO_ERROR;
}

References onert::ir::train::Adam, onert::ir::train::CategoricalCrossentropy, info, onert::ir::train::OptimizerInfo::learning_rate, onert::ir::train::LossInfo::loss_code, onert::ir::train::MeanSquaredError, NNFW_STATUS_ERROR, NNFW_STATUS_INVALID_STATE, NNFW_STATUS_NO_ERROR, NNFW_STATUS_UNEXPECTED_NULL, NNFW_TRAIN_LOSS_CATEGORICAL_CROSSENTROPY, NNFW_TRAIN_LOSS_MEAN_SQUARED_ERROR, NNFW_TRAIN_LOSS_REDUCTION_SUM, NNFW_TRAIN_LOSS_REDUCTION_SUM_OVER_BATCH_SIZE, NNFW_TRAIN_OPTIMIZER_ADAM, NNFW_TRAIN_OPTIMIZER_SGD, NNFW_TRAIN_TRAINABLE_ALL, onert::ir::train::OptimizerInfo::optim_code, onert::ir::train::LossInfo::reduction_type, onert::ir::train::SGD, onert::ir::train::Sum, onert::ir::train::SumOverBatchSize, and type.

---

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

• runtime/onert/api/nnfw/src/Session.h
• runtime/onert/api/nnfw/src/Session.cc