onert::backend::cl_common Namespace Reference

Data Structures
class	BackendContext
struct	ParentInfo
	Struct to represent parent operand in child operand. More...

Typedefs
using	LifetimeMap = std::map< size_t, std::pair< UsesType, ir::OperandIndex > >
using	LifetimeSeq = std::vector< std::pair< UsesType, ir::OperandIndex > >

Enumerations
enum class	UsesType { FIRST , LAST }

Functions
LifetimeMap	createLifetimeMap (LifetimeSeq &seq, ir::OperandIndexMap< ParentInfo > &parent_map)

Typedef Documentation

LifetimeMap

using onert::backend::cl_common::LifetimeMap = typedef std::map<size_t, std::pair<UsesType, ir::OperandIndex> >

Definition at line 38 of file LifetimeMap.h.

LifetimeSeq

using onert::backend::cl_common::LifetimeSeq = typedef std::vector<std::pair<UsesType, ir::OperandIndex> >

Definition at line 39 of file LifetimeMap.h.

Enumeration Type Documentation

UsesType

enum class onert::backend::cl_common::UsesType

strong

Enumerator
FIRST
LAST

Definition at line 31 of file LifetimeMap.h.

{
  FIRST,
  LAST
};

Function Documentation

createLifetimeMap()

LifetimeMap onert::backend::cl_common::createLifetimeMap	(	LifetimeSeq &	seq,
		ir::OperandIndexMap< ParentInfo > &	parent_map
	)

Definition at line 24 of file LifetimeMap.cc.

{
  // Update lifetime sequence to apply subtensor optimization
  std::unordered_map<ir::OperandIndex, ir::OperandIndex> root_map;
  std::function<ir::OperandIndex &(ir::OperandIndex)> find_root =
    [&](ir::OperandIndex ind) -> ir::OperandIndex & {
    ir::OperandIndex &ret = root_map[ind];
 
    // We know the root parent value already
    if (ret.valid())
      return ret;
 
    auto itr = parent_map.find(ind);
    if (itr == parent_map.end())
    {
      // If there is no parent, let's store the value of itself
      return ret = ind;
    }
    else
    {
      return ret = find_root(itr->second.parent);
    }
  };
 
  ir::OperandIndexMap<bool> first_use_check;
  ir::OperandIndexMap<bool> last_use_check;
  LifetimeMap lifetime_map;
  for (size_t i = 0; i < lifetime_seq.size(); i++)
  {
    const auto &[entry_uses_type, entry_idx] = lifetime_seq[i];
    if (entry_uses_type != UsesType::FIRST)
      continue;
    auto root_ind = find_root(entry_idx);
    if (first_use_check[root_ind])
      continue;
    first_use_check[root_ind] = true;
    lifetime_map[i] = {UsesType::FIRST, root_ind};
  }
 
  for (int i = lifetime_seq.size() - 1; i >= 0; i--)
  {
    const auto &[entry_uses_type, entry_idx] = lifetime_seq[i];
    if (entry_uses_type != UsesType::LAST)
      continue;
    auto root_ind = find_root(entry_idx);
    if (last_use_check[root_ind])
      continue;
    last_use_check[root_ind] = true;
    lifetime_map[i] = {UsesType::LAST, root_ind};
  }
 
  return lifetime_map;
}

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

Referenced by onert::backend::acl_common::AclTensorBuilder< T_ITensor, T_Tensor, T_SubTensor >::allocate().