+ +

#include <Graph.hpp>

+ + + + + + + + + + + + + + +

+Classes
struct	InputLayersAccessor
	Wrapper class returned by Graph::GetInputLayers() More...

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 = boost::transform_iterator< decltype(&PtrCast< const Layer >), Iterator >

using	ConstIteratorInputs = boost::transform_iterator< decltype(&PtrCast< const InputLayer >), Iterator >

using	ConstIteratorOutputs = boost::transform_iterator< decltype(&PtrCast< const OutputLayer >), Iterator >

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+Public Member Functions
template<typename Func >
void	ForEachLayer (Func func) const

	Graph ()

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

+ + + + +

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

+

Detailed Description

+

Definition at line 29 of file Graph.hpp.

+

Member Typedef Documentation

+ +

◆ ConstIterator

+ +

+

+ + + + +

using ConstIterator = boost::transform_iterator<decltype(&PtrCast<const Layer>), Iterator>

+

+ +

Definition at line 53 of file Graph.hpp.

+ +

+

+ +

◆ ConstIteratorInputs

+ +

+

+ + + + +

using ConstIteratorInputs = boost::transform_iterator<decltype(&PtrCast<const InputLayer>), Iterator>

+

+ +

Definition at line 54 of file Graph.hpp.

+ +

+

+ +

◆ ConstIteratorOutputs

+ +

+

+ + + + +

using ConstIteratorOutputs = boost::transform_iterator<decltype(&PtrCast<const OutputLayer>), Iterator>

+

+ +

Definition at line 55 of file Graph.hpp.

+ +

+

+ +

◆ Iterator

+ +

+

+ + + + +

using Iterator = LayerList::const_iterator

+

+ +

Definition at line 50 of file Graph.hpp.

+ +

+

+ +

◆ IteratorDifference

+ +

+

+ + + + +

using IteratorDifference = Iterator::difference_type

+

+ +

Definition at line 51 of file Graph.hpp.

+ +

+

+ +

◆ LayerList

+ +

+

+ + + + +

using LayerList = std::list<Layer*>

+

+ +

Definition at line 49 of file Graph.hpp.

+ +

+

Constructor & Destructor Documentation

+ +

◆ Graph() [1/3]

+ +

+

+ + + + + +

+ + + + + + + +

Graph ( )

+

+inline

+

+ +

Definition at line 95 of file Graph.hpp.

+ +

References Graph::operator=().

+

95 : m_LayersInOrder(true) {}

+

+ +

◆ Graph() [2/3]

+ +

+

+ + + + + + + + +

Graph ( const Graph & other )

+

+ +

Definition at line 28 of file Graph.cpp.

+ +

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

+

 :   m_LayersInOrder(other.m_LayersInOrder)
 {
     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 101 of file Graph.hpp.

+

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

+

+ +

◆ ~Graph()

+ +

+

+ + + + + +

+ + + + + + + +

~Graph ( )

+

+inline

+

+ +

Definition at line 124 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 263 of file Graph.cpp.

+ +

References 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 BOOST_AUTO_TEST_CASE(), BOOST_FIXTURE_TEST_CASE(), and Graph::GetNumLayers().

+

 {
     // 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.
         BOOST_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)
     {
         BOOST_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];
                 BOOST_ASSERT(dstInputSlot);
 
                 EdgeStrategy strategy = srcEdgeStrategies[srcConnectionIndex];
                 BOOST_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 = boost::str(boost::format("[ %1% (%2%) -> %3% (%4%) ]")
                                                                  % srcLayer->GetName()
                                                                  % srcOutputIndex
                                                                  % dstLayer.GetName()
                                                                  % dstInputSlot->GetSlotIndex());
 
                     Layer* compLayer = nullptr;
                     if (strategy == EdgeStrategy::CopyToTarget)
                     {
                         compLayer = InsertNewLayer<MemCopyLayer>(*dstInputSlot, compLayerName.c_str());
                     }
                     else
                     {
                         BOOST_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();
                     long 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(boost::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 397 of file Graph.hpp.

+ +

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

+ +

Referenced by ArgMinMaxInferOutputShapeImpl(), BatchToSpaceInferOutputShapeTest(), BOOST_AUTO_TEST_CASE(), BOOST_FIXTURE_TEST_CASE(), Layer::CloneBase(), Convolution2dInferOutputShapeTest(), CreateConvolution2dGraph(), CreateDepthwiseConvolution2dGraph(), CreateGatherGraph(), CreatePooling2dGraph(), CreatePreluLayerHelper(), CreateResizeBilinearGraph(), CreateStackLayerHelper(), DepthwiseConvolution2dInferOutputShapeTest(), MockBackend::OptimizeSubgraphView(), PreluInferOutputShapeImpl(), QuantizedLstmInferOutputShapeImpl(), SpaceToDepthInferOutputShapeTest(), StackInferOutputShapeImpl(), TransposeConvolution2dInferOutputShapeTest(), 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)...);
 
     NotifyObservables(GraphEvent::LayerAdded, layer);
 
     return layer;
 }

