WorkingMemHandle Class Reference

#include <WorkingMemHandle.hpp>

Inheritance diagram for WorkingMemHandle:

Collaboration diagram for WorkingMemHandle:

Classes
struct	InputMemDescriptorCoords
struct	OutputMemDescriptorCoords

Public Member Functions
	WorkingMemHandle (NetworkId networkId)
	WorkingMemHandle (NetworkId networkId, std::vector< InputMemDescriptorCoords > inputLayerInfo, std::vector< OutputMemDescriptorCoords > outputLayerInfo, std::vector< WorkingMemDescriptor > workingMemDescriptors, std::unique_ptr< MemoryManager > memoryManager, std::vector< std::pair< std::shared_ptr< TensorMemory >, MemorySource >> tensorMemory, std::vector< std::unique_ptr< ITensorHandle >> managedTensorHandles, std::vector< std::unique_ptr< ITensorHandle >> unmanagedTensorHandles, std::vector< std::pair< BackendId, ExecutionData >> executionDataVec, BackendPtrMap *backends)
	~WorkingMemHandle ()
NetworkId	GetNetworkId () override
	Returns the NetworkId of the Network that this IWorkingMemHandle works with. More...
void	Allocate () override
	Allocate the backing memory required for execution. More...
void	Free () override
	Free the backing memory required for execution. More...
bool	IsAllocated () override
	IsAllocated returns true if the backing memory is currently allocated. More...
WorkingMemDescriptor &	GetWorkingMemDescriptorAt (unsigned int id) override
	Get the WorkingMemDescriptor at an index. More...
std::pair< BackendId, ExecutionData > &	GetExecutionDataAt (unsigned int id) override
	Get the ExecutionData at an index. More...
ITensorHandle *	GetInputHandle (LayerBindingId layerBindingId) const
ITensorHandle *	GetOutputHandle (LayerBindingId layerBindingId) const
const std::vector< std::vector< ITensorHandle * >::iterator > &	GetInputConnections (LayerBindingId layerBindingId) const
const std::vector< std::vector< ITensorHandle * >::iterator > &	GetOutputConnection (LayerBindingId layerBindingId) const
void	MemSyncOutputs ()
std::vector< LayerBindingId > &	GetBindingIdVector ()
void	ValidateBindingIds ()
Public Member Functions inherited from IWorkingMemHandle
virtual	~IWorkingMemHandle ()

Detailed Description

Definition at line 29 of file WorkingMemHandle.hpp.

Constructor & Destructor Documentation

WorkingMemHandle() [1/2]

WorkingMemHandle ( NetworkId  networkId )

inline

Definition at line 48 of file WorkingMemHandle.hpp.

: m_NetworkId(networkId){}

WorkingMemHandle() [2/2]

WorkingMemHandle	(	NetworkId	networkId,
		std::vector< InputMemDescriptorCoords >	inputLayerInfo,
		std::vector< OutputMemDescriptorCoords >	outputLayerInfo,
		std::vector< WorkingMemDescriptor >	workingMemDescriptors,
		std::unique_ptr< MemoryManager >	memoryManager,
		std::vector< std::pair< std::shared_ptr< TensorMemory >, MemorySource >>	tensorMemory,
		std::vector< std::unique_ptr< ITensorHandle >>	managedTensorHandles,
		std::vector< std::unique_ptr< ITensorHandle >>	unmanagedTensorHandles,
		std::vector< std::pair< BackendId, ExecutionData >>	executionDataVec,
		BackendPtrMap *	backends
	)

