onert::backend::train::FirstFitPlanner< Index > Class Template Reference

Class to plan memory by firstfit way. More...

#include <MemoryPlanner.h>

Collaboration diagram for onert::backend::train::FirstFitPlanner< Index >:

Public Member Functions
void	claim (const Index &, size_t) override
	Claim memory for tensor by firstfit way.
void	release (const Index &) override
	Release memory for tensor by firstfit way.
uint32_t	capacity () override
	Get capacity for memory planning.
MemoryPlans &	memory_plans () override
	Get MemoryPlans.
Public Member Functions inherited from onert::backend::basic::IMemoryPlanner< Index >
virtual	~IMemoryPlanner ()=default

Additional Inherited Members
Public Types inherited from onert::backend::basic::IMemoryPlanner< Index >
using	MemoryPlans = std::unordered_map< Index, Block >

Detailed Description

template<typename Index>
class onert::backend::train::FirstFitPlanner< Index >

Class to plan memory by firstfit way.

Definition at line 80 of file MemoryPlanner.h.

Member Function Documentation

capacity()

template<typename Index >

uint32_t onert::backend::train::FirstFitPlanner< Index >::capacity ( )

inlineoverridevirtual

Get capacity for memory planning.

Returns

The value of capacity

Implements onert::backend::basic::IMemoryPlanner< Index >.

Definition at line 101 of file MemoryPlanner.h.

{ return _capacity; }

claim()

template<typename Index >

void onert::backend::train::FirstFitPlanner< Index >::claim ( const Index &  ind, size_t  size  )

overridevirtual

Claim memory for tensor by firstfit way.

Parameters

[in]	index	The tensor index
[in]	size	The size of the memory

Implements onert::backend::basic::IMemoryPlanner< Index >.

Definition at line 62 of file MemoryPlanner.cc.

{
  // Find the right position for claiming
  uint32_t next_offset = 0;
  for (const auto &[claimed_base_offset, claimed_index] : _claim_table)
  {
    auto claimed_size = _mem_plans[claimed_index].size;
    if (next_offset + size <= claimed_base_offset)
    {
      break;
    }
    else
    {
      next_offset = claimed_base_offset + claimed_size;
    }
  }
 
  // Now next_offset is set to the proper offset
  // std::map's operator[] requires default constructor of value
  // _claim_table[next_offset] = ind;
  _claim_table.emplace(std::make_pair(next_offset, ind));
  _mem_plans[ind] = {next_offset, size};
 
  VERBOSE(FF_PLANNER) << "claim(" << ind << "): [+" << next_offset << ", " << size << "sz]"
                      << std::endl;
 
  if (_capacity < next_offset + size)
  {
    _capacity = next_offset + size;
  }
}

References size, and VERBOSE.

memory_plans()

template<typename Index >

MemoryPlans & onert::backend::train::FirstFitPlanner< Index >::memory_plans ( )

inlineoverridevirtual

Get MemoryPlans.

Returns

MemoryPlans

Implements onert::backend::basic::IMemoryPlanner< Index >.

Definition at line 106 of file MemoryPlanner.h.

{ return _mem_plans; }

release()

template<typename Index >

void onert::backend::train::FirstFitPlanner< Index >::release ( const Index &  ind )

overridevirtual

Release memory for tensor by firstfit way.

Parameters

[in]

index

The tensor index

Implements onert::backend::basic::IMemoryPlanner< Index >.

Definition at line 94 of file MemoryPlanner.cc.

{
  for (auto it = _claim_table.cbegin(); it != _claim_table.cend(); ++it)
  {
    if (it->second == ind)
    {
      uint32_t offset = it->first;
      uint32_t size = _mem_plans[ind].size;
 
      _claim_table.erase(it);
 
      VERBOSE(FF_PLANNER) << "release(" << ind << "): [+" << offset << ", " << size << "sz]"
                          << std::endl;
      return;
    }
  }
  assert(!"Cannot release for given index. It has been not claimed or released already.");
}

References offset(), size, and VERBOSE.

---

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

• runtime/onert/backend/train/MemoryPlanner.h
• runtime/onert/backend/train/MemoryPlanner.cc