+
+
+

+

+ +

◆ AllocateDynamicBuffers()

+ +

+

+ + + + + + + +

Status AllocateDynamicBuffers ( )

+

+ +

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

+ +

Definition at line 142 of file Graph.cpp.

+ +

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

+ +

Referenced by Graph::GetNumLayers().

+

 {
     // Layers must be sorted in topological order
     BOOST_ASSERT(m_LayersInOrder);
 
     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 204 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 158 of file Graph.hpp.

+ +

Referenced by BOOST_AUTO_TEST_CASE(), and Optimizer::Pass().

+

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

+

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

+ +

References Graph::InputLayersAccessor::begin().

+ +

Referenced by BOOST_AUTO_TEST_CASE().

+

168 { 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:158

+

+ +

◆ cend()

+ +

+

+ + + + + +

+ + + + + + + +

ConstIterator cend ( ) const

+

+inline

+

+ +

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

+ +

Definition at line 170 of file Graph.hpp.

+ +

References Graph::InputLayersAccessor::end().

+ +

Referenced by BOOST_AUTO_TEST_CASE().

+

170 { 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:160

+

+ +

◆ DetachObservable()

+ +

+

+ + + + + +

+ + + + + + + + + + + + + + + + + + +

void DetachObservable	(	IGraphObservable *const	observable,
		GraphEvent	notifyOnEvent
	)

+

+inline

+

+ +

Definition at line 208 of file Graph.hpp.

+ +

References Graph::GetPosInGraph(), armnn::IgnoreUnused(), armnn::Input, Graph::InputLayersAccessor::m_Graph, armnn::Output, and armnnUtils::Filesystem::Remove().

+ +

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

+ +

Referenced by Optimizer::Pass().

+

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

+

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

+ +

References armnn::LayerErased.

+ +

Referenced by BOOST_AUTO_TEST_CASE(), Graph::EraseLayer(), DynamicQuantizationVisitor::FinishVisit(), Optimizer::Pass(), OptimizeForConnectionImpl< 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 450 of file Graph.hpp.

+ +

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

+

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

+
+

+

+ +

◆ ForEachLayer()

+ +

+

+ + + + + +

+ + + + + + + + +

void ForEachLayer ( Func func ) const

+

+inline

+

+ +

Definition at line 39 of file Graph.hpp.

+ +

Referenced by Graph::AddCompatibilityLayers(), BOOST_AUTO_TEST_CASE(), 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 181 of file Graph.hpp.

+ +

References Graph::InputLayersAccessor::InputLayersAccessor().

+ +

Referenced by armnn::BOOST_AUTO_TEST_CASE(), LoadedNetwork::EnqueueWorkload(), armnn::GetInputTensorInfo(), and NetworkQuantizer::OverrideInputRange().

+

181 { return InputLayersAccessor(*this); }

+

+ +

◆ GetNumInputs()

+ +

+

+ + + + + +

+ + + + + + + +

size_t GetNumInputs ( ) const

+

+inline

+

+ +

Definition at line 176 of file Graph.hpp.

+ +

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

+

176 { return m_InputIds.size(); }

+

+ +

◆ GetNumLayers()

+ +

+

+ + + + + +

+ + + + + + + +

size_t GetNumLayers ( ) const

+

+inline

+

+ +

Definition at line 187 of file Graph.hpp.

+ +

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

+ +

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

+

187 { return m_Layers.size(); }

+

+ +

◆ GetNumOutputs()

+ +

+

+ + + + + +

+ + + + + + + +

size_t GetNumOutputs ( ) const

+

+inline

+

+ +

Definition at line 177 of file Graph.hpp.

+ +

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

+

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

+ +

Referenced by LoadedNetwork::EnqueueWorkload().

+

185 { return OutputLayersAccessor(*this); }

+

+ +

◆ GetPosInGraph()

+ +

+

+ + + + + +

+ + + + + + + + +

Graph::Iterator GetPosInGraph ( Layer & layer )

+

+inline

+

+ +

Gets the position of a layer in the graph.

+ +

Definition at line 389 of file Graph.hpp.

+ +

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

+

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

+

+ +

◆ InferTensorInfos()

+ +

+

+ + + + + + + +

void InferTensorInfos ( )

+

+ +

Definition at line 493 of file Graph.cpp.

+ +

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

+ +

Referenced by BOOST_AUTO_TEST_CASE(), Graph::GetNumLayers(), PreluValidateTensorShapesFromInputsMatchTest(), PreluValidateTensorShapesFromInputsNoMatchTest(), StackValidateTensorShapesFromInputsMatchTest(), and StackValidateTensorShapesFromInputsNoMatchTest().

+

 {
     for (auto&& layer : TopologicalSort())
     {
         for (auto&& input : layer->GetInputSlots())
         {
             const IOutputSlot* source = input.GetConnectedOutputSlot();
             if (source == NULL)
             {
                 std::ostringstream message;
                 message << "Input not connected on "
                         << GetLayerTypeAsCString(layer->GetType())
                         << " layer \""
                         << layer->GetName()
                         << "\"";
                 throw LayerValidationException(message.str());
             }
 
             if (!source->IsTensorInfoSet())
             {
                 throw LayerValidationException("All inputs must have the TensorInfo set at this point.");
             }
         }
         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 409 of file Graph.hpp.

+ +

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

+ +

Referenced by BOOST_AUTO_TEST_CASE(), armnn::InsertConvertFp16ToFp32LayersBefore(), armnn::InsertConvertFp32ToFp16LayersAfter(), armnn::InsertDebugLayerAfter(), PermuteAsReshapeImpl::Run(), TransposeAsReshapeImpl::Run(), OptimizeConsecutiveReshapesImpl::Run(), FoldPadIntoConvolution2dImpl::Run(), MoveTransposeUpImpl::Run(), MovePermuteUpImpl::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 425 of file Graph.hpp.

+ +

References 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)...);
 
     BOOST_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 106 of file Graph.hpp.

+ +

References 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);
 
         other.ForEachLayer([this](Layer* otherLayer)
         {
             otherLayer->Reparent(*this, m_Layers.end());
         });
 
         BOOST_ASSERT(other.m_PosInGraphMap.empty());
         BOOST_ASSERT(other.m_Layers.empty());
 
         return *this;
     }

+

+ +

◆ Print()

+ +

+

+ + + + + + + +

Status Print ( ) const

+

+ +

Definition at line 61 of file Graph.cpp.

+ +

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

+
+
+
+
+

+

+ +

◆ PtrCast()

+ +

+

+ + + + + +

+ + + + + + + + +

static LayerType* PtrCast ( Layer *const layer )

+

+inlinestatic

+

+ +

Definition at line 33 of file Graph.hpp.

+

     {
         return boost::polymorphic_downcast<LayerType*>(layer);
     }

+

+ +

◆ SerializeToDot()

+ +

+

+ + + + + + + + +

Status SerializeToDot ( std::ostream & stream )

+

+ +

Definition at line 81 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 BOOST_AUTO_TEST_CASE(), and 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;
 }

