#include <BackendContext.h>

Collaboration diagram for onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >:

[legend]

Public Member Functions
	BackendContext (const Backend *backend, ContextData &&data, std::shared_ptr< ITensorRegistry > tensor_registry=nullptr, std::shared_ptr< T_TensorBuilder > tensor_builder=nullptr, std::shared_ptr< T_ConstantInitializer > constant_initializer=nullptr, std::shared_ptr< T_KernelGenerator > kernel_gen=nullptr)

FunctionMap	genKernels () override

Public Member Functions inherited from onert::backend::BackendContext
	BackendContext (const Backend *backend, ContextData &&data, std::shared_ptr< ITensorRegistry > tensor_registry=nullptr)

virtual	~BackendContext ()=default

const Backend *	backend () const

const ir::Graph *	graph () const

const util::Set< ir::OperandIndex > &	external_operands () const

const ContextData &	data () const

virtual ITensorRegistry *	genTensors ()=0

Data Fields
std::shared_ptr< T_TensorBuilder >	tensor_builder

std::shared_ptr< T_ConstantInitializer >	constant_initializer

std::shared_ptr< T_KernelGenerator >	kernel_gen

Data Fields inherited from onert::backend::BackendContext
std::shared_ptr< ITensorRegistry >	tensor_registry

Protected Member Functions
void	initConsts ()

virtual void	registerTensorInfo (const ir::OperandIndex &ind, const ir::OperandInfo &info)=0

void	planTensors ()

Additional Inherited Members
Protected Attributes inherited from onert::backend::BackendContext
const Backend *	_backend {nullptr}

ContextData	_data

Detailed Description

template<typename T_TensorBuilder, typename T_ConstantInitializer, typename T_KernelGenerator>
class onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >

Definition at line 35 of file BackendContext.h.

Constructor & Destructor Documentation

◆ BackendContext()

template<typename T_TensorBuilder , typename T_ConstantInitializer , typename T_KernelGenerator >

onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::BackendContext	(	const Backend *	backend,
		ContextData &&	data,
		std::shared_ptr< ITensorRegistry >	tensor_registry = `nullptr`,
		std::shared_ptr< T_TensorBuilder >	tensor_builder = `nullptr`,
		std::shared_ptr< T_ConstantInitializer >	constant_initializer = `nullptr`,
		std::shared_ptr< T_KernelGenerator >	kernel_gen = `nullptr`
	)

inline

Definition at line 38 of file BackendContext.h.

    : onert::backend::BackendContext(backend, std::move(data), tensor_registry),
      tensor_builder{tensor_builder}, constant_initializer{constant_initializer},
      kernel_gen{kernel_gen}
  {
  }

Member Function Documentation

◆ genKernels()

template<typename T_TensorBuilder , typename T_ConstantInitializer , typename T_KernelGenerator >

FunctionMap onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::genKernels ( )

inlineoverridevirtual

Implements onert::backend::BackendContext.

Definition at line 49 of file BackendContext.h.

  {
    FunctionMap ret;
 
    // kernel_gen
    for (auto &&op_ind : _data.op_order)
    {
      auto fn_seq = kernel_gen->generate(op_ind);
      ret.emplace(op_ind, std::move(fn_seq));
    }
 
    tensor_builder->allocate();
    initConsts();
 
    // NOTE For memory optimization, we want to free some operand data
    const_cast<ir::Graph &>(*_data.graph)
      .operands()
      .iterate([&](const ir::OperandIndex &, ir::Operand &obj) { obj.releaseData(); });
 
    for (auto &&it : ret)
    {
      auto &fn_seq = it.second;
      fn_seq->iterate([&](exec::IFunction &ifunc) {
        ifunc.prepare();
        tensor_builder->postFunctionPrepare();
      });
    }
 
    return ret;
  }

References onert::backend::BackendContext::_data, onert::backend::ContextData::graph, onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::initConsts(), onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::kernel_gen, onert::backend::ContextData::op_order, onert::exec::IFunction::prepare(), and onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::tensor_builder.

◆ initConsts()

