Graph Class Reference

#include <Graph.hpp>

Classes
struct	InputLayersAccessor
	Wrapper class returned by Graph::GetInputLayers() More...
class	LayerInGraph< ConstantLayer >
class	LayerInGraph< InputLayer >
	Inputs add/remove their binding id to m_InputIds in the graph. More...
class	LayerInGraph< OutputLayer >
	Outputs add/remove their binding id to m_OutputIds in the graph. More...
struct	OutputLayersAccessor
	Wrapper class returned by Graph::GetOutputLayers() More...

Public Types
using	LayerList = std::list<Layer*>
using	Iterator = LayerList::const_iterator
using	IteratorDifference = Iterator::difference_type
using	ConstIterator = TransformIterator<decltype(&PtrCast<const Layer>), Iterator>
using	ConstIteratorInputs = TransformIterator<decltype(&PtrCast<const InputLayer>), Iterator>
using	ConstIteratorOutputs = TransformIterator<decltype(&PtrCast<const OutputLayer>), Iterator>

Public Member Functions
template<typename Func>
void	ForEachLayer (Func func) const
	Graph (bool shapeInferenceMethod=false, bool allowExpandedDims=false)
	Graph (const Graph &other)
Graph &	operator= (const Graph &other)=delete
	Graph (Graph &&other)
Graph &	operator= (Graph &&other)
	~Graph ()
Status	Print (bool extended=false) const
Status	SerializeToDot (std::ostream &stream)
template<typename LayerT, typename... Args>
LayerT *	AddLayer (Args &&... args)
	Adds a new layer, of type LayerType, to the graph constructed with the arguments passed.
template<typename LayerT, typename... Args>
LayerT *	InsertNewLayer (InputSlot &insertBefore, Args &&... args)
	Inserts a new layer between the output slot currently connected to insertBefore and insertBefore itself.
template<typename LayerT, typename... Args>
LayerT *	InsertNewLayer (OutputSlot &insertAfter, Args &&... args)
	Inserts a new layer between insertAfter and the input slot(s) currently connected to it.
void	EraseLayer (Iterator pos)
	Deletes the layer at the specified position.
template<typename LayerT>
void	EraseLayer (LayerT *&layer)
	Deletes the layer.
Iterator	begin ()
	Returns iterator pointing to the beginning of the list. Lowercase for range-based for loops.
Iterator	end ()
	Returns iterator pointing to the end of the list. Lowercase for range-based for loops.
ConstIterator	begin () const
	Returns const iterator pointing to the beginning of the list. Lowercase for range-based for loops.
ConstIterator	end () const
	Returns const iterator pointing to the end of the list. Lowercase for range-based for loops.
ConstIterator	cbegin () const
	Returns const iterator pointing to the beginning of the list. Lowercase for range-based for loops.
ConstIterator	cend () const
	Returns const iterator pointing to the end of the list. Lowercase for range-based for loops.
Graph &	TopologicalSort ()
	Sorts layers in topological order and return this.
const Graph &	TopologicalSort () const
size_t	GetNumInputs () const
size_t	GetNumOutputs () const
InputLayersAccessor	GetInputLayers () const
	Returns a wrapper object with begin(), end() methods to iterate over the input layers in a range-based for loop.
OutputLayersAccessor	GetOutputLayers () const
	Returns a wrapper object with begin(), end() methods to iterate over the output layers in a range-based for loop.
size_t	GetNumLayers () const
Status	AllocateDynamicBuffers ()
	Allocates memory for all tensors under output tensor handers of each layer.
void	AddCompatibilityLayers (std::map< BackendId, std::unique_ptr< class IBackendInternal > > &backends, TensorHandleFactoryRegistry &registry)
	Modifies the graph in-place, removing edges connecting layers using different compute devices, and relinking them via an intermediary copy layers.
void	SubstituteSubgraph (SubgraphView &subgraph, IConnectableLayer *substituteLayer)
	Substitutes the given sub-graph with either a new layer or a new sub-graph.
void	SubstituteSubgraph (SubgraphView &subgraph, const SubgraphView &substituteSubgraph)
void	VerifyConstantLayerSetTensorInfo () const
	For each ConstantLayer in Graph, ensures TensorInfo is set on all output slots.
void	InferTensorInfos ()
void	AttachObservable (IGraphObservable *const observable, GraphEvent notifyOnEvent)
void	DetachObservable (IGraphObservable *const observable, GraphEvent notifyOnEvent)
Iterator	GetPosInGraph (Layer &layer)
	Gets the position of a layer in the graph.
const std::shared_ptr< IProfiler > &	GetProfiler () const
void	SetLayersOutOfOrder ()

Static Public Member Functions
template<typename LayerType>
static LayerType *	PtrCast (Layer *const layer)

Friends
class	SubgraphView

Detailed Description

Definition at line 30 of file Graph.hpp.

Member Typedef Documentation

ConstIterator

using ConstIterator = TransformIterator<decltype(&PtrCast<const Layer>), Iterator>

Definition at line 56 of file Graph.hpp.

ConstIteratorInputs

using ConstIteratorInputs = TransformIterator<decltype(&PtrCast<const InputLayer>), Iterator>

Definition at line 57 of file Graph.hpp.

ConstIteratorOutputs

using ConstIteratorOutputs = TransformIterator<decltype(&PtrCast<const OutputLayer>), Iterator>

Definition at line 58 of file Graph.hpp.

Iterator

using Iterator = LayerList::const_iterator

Definition at line 53 of file Graph.hpp.

IteratorDifference

using IteratorDifference = Iterator::difference_type

Definition at line 54 of file Graph.hpp.

LayerList

