#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 () 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. More...

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. More...

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. More...

void	EraseLayer (Iterator pos)
	Deletes the layer at the specified position. More...

template<typename LayerT >
void	EraseLayer (LayerT *&layer)
	Deletes the layer. More...

Iterator	begin ()
	Returns iterator pointing to the beginning of the list. Lowercase for range-based for loops. More...

Iterator	end ()
	Returns iterator pointing to the end of the list. Lowercase for range-based for loops. More...

ConstIterator	begin () const
	Returns const iterator pointing to the beginning of the list. Lowercase for range-based for loops. More...

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

ConstIterator	cbegin () const
	Returns const iterator pointing to the beginning of the list. Lowercase for range-based for loops. More...

ConstIterator	cend () const
	Returns const iterator pointing to the end of the list. Lowercase for range-based for loops. More...

Graph &	TopologicalSort ()
	Sorts layers in topological order and return this. More...

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. More...

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

size_t	GetNumLayers () const

Status	AllocateDynamicBuffers ()
	Allocates memory for all tensors under output tensor handers of each layer. More...

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. More...

void	SubstituteSubgraph (SubgraphView &subgraph, IConnectableLayer *substituteLayer)
	Substitutes the given sub-graph with either a new layer or a new sub-graph. More...

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

void	VerifyConstantLayerSetTensorInfo () const
	For each ConstantLayer in Graph, ensures TensorInfo is set on all output slots. More...

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. More...

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.

References Graph::operator=().

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

◆ Graph() [2/3]

Graph ( const Graph & other )

Definition at line 27 of file Graph.cpp.

References Layer::BeginOutputSlots(), Layer::Clone(), and Layer::GetInputSlot().

 :   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());
                 outputSlot->Connect(inputSlot);
             }
             outputSlot->SetTensorInfo(otherOutputSlot.GetTensorInfo());
             ++outputSlot;
         }
     }
 }

◆ Graph() [3/3]

Graph ( Graph && other )

inline

Definition at line 110 of file Graph.hpp.

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

◆ ~Graph()

~Graph ( )

inline

Definition at line 135 of file Graph.hpp.

References Graph::AddLayer(), Graph::EraseLayer(), Graph::ForEachLayer(), Graph::InsertNewLayer(), Graph::Print(), and Graph::SerializeToDot().

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

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 303 of file Graph.cpp.

References ARMNN_ASSERT, ARMNN_ASSERT_MSG, armnn::CopyToTarget, armnn::DirectCompatibility, armnn::ExportToTarget, Graph::ForEachLayer(), Layer::GetBackendId(), OutputSlot::GetConnections(), OutputSlot::GetEdgeStrategies(), TensorHandleFactoryRegistry::GetFactory(), Layer::GetName(), Layer::GetOutputSlot(), Layer::GetOutputSlots(), InputSlot::GetOwningLayer(), InputSlot::GetSlotIndex(), OutputSlot::GetTensorHandleFactoryId(), ITensorHandleFactory::LegacyFactoryId, armnn::MemCopy, armnn::MemImport, OutputSlot::SetEdgeStrategy(), OutputSlot::SetTensorHandleFactory(), and armnn::Undefined.

Referenced by Graph::GetNumLayers(), and armnn::Optimize().

 {
     // 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.
         ARMNN_ASSERT(layer.GetBackendId() != Compute::Undefined);
         // 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_ASSERT(srcLayer);
 
         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];
                 ARMNN_ASSERT(dstInputSlot);
 
                 EdgeStrategy strategy = srcEdgeStrategies[srcConnectionIndex];
                 ARMNN_ASSERT_MSG(strategy != EdgeStrategy::Undefined,
                                  "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
                     {
                         ARMNN_ASSERT_MSG(strategy == EdgeStrategy::ExportToTarget, "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);
                 }
             }
         }
     });
 }

◆ AddLayer()

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

inline

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

Definition at line 456 of file Graph.hpp.

References armnn::Input, armnn::LayerAdded, and armnn::Output.

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

 {
     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;
 }

