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

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

◆ 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 Layer::BeginOutputSlots(), Layer::Clone(), Layer::GetInputSlot(), and InputSlot::SetTensorInfo().

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

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

References Graph::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 ARMNN_THROW_INVALIDARG_MSG_IF_FALSE, armnn::CopyToTarget, armnn::DirectCompatibility, armnn::ExportToTarget, Graph::ForEachLayer(), Layer::GetBackendId(), OutputSlot::GetConnections(), OutputSlot::GetEdgeStrategies(), TensorHandleFactoryRegistry::GetFactory(), Layer::GetInputSlot(), Layer::GetName(), Layer::GetOutputSlot(), Layer::GetOutputSlots(), InputSlot::GetOwningLayer(), InputSlot::GetSlotIndex(), OutputSlot::GetTensorHandleFactoryId(), ITensorHandleFactory::LegacyFactoryId, armnn::MemCopy, armnn::MemImport, Layer::SetBackendId(), OutputSlot::SetEdgeStrategy(), OutputSlot::SetTensorHandleFactory(), and armnn::Undefined.

Referenced by armnn::Optimize().

◆ AddLayer()

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, 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(), ARMNN_SCOPED_PROFILING_EVENT, ARMNN_THROW_INVALIDARG_MSG_IF_FALSE, armnn::Constant, ITensorHandle::GetParent(), ITensorHandle::Manage(), armnn::Success, and armnn::Undefined.

◆ AttachObservable()

void AttachObservable	(	IGraphObservable *const	observable,
		GraphEvent	notifyOnEvent
	)

inline

Definition at line 226 of file Graph.hpp.

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

Referenced by GraphObservable< std::string >::GraphObservable().

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

176 { return m_Layers.begin(); }

Referenced by Graph::cbegin(), armnn::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.

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

186 { return begin(); }

References Graph::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.

188 { return end(); }

References Graph::end().

◆ DetachObservable()

void DetachObservable	(	IGraphObservable *const	observable,
		GraphEvent	notifyOnEvent
	)

inline

Definition at line 230 of file Graph.hpp.

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

Referenced by GraphObservable< std::string >::~GraphObservable().

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

178 { return m_Layers.end(); }

Referenced by Graph::cend(), armnn::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.

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

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

References armnn::LayerErased.

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

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

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

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

◆ ForEachLayer()

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 Graph::AddCompatibilityLayers(), armnn::SelectTensorHandleStrategy(), and Graph::~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.

199 { return InputLayersAccessor(*this); }

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

◆ GetNumInputs()

size_t GetNumInputs ( ) const

inline

Definition at line 194 of file Graph.hpp.

194 { return m_InputIds.size(); }

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

◆ GetNumLayers()

size_t GetNumLayers ( ) const

inline

Definition at line 205 of file Graph.hpp.

205 { return m_Layers.size(); }

Referenced by LoadedNetwork::EnqueueWorkload().

◆ GetNumOutputs()

size_t GetNumOutputs ( ) const

inline

Definition at line 195 of file Graph.hpp.

195 { return m_OutputIds.size(); }

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

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

203 { 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 Graph::EraseLayer(), Graph::InsertNewLayer(), and Optimizer::Pass().

◆ GetProfiler()

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

Definition at line 733 of file Graph.cpp.

 {
     return m_Profiler;
 }

Referenced by armnn::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(), and IOutputSlot::IsTensorInfoSet().

Referenced by armnn::Optimize().

◆ 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 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(), Graph::GetPosInGraph(), InputSlot::Insert(), and armnn::LayerAdded.

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

◆ 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 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(), Graph::GetPosInGraph(), armnn::LayerAdded, and OutputSlot::MoveAllConnections().

◆ operator=() [1/2]

Graph& operator= ( const Graph & other )

delete

◆ 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 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, armnn::Success, and Graph::TopologicalSort().

Referenced by CheckOrder().

◆ 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 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, DotEdge::GetAttributeSet(), DotDefaults::GetAttributeSet(), DotNode::GetContents(), Layer::GetGuid(), armnn::GetLayerTypeAsCString(), OutputSlot::GetOwningLayer(), TensorInfo::GetShape(), OutputSlot::GetTensorInfo(), and armnn::Success.

◆ SetLayersOutOfOrder()

void SetLayersOutOfOrder ( )

Definition at line 738 of file Graph.cpp.

 {
     m_LayersInOrder = false;
 }

◆ 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(), and Graph::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.

Referenced by armnn::ApplyBackendOptimizations().

◆ TopologicalSort() [1/2]

const Graph & TopologicalSort ( )

inline

Sorts layers in topological order and return this.

Definition at line 191 of file Graph.hpp.

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

References Graph::TopologicalSort().

Referenced by CheckOrder(), Optimizer::Pass(), Graph::Print(), Graph::SubstituteSubgraph(), and Graph::TopologicalSort().

◆ TopologicalSort() [2/2]

const Graph& TopologicalSort ( ) const

◆ 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 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, and armnn::GetLayerTypeAsCString().

Referenced by armnn::Optimize().

Friends And Related Function Documentation

◆ SubgraphView

friend class SubgraphView

friend

Definition at line 307 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