using LayerList = std::list<Layer*>

Definition at line 50 of file Graph.hpp.

Constructor & Destructor Documentation

Graph() [1/3]

Graph ( bool shapeInferenceMethod = false, bool allowExpandedDims = false )

inline

Definition at line 98 of file Graph.hpp.

        : m_LayersInOrder(true)
        , m_AllowExpandedDims(allowExpandedDims)
        , m_ShapeInferenceMethod(shapeInferenceMethod ? ShapeInferenceMethod::InferAndValidate :
                                                        ShapeInferenceMethod::ValidateOnly)
        , m_Profiler(std::make_shared<IProfiler>())
        {}

References armnn::InferAndValidate, and armnn::ValidateOnly.

Referenced by Graph(), Graph(), Graph::InputLayersAccessor::InputLayersAccessor(), Graph::LayerInGraph< ConstantLayer >::LayerInGraph(), Graph::LayerInGraph< ConstantLayer >::LayerInGraph(), Graph::LayerInGraph< InputLayer >::LayerInGraph(), Graph::LayerInGraph< InputLayer >::LayerInGraph(), Graph::LayerInGraph< OutputLayer >::LayerInGraph(), operator=(), operator=(), Graph::OutputLayersAccessor::OutputLayersAccessor(), TopologicalSort(), and TopologicalSort().

Graph() [2/3]

Graph

(

const Graph &

other

)

Definition at line 27 of file Graph.cpp.

:   m_LayersInOrder(other.m_LayersInOrder)
,   m_AllowExpandedDims(other.m_AllowExpandedDims)
,   m_ShapeInferenceMethod(other.m_ShapeInferenceMethod)
,   m_Profiler(other.m_Profiler)
{
    std::unordered_map<const Layer*, Layer*> otherToClonedMap;
 
    for (auto&& otherLayer : other.m_Layers)
    {
        Layer* const layer = otherLayer->Clone(*this);
        otherToClonedMap.emplace(otherLayer, layer);
    }
 
    // Copies slot connections.
    for (auto&& otherLayer : other.m_Layers)
    {
        Layer* const thisLayer = otherToClonedMap[otherLayer];
 
        auto outputSlot = thisLayer->BeginOutputSlots();
        for (auto&& otherOutputSlot : otherLayer->GetOutputSlots())
        {
            for (auto&& otherInputSlot : otherOutputSlot.GetConnections())
            {
                const Layer& otherTgtLayer = otherInputSlot->GetOwningLayer();
                Layer* const thisTgtLayer = otherToClonedMap[&otherTgtLayer];
 
                InputSlot& inputSlot = thisTgtLayer->GetInputSlot(otherInputSlot->GetSlotIndex());
 
                if (otherInputSlot->IsTensorInfoOverridden())
                {
                    inputSlot.SetTensorInfo(otherInputSlot->GetTensorInfo());
                }
                outputSlot->Connect(inputSlot);
            }
            outputSlot->SetTensorInfo(otherOutputSlot.GetTensorInfo());
            ++outputSlot;
        }
    }
}

References Graph().

Graph() [3/3]

Graph ( Graph && other )

inline

Definition at line 110 of file Graph.hpp.

    {
        *this = std::move(other);
    }

References Graph().

~Graph()

~Graph ( )

inline

Definition at line 142 of file Graph.hpp.

    {
        ForEachLayer([](Layer* layer)
        {
            delete layer;
        });
    }

References ForEachLayer().

Member Function Documentation

AddCompatibilityLayers()

void AddCompatibilityLayers	(	std::map< BackendId, std::unique_ptr< class IBackendInternal > > &	backends,
		TensorHandleFactoryRegistry &	registry )

Modifies the graph in-place, removing edges connecting layers using different compute devices, and relinking them via an intermediary copy layers.

Definition at line 330 of file Graph.cpp.