◆ AllocateDynamicBuffers()

Status AllocateDynamicBuffers ( )

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

Definition at line 181 of file Graph.cpp.

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

Referenced by Graph::GetNumLayers().

 {
     // Layers must be sorted in topological order
     ARMNN_ASSERT(m_LayersInOrder);
     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;
 }

◆ AttachObservable()

void AttachObservable	(	IGraphObservable *const	observable,
		GraphEvent	notifyOnEvent
	)

inline

Definition at line 219 of file Graph.hpp.

Referenced by GraphObservable< Layer *>::GraphObservable().

                                                                                         {
         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 169 of file Graph.hpp.

Referenced by armnn::Optimize(), and Optimizer::Pass().

169 { return m_Layers.begin(); }

◆ 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 174 of file Graph.hpp.

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

◆ cbegin()

ConstIterator cbegin ( ) const

inline

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

Definition at line 179 of file Graph.hpp.

References Graph::InputLayersAccessor::begin().

179 { return begin(); }

armnn::Graph::begin

Iterator begin()

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

Definition: Graph.hpp:169

◆ cend()

ConstIterator cend ( ) const

inline

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

Definition at line 181 of file Graph.hpp.

References Graph::InputLayersAccessor::end().

181 { return end(); }

armnn::Graph::end

Iterator end()

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

Definition: Graph.hpp:171

◆ DetachObservable()

void DetachObservable	(	IGraphObservable *const	observable,
		GraphEvent	notifyOnEvent
	)

inline

Definition at line 223 of file Graph.hpp.

References armnn::Constant, Graph::GetPosInGraph(), Graph::GetProfiler(), armnn::Input, armnn::Output, and Graph::SetLayersOutOfOrder().

Referenced by GraphObservable< Layer *>::~GraphObservable().

                                                                                         {
         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 171 of file Graph.hpp.

Referenced by armnn::Optimize(), and Optimizer::Pass().

171 { return m_Layers.end(); }

◆ 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 176 of file Graph.hpp.

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

◆ EraseLayer() [1/2]

void EraseLayer ( Iterator pos )

inline

Deletes the layer at the specified position.

Definition at line 504 of file Graph.hpp.

References armnn::LayerErased.

Referenced by Graph::EraseLayer(), Optimizer::Pass(), OptimizeForConnectionImpl< BaseType, ChildType, Wrapped >::Run(), OptimizeForExclusiveConnectionImpl< BaseType, ChildType, Wrapped >::Run(), Graph::SubstituteSubgraph(), and Graph::~Graph().

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

◆ EraseLayer() [2/2]

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 512 of file Graph.hpp.

References ARMNN_ASSERT, Graph::EraseLayer(), and Graph::GetPosInGraph().

 {
     ARMNN_ASSERT(layer != nullptr);
     EraseLayer(GetPosInGraph(*layer));
     layer = nullptr;
 }

◆ ForEachLayer()

void ForEachLayer ( Func func ) const

inline

Definition at line 40 of file Graph.hpp.

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

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

◆ 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 192 of file Graph.hpp.

References Graph::InputLayersAccessor::InputLayersAccessor().

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

192 { return InputLayersAccessor(*this); }

◆ GetNumInputs()

size_t GetNumInputs ( ) const

inline

Definition at line 187 of file Graph.hpp.

Referenced by Graph::InputLayersAccessor::end(), LoadedNetwork::EnqueueWorkload(), LoadedNetwork::Execute(), and LoadedNetwork::MakeLoadedNetwork().

187 { return m_InputIds.size(); }

◆ GetNumLayers()

size_t GetNumLayers ( ) const

inline

Definition at line 198 of file Graph.hpp.

References Graph::AddCompatibilityLayers(), Graph::AllocateDynamicBuffers(), Graph::InferTensorInfos(), Graph::SubstituteSubgraph(), and Graph::VerifyConstantLayerSetTensorInfo().

Referenced by LoadedNetwork::EnqueueWorkload().

198 { return m_Layers.size(); }

◆ GetNumOutputs()

size_t GetNumOutputs ( ) const

inline

Definition at line 188 of file Graph.hpp.

Referenced by Graph::OutputLayersAccessor::begin(), LoadedNetwork::EnqueueWorkload(), LoadedNetwork::Execute(), and LoadedNetwork::MakeLoadedNetwork().

188 { return m_OutputIds.size(); }

◆ 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 196 of file Graph.hpp.

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

196 { return OutputLayersAccessor(*this); }

◆ GetPosInGraph()

Graph::Iterator GetPosInGraph ( Layer & layer )

inline

Gets the position of a layer in the graph.

Definition at line 448 of file Graph.hpp.

References ARMNN_ASSERT.

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

 {
     auto it = m_PosInGraphMap.find(&layer);
     ARMNN_ASSERT(it != m_PosInGraphMap.end());
     return it->second;
 }

◆ GetProfiler()

const std::shared_ptr< IProfiler > & GetProfiler ( ) const

Definition at line 650 of file Graph.cpp.

Referenced by Graph::DetachObservable(), and armnn::Optimize().

 {
     return m_Profiler;
 }

◆ InferTensorInfos()

void InferTensorInfos ( )

Definition at line 562 of file Graph.cpp.

References armnn::Convolution2d, armnn::Convolution3d, armnn::DepthwiseConvolution2d, armnn::FullyConnected, InputSlot::GetConnectedOutputSlot(), Layer::GetInputSlot(), armnn::GetLayerTypeAsCString(), Layer::GetName(), Layer::GetNumInputSlots(), Layer::GetType(), IOutputSlot::IsTensorInfoSet(), Graph::TopologicalSort(), and armnn::ValidateOnly.

Referenced by Graph::GetNumLayers(), and armnn::Optimize().

 {
     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();
         }
     }
 }

