onert::backend::basic::WICPlanner Class Reference

Class to plan memory by Weighted Interval Color algorithm. More...

#include <MemoryPlanner.h>

Collaboration diagram for onert::backend::basic::WICPlanner:

Public Member Functions
	WICPlanner ()
void	claim (const ir::OperandIndex &, size_t) override
	Claim memory for operand by WIC algorithm.
void	release (const ir::OperandIndex &) override
	Release memory for operand by WIC algorithm.
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 Weighted Interval Color algorithm.

Definition at line 108 of file MemoryPlanner.h.

Constructor & Destructor Documentation

WICPlanner()

onert::backend::basic::WICPlanner::WICPlanner

(

)

Definition at line 103 of file MemoryPlanner.cc.

  : _initialized(false), _capacity(0), _mem_plans(), _live_operands(), _interference_graph(),
    _operands()
{
  // DO NOTHING
}

Member Function Documentation

capacity()

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

inlineoverridevirtual

Get capacity for memory planning.

Returns

The value of capacity

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

Definition at line 128 of file MemoryPlanner.h.

  {
    if (!_initialized)
      buildMemoryPlans();
    return _capacity;
  }

claim()

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

overridevirtual

Claim memory for operand by WIC algorithm.

Parameters

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

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

Definition at line 110 of file MemoryPlanner.cc.

{
  _operands.emplace(size, ind);
  _interference_graph[ind].insert(_interference_graph[ind].end(), _live_operands.cbegin(),
                                  _live_operands.cend());
  for (const auto &live_operand : _live_operands)
  {
    _interference_graph[live_operand].emplace_back(ind);
  }
  _live_operands.emplace(ind);
 
  VERBOSE(WIC_PLANNER) << "claim(" << ind << "): [" << size << "sz]" << std::endl;
}

References size, and VERBOSE.

memory_plans()

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

overridevirtual

Get MemoryPlans.

Returns

MemoryPlans

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

Definition at line 190 of file MemoryPlanner.cc.

{
  if (!_initialized)
    buildMemoryPlans();
  return _mem_plans;
}

release()

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

overridevirtual

Release memory for operand by WIC algorithm.

Parameters

[in]

index

The operand index

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

Definition at line 124 of file MemoryPlanner.cc.

{
  _live_operands.erase(ind);
  VERBOSE(WIC_PLANNER) << "release(" << ind << ")" << std::endl;
}

References 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