{
    // Returns true if the given layer could potentially need an intermediate copy/import layer (depending on its
    // connections to other layers).
    auto MayNeedCompatibilityLayer = [](const Layer& layer)
    {
        // All layers should have been associated with a valid compute device at this point.
        if (layer.GetBackendId() == Compute::Undefined)
        {
            throw armnn::Exception("AddCompatibilityLayers: All layers must be assigned to a backend at this point.");
        }
        // Does not need another compatibility layer if a copy or import layer is already present.
        return layer.GetType() != LayerType::MemCopy &&
               layer.GetType() != LayerType::MemImport;
    };
 
    auto IsCompatibilityStrategy = [](EdgeStrategy strategy)
    {
        return strategy == EdgeStrategy::CopyToTarget ||
               strategy == EdgeStrategy::ExportToTarget;
    };
 
    ForEachLayer([this, &backends, &registry, MayNeedCompatibilityLayer, IsCompatibilityStrategy](Layer* srcLayer)
    {
        ARMNN_THROW_INVALIDARG_MSG_IF_FALSE(srcLayer, "source layer must not be null.");
 
        if (!MayNeedCompatibilityLayer(*srcLayer))
        {
            // The current layer does not need copy layers, move to the next one
            return;
        }
 
        const std::vector<OutputSlot>& srcOutputSlots = srcLayer->GetOutputSlots();
        for (unsigned int srcOutputIndex = 0; srcOutputIndex < srcOutputSlots.size(); srcOutputIndex++)
        {
            OutputSlot& srcOutputSlot = srcLayer->GetOutputSlot(srcOutputIndex);
            const std::vector<InputSlot*> srcConnections = srcOutputSlot.GetConnections();
            const std::vector<EdgeStrategy> srcEdgeStrategies = srcOutputSlot.GetEdgeStrategies();
            for (unsigned int srcConnectionIndex = 0; srcConnectionIndex < srcConnections.size(); srcConnectionIndex++)
            {
                InputSlot* dstInputSlot = srcConnections[srcConnectionIndex];
                if (!dstInputSlot)
                {
                    throw armnn::Exception("dstInputSlot must not be null.");
                }
 
                EdgeStrategy strategy = srcEdgeStrategies[srcConnectionIndex];
                if (strategy == EdgeStrategy::Undefined)
                {
                    throw armnn::Exception("Undefined memory strategy found "
                                           "while adding copy layers for compatibility");
                }
 
                const Layer& dstLayer = dstInputSlot->GetOwningLayer();
                if (MayNeedCompatibilityLayer(dstLayer) &&
                    IsCompatibilityStrategy(strategy))
                {
                    // A copy layer is needed in between the source and destination layers.
                    // Record the operation rather than attempting to modify the graph as we go.
                    // (invalidating iterators)
                    const std::string compLayerName = fmt::format("[ {} ({}) -> {} ({}) ]",
                                                                  srcLayer->GetName(),
                                                                  srcOutputIndex,
                                                                  dstLayer.GetName(),
                                                                  dstInputSlot->GetSlotIndex());
                    Layer* compLayer = nullptr;
                    if (strategy == EdgeStrategy::CopyToTarget)
                    {
                        compLayer = InsertNewLayer<MemCopyLayer>(*dstInputSlot, compLayerName.c_str());
                    }
                    else
                    {
                        if (strategy != EdgeStrategy::ExportToTarget)
                        {
                            throw armnn::Exception("Invalid edge strategy found.");
                        }
 
                        compLayer = InsertNewLayer<MemImportLayer>(*dstInputSlot, compLayerName.c_str());
                    }
 
                    compLayer->SetBackendId(dstLayer.GetBackendId());
 
                    OutputSlot& compOutputSlot = compLayer->GetOutputSlot(0);
                    auto backendIt = backends.find(dstLayer.GetBackendId());
                    if (backendIt != backends.end() &&
                        backendIt->second &&
                        backendIt->second->SupportsTensorAllocatorAPI())
                    {
                        auto backend = backendIt->second.get();
                        auto tensorHandleFactoryIds = backend->GetHandleFactoryPreferences();
                        bool found = false;
 
                        for (auto preference : tensorHandleFactoryIds)
                        {
                            auto factory = registry.GetFactory(preference);
                            if (factory)
                            {
                                auto srcPref = srcOutputSlot.GetTensorHandleFactoryId();
                                auto srcFactory = registry.GetFactory(srcPref);
 
                                if (srcFactory)
                                {
                                    bool canExportImport =
                                        (factory->GetImportFlags() & srcFactory->GetExportFlags()) != 0;
 
                                    if (factory->SupportsMapUnmap() || canExportImport)
                                    {
                                        compOutputSlot.SetTensorHandleFactory(preference);
                                        found = true;
                                        break;
                                    }
                                }
                            }
                        }
 
                        if (!found)
                        {
                            compOutputSlot.SetTensorHandleFactory(ITensorHandleFactory::LegacyFactoryId);
                        }
                    }
                    else
                    {
                        compOutputSlot.SetTensorHandleFactory(ITensorHandleFactory::LegacyFactoryId);
                    }
 
                    // The output strategy of a compatibility layer is always DirectCompatibility.
                    compOutputSlot.SetEdgeStrategy(0, EdgeStrategy::DirectCompatibility);
 
                    // Recalculate the connection index on the previous layer as we have just inserted into it.
                    const std::vector<InputSlot*>& newSourceConnections = srcOutputSlot.GetConnections();
                    auto newSrcConnectionIndex = std::distance(newSourceConnections.begin(),
                                                               std::find(newSourceConnections.begin(),
                                                                         newSourceConnections.end(),
                                                                         &compLayer->GetInputSlot(0)));
 
                    // The input strategy of a compatibility layer is always DirectCompatibilty.
                    srcOutputSlot.SetEdgeStrategy(armnn::numeric_cast<unsigned int>(newSrcConnectionIndex),
                                                    EdgeStrategy::DirectCompatibility);
                }
            }
        }
    });
}

References AddCompatibilityLayers(), ARMNN_THROW_INVALIDARG_MSG_IF_FALSE, armnn::CopyToTarget, armnn::DirectCompatibility, armnn::ExportToTarget, ForEachLayer(), Layer::GetBackendId(), OutputSlot::GetConnections(), OutputSlot::GetEdgeStrategies(), TensorHandleFactoryRegistry::GetFactory(), Layer::GetInputSlot(), Layer::GetName(), Layer::GetOutputSlot(), Layer::GetOutputSlots(), InputSlot::GetOwningLayer(), InputSlot::GetSlotIndex(), OutputSlot::GetTensorHandleFactoryId(), InsertNewLayer(), ITensorHandleFactory::LegacyFactoryId, armnn::MemCopy, armnn::MemImport, armnn::numeric_cast(), Layer::SetBackendId(), OutputSlot::SetEdgeStrategy(), OutputSlot::SetTensorHandleFactory(), and armnn::Undefined.

Referenced by AddCompatibilityLayers(), and IOptimizedNetwork::Optimize.

AddLayer()

template<typename LayerT, typename... Args>

LayerT * AddLayer ( Args &&... args )

inline

Adds a new layer, of type LayerType, to the graph constructed with the arguments passed.

Definition at line 466 of file Graph.hpp.