◆ InsertNewLayer() [1/2]

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 471 of file Graph.hpp.

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

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

 {
     // 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;
 }

◆ InsertNewLayer() [2/2]

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 487 of file Graph.hpp.

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

 {
     Layer& owningLayer = insertAfter.GetOwningLayer();
 
     const Iterator pos = std::next(GetPosInGraph(owningLayer));
     LayerT* const layer = new LayerInGraph<LayerT>(*this, pos, std::forward<Args>(args)...);
 
     ARMNN_ASSERT(layer->GetNumInputSlots() == 1);
 
     insertAfter.MoveAllConnections(layer->GetOutputSlot());
     insertAfter.Connect(layer->GetInputSlot(0));
 
     NotifyObservables(GraphEvent::LayerAdded, layer);
 
     return layer;
 }

◆ operator=() [1/2]

Graph& operator= ( const Graph & other )

delete

Referenced by Graph::Graph().

◆ operator=() [2/2]

Graph& operator= ( Graph && other )

inline

Definition at line 115 of file Graph.hpp.

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

     {
         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());
         });
 
         ARMNN_ASSERT(other.m_PosInGraphMap.empty());
         ARMNN_ASSERT(other.m_Layers.empty());
 
         return *this;
     }

◆ Print()

Status Print ( ) const

Definition at line 63 of file Graph.cpp.

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

Referenced by CheckOrder(), and Graph::~Graph().

 {
     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();
 
         ARMNN_LOG(info) << it->GetName() << ":" << GetLayerTypeAsCString(it->GetType())
                                 << ":" << it->GetBackendId().Get()
                                 << " 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 << " ]";
             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 << " ]";
             ARMNN_LOG(info) << message.str();
         }
         ARMNN_LOG(info) << "\n";
     }
     ARMNN_LOG(info) << "\n\n";
 
     return Status::Success;
 }

◆ PtrCast()

static LayerType* PtrCast ( Layer *const layer )

inlinestatic

Definition at line 34 of file Graph.hpp.

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

◆ SerializeToDot()

Status SerializeToDot ( std::ostream & stream )

Definition at line 120 of file Graph.cpp.

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

