SingleAxisPriorityList Class Reference

SingleAxisPriorityList sorts the MemBlocks according to some priority, then trys to place them into as few bins as possible. More...

#include <SingleAxisPriorityList.hpp>

Inheritance diagram for SingleAxisPriorityList:

Collaboration diagram for SingleAxisPriorityList:

Public Member Functions
	SingleAxisPriorityList ()
std::string	GetName () const override
MemBlockStrategyType	GetMemBlockStrategyType () const override
std::vector< MemBin >	Optimize (std::vector< MemBlock > &memBlocks) override
Public Member Functions inherited from IMemoryOptimizerStrategy
virtual	~IMemoryOptimizerStrategy ()

Detailed Description

SingleAxisPriorityList sorts the MemBlocks according to some priority, then trys to place them into as few bins as possible.

Definition at line 20 of file SingleAxisPriorityList.hpp.

Constructor & Destructor Documentation

SingleAxisPriorityList()

SingleAxisPriorityList ( )

inline

Definition at line 23 of file SingleAxisPriorityList.hpp.

                : m_Name(std::string("SingleAxisPriorityList"))
                , m_MemBlockStrategyType(MemBlockStrategyType::SingleAxisPacking) {}

References armnn::SingleAxisPacking.

Member Function Documentation

GetMemBlockStrategyType()

MemBlockStrategyType GetMemBlockStrategyType ( ) const

overridevirtual

Implements IMemoryOptimizerStrategy.

Definition at line 28 of file SingleAxisPriorityList.cpp.

                                                                           {
    return m_MemBlockStrategyType;
}

GetName()

std::string GetName ( ) const

overridevirtual

Implements IMemoryOptimizerStrategy.

Definition at line 24 of file SingleAxisPriorityList.cpp.

                                                {
    return m_Name;
}

Optimize()

std::vector< MemBin > Optimize ( std::vector< MemBlock > & memBlocks )

overridevirtual

Implements IMemoryOptimizerStrategy.

Definition at line 214 of file SingleAxisPriorityList.cpp.

{
    unsigned int maxLifetime = 0;
    std::list<MemBlock*> priorityList;
    for (auto& block: blocks)
    {
        maxLifetime = std::max(maxLifetime, block.m_EndOfLife);
        priorityList.emplace_back(&block);
    }
    maxLifetime++;
 
    // From testing ordering by m_MemSize in non-descending order gives the best results overall
    priorityList.sort([](const MemBlock* lhs, const MemBlock* rhs)
                      {
                          return  lhs->m_MemSize > rhs->m_MemSize ;
                      });
 
 
    std::vector<BinTracker> placedBlocks;
    placedBlocks.reserve(maxLifetime);
    PlaceBlocks(priorityList, placedBlocks, maxLifetime);
 
    std::vector<MemBin> bins;
    bins.reserve(placedBlocks.size());
    for (auto blockList: placedBlocks)
    {
        MemBin bin;
        bin.m_MemBlocks.reserve(blockList.m_PlacedBlocks.size());
        bin.m_MemSize = blockList.m_MemSize;
 
        for (auto block : blockList.m_PlacedBlocks)
        {
            bin.m_MemBlocks.emplace_back(MemBlock{block->m_StartOfLife,
                                                  block->m_EndOfLife,
                                                  block->m_MemSize,
                                                  0,
                                                  block->m_Index,});
        }
        bins.push_back(std::move(bin));
    }
 
    return bins;
}

References MemBin::m_MemBlocks, MemBin::m_MemSize, and MemBlock::m_MemSize.

---

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

• src/backends/backendsCommon/memoryOptimizerStrategyLibrary/strategies/SingleAxisPriorityList.hpp
• src/backends/backendsCommon/memoryOptimizerStrategyLibrary/strategies/SingleAxisPriorityList.cpp