template<typename T_TensorBuilder , typename T_ConstantInitializer , typename T_KernelGenerator >

void onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::initConsts ( )

inlineprotected

Definition at line 81 of file BackendContext.h.

  {
    _data.graph->operations().iterate([&](const ir::OperationIndex &, const ir::IOperation &op) {
      op.accept(*constant_initializer);
    });
 
    _data.graph->operands().iterate([&](const ir::OperandIndex &ind, const ir::Operand &operand) {
      if (_data.external_operands.contains(ind) || !operand.isConstant())
        return;
      const auto &obj = graph()->operands().at(ind);
      if (obj.isConstant() && !constant_initializer->exist(ind))
      {
        constant_initializer->registerDefaultInitializer(ind, obj);
      }
    });
 
    constant_initializer->run();
  }

References onert::backend::BackendContext::_data, onert::ir::IOperation::accept(), onert::util::ObjectManager< Index, Object >::at(), onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::constant_initializer, onert::backend::ContextData::external_operands, onert::backend::ContextData::graph, onert::backend::BackendContext::graph(), onert::ir::Operand::isConstant(), and onert::ir::Graph::operands().

Referenced by onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::genKernels().

◆ planTensors()

template<typename T_TensorBuilder , typename T_ConstantInitializer , typename T_KernelGenerator >

void onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::planTensors ( )

inlineprotected

Definition at line 102 of file BackendContext.h.

  {
    ir::OperandIndexMap<uint32_t> uses_map;
    ir::OperandIndexMap<uint32_t> def_map;
    ir::OperandIndexSequence constants;
 
    // Prepare scanning
    _data.graph->operands().iterate([&](const ir::OperandIndex &ind, const ir::Operand &obj) {
      if (_data.external_operands.contains(ind))
        return;
 
      uses_map[ind] = obj.getUses().size();
      def_map[ind] = obj.getDef().valid() ? 1 : 0;
 
      if (obj.isConstant())
        constants.append(ind);
 
      if (!tensor_builder->isRegistered(ind))
      {
        // These tensors do not exist in any operation (No use and def)
        const auto &info = obj.info();
        registerTensorInfo(ind, info);
      }
    });
 
    // Start scanning to do notify{First|Last}Use for each tensor
 
    // If a tensor is a constant, increase the use of the tensor and allocate it first.
    // Increasing use count here makes the tensor never be deallocated, i.e it they will be
    // deallocated last.
    VERBOSE(planTensors) << "TENSORS as CONSTANT" << std::endl;
    for (const auto &ind : constants)
    {
      uses_map[ind]++;
      tensor_builder->notifyFirstUse(ind);
    }
 
    // At each operation,
    // 1. Scan DEF of outputs. If the DEF, allocate it
    // 2. Scan DEF of inputs. If variable tensor, allocate it
    // 3. Scan USE of inputs. Decrease the USE and deallocate if the USE is 0
    for (const auto &op_ind : _data.op_order)
    {
      const auto &op = graph()->operations().at(op_ind);
      auto op_inputs = op.getInputs() | ir::Remove::DUPLICATED | ir::Remove::UNDEFINED;
      auto op_outputs = op.getOutputs() | ir::Remove::DUPLICATED | ir::Remove::UNDEFINED;
 
      // Define outputs
      for (const auto &ind : op_outputs)
      {
        if (!tensor_builder->isRegistered(ind))
          continue;
        assert(def_map.find(ind) != def_map.end());
        if (def_map[ind])
        {
          def_map[ind] = 0;
          tensor_builder->notifyFirstUse(ind);
        }
      }
 
      // Scan variable tensors
      // This tensor has features like constant. But OperandInfo and LowerInfo treat them as
      // non-constant because of less memory usage by memory planning in here
      for (const auto &ind : op_inputs)
      {
        if (!tensor_builder->isRegistered(ind))
          continue;
        const auto &operand = graph()->operands().at(ind);
        if (operand.info().isVariable())
        {
          // The variable tensor with buffer is not supported yet
          assert(operand.data() == nullptr);
          assert(operand.getUses().size() == 1 && !operand.getDef().valid());
          assert(uses_map[ind] == 1 && def_map[ind] == 0);
          tensor_builder->notifyFirstUse(ind);
        }
      }
 
      for (const auto &ind : op_inputs)
      {
        if (!tensor_builder->isRegistered(ind))
          continue;
        assert(uses_map.find(ind) != uses_map.end());
        assert(uses_map[ind] > 0);
        uses_map[ind]--;
        if (uses_map[ind] == 0)
        {
          // plan for deallocation of static tensornode
          tensor_builder->notifyLastUse(ind);
        }
      }
    }
 
    _data.graph->operands().iterate([&](const ir::OperandIndex &ind, const ir::Operand &) {
      if (uses_map[ind] == 0)
      {
        tensor_builder->notifyLastUse(ind);
      }
    });
 
    // Dispose and validate
    for (const auto &ind : constants)
    {
      --uses_map[ind];
      if (uses_map[ind] == 0) // To prevent notifyLastUse from being called twice
      {
        tensor_builder->notifyLastUse(ind);
      }
    }
 
    assert(
      std::all_of(uses_map.begin(), uses_map.end(),
                  [](std::pair<const ir::OperandIndex, uint32_t> it) { return it.second == 0; }));
 
    assert(
      std::all_of(def_map.begin(), def_map.end(),
                  [](std::pair<const ir::OperandIndex, uint32_t> it) { return it.second == 0; }));
  }

