onert::odc::MinMaxReader Class Reference

#include <MinMaxReader.h>

Public Member Functions
	MinMaxReader (const std::string &filepath)
MinMaxVectors	readOP (uint32_t model_idx, uint32_t subg_idx, uint32_t op_idx) const
	Returns minmax recording for op {model_idx, subg_idx, op_idx}.
MinMaxVectors	readInput (uint32_t model_idx, uint32_t subg_idx, uint32_t input_idx) const
	Returns minmax recording for input {model_idx, subg_idx, input_idx}.
uint32_t	readNumRuns () const
	Returns minmax recording count.

Detailed Description

Definition at line 56 of file MinMaxReader.h.

Constructor & Destructor Documentation

MinMaxReader()

onert::odc::MinMaxReader::MinMaxReader

(

const std::string &

filepath

)

Definition at line 78 of file MinMaxReader.cc.

                                                    : _filepath(filepath)
{
  // DO NOTHING
}

Member Function Documentation

readInput()

MinMaxVectors onert::odc::MinMaxReader::readInput	(	uint32_t	model_idx,
		uint32_t	subg_idx,
		uint32_t	input_idx
	)		const

Returns minmax recording for input {model_idx, subg_idx, input_idx}.

Returns

MinMaxVectors

Definition at line 160 of file MinMaxReader.cc.

{
  // Find file to read
  auto file = std::fopen(_filepath.c_str(), "rb");
  if (!file)
    throw std::runtime_error("Cannot open file: " + _filepath);
 
  checkHeader(file);
 
  // Read num_run
  uint32_t num_run = 0;
  readMMFile(&num_run, sizeof(uint32_t), 1, file, "Cannot read num_run from file");
 
  MinMaxVectors mmv;
  float minmax[2];
  const int64_t data_size = sizeof(float) * 2 + sizeof(uint32_t) * 3;
 
  // Check num_run overflow
  if (num_run > std::numeric_limits<uint32_t>::max() / data_size)
    throw std::runtime_error("num_run overflow");
 
  for (uint32_t r = 0; r < num_run; ++r)
  {
    // Read num of operations and num of inputs
    uint32_t num_op = 0;
    readMMFile(&num_op, sizeof(uint32_t), 1, file, "Cannot read num of operations");
    uint32_t num_input = 0;
    readMMFile(&num_input, sizeof(uint32_t), 1, file, "Cannot read num of inputs");
 
    // Check num_op overflow
    if (num_op > std::numeric_limits<uint32_t>::max() / data_size / num_run)
      throw std::runtime_error("num_op overflow");
    // Check num_input overflow
    if (num_input > std::numeric_limits<uint32_t>::max() / data_size / num_run)
      throw std::runtime_error("num_input overflow");
 
    // Skip operation minmax data
    seekMMFile(file, static_cast<int64_t>(data_size * num_op), SEEK_CUR,
               "Cannot skip operation minmax data");
 
    // Find operation
    for (uint32_t i = 0; i < num_input; ++i)
    {
      uint32_t model_id_from_file = 0;
      uint32_t subg_idx_from_file = 0;
      uint32_t input_idx_from_file = 0;
 
      readMMFile(&model_id_from_file, sizeof(uint32_t), 1, file, "Cannot read model_id from file");
      readMMFile(&subg_idx_from_file, sizeof(uint32_t), 1, file, "Cannot read subg_idx from file");
      readMMFile(&input_idx_from_file, sizeof(uint32_t), 1, file,
                 "Cannot read input_idx from file");
 
      if (model_id_from_file == model_idx && subg_idx_from_file == subg_idx &&
          input_idx_from_file == input_idx)
      {
        // Read minmax data
        readMMFile(minmax, sizeof(float), 2, file, "Cannot read minmax data from file");
        mmv.min_vector.emplace_back(minmax[0]);
        mmv.max_vector.emplace_back(minmax[1]);
 
        // Skip remain input minmax data
        const uint32_t remain_elem = num_input - i - 1;
        seekMMFile(file, static_cast<int64_t>(data_size * remain_elem), SEEK_CUR,
                   "Cannot skip remain minmax data from file");
        break;
      }
 
      // Skip minmax data
      seekMMFile(file, sizeof(float) * 2, SEEK_CUR, "Cannot skip minmax data from file");
    }
  }
 
  std::fclose(file);
  return mmv;
}

