patch/23.02/_constant_layer_8hpp_source.xhtml

 //
 // Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
 // SPDX-License-Identifier: MIT
 //
 #pragma once

 #include <Layer.hpp>

 namespace armnn
 {

 class ScopedTensorHandle;

 /// A layer that the constant data can be bound to.
 class ConstantLayer : public Layer
 {
 public:
     /// Makes a workload for the Constant type.
     /// @param [in] graph The graph where this layer can be found.
     /// @param [in] factory The workload factory which will create the workload.
     /// @return A pointer to the created workload, or nullptr if not created.
     virtual std::unique_ptr<IWorkload> CreateWorkload(const IWorkloadFactory& factory) const override;

     /// Creates a dynamically-allocated copy of this layer.
     /// @param [in] graph The graph into which this layer is being cloned.
     ConstantLayer* Clone(Graph& graph) const override;

     /// Check if the input tensor shape(s)
     /// will lead to a valid configuration of @ref ConstantLayer
     /// @param [in] shapeInferenceMethod Indicates if output shape shall be overwritten or just validated.
     void ValidateTensorShapesFromInputs() override;

     /// By default returns inputShapes if the number of inputs are equal to number of outputs,
     /// otherwise infers the output shapes from given input shapes and layer properties.
     /// @param [in] inputShapes The input shapes layer has.
     /// @return a vector to the inferred output shape.
     std::vector<TensorShape> InferOutputShapes(const std::vector<TensorShape>& inputShapes) const override;

     /// Free up the constant source data stored by the layer.
     void ReleaseConstantData() override {}

     void ExecuteStrategy(IStrategy& strategy) const override;

     std::shared_ptr<ConstTensorHandle> m_LayerOutput;

 protected:
     /// Constructor to create a ConstantLayer.
     /// @param [in] name Optional name for the layer.
     ConstantLayer(const char* name);

     /// Default destructor
     ~ConstantLayer() = default;

     /// Retrieve the handles to the constant values stored by the layer.
     // For API stability DO NOT ALTER order and add new members to the end of vector
     ConstantTensors GetConstantTensorsByRef() override { return {m_LayerOutput}; }
 };

 } // namespace
armnn::ConstantLayer
A layer that the constant data can be bound to.
Definition: ConstantLayer.hpp:15

-armnn::ConstantLayer::CreateWorkload
virtual std::unique_ptr< IWorkload > CreateWorkload(const IWorkloadFactory &factory) const override
Makes a workload for the Constant type.
Definition: ConstantLayer.cpp:21

-armnn::IWorkloadFactory
Definition: WorkloadFactory.hpp:22

-armnn::ConstantLayer::m_LayerOutput
std::shared_ptr< ConstTensorHandle > m_LayerOutput
Definition: ConstantLayer.hpp:44

-armnn::ConstantLayer::ValidateTensorShapesFromInputs
void ValidateTensorShapesFromInputs() override
Check if the input tensor shape(s) will lead to a valid configuration of ConstantLayer.
Definition: ConstantLayer.cpp:45

-armnn::ConstantLayer::ExecuteStrategy
void ExecuteStrategy(IStrategy &strategy) const override
Apply a visitor to this layer.
Definition: ConstantLayer.cpp:65

-armnn::ConstantLayer::InferOutputShapes
std::vector< TensorShape > InferOutputShapes(const std::vector< TensorShape > &inputShapes) const override
By default returns inputShapes if the number of inputs are equal to number of outputs, otherwise infers the output shapes from given input shapes and layer properties.
Definition: ConstantLayer.cpp:40

-armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_quick_start.dox:6

-armnn::IStrategy
Definition: IStrategy.hpp:16

-armnn::ConstantLayer::~ConstantLayer
~ConstantLayer()=default
Default destructor.

-armnn::IConnectableLayer::ConstantTensors
std::vector< std::reference_wrapper< std::shared_ptr< ConstTensorHandle > >> ConstantTensors
Definition: INetwork.hpp:124

-armnn::ConstantLayer::Clone
ConstantLayer * Clone(Graph &graph) const override
Creates a dynamically-allocated copy of this layer.
Definition: ConstantLayer.cpp:30

-armnn::Graph
Definition: Graph.hpp:30

-Layer.hpp

-armnn::ConstantLayer::ReleaseConstantData
void ReleaseConstantData() override
Free up the constant source data stored by the layer.
Definition: ConstantLayer.hpp:40

-armnn::ConstantLayer::GetConstantTensorsByRef
ConstantTensors GetConstantTensorsByRef() override
Retrieve the handles to the constant values stored by the layer.
Definition: ConstantLayer.hpp:56

-armnn::ConstantLayer::ConstantLayer
ConstantLayer(const char *name)
Constructor to create a ConstantLayer.
Definition: ConstantLayer.cpp:16

-armnn::Layer
Definition: Layer.hpp:217

+Go to the documentation of this file. //

+ // Copyright © 2017 Arm Ltd and Contributors. All rights reserved.

+ // SPDX-License-Identifier: MIT

+ //

+ #pragma once

+

+ #include <Layer.hpp>

+

+ namespace armnn

+ {

+

+ class ScopedTensorHandle;

+

+ /// A layer that the constant data can be bound to.

+ class ConstantLayer : public Layer

+ {

+ public:

+     /// Makes a workload for the Constant type.

+     /// @param [in] graph The graph where this layer can be found.

+     /// @param [in] factory The workload factory which will create the workload.

+     /// @return A pointer to the created workload, or nullptr if not created.

+     virtual std::unique_ptr<IWorkload> CreateWorkload(const IWorkloadFactory& factory) const override;

+

+     /// Creates a dynamically-allocated copy of this layer.

+     /// @param [in] graph The graph into which this layer is being cloned.

+     ConstantLayer* Clone(Graph& graph) const override;

+

+     /// Check if the input tensor shape(s)

+     /// will lead to a valid configuration of @ref ConstantLayer

+     /// @param [in] shapeInferenceMethod Indicates if output shape shall be overwritten or just validated.

+     void ValidateTensorShapesFromInputs() override;

+

+     /// By default returns inputShapes if the number of inputs are equal to number of outputs,

+     /// otherwise infers the output shapes from given input shapes and layer properties.

+     /// @param [in] inputShapes The input shapes layer has.

+     /// @return a vector to the inferred output shape.

+     std::vector<TensorShape> InferOutputShapes(const std::vector<TensorShape>& inputShapes) const override;

+

+     /// Free up the constant source data stored by the layer.

+     void ReleaseConstantData() override {}

+

+     void ExecuteStrategy(IStrategy& strategy) const override;

+

+     std::shared_ptr<ConstTensorHandle> m_LayerOutput;

+

+ protected:

+     /// Constructor to create a ConstantLayer.

+     /// @param [in] name Optional name for the layer.

+     ConstantLayer(const char* name);

+

+     /// Default destructor

+     ~ConstantLayer() = default;

+

+     /// Retrieve the handles to the constant values stored by the layer.

+     // For API stability DO NOT ALTER order and add new members to the end of vector

+     ConstantTensors GetConstantTensorsByRef() override { return {m_LayerOutput}; }

+ };

+

+ } // namespace