{
    m_LayersInOrder = m_LayersInOrder &&
        ((LayerEnumOf<LayerT>() == LayerType::Input) || (LayerEnumOf<LayerT>() == LayerType::Output));
    LayerT* const layer = new LayerInGraph<LayerT>(*this, std::forward<Args>(args)...);
 
    layer->SetShapeInferenceMethod(m_ShapeInferenceMethod);
    layer->SetAllowExpandedDims(m_AllowExpandedDims);
 
    NotifyObservables(GraphEvent::LayerAdded, layer);
 
    return layer;
}

References armnn::Input, armnn::LayerAdded, armnn::LayerEnumOf(), and armnn::Output.

Referenced by Layer::CloneBase(), and FuseBatchNorm< ConvLayer, ArmnnType, T >::Run().

AllocateDynamicBuffers()

Status AllocateDynamicBuffers

(

)

Allocates memory for all tensors under output tensor handers of each layer.

Definition at line 207 of file Graph.cpp.

{
    // Layers must be sorted in topological order
    ARMNN_THROW_INVALIDARG_MSG_IF_FALSE(m_LayersInOrder, "layers must be in order.");
 
    ARMNN_SCOPED_PROFILING_EVENT(Compute::Undefined, "LoadNetwork_AllocateDynamicBuffers");
 
    std::unordered_set<const ITensorHandle*> preallocatedTensors;
    std::unordered_map<const ITensorHandle*, unsigned int> handleReferenceCounts;
 
    // Finds the first TensorHandle ancestor of a SubTensorHandle. If the ITensorHandle provided
    // is a TensorHandle, the function just returns it
    auto TraceSubTensorHandleAncestry = [](ITensorHandle* const subTensorHandle)
    {
        ITensorHandle* ancestor = subTensorHandle;
        while (ancestor && ancestor->GetParent())
        {
            ancestor = ancestor->GetParent();
        }
        return ancestor;
    };
 
    // Checks whether a TensorHandle has been pre-allocated
    auto IsPreallocated = [&](ITensorHandle* const tensorHandle)
    {
        return tensorHandle && preallocatedTensors.find(tensorHandle) != preallocatedTensors.end();
    };
 
    // Constant tensor handles need to last from the beginning of execution till the end,
    // therefore we pre-allocate them upfront
    for (auto&& layer : m_Layers)
    {
        if (layer->GetType() == LayerType::Constant)
        {
            for (auto&& slot = layer->BeginOutputSlots(); slot != layer->EndOutputSlots(); ++slot)
            {
                ITensorHandle *tensorHandle = TraceSubTensorHandleAncestry(slot->GetOutputHandler().GetData());
 
                if (tensorHandle && !IsPreallocated(tensorHandle))
                {
                    tensorHandle->Allocate();
                    preallocatedTensors.insert(tensorHandle);
                }
            }
        }
    }
 
    // Iterate over the network in topological order
    for (auto&& layer : m_Layers)
    {
        // Count the amount of times each output slot references a certain buffer (ITensorHandle).
        // The first time we encounter a new tensor handle, we start managing its lifetime.
        for (auto&& slot = layer->BeginOutputSlots(); slot != layer->EndOutputSlots(); ++slot)
        {
            ITensorHandle *tensorHandle = TraceSubTensorHandleAncestry(slot->GetOutputHandler().GetData());
 
            if (tensorHandle && !IsPreallocated(tensorHandle))
            {
                unsigned int numConnections = slot->GetNumConnections();
                if (handleReferenceCounts.find(tensorHandle) == handleReferenceCounts.end())
                {
                    handleReferenceCounts[tensorHandle] = numConnections;
                    tensorHandle->Manage();
                    if (handleReferenceCounts[tensorHandle] == 0u)
                    {
                          // if nobody consumes this tensor we call Allocate()
                          tensorHandle->Allocate();
                    }
                }
                else
                {
                    handleReferenceCounts[tensorHandle] += numConnections;
                }
            }
        }
 
        // Loop through the input slots in the same layer and decrement the reference counter associated
        // to each tensor handle we encounter. Once it reaches zero, we end the lifetime of the tensor handle
        for (auto&& slot = layer->BeginInputSlots(); slot != layer->EndInputSlots(); ++slot)
        {
            ITensorHandle *tensorHandle = TraceSubTensorHandleAncestry(
                slot->GetConnectedOutputSlot()->GetOutputHandler().GetData());
 
            if (tensorHandle && !IsPreallocated(tensorHandle))
            {
                --handleReferenceCounts[tensorHandle];
 
                if (handleReferenceCounts[tensorHandle] == 0u)
                {
                    // Stop managing lifetime of tensor handle
                    tensorHandle->Allocate();
                    handleReferenceCounts.erase(tensorHandle);
                }
            }
        }
    }
 
    return Status::Success;
}

References ITensorHandle::Allocate(), AllocateDynamicBuffers(), ARMNN_SCOPED_PROFILING_EVENT, ARMNN_THROW_INVALIDARG_MSG_IF_FALSE, armnn::Constant, ITensorHandle::GetParent(), ITensorHandle::Manage(), armnn::Success, and armnn::Undefined.

Referenced by AllocateDynamicBuffers().

AttachObservable()

void AttachObservable ( IGraphObservable *const observable, GraphEvent notifyOnEvent )

inline

Definition at line 226 of file Graph.hpp.

                                                                                        {
        m_Views[notifyOnEvent].emplace_back(observable);
    }

begin() [1/2]

Iterator begin ( )

inline

Returns iterator pointing to the beginning of the list. Lowercase for range-based for loops.

Definition at line 176 of file Graph.hpp.

{ return m_Layers.begin(); }