References onert::backend::BackendContext::_data, onert::ir::OperandIndexSequence::append(), onert::util::ObjectManager< Index, Object >::at(), onert::ir::DUPLICATED, onert::backend::ContextData::external_operands, onert::backend::ContextData::graph, onert::backend::BackendContext::graph(), info, onert::backend::ContextData::op_order, onert::ir::Graph::operands(), onert::ir::Graph::operations(), onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::planTensors(), onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::registerTensorInfo(), onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::tensor_builder, onert::ir::UNDEFINED, and VERBOSE.

Referenced by onert::backend::acl_common::AclBackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator, T_Optimizer >::genTensors(), and onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::planTensors().

◆ registerTensorInfo()

template<typename T_TensorBuilder , typename T_ConstantInitializer , typename T_KernelGenerator >

virtual void onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::registerTensorInfo	(	const ir::OperandIndex &	ind,
		const ir::OperandInfo &	info
	)

protectedpure virtual

Implemented in onert::backend::acl_common::AclBackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator, T_Optimizer >.

Referenced by onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::planTensors().

Field Documentation

◆ constant_initializer

template<typename T_TensorBuilder , typename T_ConstantInitializer , typename T_KernelGenerator >

std::shared_ptr<T_ConstantInitializer> onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::constant_initializer

Definition at line 224 of file BackendContext.h.

Referenced by onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::initConsts().

◆ kernel_gen

template<typename T_TensorBuilder , typename T_ConstantInitializer , typename T_KernelGenerator >

std::shared_ptr<T_KernelGenerator> onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::kernel_gen

Definition at line 225 of file BackendContext.h.

Referenced by onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::genKernels().

◆ tensor_builder

template<typename T_TensorBuilder , typename T_ConstantInitializer , typename T_KernelGenerator >

std::shared_ptr<T_TensorBuilder> onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::tensor_builder

Definition at line 223 of file BackendContext.h.

Referenced by onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::genKernels(), onert::backend::acl_common::AclBackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator, T_Optimizer >::genTensors(), onert::backend::cl_common::BackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator >::planTensors(), and onert::backend::acl_common::AclBackendContext< T_TensorBuilder, T_ConstantInitializer, T_KernelGenerator, T_Optimizer >::registerTensorInfo().

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

runtime/onert/backend/cl_common/include/cl_common/BackendContext.h

Public Member Functions

Data Fields

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ BackendContext()

Member Function Documentation

◆ genKernels()

◆ initConsts()

◆ planTensors()

◆ registerTensorInfo()

Field Documentation

◆ constant_initializer

◆ kernel_gen

◆ tensor_builder