Definition at line 18 of file WorkingMemHandle.cpp.

    : m_NetworkId(networkId)
    , m_WorkingMemDescriptors(workingMemDescriptors)
    , m_MemoryManager(std::move(memoryManager))
    , m_TensorMemory(std::move(tensorMemory))
    , m_ManagedTensorHandles(std::move(managedTensorHandles))
    , m_UnmanagedTensorHandles(std::move(unmanagedTensorHandles))
    , m_InputSize(numeric_cast<DifferenceType>(inputLayerInfo.size()))
    , m_IsAllocated(false)
    , m_ExecutionDataVec(executionDataVec)
    , m_Backends(backends)
{
    for (const auto& inputInfo : inputLayerInfo)
    {
        m_InputValidationMap[inputInfo.m_LayerBindingId] = false;
 
        // Map the LayerBindingIds to the corresponding input ITensorHandle*
        auto memDesc = m_WorkingMemDescriptors.at(inputInfo.m_InputSlotCoords[0].first);
        ITensorHandle* inputTensorHandle = memDesc.m_Inputs[inputInfo.m_InputSlotCoords[0].second];
        m_InputHandleMap[inputInfo.m_LayerBindingId] = inputTensorHandle;
 
        // For every input we need to store all locations from which that input's ITensorHandle* is read.
        // So we can, at a later point, swap in and out the ITensorHandle* at that location.
        for (auto inputSlot : inputInfo.m_InputSlotCoords)
        {
            WorkingMemDescriptor& workingMemDescriptor = m_WorkingMemDescriptors.at(inputSlot.first);
 
            auto inputPos = workingMemDescriptor.m_Inputs.begin();
 
            // The DifferenceType of a vector can be unsigned int or signed int depending on the std implementation
            // This cast removes any conversion warnings
            inputPos += numeric_cast<DifferenceType>(inputSlot.second);
            m_InputConnectionMap[inputInfo.m_LayerBindingId].push_back(inputPos);
        }
    }
    size_t bindingIdCount = inputLayerInfo.size();
    for (const auto& outputInfo : outputLayerInfo)
    {
        for (auto bindingId : outputInfo.m_LayerBindingIds)
        {
            m_OutputValidationMap[bindingId] = false;
 
            // Store the outputSlot position of the tensorhandle
            auto outputPos = m_WorkingMemDescriptors.at(outputInfo.m_OutputSlotCoords.first).m_Outputs.begin();
            outputPos += numeric_cast<DifferenceType>(outputInfo.m_OutputSlotCoords.second);
 
            m_OutputHandleMap[bindingId] = *outputPos;
        }
        bindingIdCount += outputInfo.m_LayerBindingIds.size();
        // More than one layerBinding id means the tensorhandle is connected to more than one OutputLayer.
        // Importing in this case would likely cause unexpected behaviour, so we disallow it.
        if (outputInfo.m_LayerBindingIds.size() != 1)
        {
            continue;
        }
 
        // Store the inputSlot positions of the tensorhandle
        for (auto outputSlot : outputInfo.m_InputSlotCoords)
        {
            WorkingMemDescriptor& workingMemDescriptor = m_WorkingMemDescriptors.at(outputSlot.first);
 
            auto inputPos = workingMemDescriptor.m_Inputs.begin();
 
            // The DifferenceType of a vector can be unsigned int or signed int depending on the std implementation
            // This cast removes any conversion warnings
            inputPos += numeric_cast<DifferenceType>(outputSlot.second);
            m_OutputConnectionMap[outputInfo.m_LayerBindingIds[0]].push_back(inputPos);
        }
    }
    m_BindingIdVec = std::vector<LayerBindingId>(bindingIdCount);
    IgnoreUnused(m_UnmanagedTensorHandles);
}

References armnn::IgnoreUnused(), and WorkingMemDescriptor::m_Inputs.

~WorkingMemHandle()

~WorkingMemHandle ( )

inline

Definition at line 61 of file WorkingMemHandle.hpp.

    { Free(); }

References WorkingMemHandle::Free().

Member Function Documentation

Allocate()

void Allocate ( )

overridevirtual

Allocate the backing memory required for execution.

If this is not called, then allocation will be deferred to execution time.

Implements IWorkingMemHandle.

Definition at line 100 of file WorkingMemHandle.cpp.

{
    if (m_IsAllocated)
    {
        return;
    }
    m_IsAllocated = true;
 
    m_MemoryManager->Allocate();
 
    for (unsigned int i = 0; i < m_TensorMemory.size(); ++i)
    {
        m_ManagedTensorHandles[i]->Import(m_TensorMemory[i].first->m_Data, m_TensorMemory[i].second);
    }
 
    // Assign previously allocated ExecutionData. Needs to be assigned after allocation so the void* are allocated.
    for (unsigned int i = 0; i < m_ExecutionDataVec.size(); ++i)
    {
        auto& backend = m_Backends->at(m_ExecutionDataVec[i].first);
 
        ExecutionData executionData = backend->CreateExecutionData(GetWorkingMemDescriptorAt(i));
        m_ExecutionDataVec[i].second = executionData;
    }
}

References WorkingMemHandle::GetWorkingMemDescriptorAt().

Referenced by LoadedNetwork::Execute().

Free()

void Free ( )

overridevirtual

Free the backing memory required for execution.

Implements IWorkingMemHandle.

Definition at line 125 of file WorkingMemHandle.cpp.

{
    if (!m_IsAllocated)
    {
        return;
    }
    m_IsAllocated = false;
 
    m_MemoryManager->Deallocate();
}

Referenced by WorkingMemHandle::~WorkingMemHandle().

GetBindingIdVector()

std::vector<LayerBindingId>& GetBindingIdVector ( )

inline

Definition at line 119 of file WorkingMemHandle.hpp.

    {
        return m_BindingIdVec;
    };

Referenced by LoadedNetwork::Execute().

GetExecutionDataAt()

std::pair<BackendId, ExecutionData>& GetExecutionDataAt ( unsigned int  id )

inlineoverridevirtual

Get the ExecutionData at an index.

The ExecutionData is paired with a BackendId to be able to call backend specific functions upon it. The ExecutionData are stored in the same order as the Workloads in a topologically sorted graph.

Implements IWorkingMemHandle.

