onert::backend::basic::FirstFitPlanner Class Reference

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

#include <MemoryPlanner.h>

Collaboration diagram for onert::backend::basic::FirstFitPlanner:

Public Member Functions
void	claim (const ir::OperandIndex &, size_t) override
	Claim memory for operand by firstfit way.
void	release (const ir::OperandIndex &) override
	Release memory for operand 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< ir::OperandIndex >
virtual	~IMemoryPlanner ()=default

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

Detailed Description

Class to plan memory by firstfit way.

Definition at line 77 of file MemoryPlanner.h.

Member Function Documentation

capacity()

uint32_t onert::backend::basic::FirstFitPlanner::capacity ( )

inlineoverridevirtual

Get capacity for memory planning.

Returns

The value of capacity

Implements onert::backend::basic::IMemoryPlanner< ir::OperandIndex >.

Definition at line 95 of file MemoryPlanner.h.

{ return _capacity; }

claim()

void onert::backend::basic::FirstFitPlanner::claim ( const ir::OperandIndex &  ind, size_t  size  )

overridevirtual

Claim memory for operand by firstfit way.

Parameters

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

Implements onert::backend::basic::IMemoryPlanner< ir::OperandIndex >.

Definition at line 57 of file MemoryPlanner.cc.

{
  // Find the right position for claiming
  uint32_t next_offset = 0;
  for (const auto &[claimed_base_offset, claimed_operand_idx] : _claim_table)
  {
    auto claimed_size = _mem_plans[claimed_operand_idx].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
  _claim_table[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()

MemoryPlans & onert::backend::basic::FirstFitPlanner::memory_plans ( )

inlineoverridevirtual

Get MemoryPlans.

Returns

MemoryPlans

Implements onert::backend::basic::IMemoryPlanner< ir::OperandIndex >.

Definition at line 100 of file MemoryPlanner.h.

{ return _mem_plans; }

release()

void onert::backend::basic::FirstFitPlanner::release ( const ir::OperandIndex &  ind )

overridevirtual

Release memory for operand by firstfit way.

Parameters

[in]

index

The operand index

Implements onert::backend::basic::IMemoryPlanner< ir::OperandIndex >.

Definition at line 87 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 index = ind.value();
      uint32_t size = _mem_plans[ind].size;
 
      _claim_table.erase(it);
 
      VERBOSE(FF_PLANNER) << "release(" << index << "): [+" << offset << ", " << size << "sz]"
                          << std::endl;
      return;
    }
  }
  assert(!"Cannot release for given index. It has been not claimed or released already.");
}

References offset(), size, onert::util::Index< T, DummyTag >::value(), and VERBOSE.

---

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

• runtime/onert/core/src/backend/basic/MemoryPlanner.h
• runtime/onert/core/src/backend/basic/MemoryPlanner.cc