+
+
+
+
+

+

+ +

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

+ +

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

+

 {
     BOOST_ASSERT(substituteLayer != nullptr);
 
     ReplaceSubgraphConnections(subgraph, substituteLayer);
     EraseSubgraphLayers(subgraph);
 }

+

+ +

◆ SubstituteSubgraph() [2/2]

+ +

+

+ + + + + + + + + + + + + + + + + + +

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

+

+ +

Definition at line 404 of file Graph.cpp.

+ +

References SubgraphView::Clear(), IOutputSlot::Connect(), IOutputSlot::Disconnect(), Graph::EraseLayer(), SubgraphView::ForEachLayer(), InputSlot::GetConnection(), SubgraphView::GetInputSlots(), SubgraphView::GetLayers(), SubgraphView::GetOutputSlots(), armnn::IgnoreUnused(), OutputSlot::MoveAllConnections(), armnn::numeric_cast(), Layer::Reparent(), and Graph::TopologicalSort().

+

 {
     // Look through each layer in the new subgraph and add any that are not already a member of this graph
     substituteSubgraph.ForEachLayer([this](Layer* layer)
     {
         if (std::find(std::begin(m_Layers), std::end(m_Layers), layer) == std::end(m_Layers))
         {
             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 173 of file Graph.hpp.

+ +

References Graph::TopologicalSort().

+ +

Referenced by BOOST_AUTO_TEST_CASE(), CheckOrder(), NetworkQuantizer::ExportNetwork(), Graph::InferTensorInfos(), LoadedNetwork::MakeLoadedNetwork(), Optimizer::Pass(), Graph::Print(), NetworkQuantizer::Refine(), Graph::SubstituteSubgraph(), and Graph::TopologicalSort().

+

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

armnn::Graph::Graph

Graph()

Definition: Graph.hpp:95

+

armnn::Graph::TopologicalSort

Graph & TopologicalSort()

Sorts layers in topological order and return this.

Definition: Graph.hpp:173

+

+ +

◆ TopologicalSort() [2/2]

+ +

+

+ + + + + + + +

const Graph & TopologicalSort ( ) const

+

+ +

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

+

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

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()

◆ InferTensorInfos()

◆ InsertNewLayer() [1/2]

◆ InsertNewLayer() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ Print()

◆ PtrCast()

◆ SerializeToDot()

◆ SubstituteSubgraph() [1/2]

◆ SubstituteSubgraph() [2/2]

◆ TopologicalSort() [1/2]

◆ TopologicalSort() [2/2]