Definition at line 92 of file WorkingMemHandle.hpp.

    {
        return m_ExecutionDataVec[id];
    }

Referenced by LoadedNetwork::Execute().

GetInputConnections()

const std::vector<std::vector<ITensorHandle*>::iterator>& GetInputConnections ( LayerBindingId  layerBindingId ) const

inline

Definition at line 107 of file WorkingMemHandle.hpp.

    {
        return m_InputConnectionMap.at(layerBindingId);
    };

Referenced by LoadedNetwork::Execute().

GetInputHandle()

ITensorHandle* GetInputHandle ( LayerBindingId  layerBindingId ) const

inline

Definition at line 97 of file WorkingMemHandle.hpp.

    {
        return m_InputHandleMap.at(layerBindingId);
    };

Referenced by LoadedNetwork::Execute().

GetNetworkId()

NetworkId GetNetworkId ( )

inlineoverridevirtual

Returns the NetworkId of the Network that this IWorkingMemHandle works with.

Implements IWorkingMemHandle.

Definition at line 64 of file WorkingMemHandle.hpp.

    {
        return m_NetworkId;
    }

GetOutputConnection()

const std::vector<std::vector<ITensorHandle*>::iterator>& GetOutputConnection ( LayerBindingId  layerBindingId ) const

inline

Definition at line 112 of file WorkingMemHandle.hpp.

    {
        return m_OutputConnectionMap.at(layerBindingId);
    };

Referenced by LoadedNetwork::Execute().

GetOutputHandle()

ITensorHandle* GetOutputHandle ( LayerBindingId  layerBindingId ) const

inline

Definition at line 102 of file WorkingMemHandle.hpp.

    {
        return m_OutputHandleMap.at(layerBindingId);
    };

Referenced by LoadedNetwork::Execute().

GetWorkingMemDescriptorAt()

WorkingMemDescriptor& GetWorkingMemDescriptorAt ( unsigned int  id )

inlineoverridevirtual

Get the WorkingMemDescriptor at an index.

The WorkingMemDescriptors are stored in the same order as the Workloads in a topologically sorted graph.

Implements IWorkingMemHandle.

Definition at line 84 of file WorkingMemHandle.hpp.

    {
        return m_WorkingMemDescriptors[id];
    }

Referenced by WorkingMemHandle::Allocate().

IsAllocated()

bool IsAllocated ( )

inlineoverridevirtual

IsAllocated returns true if the backing memory is currently allocated.

Implements IWorkingMemHandle.

Definition at line 77 of file WorkingMemHandle.hpp.

    {
        return m_IsAllocated;
    }

Referenced by LoadedNetwork::Execute().

MemSyncOutputs()

void MemSyncOutputs

(

)

Definition at line 136 of file WorkingMemHandle.cpp.

{
    for (auto output : m_OutputConnectionMap)
    {
        (*output.second[0])->Map(true);
        (*output.second[0])->Unmap();
    }
}

References armnn::Map, and armnn::Unmap.

Referenced by LoadedNetwork::Execute().

ValidateBindingIds()

void ValidateBindingIds

(

)

Definition at line 145 of file WorkingMemHandle.cpp.

{
    auto resetInputValidationMap = [&]()
    {
        for (auto& pair: m_InputValidationMap)
        {
            pair.second = false;
        }
    };
 
    auto resetOutputValidationMap = [&]()
    {
        for (auto& pair: m_OutputValidationMap)
        {
            pair.second = false;
        }
    };
 
    std::for_each(m_BindingIdVec.begin(), m_BindingIdVec.begin() + m_InputSize, [&](LayerBindingId id)
    {
        try
        {
            bool& isUsed = m_InputValidationMap.at(id);
            if (isUsed)
            {
                resetInputValidationMap();
                throw InvalidArgumentException(fmt::format("Duplicate Input LayerBindingId: {}", id));
            }
            isUsed = true;
        }
        catch (const std::out_of_range&)
        {
            resetInputValidationMap();
            throw InvalidArgumentException(fmt::format("Unknown Input LayerBindingId: {}", id));
        }
    });
    resetInputValidationMap();
 
    std::for_each(m_BindingIdVec.begin() + m_InputSize, m_BindingIdVec.end(), [&](LayerBindingId id)
    {
        try
        {
            bool& isUsed = m_OutputValidationMap.at(id);
            if (isUsed)
            {
                resetOutputValidationMap();
                throw InvalidArgumentException(fmt::format("Duplicate Output LayerBindingId: {}", id));
            }
            isUsed = true;
        }
        catch (const std::out_of_range&)
        {
            resetOutputValidationMap();
            throw InvalidArgumentException(fmt::format("Unknown Output LayerBindingId: {}", id));
        }
    });
    resetOutputValidationMap();
}

Referenced by LoadedNetwork::Execute().

---

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

• src/armnn/WorkingMemHandle.hpp
• src/armnn/WorkingMemHandle.cpp