+ +

Algorithm that splits a Graph into Subgraphs based on a filtering of layers (e.g. + More...

+ +

#include <SubgraphViewSelector.hpp>

+ + + + + + + + +

+Public Types
using	SubgraphViewPtr = std::unique_ptr< SubgraphView >

using	Subgraphs = std::vector< SubgraphViewPtr >

using	LayerSelectorFunction = std::function< bool(const Layer &)>

+ + + + + + +

+Static Public Member Functions
static Subgraphs	SelectSubgraphs (Graph &graph, const LayerSelectorFunction &selector)
	Selects subgraphs from a graph based on the selector function and the algorithm. More...

static Subgraphs	SelectSubgraphs (SubgraphView &subgraph, const LayerSelectorFunction &selector)

+

Detailed Description

+

Algorithm that splits a Graph into Subgraphs based on a filtering of layers (e.g.

+

which layers are appropriate for a certain backend). The resulting subgraphs are guaranteed to be form a DAG (i.e. there are no dependency loops).

+

The algorithm aims to produce as few subgraphs as possible.

+ +

Definition at line 21 of file SubgraphViewSelector.hpp.

+

Member Typedef Documentation

+ +

◆ LayerSelectorFunction

+ +

+

+ + + + +

using LayerSelectorFunction = std::function<bool(const Layer&)>

+

+ +

Definition at line 26 of file SubgraphViewSelector.hpp.

+ +

+

+ +

◆ Subgraphs

+ +

+

+ + + + +

using Subgraphs = std::vector<SubgraphViewPtr>

+

+ +

Definition at line 25 of file SubgraphViewSelector.hpp.

+ +

+

+ +

◆ SubgraphViewPtr

+ +

+

+ + + + +

using SubgraphViewPtr = std::unique_ptr<SubgraphView>

+

+ +

Definition at line 24 of file SubgraphViewSelector.hpp.

+ +

+

Member Function Documentation

+ +

◆ SelectSubgraphs() [1/2]

+ +

+

+ + + + + +

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

SubgraphViewSelector::Subgraphs SelectSubgraphs	(	Graph &	graph,
		const LayerSelectorFunction &	selector
	)

+

+static

+

+ +

Selects subgraphs from a graph based on the selector function and the algorithm.

+

Since the Subgraphs object returns modifiable pointers to the input and output slots of the graph: 1) the graph/sub-graph cannot be const 2) the caller needs to make sure that the Subgraphs lifetime is shorter than the parent graph's

+ +

Definition at line 254 of file SubgraphViewSelector.cpp.

+ +

Referenced by armnn::ApplyBackendOptimizations(), BOOST_AUTO_TEST_CASE(), and MockBackend::OptimizeSubgraphView().

+

 {
     SubgraphView subgraph(graph);
     return SubgraphViewSelector::SelectSubgraphs(subgraph, selector);
 }

+

+

+ +

◆ SelectSubgraphs() [2/2]

+ +

+

+ + + + + +

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

SubgraphViewSelector::Subgraphs SelectSubgraphs	(	SubgraphView &	subgraph,
		const LayerSelectorFunction &	selector
	)

+

+static

+

+ +

Definition at line 384 of file SubgraphViewSelector.cpp.

+ +

References armnn::AssignSplitId(), armnn::ForEachLayerOutput(), armnn::info, and armnn::IsReadyForSplitAssignment().

+

 {
     LayerSelectionInfo::LayerInfoContainer layerInfos;
 
     LayerSelectionInfo::LayerInfoQueue processQueue;
     for (auto& layer : subgraph)
     {
         auto emplaced = layerInfos.emplace(layer, LayerSelectionInfo{layer, selector});
         LayerSelectionInfo& layerInfo = emplaced.first->second;
 
         // Start with Input type layers
         if (layerInfo.IsInputLayer())
         {
             processQueue.push(&layerInfo);
         }
     }
 
     const SubgraphView::InputSlots& subgraphInputSlots = subgraph.GetInputSlots();
     for (auto& inputSlot : subgraphInputSlots)
     {
         Layer& layer = inputSlot->GetOwningLayer();
         auto emplaced = layerInfos.emplace(&layer, LayerSelectionInfo{&layer, selector});
         LayerSelectionInfo& layerInfo = emplaced.first->second;
 
         processQueue.push(&layerInfo);
     }
 
     while (!processQueue.empty())
     {
         LayerSelectionInfo& layerInfo = *processQueue.front();
         processQueue.pop(); // remove front from queue
 
         // This layerInfo may have been added to the queue multiple times, so skip if we have already processed it
         if (!layerInfo.m_IsProcessed)
         {
             // Only process this layerInfo if all inputs have been processed
             if (!IsReadyForSplitAssignment(layerInfos, layerInfo))
             {
                 // Put back of the process queue if we can't process it just yet
                 processQueue.push(&layerInfo);
                 continue; // Skip to next iteration
             }
 
             // Now we do the processing
             AssignSplitId(layerInfos, layerInfo);
 
             // Queue any child nodes for processing
             ForEachLayerOutput(layerInfos, layerInfo, [&processQueue](LayerSelectionInfo& childInfo)
                 {
                     processQueue.push(&childInfo);
                 });
 
             // We don't need to process this node again
             layerInfo.m_IsProcessed = true;
         }
     }
 
     // Collect all selected layers keyed by subgraph representative into a map
     using SelectionInfoPtrs = std::vector<LayerSelectionInfo*>;
     std::map<PartialSubgraph*, SelectionInfoPtrs> splitMap;
     for (auto& info : layerInfos)
     {
         if (info.second.m_IsSelected)
         {
             auto it = splitMap.find(info.second.m_Subgraph->GetRepresentative());
             if (it == splitMap.end())
             {
                 splitMap.insert(
                     std::make_pair(info.second.m_Subgraph->GetRepresentative(), SelectionInfoPtrs{&info.second}));
             }
             else
             {
                 it->second.push_back(&info.second);
             }
         }
     }
 
     // Now each entry in splitMap represents a subgraph
     Subgraphs result;
     for (auto& splitGraph : splitMap)
     {
         SubgraphView::InputSlots inputs;
         SubgraphView::OutputSlots outputs;
         SubgraphView::Layers layers;
         for (auto&& infoPtr : splitGraph.second)
         {
             infoPtr->CollectNonSelectedInputs(layerInfos, inputs);
             infoPtr->CollectNonSelectedOutputSlots(layerInfos, outputs);
             layers.push_back(infoPtr->m_Layer);
         }
         // Create a new sub-graph with the new lists of input/output slots and layer
         result.emplace_back(std::make_unique<SubgraphView>(std::move(inputs),
                                                             std::move(outputs),
                                                             std::move(layers)));
     }
 
     return result;
 }

+
+
+
+
+
+
+
+

+

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

src/armnn/SubgraphViewSelector.hpp
src/armnn/SubgraphViewSelector.cpp

+

+Public Types

+Static Public Member Functions

Detailed Description

Member Typedef Documentation

◆ LayerSelectorFunction

◆ Subgraphs

◆ SubgraphViewPtr

Member Function Documentation

◆ SelectSubgraphs() [1/2]

◆ SelectSubgraphs() [2/2]