Referenced by Graph::~Graph().

 {
     {
         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;
 }

◆ SetLayersOutOfOrder()

void SetLayersOutOfOrder ( )

Definition at line 655 of file Graph.cpp.

Referenced by Graph::DetachObservable(), and LoadedNetwork::MakeLoadedNetwork().

 {
     m_LayersInOrder = false;
 }

◆ SubstituteSubgraph() [1/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 435 of file Graph.cpp.

References ARMNN_ASSERT.

Referenced by armnn::ApplyBackendOptimizations(), and Graph::GetNumLayers().

 {
     ARMNN_ASSERT(substituteLayer != nullptr);
 
     // 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);
 }

◆ SubstituteSubgraph() [2/2]

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

Definition at line 446 of file Graph.cpp.

References ARMNN_ASSERT, ARMNN_ASSERT_MSG, SubgraphView::Clear(), IOutputSlot::Connect(), IOutputSlot::Disconnect(), Graph::EraseLayer(), SubgraphView::ForEachIConnectableLayer(), IInputSlot::GetConnection(), SubgraphView::GetIConnectableLayers(), SubgraphView::GetIInputSlots(), SubgraphView::GetIOutputSlots(), armnn::IgnoreUnused(), armnn::numeric_cast(), and Graph::TopologicalSort().

 {
     // 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();
 }

◆ TopologicalSort() [1/2]

Graph& TopologicalSort ( )

inline

Sorts layers in topological order and return this.

Definition at line 184 of file Graph.hpp.

References Graph::TopologicalSort().

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

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

armnn::Graph::TopologicalSort

Graph & TopologicalSort()

Sorts layers in topological order and return this.

Definition: Graph.hpp:184

armnn::Graph::Graph

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

Definition: Graph.hpp:98

◆ TopologicalSort() [2/2]

const Graph & TopologicalSort ( ) const

Definition at line 280 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;
 }

◆ VerifyConstantLayerSetTensorInfo()

void VerifyConstantLayerSetTensorInfo ( ) const

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

LayerValidationException thrown if no TensorInfo is set.

Exceptions

LayerValidationException

Definition at line 539 of file Graph.cpp.

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

Referenced by Graph::GetNumLayers(), and armnn::Optimize().

 {
     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());
                 }
             }
         }
     }
 }

Friends And Related Function Documentation

◆ SubgraphView

friend class SubgraphView

friend

Definition at line 300 of file Graph.hpp.

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

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

Classes

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ ConstIterator

◆ ConstIteratorInputs

◆ ConstIteratorOutputs

◆ Iterator

◆ IteratorDifference

◆ LayerList

Constructor & Destructor Documentation

◆ Graph() [1/3]

◆ Graph() [2/3]

◆ Graph() [3/3]

◆ ~Graph()

Member Function Documentation

◆ AddCompatibilityLayers()

◆ AddLayer()

◆ AllocateDynamicBuffers()

◆ AttachObservable()

◆ begin() [1/2]

◆ begin() [2/2]

◆ cbegin()

◆ cend()

◆ DetachObservable()

◆ end() [1/2]

◆ end() [2/2]

◆ EraseLayer() [1/2]

◆ EraseLayer() [2/2]

◆ ForEachLayer()

◆ GetInputLayers()

◆ GetNumInputs()

◆ GetNumLayers()

◆ GetNumOutputs()

◆ GetOutputLayers()

◆ GetPosInGraph()

◆ GetProfiler()

◆ InferTensorInfos()

◆ InsertNewLayer() [1/2]

◆ InsertNewLayer() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ Print()

◆ PtrCast()

◆ SerializeToDot()

◆ SetLayersOutOfOrder()

◆ SubstituteSubgraph() [1/2]

◆ SubstituteSubgraph() [2/2]

◆ TopologicalSort() [1/2]

◆ TopologicalSort() [2/2]

◆ VerifyConstantLayerSetTensorInfo()

Friends And Related Function Documentation

◆ SubgraphView