Referenced by cbegin(), armnn::IsTfLiteTurboModel(), Graph::LayerInGraph< ConstantLayer >::LayerInGraph(), Graph::LayerInGraph< InputLayer >::LayerInGraph(), IOptimizedNetwork::Optimize, and Optimizer::Pass().

begin() [2/2]

ConstIterator begin ( ) const

inline

Returns const iterator pointing to the beginning of the list. Lowercase for range-based for loops.

Definition at line 181 of file Graph.hpp.

{ return {m_Layers.begin(), &(PtrCast<const Layer>)}; }

References PtrCast().

cbegin()

ConstIterator cbegin ( ) const

inline

Returns const iterator pointing to the beginning of the list. Lowercase for range-based for loops.

Definition at line 186 of file Graph.hpp.

{ return begin(); }

References begin().

cend()

ConstIterator cend ( ) const

inline

Returns const iterator pointing to the end of the list. Lowercase for range-based for loops.

Definition at line 188 of file Graph.hpp.

{ return end(); }

References end().

DetachObservable()

void DetachObservable ( IGraphObservable *const observable, GraphEvent notifyOnEvent )

inline

Definition at line 230 of file Graph.hpp.

                                                                                        {
        m_Views[notifyOnEvent].remove(observable);
    }

end() [1/2]

Iterator end ( )

inline

Returns iterator pointing to the end of the list. Lowercase for range-based for loops.

Definition at line 178 of file Graph.hpp.

{ return m_Layers.end(); }

Referenced by cend(), armnn::IsTfLiteTurboModel(), Graph::LayerInGraph< OutputLayer >::LayerInGraph(), IOptimizedNetwork::Optimize, and Optimizer::Pass().

end() [2/2]

ConstIterator end ( ) const

inline

Returns const iterator pointing to the end of the list. Lowercase for range-based for loops.

Definition at line 183 of file Graph.hpp.

{ return {m_Layers.end(), &(PtrCast<const Layer>)}; }

References PtrCast().

EraseLayer() [1/2]

void EraseLayer ( Iterator pos )

inline

Deletes the layer at the specified position.

Definition at line 517 of file Graph.hpp.

{
    NotifyObservables(GraphEvent::LayerErased, *pos);
 
    delete *pos;
}

References armnn::LayerErased.

Referenced by armnn::ApplyBackendOptimizations(), EraseLayer(), Optimizer::Pass(), OptimizeForConnectionImpl< BaseType, ChildType, Wrapped >::Run(), and OptimizeForExclusiveConnectionImpl< BaseType, ChildType, Wrapped >::Run().

EraseLayer() [2/2]

template<typename LayerT>

void EraseLayer ( LayerT *& layer )

inline

Deletes the layer.

Sets layer to nullptr on return. Templated to support pointers to any layer type.

Definition at line 525 of file Graph.hpp.

{
    if (!layer)
    {
        throw armnn::NullPointerException("layer must not be null.");
    }
 
    EraseLayer(GetPosInGraph(*layer));
    layer = nullptr;
}

References EraseLayer(), and GetPosInGraph().

ForEachLayer()

template<typename Func>

void ForEachLayer ( Func func ) const

inline

Definition at line 40 of file Graph.hpp.

    {
        for (auto it = m_Layers.begin(); it != m_Layers.end(); )
        {
             auto next = std::next(it);
             func(*it);
             it = next;
        }
    }

Referenced by AddCompatibilityLayers(), armnn::SelectTensorHandleStrategy(), and ~Graph().

GetInputLayers()

InputLayersAccessor GetInputLayers ( ) const

inline

Returns a wrapper object with begin(), end() methods to iterate over the input layers in a range-based for loop.

Definition at line 199 of file Graph.hpp.

{ return InputLayersAccessor(*this); }

Referenced by LoadedNetwork::EnqueueWorkload(), and LoadedNetwork::ImportInputs().

GetNumInputs()

size_t GetNumInputs ( ) const

inline

Definition at line 194 of file Graph.hpp.

{ return m_InputIds.size(); }

Referenced by LoadedNetwork::EnqueueWorkload(), Graph::LayerInGraph< ConstantLayer >::LayerInGraph(), and Graph::LayerInGraph< InputLayer >::LayerInGraph().

GetNumLayers()

size_t GetNumLayers ( ) const

inline

Definition at line 205 of file Graph.hpp.

{ return m_Layers.size(); }

Referenced by LoadedNetwork::EnqueueWorkload().

GetNumOutputs()

size_t GetNumOutputs ( ) const

inline

Definition at line 195 of file Graph.hpp.

{ return m_OutputIds.size(); }

Referenced by LoadedNetwork::EnqueueWorkload().

GetOutputLayers()

OutputLayersAccessor GetOutputLayers ( ) const

inline

Returns a wrapper object with begin(), end() methods to iterate over the output layers in a range-based for loop.

Definition at line 203 of file Graph.hpp.

{ return OutputLayersAccessor(*this); }

Referenced by LoadedNetwork::EnqueueWorkload(), and LoadedNetwork::ImportOutputs().

GetPosInGraph()

Graph::Iterator GetPosInGraph ( Layer & layer )

inline

Gets the position of a layer in the graph.

Definition at line 455 of file Graph.hpp.

{
    auto it = m_PosInGraphMap.find(&layer);
    if (it == m_PosInGraphMap.end())
    {
        throw armnn::Exception("unable to find layer in graph map.");
    }
    return it->second;
}

Referenced by EraseLayer(), InsertNewLayer(), InsertNewLayer(), and Optimizer::Pass().

GetProfiler()

const std::shared_ptr< IProfiler > & GetProfiler

(

)

const

Definition at line 733 of file Graph.cpp.

{
    return m_Profiler;
}

