#include <MinMaxRecorder.h>

Collaboration diagram for onert::exec::MinMaxRecorder:

Public Member Functions
	MinMaxRecorder (const std::string &workspace_dir, const ir::Graph &graph, const backend::BackendContexts &backend_contexts)

void	handleJobBegin (IExecutor , ir::SubgraphIndex, ir::OperationIndex, const backend::Backend ) override

void	handleJobEnd (IExecutor , ir::SubgraphIndex, ir::OperationIndex, const backend::Backend ) override

void	handleSubgraphBegin (ir::SubgraphIndex) override
	Invoked just before model (not individual operation) execution begins.

void	handleSubgraphEnd (ir::SubgraphIndex) override
	Invoked just after model (not individual operation) execution ends.

ObserverType	type () const override

Public Member Functions inherited from onert::exec::IExecutionObserver
virtual	~IExecutionObserver ()=default

Detailed Description

Definition at line 31 of file MinMaxRecorder.h.

Constructor & Destructor Documentation

◆ MinMaxRecorder()

onert::exec::MinMaxRecorder::MinMaxRecorder	(	const std::string &	workspace_dir,
		const ir::Graph &	graph,
		const backend::BackendContexts &	backend_contexts
	)

Definition at line 29 of file MinMaxRecorder.cc.

  : _graph{graph}, _backend_contexts{backend_contexts}, _workspace_dir(workspace_dir)
{
  // DO NOTHING
}

Member Function Documentation

◆ handleJobBegin()

void onert::exec::MinMaxRecorder::handleJobBegin	(	IExecutor *	,
		ir::SubgraphIndex	,
		ir::OperationIndex	,
		const backend::Backend *
	)

inlineoverridevirtual

Implements onert::exec::IExecutionObserver.

Definition at line 36 of file MinMaxRecorder.h.

  {
    return;
  }

◆ handleJobEnd()

void onert::exec::MinMaxRecorder::handleJobEnd	(	IExecutor *	,
		ir::SubgraphIndex	subg_idx,
		ir::OperationIndex	op_idx,
		const backend::Backend *	backend
	)

overridevirtual

Implements onert::exec::IExecutionObserver.

Definition at line 69 of file MinMaxRecorder.cc.

{
  const auto &tensor_reg = _backend_contexts.at(backend)->tensor_registry;
  const auto &op = _graph.operations().at(op_idx);
  const auto &outputs = op.getOutputs();
  // TODO: Support multiple output
  if (outputs.size() != 1)
    throw std::runtime_error("Only 1 output operator is supported for recording minmax.");
 
  auto tensor = tensor_reg->getITensor(outputs.at(0));
 
  // Logic copied from MinMaxObserver.cpp.
 
  // Filter Ops
  if (tensor->is_constant())
    return;
 
  if (tensor->data_type() != ir::DataType::FLOAT32)
    return;
 
  switch (op.opcode())
  {
    // Operators with multiple outputs
    case ir::OpCode::If:
    case ir::OpCode::Split:
    case ir::OpCode::SplitV:
    case ir::OpCode::TopKV2:
    case ir::OpCode::Unpack:
    case ir::OpCode::While:
      return;
    // NOTE: Sin, Cos, Tanh's output is in [-1, 1]
    // We may not need to dump those operators.
    default:; // Do Nothing
  }
 
  // Otherwise, dump!
  assert(tensor->data_type() == ir::DataType::FLOAT32);
  auto [min, max] = minmaxFrom(tensor);
  _op_minmax.append({subg_idx, op_idx}, min, max);
}

References onert::util::MinMaxMap< N, Hash >::append(), onert::util::ObjectManager< Index, Object >::at(), onert::exec::minmaxFrom(), and onert::ir::Graph::operations().

◆ handleSubgraphBegin()

void onert::exec::MinMaxRecorder::handleSubgraphBegin ( ir::SubgraphIndex )

overridevirtual

Invoked just before model (not individual operation) execution begins.

Reimplemented from onert::exec::IExecutionObserver.

Definition at line 111 of file MinMaxRecorder.cc.

{
  // Make sure there is only cpu backend except for builtin backend
  std::set<std::string> backend_names;
  backend::ITensorRegistry *tensor_reg = nullptr;
  for (const auto &[backend, bctx] : _backend_contexts)
  {
    backend_names.insert(backend->config()->id());
    if (backend->config()->id() == "cpu")
    {
      tensor_reg = bctx->tensor_registry.get();
    }
  }
  if (backend_names != std::set<std::string>{"builtin", "cpu"})
    throw std::runtime_error("MinMaxRecorder must have cpu backend only.");
 
  const auto &inputs = _graph.getInputs(); //.at(op_idx);
  for (uint32_t i = 0; i < inputs.size(); ++i)
  {
    auto input_idx = inputs.at(i);
    auto tensor = tensor_reg->getITensor(input_idx);
 
    if (tensor->is_constant())
      return;
    if (tensor->data_type() != ir::DataType::FLOAT32)
      return;
 
    auto minmax = minmaxFrom(tensor);
    _input_minmax.append({subg_idx, ir::IOIndex{i}}, minmax.first, minmax.second);
  }
}

References onert::util::MinMaxMap< N, Hash >::append(), onert::ir::Graph::getInputs(), onert::backend::ITensorRegistry::getITensor(), and onert::exec::minmaxFrom().

◆ handleSubgraphEnd()

void onert::exec::MinMaxRecorder::handleSubgraphEnd ( ir::SubgraphIndex )

overridevirtual

Invoked just after model (not individual operation) execution ends.

Reimplemented from onert::exec::IExecutionObserver.

Definition at line 143 of file MinMaxRecorder.cc.

{
  // It would be better to dump at the end of model execution, not subgraph
  // But it requires more changes than subgraph.
  auto raw_dumper = RawMinMaxDumper(_workspace_dir + "/minmax.bin");
  raw_dumper.dump(_input_minmax, _op_minmax);
}