Public Member Functions
	TensorAllocPlan (IMemoryManager *memory_manager)

void	invalidate ()

bool	isValid () const

void	build (const RuntimeGraph &graph)

void	allocate (size_t kernel_index) const

void	deallocate (size_t kernel_index) const

Detailed Description

Definition at line 27 of file RuntimeGraph.cpp.

Constructor & Destructor Documentation

◆ TensorAllocPlan()

luci_interpreter::RuntimeGraph::TensorAllocPlan::TensorAllocPlan ( IMemoryManager * memory_manager )

explicit

Definition at line 43 of file RuntimeGraph.cpp.

  : _memory_manager(memory_manager)
{
}

Member Function Documentation

◆ allocate()

void luci_interpreter::RuntimeGraph::TensorAllocPlan::allocate ( size_t kernel_index ) const

Definition at line 85 of file RuntimeGraph.cpp.

{
  assert(_valid && kernel_index < _alloc_plan.size());
  for (Tensor *tensor : _alloc_plan[kernel_index])
  {
    _memory_manager->allocate_memory(*tensor);
  }
}

References luci_interpreter::IMemoryManager::allocate_memory().

◆ build()

void luci_interpreter::RuntimeGraph::TensorAllocPlan::build ( const RuntimeGraph & graph )

Definition at line 48 of file RuntimeGraph.cpp.

{
  invalidate();
  using Lifetime = std::pair<size_t, size_t>;
  std::unordered_map<Tensor *, Lifetime> lifetimes;
  const size_t num_kernels = graph._kernels.size();
  for (size_t index = 0; index < num_kernels; ++index)
  {
    const auto &kernel = graph._kernels[index];
    for (const Tensor *tensor : kernel->getInputTensors())
    {
      auto nc_tensor = const_cast<Tensor *>(tensor);
      if (lifetimes.count(nc_tensor) > 0)
        lifetimes.at(nc_tensor).second = index;
    }
    for (Tensor *tensor : kernel->getOutputTensors())
    {
      assert(lifetimes.count(tensor) == 0);
      lifetimes[tensor] = Lifetime(index, index);
    }
  }
  for (const Tensor *tensor : graph.getOutputTensors())
  {
    auto nc_tensor = const_cast<Tensor *>(tensor);
    if (lifetimes.count(nc_tensor) > 0)
      lifetimes.at(nc_tensor).second = num_kernels;
  }
  _alloc_plan.assign(num_kernels, std::vector<Tensor *>());
  _dealloc_plan.assign(num_kernels + 1, std::vector<Tensor *>());
  for (const auto &item : lifetimes)
  {
    _alloc_plan[item.second.first].push_back(item.first);
    _dealloc_plan[item.second.second].push_back(item.first);
  }
  _valid = true;
}

References luci_interpreter::RuntimeGraph::invalidate().

◆ deallocate()

void luci_interpreter::RuntimeGraph::TensorAllocPlan::deallocate ( size_t kernel_index ) const

Definition at line 94 of file RuntimeGraph.cpp.

{
  assert(_valid && kernel_index < _dealloc_plan.size());
  for (Tensor *tensor : _dealloc_plan[kernel_index])
  {
    _memory_manager->release_memory(*tensor);
  }
}

References luci_interpreter::IMemoryManager::release_memory().

◆ invalidate()

void luci_interpreter::RuntimeGraph::TensorAllocPlan::invalidate ( )

inline

Definition at line 36 of file RuntimeGraph.cpp.

36{ _valid = false; }

◆ isValid()

bool luci_interpreter::RuntimeGraph::TensorAllocPlan::isValid ( ) const