References GetProfiler().

Referenced by GetProfiler(), and IOptimizedNetwork::Optimize.

InferTensorInfos()

void InferTensorInfos

(

)

Definition at line 645 of file Graph.cpp.

{
    for (auto&& layer : TopologicalSort())
    {
        for (auto&& input : layer->GetInputSlots())
        {
            const IOutputSlot* source = input.GetConnectedOutputSlot();
            if (source == NULL)
            {
                // Throws exception due to a layer input not being connected to an output slot.
                // Verifies input slot weights and bias are set for FullyConnected layers.
                ConstructErrorMessageForUnconnectedInputs(layer, input.GetSlotIndex());
            }
 
            if (!source->IsTensorInfoSet())
            {
                std::ostringstream message;
                message << "Output slot TensorInfo not set on "
                        << GetLayerTypeAsCString(layer->GetType())
                        << " layer "
                        << std::quoted(layer->GetName());
                throw LayerValidationException(message.str());
            }
        }
 
        if (layer->m_ShapeInferenceMethod == ShapeInferenceMethod::ValidateOnly)
        {
            layer->ValidateTensorShapesFromInputs();
        }
    }
}

References armnn::GetLayerTypeAsCString(), InferTensorInfos(), IOutputSlot::IsTensorInfoSet(), TopologicalSort(), and armnn::ValidateOnly.

Referenced by InferTensorInfos(), and IOptimizedNetwork::Optimize.

InsertNewLayer() [1/2]

template<typename LayerT, typename... Args>

LayerT * InsertNewLayer ( InputSlot & insertBefore, Args &&... args )

inline

Inserts a new layer between the output slot currently connected to insertBefore and insertBefore itself.

Definition at line 481 of file Graph.hpp.

{
    // Insert after the parent if any, or before the child otherwise, so the topological order is kept.
    OutputSlot* parentOut = insertBefore.GetConnectedOutputSlot();
    const Iterator pos = (parentOut != nullptr)
                         ? std::next(GetPosInGraph(parentOut->GetOwningLayer()))
                         : GetPosInGraph(insertBefore.GetOwningLayer());
    LayerT* const layer = new LayerInGraph<LayerT>(*this, pos, std::forward<Args>(args)...);
    insertBefore.Insert(*layer);
 
    NotifyObservables(GraphEvent::LayerAdded, layer);
 
    return layer;
}

References InputSlot::GetConnectedOutputSlot(), InputSlot::GetOwningLayer(), OutputSlot::GetOwningLayer(), GetPosInGraph(), InputSlot::Insert(), and armnn::LayerAdded.

Referenced by AddCompatibilityLayers(), armnn::optimizations::pad_fold::FoldPadIntoLayer2dImpl(), armnn::InsertConvertFp16ToFp32LayersBefore(), armnn::InsertConvertFp32ToFp16LayersAfter(), armnn::InsertDebugLayerAfter(), AddBroadcastReshapeLayerImpl::Run(), FuseBatchNorm< ConvLayer, ArmnnType, T >::Run(), MaxMinIntoBoundedReluImpl::Run(), MovePermuteUpImpl::Run(), MoveTransposeUpImpl::Run(), OptimizeConsecutiveReshapesImpl::Run(), PermuteAsReshapeImpl::Run(), TransposeAsReshapeImpl::Run(), and PermuteDepthwiseConv2dWeightsImpl::~PermuteDepthwiseConv2dWeightsImpl().

InsertNewLayer() [2/2]

template<typename LayerT, typename... Args>

LayerT * InsertNewLayer ( OutputSlot & insertAfter, Args &&... args )

inline

Inserts a new layer between insertAfter and the input slot(s) currently connected to it.

Definition at line 497 of file Graph.hpp.

{
    Layer& owningLayer = insertAfter.GetOwningLayer();
 
    const Iterator pos = std::next(GetPosInGraph(owningLayer));
    LayerT* const layer = new LayerInGraph<LayerT>(*this, pos, std::forward<Args>(args)...);
 
    if (layer->GetNumInputSlots() != 1)
    {
        throw armnn::Exception("layer must only one input slot.");
    }
 
    insertAfter.MoveAllConnections(layer->GetOutputSlot());
    insertAfter.Connect(layer->GetInputSlot(0));
 
    NotifyObservables(GraphEvent::LayerAdded, layer);
 
    return layer;
}

References OutputSlot::Connect(), OutputSlot::GetOwningLayer(), GetPosInGraph(), armnn::LayerAdded, and OutputSlot::MoveAllConnections().

operator=() [1/2]

Graph & operator= ( const Graph & other )

delete

References Graph().

operator=() [2/2]

Graph & operator= ( Graph && other )

inline

Definition at line 115 of file Graph.hpp.

    {
        m_InputIds      = std::move(other.m_InputIds);
        m_OutputIds     = std::move(other.m_OutputIds);
        m_LayersInOrder = std::move(other.m_LayersInOrder);
        m_Views         = std::move(other.m_Views);
        m_Profiler      = std::move(other.m_Profiler);
        m_AllowExpandedDims    = other.m_AllowExpandedDims;
        m_ShapeInferenceMethod = other.m_ShapeInferenceMethod;
        other.ForEachLayer([this](Layer* otherLayer)
        {
            otherLayer->Reparent(*this, m_Layers.end());
        });
 
        if (!other.m_PosInGraphMap.empty())
        {
            throw armnn::Exception("assignment positions in graph map must be empty.");
        }
 
        if (!other.m_Layers.empty())
        {
            throw armnn::Exception("assignment layers must be empty.");
        }
 
        return *this;
    }

References Graph(), and Layer::Reparent().

