prunner::PModelsRunner Class Reference

PModelsRunner runs partitioned models from input data file and stores output data to a file. More...

#include <PModelsRunner.h>

Public Member Functions
	PModelsRunner ()=default
bool	load_config (const std::string &filename)
void	load_inputs (const std::string &input_prefix, int32_t num_inputs)
bool	run (void)
void	save_outputs (const std::string &output_file)

Detailed Description

PModelsRunner runs partitioned models from input data file and stores output data to a file.

Definition at line 41 of file PModelsRunner.h.

Constructor & Destructor Documentation

PModelsRunner()

prunner::PModelsRunner::PModelsRunner ( )

default

Member Function Documentation

load_config()

bool prunner::PModelsRunner::load_config

(

const std::string &

filename

)

Definition at line 92 of file PModelsRunner.cpp.

{
  if (!crew::read_ini(filename, _pconfig))
  {
    std::cerr << "ERROR: Invalid config ini file: '" << filename << "'" << std::endl;
    return false;
  }
 
  for (auto &part : _pconfig.parts)
  {
    _models_to_run.push_back(part.model_file);
  }
  return true;
}

References crew::PConfig::parts, and crew::read_ini().

Referenced by entry().

load_inputs()

void prunner::PModelsRunner::load_inputs	(	const std::string &	input_prefix,
		int32_t	num_inputs
	)

Definition at line 107 of file PModelsRunner.cpp.

{
  LOGGER(l);
 
  auto its = _pconfig.source.inputs.begin();
  for (int32_t i = 0; i < num_inputs; ++i, ++its)
  {
    std::string filename = input_prefix + std::to_string(i);
 
    INFO(l) << "Load input data: " << filename << std::endl;
    foder::FileLoader file_loader{filename};
 
    std::string input_name = *its;
    _data_stage[input_name] = file_loader.load();
 
    INFO(l) << "Input: [" << input_name << "], size " << _data_stage[input_name].size()
            << std::endl;
  }
}

References INFO, crew::Part::inputs, LOGGER, and crew::PConfig::source.

Referenced by entry().

run()

bool prunner::PModelsRunner::run

(

void

)

Definition at line 147 of file PModelsRunner.cpp.

{
  LOGGER(l);
 
  // for each partitioned model, if the inputs of the model are ready, run the model
  do
  {
    bool found_model = false;
 
    for (auto it = _models_to_run.begin(); it != _models_to_run.end(); ++it)
    {
      auto model_fname = *it;
 
      INFO(l) << "Check model input ready: " << model_fname << std::endl;
      if (is_input_ready(model_fname))
      {
        found_model = true;
 
        INFO(l) << "Run model: " << model_fname << std::endl;
        auto module = import_circle(model_fname);
 
        luci_interpreter::Interpreter interpreter(module.get());
 
        // Set input
        const auto input_nodes = loco::input_nodes(module->graph());
        int32_t num_inputs = static_cast<int32_t>(input_nodes.size());
        for (int32_t i = 0; i < num_inputs; i++)
        {
          const auto *input_node = loco::must_cast<const luci::CircleInput *>(input_nodes[i]);
 
          auto input_name = input_node->name();
          assert(_data_stage.find(input_name) != _data_stage.end());
 
          auto input_data = _data_stage[input_name];
 
          interpreter.writeInputTensor(input_node, input_data.data(), input_data.size());
        }
 
        // Run interpreter
        interpreter.interpret();
        INFO(l) << "Run model: " << model_fname << " done" << std::endl;
 
        // Get output.
        const auto output_nodes = loco::output_nodes(module->graph());
        for (uint32_t i = 0; i < module->graph()->outputs()->size(); i++)
        {
          const auto *output_node = loco::must_cast<const luci::CircleOutput *>(output_nodes[i]);
          auto output_name = output_node->name();
 
          Buffer output_data(tensor_size(output_node));
 
          interpreter.readOutputTensor(output_node, output_data.data(), output_data.size());
 
          // There should not exist same output names
          // TODO check with multiple virtual outputs
          assert(_data_stage.find(output_name) == _data_stage.end());
          _data_stage[output_name] = output_data;
        }
 
        // We've ran this model, remove from the model list
        _models_to_run.erase(it);
        break;
      }
    }
 
    if (not found_model)
    {
      std::cerr << "ERROR: model partition or configuration has problems" << std::endl;
      return false;
    }
  } while (not _models_to_run.empty());
 
  return true;
}

References INFO, loco::input_nodes(), LOGGER, luci::CircleNode::name(), and loco::output_nodes().

Referenced by entry(), and package.infer.session::inference().

save_outputs()

void prunner::PModelsRunner::save_outputs

(

const std::string &

output_file

)

Definition at line 222 of file PModelsRunner.cpp.

{
  LOGGER(l);
 
  // load source model as we need to get both shape and node name
  // TODO check for unknown shape
  auto source_fname = _pconfig.source.model_file;
 
  INFO(l) << "save_outputs() loading file: " << source_fname << std::endl;
  auto module = import_circle(source_fname);
 
  const auto output_nodes = loco::output_nodes(module->graph());
  for (uint32_t i = 0; i < module->graph()->outputs()->size(); i++)
  {
    const auto *output_node = loco::must_cast<const luci::CircleOutput *>(output_nodes[i]);
 
    auto output_name = output_node->name();
    INFO(l) << "save_outputs() save output node: " << output_name << std::endl;
    assert(_data_stage.find(output_name) != _data_stage.end());
 
    auto tensor_data = _data_stage[output_name];
    auto output_filename = output_file + std::to_string(i);
 
    write_file(output_filename, tensor_data.data(), tensor_data.size());
    save_shape(output_filename + ".shape", output_node);
  }
}

References INFO, LOGGER, crew::Part::model_file, luci::CircleNode::name(), loco::output_nodes(), and crew::PConfig::source.

Referenced by entry().

---

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

• compiler/circle-part-driver/src/PModelsRunner.h
• compiler/circle-part-driver/src/PModelsRunner.cpp