ArmNN
 24.02
SubgraphView.cpp
Go to the documentation of this file.
1 //
2 // Copyright © 2017, 2019-2023 Arm Ltd and Contributors. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5 
7 
8 #include <Graph.hpp>
9 
13 
14 #include <fmt/format.h>
15 #include <utility>
16 
17 namespace armnn
18 {
19 
20 namespace
21 {
22 
23 template <class C>
24 void AssertIfNullsOrDuplicates(const C& container, const std::string& errorMessage)
25 {
26  using T = typename C::value_type;
27  std::unordered_set<T> duplicateSet;
28  std::for_each(container.begin(), container.end(), [&duplicateSet, &errorMessage](const T& i)
29  {
30  // Ignore unused for release builds
31  IgnoreUnused(errorMessage);
32 
33  // Check if the item is valid
34  ARMNN_ASSERT_MSG(i, errorMessage.c_str());
35 
36  // Check if a duplicate has been found
37  ARMNN_ASSERT_MSG(duplicateSet.find(i) == duplicateSet.end(), errorMessage.c_str());
38 
39  duplicateSet.insert(i);
40  });
41 }
42 
43 } // anonymous namespace
44 
46  : enable_shared_from_this()
47  , m_InputSlots{}
48  , m_OutputSlots{}
49  , m_Layers(graph.begin(), graph.end())
50  , m_IConnectableLayers(graph.begin(), graph.end())
51 {
52  ArrangeBySortOrder();
53  CheckSubgraph();
54 }
55 
56 /// IConnectable Duplication to maintain backwards compatibility
57 SubgraphView::SubgraphView(InputSlots&& inputs, OutputSlots&& outputs, Layers&& layers)
58  : enable_shared_from_this()
59  , m_InputSlots{InputSlots{inputs.begin(), inputs.end()}}
60  , m_IInputSlots{IInputSlots{inputs.begin(), inputs.end()}}
61  , m_OutputSlots{OutputSlots{outputs.begin(), outputs.end()}}
62  , m_IOutputSlots{IOutputSlots{outputs.begin(), outputs.end()}}
63  , m_Layers(layers)
64  , m_IConnectableLayers(IConnectableLayers{layers.begin(), layers.end()})
65 {
66  ArrangeBySortOrder();
67  CheckSubgraph();
68 }
69 
70 /// IConnectable Duplication to maintain backwards compatibility
74  : enable_shared_from_this()
75  , m_IInputSlots{inputs}
76  , m_IOutputSlots{outputs}
77  , m_IConnectableLayers(IConnectableLayers{layers.begin(), layers.end()})
78 {
79  // Cast from IConnectableLayer to Layer for backward compatibility
80  auto f = [](IConnectableLayer* value)
81  {
82  return PolymorphicDowncast<Layer*>(value);
83  };
84  std::transform(layers.begin(), layers.end(), std::back_inserter(m_Layers), f);
85 
86  m_InputSlots.resize(inputs.size());
87  m_IInputSlots.resize(inputs.size());
88  for (unsigned int i = 0; i < inputs.size(); i++)
89  {
90  m_InputSlots.at(i) = PolymorphicDowncast<InputSlot*>(inputs[i]);
91  m_IInputSlots.at(i) = inputs[i];
92  }
93 
94  m_OutputSlots.resize(outputs.size());
95  m_IOutputSlots.resize(outputs.size());
96  for (unsigned int i = 0; i < outputs.size(); i++)
97  {
98  m_OutputSlots.at(i) = PolymorphicDowncast<OutputSlot*>(outputs[i]);
99  m_IOutputSlots.at(i) = outputs[i];
100  }
101 
102  ArrangeBySortOrder();
103  CheckSubgraph();
104 }
105 
106 /// IConnectable Duplication to maintain backwards compatibility
108  SubgraphView::IInputSlots&& inputs,
109  SubgraphView::IOutputSlots&& outputs,
110  std::shared_ptr<SubgraphViewWorkingCopy> ptr)
111  : enable_shared_from_this()
112  , m_IInputSlots{inputs}
113  , m_IOutputSlots{outputs}
114  , m_IConnectableLayers(IConnectableLayers{layers.begin(), layers.end()})
115  , p_WorkingCopyImpl(std::move(ptr))
116 {
117  // Cast from IConnectableLayer to Layer for backward compatibility
118  auto f = [](IConnectableLayer* value)
119  {
120  return PolymorphicDowncast<Layer*>(value);
121  };
122  std::transform(layers.begin(), layers.end(), std::back_inserter(m_Layers), f);
123 
124  m_InputSlots.resize(inputs.size());
125  m_IInputSlots.resize(inputs.size());
126  for (unsigned int i = 0; i < inputs.size(); i++)
127  {
128  m_InputSlots.at(i) = PolymorphicDowncast<InputSlot*>(inputs[i]);
129  m_IInputSlots.at(i) = inputs[i];
130  }
131 
132  m_OutputSlots.resize(outputs.size());
133  m_IOutputSlots.resize(outputs.size());
134  for (unsigned int i = 0; i < outputs.size(); i++)
135  {
136  m_OutputSlots.at(i) = PolymorphicDowncast<OutputSlot*>(outputs[i]);
137  m_IOutputSlots.at(i) = outputs[i];
138  }
139 
140  ArrangeBySortOrder();
141  CheckSubgraph();
142 }
143 
145  : enable_shared_from_this()
146  , m_InputSlots(subgraph.m_InputSlots.begin(), subgraph.m_InputSlots.end())
147  , m_IInputSlots(subgraph.m_IInputSlots.begin(), subgraph.m_IInputSlots.end())
148  , m_OutputSlots(subgraph.m_OutputSlots.begin(), subgraph.m_OutputSlots.end())
149  , m_IOutputSlots(subgraph.m_IOutputSlots.begin(), subgraph.m_IOutputSlots.end())
150  , m_Layers(subgraph.m_Layers.begin(), subgraph.m_Layers.end())
151  , m_IConnectableLayers(IConnectableLayers{subgraph.m_IConnectableLayers.begin(),
152  subgraph.m_IConnectableLayers.end()})
153 {
154  ArrangeBySortOrder();
155  CheckSubgraph();
156 }
157 
159  : enable_shared_from_this()
160  , m_InputSlots(std::move(subgraph.m_InputSlots))
161  , m_IInputSlots(std::move(subgraph.m_IInputSlots))
162  , m_OutputSlots(std::move(subgraph.m_OutputSlots))
163  , m_IOutputSlots(std::move(subgraph.m_IOutputSlots))
164  , m_Layers(std::move(subgraph.m_Layers))
165  , m_IConnectableLayers(std::move(subgraph.m_IConnectableLayers))
166 {
167  ArrangeBySortOrder();
168  CheckSubgraph();
169 }
170 
172  : enable_shared_from_this()
173  , m_Layers{PolymorphicDowncast<Layer*>(layer)}
174  , m_IConnectableLayers{layer}
175 {
176  unsigned int numInputSlots = layer->GetNumInputSlots();
177  m_InputSlots.resize(numInputSlots);
178  m_IInputSlots.resize(numInputSlots);
179  for (unsigned int i = 0; i < numInputSlots; i++)
180  {
181  m_InputSlots.at(i) = PolymorphicDowncast<InputSlot*>(&(layer->GetInputSlot(i)));
182  m_IInputSlots.at(i) = &(layer->GetInputSlot(i));
183  }
184 
185  unsigned int numOutputSlots = layer->GetNumOutputSlots();
186  m_OutputSlots.resize(numOutputSlots);
187  m_IOutputSlots.resize(numOutputSlots);
188  for (unsigned int i = 0; i < numOutputSlots; i++)
189  {
190  m_OutputSlots.at(i) = PolymorphicDowncast<OutputSlot*>(&(layer->GetOutputSlot(i)));
191  m_IOutputSlots.at(i) = &(layer->GetOutputSlot(i));
192  }
193 
194  CheckSubgraph();
195 }
196 
198 {
199  m_InputSlots = std::move(other.m_InputSlots);
200  m_IInputSlots = std::move(other.m_IInputSlots);
201  m_OutputSlots = std::move(other.m_OutputSlots);
202  m_IOutputSlots = std::move(other.m_IOutputSlots);
203  m_Layers = std::move(other.m_Layers);
204  m_IConnectableLayers = std::move(other.m_IConnectableLayers);
205 
206  CheckSubgraph();
207 
208  return *this;
209 }
210 
211 void SubgraphView::CheckSubgraph()
212 {
213  // Check for invalid or duplicate input slots
214  AssertIfNullsOrDuplicates(m_InputSlots, "Sub-graphs cannot contain null or duplicate input slots");
215 
216  // Check for invalid or duplicate output slots
217  AssertIfNullsOrDuplicates(m_OutputSlots, "Sub-graphs cannot contain null or duplicate output slots");
218 
219  // Check for invalid or duplicate layers
220  AssertIfNullsOrDuplicates(m_Layers, "Sub-graphs cannot contain null or duplicate layers");
221 
222  // Check for invalid or duplicate input slots
223  AssertIfNullsOrDuplicates(m_IInputSlots, "Sub-graphs cannot contain null or duplicate IInputSlots");
224 
225  // Check for invalid or duplicate output slots
226  AssertIfNullsOrDuplicates(m_IOutputSlots, "Sub-graphs cannot contain null or duplicate IOutputSlots");
227 
228  // Check for invalid or duplicate layers
229  AssertIfNullsOrDuplicates(m_IConnectableLayers,
230  "Sub-graphs cannot contain null or duplicate IConnectableLayers");
231 }
232 
234 {
235  return m_IInputSlots;
236 }
237 
239 {
240  return m_IOutputSlots;
241 }
242 
243 const IInputSlot* SubgraphView::GetIInputSlot(unsigned int index) const
244 {
245  return m_IInputSlots.at(index);
246 }
247 
249 {
250  return m_IInputSlots.at(index);
251 }
252 
253 const IOutputSlot* SubgraphView::GetIOutputSlot(unsigned int index) const
254 {
255  return m_IOutputSlots.at(index);
256 }
257 
259 {
260  return m_OutputSlots.at(index);
261 }
262 
264 {
265  return m_IOutputSlots.at(index);
266 }
267 
268 unsigned int SubgraphView::GetNumInputSlots() const
269 {
270  return armnn::numeric_cast<unsigned int>(m_IInputSlots.size());
271 }
272 
274 {
275  return armnn::numeric_cast<unsigned int>(m_IOutputSlots.size());
276 }
277 
279 {
280  return m_IConnectableLayers;
281 }
282 
284 {
285  return m_IConnectableLayers.begin();
286 }
287 
289 {
290  return m_IConnectableLayers.end();
291 }
292 
293 // IConnectable Duplication to maintain backwards compatibility
294 SubgraphView::IConnectableLayerIterator SubgraphView::beginIConnectable()
295 {
296  return m_IConnectableLayers.begin();
297 }
298 
299 SubgraphView::IConnectableLayerIterator SubgraphView::endIConnectable()
300 {
301  return m_IConnectableLayers.end();
302 }
303 
305 {
306  return m_IConnectableLayers.begin();
307 }
308 
310 {
311  return m_IConnectableLayers.end();
312 }
313 
314 // IConnectable Duplication to maintain backwards compatibility
315 SubgraphView::ConstIConnectableIterator SubgraphView::beginIConnectable() const
316 {
317  return m_IConnectableLayers.begin();
318 }
319 
320 SubgraphView::ConstIConnectableIterator SubgraphView::endIConnectable() const
321 {
322  return m_IConnectableLayers.end();
323 }
324 
326 {
327  return begin();
328 }
329 
331 {
332  return end();
333 }
334 
335 // IConnectable Duplication to maintain backwards compatibility
336 SubgraphView::ConstIConnectableIterator SubgraphView::cbeginIConnectable() const
337 {
338  return begin();
339 }
340 
341 SubgraphView::ConstIConnectableIterator SubgraphView::cendIConnectable() const
342 {
343  return end();
344 }
345 
347 {
348  m_InputSlots.clear();
349  m_OutputSlots.clear();
350  m_Layers.clear();
351 
352  m_IInputSlots.clear();
353  m_IOutputSlots.clear();
354  m_IConnectableLayers.clear();
355 }
356 
357 void SubgraphView::ArrangeBySortOrder()
358 {
359  using LayerList = std::list<Layer*>;
360  auto compareLayerPriority = [](const LayerList::value_type& layerA, const LayerList::value_type& layerB)
361  {
362  return layerA->GetPriority() < layerB->GetPriority();
363  };
364 
365  m_Layers.sort(compareLayerPriority);
366 
367  using IConnectableLayersList = std::list<IConnectableLayer*>;
368  auto compareIConnectableLayerPriority = [](const IConnectableLayersList::value_type& layerA,
369  const IConnectableLayersList::value_type& layerB)
370  {
371  return PolymorphicDowncast<Layer*>(layerA)->GetPriority() <
372  PolymorphicDowncast<Layer*>(layerB)->GetPriority();
373  };
374 
375  m_IConnectableLayers.sort(compareIConnectableLayerPriority);
376 }
377 
378 struct SubgraphView::SubgraphViewWorkingCopy
379 {
380 public:
381 
382  SubgraphViewWorkingCopy() = default;
383  SubgraphViewWorkingCopy(Graph graph, std::shared_ptr<const SubgraphView> originalSubgraphView)
384  : m_Graph(graph)
385  , m_OriginalSubgraphView(originalSubgraphView)
386  {};
387 
388  Graph m_Graph;
389  std::shared_ptr<const SubgraphView> m_OriginalSubgraphView;
390 
391 };
392 
394 {
395  if (p_WorkingCopyImpl)
396  {
397  throw Exception("The SubgraphView calling GetWorkingCopy() is already a working copy. This function "
398  "should be called on original SubgraphView obtained from OptimizeSubgraphView()");
399  }
400 
401  // Create a cut down SubgraphView with underlying graph containing only the relevant layers.
402  // It needs its own underlying layers so that they can be replaced safely.
403  auto ptr = std::make_shared<SubgraphViewWorkingCopy>(Graph(), shared_from_this());
404 
405  std::unordered_map<const IConnectableLayer*, IConnectableLayer*> originalToClonedLayerMap;
406  std::list<armnn::IConnectableLayer*> originalSubgraphLayers = GetIConnectableLayers();
407 
408  for (auto&& originalLayer : originalSubgraphLayers)
409  {
410  Layer* const layer = PolymorphicDowncast<const Layer*>(originalLayer)->Clone(ptr->m_Graph);
411  originalToClonedLayerMap.emplace(originalLayer, layer);
412  }
413 
414  SubgraphView::IInputSlots workingCopyInputs;
415  // Add IInputSlots to workingCopy
416  for (auto originalSubgraphInputSlot : GetIInputSlots())
417  {
418  const IConnectableLayer& originalSubgraphLayer =
419  PolymorphicDowncast<InputSlot*>(originalSubgraphInputSlot)->GetOwningLayer();
420 
421  auto* clonedLayer = originalToClonedLayerMap[&originalSubgraphLayer];
422 
423  workingCopyInputs.push_back(&clonedLayer->GetInputSlot(originalSubgraphInputSlot->GetSlotIndex()));
424  }
425 
426  for (auto originalSubgraphLayer : originalSubgraphLayers)
427  {
428  IConnectableLayer* const clonedLayer = originalToClonedLayerMap[originalSubgraphLayer];
429 
430  // OutputLayers have no OutputSlots to be connected
431  if (clonedLayer->GetType() != LayerType::Output)
432  {
433  // connect all cloned layers as per original subgraph
434  for (unsigned int i = 0; i < clonedLayer->GetNumOutputSlots(); i++)
435  {
436  auto& originalOutputSlot = originalSubgraphLayer->GetOutputSlot(i);
437  auto& clonedOutputSlot = clonedLayer->GetOutputSlot(i);
438  for (unsigned int j = 0; j < originalOutputSlot.GetNumConnections(); j++)
439  {
440  // nextLayer is the layer with IInputSlot connected to IOutputSlot we are working on
441  const IConnectableLayer& nextLayerOnOriginalSubgraph =
442  originalOutputSlot.GetConnection(j)->GetOwningIConnectableLayer();
443 
444  // Check the layer is in our map and so has a clonedLayer
445  if (originalToClonedLayerMap.find(&nextLayerOnOriginalSubgraph) != originalToClonedLayerMap.end())
446  {
447  auto* nextLayerOnClonedSubgraph = originalToClonedLayerMap[&nextLayerOnOriginalSubgraph];
448 
449  auto index = PolymorphicDowncast<OutputSlot*>(
450  &originalOutputSlot)->GetConnection(j)->GetSlotIndex();
451 
452  IInputSlot& inputSlot = nextLayerOnClonedSubgraph->GetInputSlot(index);
453 
454  // Then make the connection
455  clonedOutputSlot.Connect(inputSlot);
456  }
457  }
458  // Copy the tensorInfo to the clonedOutputSlot
459  clonedOutputSlot.SetTensorInfo(originalOutputSlot.GetTensorInfo());
460  }
461  }
462  }
463 
464  SubgraphView::IOutputSlots workingCopyOutputs;
465 
466  // Add IOutputSlots to workingCopy
467  for (auto outputSlot : GetIOutputSlots())
468  {
469  auto outputSlotIndex = outputSlot->CalculateIndexOnOwner();
470  const IConnectableLayer& originalSubgraphLayer = outputSlot->GetOwningIConnectableLayer();
471 
472  // OutputLayers have no OutputSlots to be connected
473  if (originalSubgraphLayer.GetType() != LayerType::Output)
474  {
475  IConnectableLayer* clonedLayer = originalToClonedLayerMap[&originalSubgraphLayer];
476 
477  // Add the OutputSlot of clonedLayer to WorkingCopy OutputSlots
478  workingCopyOutputs.push_back(&clonedLayer->GetOutputSlot(outputSlotIndex));
479  }
480  }
481 
482  SubgraphView::IConnectableLayers workingCopyLayers;
483  for (auto& pair : originalToClonedLayerMap)
484  {
485  workingCopyLayers.push_back(pair.second);
486  }
487 
488  return {std::move(workingCopyLayers),
489  std::move(workingCopyInputs),
490  std::move(workingCopyOutputs),
491  ptr};
492 }
493 
495 {
496  ARMNN_ASSERT(substituteLayer != nullptr);
497  SubgraphView substituteSubgraph(substituteLayer);
498 
499  SubstituteSubgraph(subgraph, substituteSubgraph);
500 }
501 
502 void SubgraphView::UpdateSubgraphViewSlotPointers(SubgraphView& patternSubgraph,
503  const SubgraphView& substituteSubgraph)
504 {
505  std::vector<IInputSlot*>::iterator inputSlotPosition;
506  // search for and erase any InputSlots that appear in the WorkingCopy that match those in the PatternSubgraph
507  for (unsigned long idx = 0; idx < patternSubgraph.GetIInputSlots().size(); idx++)
508  {
509  IInputSlot *slot = patternSubgraph.GetIInputSlots()[idx];
510  inputSlotPosition = std::find(m_IInputSlots.begin(), m_IInputSlots.end(), slot);
511  if (inputSlotPosition != m_IInputSlots.end())
512  {
513  m_IInputSlots.erase(inputSlotPosition);
514 
515  // while here, with correct position, add in replacement InputSlot from the substituteSubgraph
516  m_IInputSlots.insert(inputSlotPosition, substituteSubgraph.GetIInputSlots()[idx]);
517  }
518  }
519 
520  std::vector<IOutputSlot*>::iterator outputSlotPosition;
521  // search for and erase any OutputSlots that appear in the WorkingCopy that match those in the PatternSubgraph
522  for (unsigned long idx = 0; idx < patternSubgraph.GetIOutputSlots().size(); idx++)
523  {
524  IOutputSlot *slot = patternSubgraph.GetIOutputSlots()[idx];
525  outputSlotPosition = std::find(m_IOutputSlots.begin(), m_IOutputSlots.end(), slot);
526  if (outputSlotPosition != m_IOutputSlots.end())
527  {
528  m_IOutputSlots.erase(outputSlotPosition);
529 
530  // while here, with correct position, add in replacement OutputSlot from the substituteSubgraph
531  m_IOutputSlots.insert(outputSlotPosition, substituteSubgraph.GetIOutputSlots()[idx]);
532  }
533  }
534 }
535 
536 void SubgraphView::SubstituteSubgraph(SubgraphView& patternSubgraph, const SubgraphView& substituteSubgraph)
537 {
538  if (!p_WorkingCopyImpl)
539  {
540  throw NullPointerException("The SubgraphView calling SubstituteSubgraphView is not a working copy. "
541  "Call this function on SubgraphView returned from SubgraphView::GetWorkingCopy()");
542  }
543 
544  auto numPatternInputs = patternSubgraph.GetIInputSlots().size();
545  auto numSubInputs = substituteSubgraph.GetIInputSlots().size();
546  if (numPatternInputs != numSubInputs)
547  {
549  fmt::format("Number of InputSlots on substitute SubgraphView ({}) must equal the number of"
550  " InputSlots on pattern SubgraphView ({})",
551  numSubInputs,
552  numPatternInputs));
553  }
554 
555  auto numPatternOutputs = patternSubgraph.GetIOutputSlots().size();
556  auto numSubOutputs = substituteSubgraph.GetIOutputSlots().size();
557  if (numPatternOutputs != numSubOutputs)
558  {
560  fmt::format("Number of OutputSlots on substitute SubgraphView ({}) must equal the number of"
561  " OutputSlots on pattern SubgraphView ({})",
562  numSubOutputs,
563  numPatternOutputs));
564  }
565 
566  // Add substitute layer to the Main graph i.e. graph in p_WorkingCopyImpl
567  auto workingCopyGraph = &p_WorkingCopyImpl->m_Graph;
568  substituteSubgraph.ForEachIConnectableLayer([workingCopyGraph](IConnectableLayer* iConnectableLayer)
569  {
570  // Search WorkingCopy Graph for substituteLayer and add if missing
571  if (std::find(std::begin(workingCopyGraph->m_Layers),
572  std::end(workingCopyGraph->m_Layers),
573  iConnectableLayer) ==
574  std::end(workingCopyGraph->m_Layers))
575  {
576  auto layer = PolymorphicDowncast<Layer*>(iConnectableLayer);
577 
578  layer->Reparent(*workingCopyGraph,
579  (workingCopyGraph->m_Layers).end());
580 
581  workingCopyGraph->m_LayersInOrder = false;
582  }
583  });
584 
585  // Replace the old connections with connections to new layer
586  workingCopyGraph->ReplaceSubgraphConnections(patternSubgraph, substituteSubgraph);
587 
588  // Update input/outputSlot pointers
589  UpdateSubgraphViewSlotPointers(patternSubgraph, substituteSubgraph);
590 
591  // Delete the old layers.
592  workingCopyGraph->EraseSubgraphLayers(patternSubgraph);
593 
594  // Sort
595  workingCopyGraph->TopologicalSort();
596 
597  // Update SubgraphView layer pointers to match those of the internal WorkingCopy layer pointers
598  m_IConnectableLayers = IConnectableLayers{ workingCopyGraph->m_Layers.begin(),
599  workingCopyGraph->m_Layers.end() };
600 }
601 
603 {
604  if (!p_WorkingCopyImpl)
605  {
606  throw NullPointerException("The SubgraphView calling GetOriginalInputSlots is not a working copy. "
607  "Call this function on SubgraphView returned from SubgraphView::GetWorkingCopy()");
608  }
609  if (!p_WorkingCopyImpl->m_OriginalSubgraphView)
610  {
611  throw NullPointerException("The working copy SubgraphView pointer to its original SubgraphView is null.");
612  }
613  return p_WorkingCopyImpl->m_OriginalSubgraphView->GetIInputSlots();
614 }
616 {
617  if (!p_WorkingCopyImpl)
618  {
619  throw NullPointerException("The SubgraphView calling GetOriginalOutputSlots is not a working copy. "
620  "Call this function on SubgraphView returned from SubgraphView::GetWorkingCopy()");
621  }
622  if (!p_WorkingCopyImpl->m_OriginalSubgraphView)
623  {
624  throw NullPointerException("The working copy SubgraphView pointer to its original SubgraphView is null.");
625  }
626  return p_WorkingCopyImpl->m_OriginalSubgraphView->GetIOutputSlots();
627 }
628 
629 
630 } // namespace armnn
ARMNN_ASSERT
#define ARMNN_ASSERT(COND)
Definition: Assert.hpp:14
armnn::SubgraphView::IOutputSlots
std::vector< IOutputSlot * > IOutputSlots
Definition: SubgraphView.hpp:60
armnn::SubgraphView::GetIInputSlot
const IInputSlot * GetIInputSlot(unsigned int index) const
Definition: SubgraphView.cpp:243
armnn::SubgraphView::GetOutputSlot
OutputSlot * GetOutputSlot(unsigned int index)
Definition: SubgraphView.cpp:258
armnn::OutputSlot
Definition: Layer.hpp:100
Graph.hpp
armnn::SubgraphView::cbegin
ConstIConnectableIterator cbegin() const
Definition: SubgraphView.cpp:325
armnn::SubgraphView::GetIOutputSlot
const IOutputSlot * GetIOutputSlot(unsigned int index) const
Definition: SubgraphView.cpp:253
armnn::SubgraphView::GetNumInputSlots
unsigned int GetNumInputSlots() const
Definition: SubgraphView.cpp:268
armnn::SubgraphView::IConnectableLayerIterator
IConnectableLayers::iterator IConnectableLayerIterator
Definition: SubgraphView.hpp:64
IgnoreUnused.hpp
armnn::SubgraphView::operator=
SubgraphView & operator=(SubgraphView &&other)
Move-assignment operator.
Definition: SubgraphView.cpp:197
armnn::IConnectableLayer::GetNumOutputSlots
virtual unsigned int GetNumOutputSlots() const =0
Returns the number of connectable output slots.
NumericCast.hpp
armnn::SubgraphView::InputSlots
std::vector< InputSlot * > InputSlots
Definition: SubgraphView.hpp:57
armnn::Layer
Definition: Layer.hpp:230
armnn::SubgraphView::cend
ConstIConnectableIterator cend() const
Definition: SubgraphView.cpp:330
armnn::SubgraphView::Clear
void Clear()
Definition: SubgraphView.cpp:346
armnn::SubgraphView::IConnectableLayers
std::list< IConnectableLayer * > IConnectableLayers
Definition: SubgraphView.hpp:62
armnn::SubgraphView::ConstIConnectableIterator
IConnectableLayers::const_iterator ConstIConnectableIterator
Definition: SubgraphView.hpp:66
armnn::IOutputSlot
An output connection slot for a layer.
Definition: INetwork.hpp:53
armnn::SubgraphView::GetIConnectableLayers
const IConnectableLayers & GetIConnectableLayers() const
Definition: SubgraphView.cpp:278
armnn::SubgraphView::begin
IConnectableLayerIterator begin()
Definition: SubgraphView.cpp:283
PolymorphicDowncast.hpp
armnn::InvalidArgumentException
Definition: Exceptions.hpp:80
armnn::SubgraphView::IInputSlots
std::vector< IInputSlot * > IInputSlots
Definition: SubgraphView.hpp:58
armnn::IConnectableLayer::GetType
virtual LayerType GetType() const =0
Returns the armnn::LayerType of this layer.
armnn::SubgraphView
The SubgraphView class represents a subgraph of a Graph.
Definition: SubgraphView.hpp:31
armnn::Exception
Base class for all ArmNN exceptions so that users can filter to just those.
Definition: Exceptions.hpp:46
armnn::SubgraphView::GetWorkingCopy
SubgraphView GetWorkingCopy() const
This method returns a copy of the original SubgraphView provided by OptimizeSubgraphView with a separ...
Definition: SubgraphView.cpp:393
SubgraphView.hpp
armnn::SubgraphView::GetNumOutputSlots
unsigned int GetNumOutputSlots() const
Definition: SubgraphView.cpp:273
armnn::Layer::Clone
virtual Layer * Clone(Graph &graph) const =0
Creates a dynamically-allocated copy of this layer.
std
Definition: BackendId.hpp:149
armnn::SubgraphView::GetIInputSlots
const IInputSlots & GetIInputSlots() const
Definition: SubgraphView.cpp:233
armnn::SubgraphView::end
IConnectableLayerIterator end()
Definition: SubgraphView.cpp:288
armnn::IInputSlot::SetTensorInfo
virtual void SetTensorInfo(const TensorInfo tensorInfo)=0
Sets the TensorInfo for this InputSlot.
armnn::IConnectableLayer::GetOutputSlot
virtual const IOutputSlot & GetOutputSlot(unsigned int index) const =0
Get the const output slot handle by slot index.
armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_quick_start.dox:6
armnn::SubgraphView::ForEachIConnectableLayer
void ForEachIConnectableLayer(Func func) const
Definition: SubgraphView.hpp:46
armnn::IConnectableLayer
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
Definition: INetwork.hpp:80
armnn::IInputSlot
An input connection slot for a layer.
Definition: INetwork.hpp:25
armnn::NullPointerException
Definition: Exceptions.hpp:146
armnn::Graph
Definition: Graph.hpp:30
armnn::SubgraphView::GetIOutputSlots
const IOutputSlots & GetIOutputSlots() const
Definition: SubgraphView.cpp:238
armnn::SubgraphView::SubstituteSubgraph
void SubstituteSubgraph(SubgraphView &, IConnectableLayer *)
These methods should be called on a working copy subgraph created from GetWorkingCopy.
Definition: SubgraphView.cpp:494
armnn::SubgraphView::GetOriginalOutputSlots
const IOutputSlots & GetOriginalOutputSlots() const
Definition: SubgraphView.cpp:615
armnn::SubgraphView::SubgraphView
SubgraphView(Graph &graph)
Constructs a sub-graph from the entire given graph.
Definition: SubgraphView.cpp:45
armnn::LayerType::Output
@ Output
armnn::SubgraphView::GetOriginalInputSlots
const IInputSlots & GetOriginalInputSlots() const
These methods should be called on a working copy subgraph created from GetWorkingCopy.
Definition: SubgraphView.cpp:602