Driver.cpp File Reference

#include "OMInterpreter.h"
#include "arser/arser.h"
#include <stdexcept>
#include <cstdlib>
#include <fstream>
#include <vector>
#include <string>
#include <iostream>
#include <random>

Go to the source code of this file.

Functions
int	entry (int argc, char **argv)
	Dump IR for given arguments.
int	main (int argc, char **argv)

Function Documentation

entry()

int entry	(	int	argc,
		char **	argv
	)

Dump IR for given arguments.

Call example: $ ./build/compiler/encodump/encodump \ –frontend build/compiler/enco/frontend/caffe/libenco_caffe_frontend.so \ –frontend-arg build/compiler/enco/test/caffe/Convolution_003.prototxt \ –frontend-arg build/compiler/enco/test/caffe/Convolution_003.caffemodel

HDF5 layout is like below

GROUP "/" ㄴGROUP "name" ㄴATTRIBUTE "0" ㄴDATA (0): "input_01:0" ㄴATTRIBUTE "1" ㄴDATA (0): "input_02:0" ㄴGROUP "value" ㄴDATASET "0" ㄴDATA ... ㄴDATASET "1" ㄴDATA ...

Definition at line 70 of file Driver.cpp.

{
  // Parse command line arguments using arser
  arser::Arser arser;
  arser.add_argument("--model")
    .type(arser::DataType::STR)
    .required(true)
    .help("Path to model.circle file");
  arser.add_argument("--input_prefix")
    .type(arser::DataType::STR)
    .help("Prefix for input files (generates random inputs if not provided)");
  arser.add_argument("--output_prefix").type(arser::DataType::STR).help("Prefix for output files");
 
  try
  {
    arser.parse(argc, argv);
  }
  catch (const std::runtime_error &err)
  {
    std::cerr << err.what() << std::endl;
    std::cerr << arser;
    return EXIT_FAILURE;
  }
 
  const auto filename = arser.get<std::string>("--model");
  std::string input_prefix;
  std::string output_prefix;
 
  if (arser["--input_prefix"])
  {
    input_prefix = arser.get<std::string>("--input_prefix");
  }
  if (arser["--output_prefix"])
  {
    output_prefix = arser.get<std::string>("--output_prefix");
  }
  const bool auto_input = !arser["--input_prefix"];
  int32_t num_inputs = 1; // Default number of inputs
 
  std::ifstream file(filename, std::ios::binary | std::ios::in);
  if (!file.good())
  {
    std::string errmsg = "Failed to open file";
    throw std::runtime_error(errmsg.c_str());
  }
 
  file.seekg(0, std::ios::end);
  auto fileSize = file.tellg();
  file.seekg(0, std::ios::beg);
 
  // reserve capacity
  DataBuffer model_data(fileSize);
 
  // read the data
  file.read(model_data.data(), fileSize);
  if (file.fail())
  {
    std::string errmsg = "Failed to read file";
    throw std::runtime_error(errmsg.c_str());
  }
 
  // Create interpreter.
  onert_micro::OMInterpreter interpreter;
  onert_micro::OMConfig config;
  interpreter.importModel(model_data.data(), config);
 
  num_inputs = interpreter.getNumberOfInputs(); // To initialize input buffers
 
  // Set input.
  // Data for n'th input is read from ${input_prefix}n
  // (ex: Add.circle.input0, Add.circle.input1 ..)
  int num_inference = 1;
  for (int j = 0; j < num_inference; ++j)
  {
    interpreter.reset();
    interpreter.allocateInputs();
    for (int32_t i = 0; i < num_inputs; i++)
    {
      auto input_data = reinterpret_cast<char *>(interpreter.getInputDataAt(i));
      size_t input_size = interpreter.getInputSizeAt(i);
 
      if (auto_input)
      {
        generateRandomData(input_data, input_size);
      }
      else
      {
        readDataFromFile(input_prefix + std::to_string(i), input_data, input_size);
      }
    }
 
    // Do inference.
    interpreter.run(config);
  }
 
  // Get output.
  int num_outputs = 1;
  for (int i = 0; i < num_outputs; i++)
  {
    auto data = interpreter.getOutputDataAt(i);
    size_t output_size = interpreter.getOutputSizeAt(i);
 
    if (arser["--output_prefix"])
    {
      writeDataToFile(output_prefix + std::to_string(i), reinterpret_cast<char *>(data),
                      output_size);
    }
    // Otherwise, output remains in interpreter memory
  }
  interpreter.reset();
  return EXIT_SUCCESS;
}

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 200 of file Driver.cpp.

{
  // NOTE main does not catch internal exceptions for debug build to make it easy to
  //      check the stacktrace with a debugger
  return entry(argc, argv);
}

References entry().