#include <CircleExporter.h>

Public Member Functions
	CircleExporter (const std::string &source, const std::string &path)

	~CircleExporter ()

void	updateWeight (const std::unique_ptr< onert::exec::Execution > &exec)

void	updateMetadata (const std::unique_ptr< onert::ir::train::TrainingInfo > &training_info)

Detailed Description

Definition at line 44 of file CircleExporter.h.

Constructor & Destructor Documentation

◆ CircleExporter()

onert::exporter::CircleExporter::CircleExporter	(	const std::string &	source,
		const std::string &	path
	)

Definition at line 32 of file CircleExporter.cc.

  : _path{path}, _data{}, _model{nullptr}
{
  // make sure the architecture is little endian before direct access to flatbuffers
  assert(FLATBUFFERS_LITTLEENDIAN);
 
  std::ifstream src(source.c_str(), std::ios::binary);
  if (src.is_open())
  {
    src.seekg(0, std::ios::end);
    _data.resize(src.tellg());
    src.seekg(0, std::ios::beg);
    src.read(&_data[0], static_cast<std::streamsize>(_data.size()));
    src.close();
  }
 
  if (_data.size() == 0)
    throw std::runtime_error("Invalid source file");
 
  const auto model = ::circle::GetModel(_data.data());
  if (!model)
    throw std::runtime_error("Failed to load original circle file");
  _model.reset(model->UnPack());
}

◆ ~CircleExporter()

onert::exporter::CircleExporter::~CircleExporter ( )

Definition at line 57 of file CircleExporter.cc.

57{ finish(); }

Member Function Documentation

◆ updateMetadata()

void onert::exporter::CircleExporter::updateMetadata ( const std::unique_ptr< onert::ir::train::TrainingInfo > & training_info )

Definition at line 99 of file CircleExporter.cc.

{
  const char *const TRAININFO_METADATA_NAME = "CIRCLE_TRAINING";
 
  TrainInfoBuilder tbuilder(training_info);
  bool found = false;
  for (const auto &meta : _model->metadata)
  {
    if (meta->name == std::string{TRAININFO_METADATA_NAME})
    {
      std::lock_guard<std::mutex> guard(_mutex);
      const uint32_t buf_idx = meta->buffer;
      auto &buffer = _model->buffers.at(buf_idx);
 
      if (tbuilder.size() != buffer->data.size())
      {
        buffer->data.resize(tbuilder.size());
        buffer->size = tbuilder.size();
      }
 
      memcpy(buffer->data.data(), tbuilder.get(), tbuilder.size());
      found = true;
      break;
    }
  }
 
  if (!found)
  {
    std::lock_guard<std::mutex> guard(_mutex);
    auto buffer = std::make_unique<::circle::BufferT>();
    buffer->size = tbuilder.size();
    buffer->data.resize(buffer->size);
    memcpy(buffer->data.data(), tbuilder.get(), buffer->size);
 
    auto meta = std::make_unique<::circle::MetadataT>();
    meta->name = std::string{TRAININFO_METADATA_NAME};
    meta->buffer = _model->buffers.size();
 
    _model->buffers.push_back(std::move(buffer));
    _model->metadata.push_back(std::move(meta));
  }
}

References onert::exporter::TrainInfoBuilder::get(), and onert::exporter::TrainInfoBuilder::size().

Referenced by nnfw_session::train_export_circleplus().

◆ updateWeight()

void onert::exporter::CircleExporter::updateWeight ( const std::unique_ptr< onert::exec::Execution > & exec )

Definition at line 59 of file CircleExporter.cc.

{
  exec->iterateTrainableTensors(
    [&](const ir::OperandIndex &idx, const backend::train::ITrainableTensor *tensor) {
      std::lock_guard<std::mutex> guard(_mutex);
      const auto &subgs = _model->subgraphs;
      if (subgs.size() != 1)
        throw std::runtime_error("Circle does not has valid subgraph or has multiple subgraphs");
 
      if (!idx.valid())
        throw std::runtime_error("Trainable tensor is invalid");
 
      uint32_t buf_idx = -1;
      const auto &subg = subgs.at(0); // Get 1st subgraph
      if (idx.value() >= subg->tensors.size())
      {
        auto buffer = std::make_unique<::circle::BufferT>();
        buffer->size = tensor->total_size();
        buffer->data.resize(buffer->size);
 
        buf_idx = _model->buffers.size();
        _model->buffers.push_back(std::move(buffer));
      }
      else
      {
        buf_idx = subg->tensors.at(idx.value())->buffer;
        if (buf_idx >= _model->buffers.size())
          throw std::runtime_error("Buffer for trainable tensors is invalid");
      }
 
      const auto &buffer = _model->buffers.at(buf_idx);
 
      auto org_buf_sz = buffer->data.size();
      if (org_buf_sz != tensor->total_size())
        throw std::runtime_error("Trained tensor buffer size does not match original tensor's one");
 
      memcpy(buffer->data.data(), tensor->buffer(), org_buf_sz);
    });
}

References onert::util::Index< T, DummyTag >::valid(), and onert::util::Index< T, DummyTag >::value().