Print()

Status Print

(

bool

extended = false

)

const

Definition at line 68 of file Graph.cpp.

{
    if (m_Layers.empty())
    {
        ARMNN_LOG(info) << "\n Graph is empty.\n";
        return Status::Success;
    }
    ARMNN_LOG(info) << "\n";
    ARMNN_LOG(info) << "Walking Pattern: \n";
 
    for (auto&& it : TopologicalSort())
    {
        auto numInputSlots = it->GetNumInputSlots();
        auto numOutputSlots = it->GetNumOutputSlots();
 
        std::string guid;
        if (extended)
        {
            guid += ":";
            guid += std::to_string(it->GetGuid());
        }
        ARMNN_LOG(info) << it->GetName() << ":" << GetLayerTypeAsCString(it->GetType())
                                << ":" << it->GetBackendId().Get()
                                << guid
                                << " has " << numInputSlots << " input slots"
                                << " and " << numOutputSlots << " output slots.";
 
        for (auto i : it->GetInputSlots())
        {
            std::ostringstream message;
            auto inputTensorShape = i.GetConnectedOutputSlot()->GetTensorInfo().GetShape();
            unsigned int numDims = inputTensorShape.GetNumDimensions();
 
            message << "The input slot has shape [ ";
            for (unsigned int dim=0; dim < numDims; dim++)
            {
                message << inputTensorShape[dim] << ",";
            }
            message << " ]";
            if (extended)
            {
                message << " Scale: " << i.GetConnectedOutputSlot()->GetTensorInfo().GetQuantizationScale();
                message << " Offset: " << i.GetConnectedOutputSlot()->GetTensorInfo().GetQuantizationOffset();
                message <<  " The input slot is connected to: ";
                message << i.GetConnectedOutputSlot()->GetOwningIConnectableLayer().GetGuid();
            }
            ARMNN_LOG(info) << message.str();
        }
 
        for (unsigned int i = 0; i < it->GetNumOutputSlots(); i++)
        {
            const armnn::Layer *layer = it;
            std::ostringstream message;
            auto outputTensorShape = layer->GetOutputSlots()[i].GetTensorInfo().GetShape();
            unsigned int numDims = outputTensorShape.GetNumDimensions();
 
            message << "The output slot has shape [ ";
            for (unsigned int dim=0; dim < numDims; dim++)
            {
                message << outputTensorShape[dim] << ",";
            }
            message << " ]";
            if (extended)
            {
                message << " Scale: " << layer->GetOutputSlots()[i].GetTensorInfo().GetQuantizationScale();
                message << " Offset: " << layer->GetOutputSlots()[i].GetTensorInfo().GetQuantizationOffset();
                message <<  " The output slot is connected to: ";
                message << layer->GetOutputSlots()[i].GetConnection(0)->GetOwningIConnectableLayer().GetGuid();
            }
            ARMNN_LOG(info) << message.str();
        }
        ARMNN_LOG(info) << "\n";
    }
    ARMNN_LOG(info) << "\n\n";
 
    return Status::Success;
}

References ARMNN_LOG, armnn::GetLayerTypeAsCString(), Layer::GetOutputSlots(), armnn::info, Print(), armnn::Success, and TopologicalSort().

Referenced by CheckOrder(), and Print().

PtrCast()

template<typename LayerType>

LayerType * PtrCast ( Layer *const layer )

inlinestatic

Definition at line 34 of file Graph.hpp.

    {
        return PolymorphicDowncast<LayerType*>(layer);
    }

References armnn::PolymorphicDowncast().

Referenced by begin(), Graph::InputLayersAccessor::begin(), Graph::OutputLayersAccessor::begin(), end(), Graph::InputLayersAccessor::end(), and Graph::OutputLayersAccessor::end().

SerializeToDot()

Status SerializeToDot

(

std::ostream &

stream

)

Definition at line 146 of file Graph.cpp.

{
    {
        DotGraph graph(stream, "Optimized");
 
        {
            // Default node attributes:
            DotDefaults nodes(stream, "node");
            nodes.GetAttributeSet()
                .AddAttribute("shape", "record");
        }
 
        {
            // Default edge attributes:
            DotDefaults edges(stream, "edge");
            edges.GetAttributeSet()
                .AddAttribute("fontsize", 8)
                .AddAttribute("fontcolor", "blue")
                .AddAttribute("fontname", "arial-bold");
        }
 
        // First declares the nodes.
        for (auto&& layer : m_Layers)
        {
            DotNode node(stream, layer->GetGuid(), GetLayerTypeAsCString(layer->GetType()));
            // Extracts the layer parameters.
            ParameterStringifyFunction extractParams = [&node](const std::string & name, const std::string & value){
                node.GetContents().AddContent(name + " : " + value);
            };
            layer->SerializeLayerParameters(extractParams);
        }
 
        // Second declares the edges.
        for (auto&& layer : m_Layers)
        {
            LayerGuid toId = layer->GetGuid();
 
            for (unsigned int i=0;i<layer->GetNumInputSlots(); i++)
            {
                OutputSlot* outputSlot = static_cast<OutputSlot*>(layer->GetInputSlot(i).GetConnection());
                LayerGuid fromId = outputSlot->GetOwningLayer().GetGuid();
                DotEdge edge(stream, fromId, toId);
 
                // Now print the tensor shape on the edge.
                {
                    // Constructs the label attribute with HTML markup.
                    std::stringstream ss;
                    ss << "< " << outputSlot->GetTensorInfo().GetShape() << " >";
                    edge.GetAttributeSet().AddAttribute("label", ss);
                }
            }
        }
    }
 
    if (stream.bad())
    {
        return Status::Failure;
    }
    return Status::Success;
}