References onert::odc::MinMaxVectors::max_vector, and onert::odc::MinMaxVectors::min_vector.

readNumRuns()

uint32_t onert::odc::MinMaxReader::readNumRuns

(

)

const

Returns minmax recording count.

Returns

minmax recording count

Definition at line 237 of file MinMaxReader.cc.

{
  // Find file to read
  auto file = std::fopen(_filepath.c_str(), "rb");
  if (!file)
    throw std::runtime_error("Cannot open file: " + _filepath);
 
  checkHeader(file);
 
  // Read num_run
  uint32_t num_run = 0;
  readMMFile(&num_run, sizeof(uint32_t), 1, file, "Cannot read num_run from file");
 
  std::fclose(file);
 
  return num_run;
}

Referenced by onert::odc::Quantizer::readyForQuantize().

readOP()

MinMaxVectors onert::odc::MinMaxReader::readOP	(	uint32_t	model_idx,
		uint32_t	subg_idx,
		uint32_t	op_idx
	)		const

Returns minmax recording for op {model_idx, subg_idx, op_idx}.

Returns

MinMaxVectors

Definition at line 84 of file MinMaxReader.cc.

{
  // Find file to read
  auto file = std::fopen(_filepath.c_str(), "rb");
  if (!file)
    throw std::runtime_error("Cannot open file: " + _filepath);
 
  checkHeader(file);
 
  // Read num_run
  uint32_t num_run = 0;
  readMMFile(&num_run, sizeof(uint32_t), 1, file, "Cannot read num_run from file");
 
  MinMaxVectors mmv;
  float minmax[2];
  const int64_t data_size = sizeof(float) * 2 + sizeof(uint32_t) * 3;
 
  // Check num_run overflow
  if (num_run > std::numeric_limits<uint32_t>::max() / data_size)
    throw std::runtime_error("num_run overflow");
 
  for (uint32_t r = 0; r < num_run; ++r)
  {
    // Read num of operations and num of inputs
    uint32_t num_op = 0;
    readMMFile(&num_op, sizeof(uint32_t), 1, file, "Cannot read num of operations");
    uint32_t num_input = 0;
    readMMFile(&num_input, sizeof(uint32_t), 1, file, "Cannot read num of inputs");
 
    // Check num_op overflow
    if (num_op > std::numeric_limits<uint32_t>::max() / data_size / num_run)
      throw std::runtime_error("num_op overflow");
    // Check num_input overflow
    if (num_input > std::numeric_limits<uint32_t>::max() / data_size / num_run)
      throw std::runtime_error("num_input overflow");
 
    // Find operation
    for (uint32_t i = 0; i < num_op; ++i)
    {
      uint32_t model_id_from_file = 0;
      uint32_t subg_idx_from_file = 0;
      uint32_t op_idx_from_file = 0;
 
      readMMFile(&model_id_from_file, sizeof(uint32_t), 1, file, "Cannot read model_id from file");
      readMMFile(&subg_idx_from_file, sizeof(uint32_t), 1, file, "Cannot read subg_idx from file");
      readMMFile(&op_idx_from_file, sizeof(uint32_t), 1, file, "Cannot read op_idx from file");
 
      if (model_id_from_file == model_idx && subg_idx_from_file == subg_idx &&
          op_idx_from_file == op_idx)
      {
        // Read minmax data
        readMMFile(minmax, sizeof(float), 2, file, "Cannot read minmax data from file");
        mmv.min_vector.emplace_back(minmax[0]);
        mmv.max_vector.emplace_back(minmax[1]);
 
        // Skip remain operation minmax data
        const uint32_t remain_elem = num_op - i - 1;
        seekMMFile(file, static_cast<int64_t>(data_size * remain_elem), SEEK_CUR,
                   "Failed to skip remain minmax data");
 
        break;
      }
 
      // Skip minmax data
      seekMMFile(file, sizeof(float) * 2, SEEK_CUR, "Failed to skip minmax data");
    }
 
    // Skip input minmax data
    seekMMFile(file, static_cast<int64_t>(data_size * num_input), SEEK_CUR,
               "Failed to skip input minmax data");
  }
 
  std::fclose(file);
  return mmv;
}

References onert::odc::MinMaxVectors::max_vector, and onert::odc::MinMaxVectors::min_vector.

---

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

• runtime/onert/odc/MinMaxReader.h
• runtime/onert/odc/MinMaxReader.cc