References DotAttributeSet::AddAttribute(), NodeContent::AddContent(), armnn::Failure, DotDefaults::GetAttributeSet(), DotEdge::GetAttributeSet(), DotNode::GetContents(), Layer::GetGuid(), armnn::GetLayerTypeAsCString(), OutputSlot::GetOwningLayer(), TensorInfo::GetShape(), OutputSlot::GetTensorInfo(), SerializeToDot(), and armnn::Success.

Referenced by SerializeToDot().

SetLayersOutOfOrder()

void SetLayersOutOfOrder

(

)

Definition at line 738 of file Graph.cpp.

{
    m_LayersInOrder = false;
}

References SetLayersOutOfOrder().

Referenced by SetLayersOutOfOrder().

SubstituteSubgraph() [1/2]

void SubstituteSubgraph	(	SubgraphView &	subgraph,
		const SubgraphView &	substituteSubgraph )

Definition at line 486 of file Graph.cpp.

{
    // Look through each layer in the new subgraph and add any that are not already a member of this graph
    substituteSubgraph.ForEachIConnectableLayer([this](IConnectableLayer* iConnectableLayer)
    {
        if (std::find(std::begin(m_Layers),
                      std::end(m_Layers),
                      iConnectableLayer) == std::end(m_Layers))
        {
            auto layer = PolymorphicDowncast<Layer*>(iConnectableLayer);
            layer->Reparent(*this, m_Layers.end());
            m_LayersInOrder = false;
        }
    });
 
    ReplaceSubgraphConnections(subgraph, substituteSubgraph);
    EraseSubgraphLayers(subgraph);
    TopologicalSort();
}

References SubgraphView::ForEachIConnectableLayer(), armnn::PolymorphicDowncast(), SubgraphView, SubstituteSubgraph(), and TopologicalSort().

SubstituteSubgraph() [2/2]

void SubstituteSubgraph	(	SubgraphView &	subgraph,
		IConnectableLayer *	substituteLayer )

Substitutes the given sub-graph with either a new layer or a new sub-graph.

In either case, the given layer or all the layers in the given sub-graph must belong to this graph.

Definition at line 475 of file Graph.cpp.

{
    ARMNN_THROW_INVALIDARG_MSG_IF_FALSE(substituteLayer, "substituteLayer should not be null");
 
    // Create a new sub-graph with only the given layer, using
    // the given sub-graph as a reference of which parent graph to use
    SubgraphView substituteSubgraph(substituteLayer);
 
    SubstituteSubgraph(subgraph, substituteSubgraph);
}

References ARMNN_THROW_INVALIDARG_MSG_IF_FALSE, SubgraphView, and SubstituteSubgraph().

Referenced by armnn::ApplyBackendOptimizations(), SubstituteSubgraph(), and SubstituteSubgraph().

TopologicalSort() [1/2]

Graph & TopologicalSort ( )

inline

Sorts layers in topological order and return this.

Definition at line 191 of file Graph.hpp.

{ const_cast<const Graph*>(this)->TopologicalSort(); return *this; }

References Graph(), and TopologicalSort().

Referenced by CheckOrder(), LoadedNetwork::ImportInputs(), LoadedNetwork::ImportOutputs(), InferTensorInfos(), Optimizer::Pass(), Print(), LoadedNetwork::SendNetworkStructure(), SubstituteSubgraph(), TopologicalSort(), TopologicalSort(), and VerifyConstantLayerSetTensorInfo().

TopologicalSort() [2/2]

const Graph & TopologicalSort

(

)

const

Definition at line 307 of file Graph.cpp.

{
    if (!m_LayersInOrder)
    {
        // Resets layer order.
        for (auto&& it : m_Layers)
        {
            it->ResetPriority();
        }
 
        auto compareLayerPriority = [](const LayerList::value_type& layerA, const LayerList::value_type& layerB)
            {
                return layerA->GetPriority() < layerB->GetPriority();
            };
 
        m_Layers.sort(compareLayerPriority);
 
        m_LayersInOrder = true;
    }
 
    return *this;
}

References Graph(), and TopologicalSort().

VerifyConstantLayerSetTensorInfo()

void VerifyConstantLayerSetTensorInfo

(

)

const

For each ConstantLayer in Graph, ensures TensorInfo is set on all output slots.

LayerValidationException thrown if no TensorInfo is set.

LayerValidationException thrown if no TensorInfo is set.

Exceptions

LayerValidationException

Definition at line 622 of file Graph.cpp.

{
    for (auto&& layer : TopologicalSort())
    {
        if (layer->GetType() == armnn::LayerType::Constant)
        {
            for (auto&& output: layer->GetOutputSlots())
            {
                if (!output.IsTensorInfoSet())
                {
                    std::ostringstream message;
                    message << "Output slot TensorInfo not set on "
                            << GetLayerTypeAsCString(layer->GetType())
                            << " layer \""
                            << layer->GetName()
                            << "\"";
                    throw LayerValidationException(message.str());
                }
            }
        }
    }
}

References armnn::Constant, armnn::GetLayerTypeAsCString(), TopologicalSort(), and VerifyConstantLayerSetTensorInfo().

Referenced by IOptimizedNetwork::Optimize, and VerifyConstantLayerSetTensorInfo().

Friends And Related Symbol Documentation

SubgraphView

friend class SubgraphView

friend

Definition at line 307 of file Graph.hpp.

References SubgraphView.

Referenced by SubgraphView, SubstituteSubgraph(), and SubstituteSubgraph().

---

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

• src/armnn/Graph.hpp
• src/armnn/Graph.cpp