plain/21.08/_serializer_8hpp_source.xhtml

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

 #include <armnn/ILayerVisitor.hpp>
 #include <armnn/IStrategy.hpp>
 #include <armnn/LayerVisitorBase.hpp>

 #include <armnnSerializer/ISerializer.hpp>

 #include <common/include/ProfilingGuid.hpp>

 #include <unordered_map>

 #include "ArmnnSchema_generated.h"

 #include <armnn/Types.hpp>

 namespace armnnSerializer
 {

 class SerializerStrategy : public armnn::IStrategy
 {
 public:
     void ExecuteStrategy(const armnn::IConnectableLayer* layer,
                          const armnn::BaseDescriptor& descriptor,
                          const std::vector<armnn::ConstTensor>& constants,
                          const char* name,
                          const armnn::LayerBindingId id) override;

     SerializerStrategy() : m_layerId(0) {}
     ~SerializerStrategy() {}

     flatbuffers::FlatBufferBuilder& GetFlatBufferBuilder()
     {
         return m_flatBufferBuilder;
     }

     std::vector<int>& GetInputIds()
     {
         return m_inputIds;
     }

     std::vector<int>& GetOutputIds()
     {
         return m_outputIds;
     }

     std::vector<flatbuffers::Offset<armnnSerializer::AnyLayer>>& GetSerializedLayers()
     {
         return m_serializedLayers;
     }

     flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> GetVersionTable();

 private:
     /// Creates the Input Slots and Output Slots and LayerBase for the layer.
     flatbuffers::Offset<armnnSerializer::LayerBase> CreateLayerBase(
             const armnn::IConnectableLayer* layer,
             const armnnSerializer::LayerType layerType);

     /// Creates the serializer AnyLayer for the layer and adds it to m_serializedLayers.
     void CreateAnyLayer(const flatbuffers::Offset<void>& layer, const armnnSerializer::Layer serializerLayer);

     /// Creates the serializer ConstTensor for the armnn ConstTensor.
     flatbuffers::Offset<armnnSerializer::ConstTensor> CreateConstTensorInfo(
             const armnn::ConstTensor& constTensor);

     /// Creates the serializer TensorInfo for the armnn TensorInfo.
     flatbuffers::Offset<TensorInfo>  CreateTensorInfo(const armnn::TensorInfo& tensorInfo);

     template <typename T>
     flatbuffers::Offset<flatbuffers::Vector<T>> CreateDataVector(const void* memory, unsigned int size);

     ///Function which maps Guid to an index
     uint32_t GetSerializedId(armnn::LayerGuid guid);

     /// Creates the serializer InputSlots for the layer.
     std::vector<flatbuffers::Offset<armnnSerializer::InputSlot>> CreateInputSlots(
     const armnn::IConnectableLayer* layer);

     /// Creates the serializer OutputSlots for the layer.
     std::vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> CreateOutputSlots(
     const armnn::IConnectableLayer* layer);

     /// FlatBufferBuilder to create our layers' FlatBuffers.
     flatbuffers::FlatBufferBuilder m_flatBufferBuilder;

     /// AnyLayers required by the SerializedGraph.
     std::vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> m_serializedLayers;

     /// Vector of the binding ids of all Input Layers required by the SerializedGraph.
     std::vector<int> m_inputIds;

     /// Vector of the binding ids of all Output Layers required by the SerializedGraph.
     std::vector<int> m_outputIds;

     /// Mapped Guids of all Layers to match our index.
     std::unordered_map<armnn::LayerGuid, uint32_t > m_guidMap;

     /// layer within our FlatBuffer index.
     uint32_t m_layerId;

 private:
     ARMNN_DEPRECATED_MSG("Use VisitElementwiseUnaryLayer instead")
     void SerializeAbsLayer(const armnn::IConnectableLayer* layer,
                                   const char* name = nullptr);

     void SerializeActivationLayer(const armnn::IConnectableLayer* layer,
                                   const armnn::ActivationDescriptor& descriptor,
                                   const char* name = nullptr);

     void SerializeAdditionLayer(const armnn::IConnectableLayer* layer,
                                 const char* name = nullptr);

     void SerializeArgMinMaxLayer(const armnn::IConnectableLayer* layer,
                                  const armnn::ArgMinMaxDescriptor& argMinMaxDescriptor,
                                  const char* name = nullptr);

     void SerializeBatchToSpaceNdLayer(const armnn::IConnectableLayer* layer,
                                       const armnn::BatchToSpaceNdDescriptor& descriptor,
                                       const char* name = nullptr);

     void SerializeBatchNormalizationLayer(const armnn::IConnectableLayer* layer,
                                           const armnn::BatchNormalizationDescriptor& BatchNormalizationDescriptor,
                                           const std::vector<armnn::ConstTensor>& constants,
                                           const char* name = nullptr);

     void SerializeCastLayer(const armnn::IConnectableLayer* layer,
                             const char* name = nullptr);

     void SerializeComparisonLayer(const armnn::IConnectableLayer* layer,
                                   const armnn::ComparisonDescriptor& descriptor,
                                   const char* name = nullptr);

     void SerializeConcatLayer(const armnn::IConnectableLayer* layer,
                               const armnn::ConcatDescriptor& concatDescriptor,
                               const char* name = nullptr);

     void SerializeConstantLayer(const armnn::IConnectableLayer* layer,
                                 const std::vector<armnn::ConstTensor>& contants,
                                 const char* name = nullptr);

     void SerializeConvolution2dLayer(const armnn::IConnectableLayer* layer,
                                      const armnn::Convolution2dDescriptor& descriptor,
                                      const std::vector<armnn::ConstTensor>& contants,
                                      const char* name = nullptr);

     void SerializeDepthToSpaceLayer(const armnn::IConnectableLayer* layer,
                                     const armnn::DepthToSpaceDescriptor& descriptor,
                                     const char* name = nullptr);

     void SerializeDepthwiseConvolution2dLayer(const armnn::IConnectableLayer* layer,
                                               const armnn::DepthwiseConvolution2dDescriptor& descriptor,
                                               const std::vector<armnn::ConstTensor>& constants,
                                               const char* name = nullptr);

     void SerializeDequantizeLayer(const armnn::IConnectableLayer* layer,
                                   const char* name = nullptr);

     void SerializeDetectionPostProcessLayer(const armnn::IConnectableLayer* layer,
                                             const armnn::DetectionPostProcessDescriptor& descriptor,
                                             const std::vector<armnn::ConstTensor>& constants,
                                             const char* name = nullptr);

     void SerializeDivisionLayer(const armnn::IConnectableLayer* layer,
                                 const char* name = nullptr);

     void SerializeElementwiseUnaryLayer(const armnn::IConnectableLayer* layer,
                                         const armnn::ElementwiseUnaryDescriptor& descriptor,
                                         const char* name = nullptr);

     ARMNN_DEPRECATED_MSG("Use VisitComparisonLayer instead")
     void SerializeEqualLayer(const armnn::IConnectableLayer* layer, const char* name);

     void SerializeFillLayer(const armnn::IConnectableLayer* layer,
                             const armnn::FillDescriptor& fillDescriptor,
                             const char* name = nullptr);

     void SerializeFloorLayer(const armnn::IConnectableLayer *layer,
                              const char *name = nullptr);

     void SerializeFullyConnectedLayer(const armnn::IConnectableLayer* layer,
                                       const armnn::FullyConnectedDescriptor& fullyConnectedDescriptor,
                                       const char* name = nullptr);

     void SerializeGatherLayer(const armnn::IConnectableLayer* layer,
                               const armnn::GatherDescriptor& gatherDescriptor,
                               const char* name = nullptr);

     ARMNN_DEPRECATED_MSG("Use VisitComparisonLayer instead")
     void SerializeGreaterLayer(const armnn::IConnectableLayer* layer, const char* name = nullptr);

     void SerializeInputLayer(const armnn::IConnectableLayer* layer,
                          armnn::LayerBindingId id,
                          const char* name = nullptr);

     void SerializeInstanceNormalizationLayer(const armnn::IConnectableLayer* layer,
                                          const armnn::InstanceNormalizationDescriptor& instanceNormalizationDescriptor,
                                          const char* name = nullptr);

     void SerializeL2NormalizationLayer(const armnn::IConnectableLayer* layer,
                                    const armnn::L2NormalizationDescriptor& l2NormalizationDescriptor,
                                    const char* name = nullptr);

     void SerializeLogicalBinaryLayer(const armnn::IConnectableLayer* layer,
                                  const armnn::LogicalBinaryDescriptor& descriptor,
                                  const char* name = nullptr);

     void SerializeLogSoftmaxLayer(const armnn::IConnectableLayer* layer,
                               const armnn::LogSoftmaxDescriptor& logSoftmaxDescriptor,
                               const char* name = nullptr);

     void SerializeLstmLayer(const armnn::IConnectableLayer* layer,
                             const armnn::LstmDescriptor& descriptor,
                             const std::vector<armnn::ConstTensor>& constants,
                             const char* name = nullptr);

     void SerializeMeanLayer(const armnn::IConnectableLayer* layer,
                             const armnn::MeanDescriptor& descriptor,
                             const char* name);

     void SerializeMinimumLayer(const armnn::IConnectableLayer* layer,
                                const char* name = nullptr);

     void SerializeMaximumLayer(const armnn::IConnectableLayer* layer,
                                const char* name = nullptr);

     void SerializeMergeLayer(const armnn::IConnectableLayer* layer,
                              const char* name = nullptr);

     ARMNN_DEPRECATED_MSG("Use VisitConcatLayer instead")
     void SerializeMergerLayer(const armnn::IConnectableLayer* layer,
                               const armnn::MergerDescriptor& mergerDescriptor,
                               const char* name = nullptr);

     void SerializeMultiplicationLayer(const armnn::IConnectableLayer* layer,
                                       const char* name = nullptr);

     void SerializeOutputLayer(const armnn::IConnectableLayer* layer,
                               armnn::LayerBindingId id,
                               const char* name = nullptr);

     void SerializePadLayer(const armnn::IConnectableLayer* layer,
                            const armnn::PadDescriptor& PadDescriptor,
                            const char* name = nullptr);

     void SerializePermuteLayer(const armnn::IConnectableLayer* layer,
                                const armnn::PermuteDescriptor& PermuteDescriptor,
                                const char* name = nullptr);

     void SerializePooling2dLayer(const armnn::IConnectableLayer* layer,
                                  const armnn::Pooling2dDescriptor& pooling2dDescriptor,
                                  const char* name = nullptr);

     void SerializePreluLayer(const armnn::IConnectableLayer* layer,
                              const char* name = nullptr);

     void SerializeQuantizeLayer(const armnn::IConnectableLayer* layer,
                                 const char* name = nullptr);

     void SerializeQLstmLayer(const armnn::IConnectableLayer* layer,
                              const armnn::QLstmDescriptor& descriptor,
                              const std::vector<armnn::ConstTensor>& constants,
                              const char* name = nullptr);

     void SerializeQuantizedLstmLayer(const armnn::IConnectableLayer* layer,
                                      const std::vector<armnn::ConstTensor>& constants,
                                      const char* name = nullptr);

     void SerializeRankLayer(const armnn::IConnectableLayer* layer,
                             const char* name = nullptr);

     void SerializeReduceLayer(const armnn::IConnectableLayer* layer,
                           const armnn::ReduceDescriptor& reduceDescriptor,
                           const char* name = nullptr);

     void SerializeReshapeLayer(const armnn::IConnectableLayer* layer,
                                const armnn::ReshapeDescriptor& reshapeDescriptor,
                                const char* name = nullptr);

     void SerializeResizeLayer(const armnn::IConnectableLayer* layer,
                               const armnn::ResizeDescriptor& resizeDescriptor,
                               const char* name = nullptr);

     ARMNN_DEPRECATED_MSG("Use VisitResizeLayer instead")
     void SerializeResizeBilinearLayer(const armnn::IConnectableLayer* layer,
                                       const armnn::ResizeBilinearDescriptor& resizeDescriptor,
                                       const char* name = nullptr);

     ARMNN_DEPRECATED_MSG("Use VisitElementwiseUnaryLayer instead")
     void SerializeRsqrtLayer(const armnn::IConnectableLayer* layer,
                              const char* name = nullptr);

     void SerializeSliceLayer(const armnn::IConnectableLayer* layer,
                              const armnn::SliceDescriptor& sliceDescriptor,
                              const char* name = nullptr);

     void SerializeSoftmaxLayer(const armnn::IConnectableLayer* layer,
                                const armnn::SoftmaxDescriptor& softmaxDescriptor,
                                const char* name = nullptr);

     void SerializeSpaceToBatchNdLayer(const armnn::IConnectableLayer* layer,
                                       const armnn::SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor,
                                       const char* name = nullptr);

     void SerializeSpaceToDepthLayer(const armnn::IConnectableLayer* layer,
                                     const armnn::SpaceToDepthDescriptor& spaceToDepthDescriptor,
                                     const char* name = nullptr);

     void SerializeNormalizationLayer(const armnn::IConnectableLayer* layer,
                                      const armnn::NormalizationDescriptor& normalizationDescriptor,
                                      const char* name = nullptr);

     void SerializeShapeLayer(const armnn::IConnectableLayer* layer,
                              const char* name = nullptr);

     void SerializeSplitterLayer(const armnn::IConnectableLayer* layer,
                                 const armnn::ViewsDescriptor& viewsDescriptor,
                                 const char* name = nullptr);

     void SerializeStandInLayer(const armnn::IConnectableLayer* layer,
                                const armnn::StandInDescriptor& standInDescriptor,
                                const char* name = nullptr);

     void SerializeStackLayer(const armnn::IConnectableLayer* layer,
                              const armnn::StackDescriptor& stackDescriptor,
                              const char* name = nullptr);

     void SerializeStridedSliceLayer(const armnn::IConnectableLayer* layer,
                                     const armnn::StridedSliceDescriptor& stridedSliceDescriptor,
                                     const char* name = nullptr);

     void SerializeSubtractionLayer(const armnn::IConnectableLayer* layer,
                                    const char* name = nullptr);

     void SerializeSwitchLayer(const armnn::IConnectableLayer* layer,
                               const char* name = nullptr);

     void SerializeTransposeConvolution2dLayer(const armnn::IConnectableLayer* layer,
                                               const armnn::TransposeConvolution2dDescriptor& descriptor,
                                               const std::vector<armnn::ConstTensor>& constants,
                                               const char* = nullptr);

     void SerializeTransposeLayer(const armnn::IConnectableLayer* layer,
                                  const armnn::TransposeDescriptor& descriptor,
                                  const char* name = nullptr);

     void SerializeUnidirectionalSequenceLstmLayer(const armnn::IConnectableLayer* layer,
                                                   const armnn::UnidirectionalSequenceLstmDescriptor& descriptor,
                                                   const std::vector<armnn::ConstTensor>& constants,
                                                   const char* name = nullptr);
 };


 class ISerializer::SerializerImpl
 {
 public:
     SerializerImpl() = default;
     ~SerializerImpl() = default;

     /// Serializes the network to ArmNN SerializedGraph.
     /// @param [in] inNetwork The network to be serialized.
     void Serialize(const armnn::INetwork& inNetwork);

     /// Serializes the SerializedGraph to the stream.
     /// @param [stream] the stream to save to
     /// @return true if graph is Serialized to the Stream, false otherwise
     bool SaveSerializedToStream(std::ostream& stream);

 private:

     /// Visitor to contruct serialized network
     SerializerStrategy m_SerializerStrategy;
 };

 } //namespace armnnSerializer
armnnSerializer::SerializerStrategy
Definition: Serializer.hpp:24

armnnSerializer::ISerializer::SerializerImpl
Definition: Serializer.hpp:359

armnn::ViewsDescriptor
A ViewsDescriptor for the SplitterLayer.
Definition: Descriptors.hpp:206

armnn::IConnectableLayer
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
Definition: INetwork.hpp:61

armnnSerializer::SerializerStrategy::GetFlatBufferBuilder
flatbuffers::FlatBufferBuilder & GetFlatBufferBuilder()
Definition: Serializer.hpp:36

armnn::TransposeConvolution2dDescriptor
A TransposeConvolution2dDescriptor for the TransposeConvolution2dLayer.
Definition: Descriptors.hpp:1231

armnn::ReshapeDescriptor
A ReshapeDescriptor for the ReshapeLayer.
Definition: Descriptors.hpp:844

armnnSerializer
Definition: ISerializer.hpp:11

armnn::TensorInfo
Definition: Tensor.hpp:152

armnn::ComparisonDescriptor
A ComparisonDescriptor for the ComparisonLayer.
Definition: Descriptors.hpp:78

IStrategy.hpp

armnnSerializer::Layer
Layer
Definition: ArmnnSchema_generated.h:1174

armnn::Convolution2dDescriptor
A Convolution2dDescriptor for the Convolution2dLayer.
Definition: Descriptors.hpp:420

armnnSerializer::SerializerStrategy::~SerializerStrategy
~SerializerStrategy()
Definition: Serializer.hpp:34

armnn::INetwork
Main network class which provides the interface for building up a neural network. ...
Definition: INetwork.hpp:177

armnn::LogicalBinaryDescriptor
A LogicalBinaryDescriptor for the LogicalBinaryLayer.
Definition: Descriptors.hpp:1302

armnn::SpaceToDepthDescriptor
A SpaceToDepthDescriptor for the SpaceToDepthLayer.
Definition: Descriptors.hpp:896

armnn::BatchToSpaceNdDescriptor
A BatchToSpaceNdDescriptor for the BatchToSpaceNdLayer.
Definition: Descriptors.hpp:685

armnnSerializer::SerializerStrategy::ExecuteStrategy
void ExecuteStrategy(const armnn::IConnectableLayer *layer, const armnn::BaseDescriptor &descriptor, const std::vector< armnn::ConstTensor > &constants, const char *name, const armnn::LayerBindingId id) override
Definition: Serializer.cpp:1947

armnn::LayerBindingId
int LayerBindingId
Type of identifiers for bindable layers (inputs, outputs).
Definition: Types.hpp:244

armnn::ResizeDescriptor
A ResizeDescriptor for the ResizeLayer.
Definition: Descriptors.hpp:806

armnn::BaseDescriptor
Base class for all descriptors.
Definition: Descriptors.hpp:22

armnn::StackDescriptor
A StackDescriptor for the StackLayer.
Definition: Descriptors.hpp:1042

armnn::IStrategy
Definition: IStrategy.hpp:13

armnn::PadDescriptor
A PadDescriptor for the PadLayer.
Definition: Descriptors.hpp:993

ISerializer.hpp

armnn::LstmDescriptor
An LstmDescriptor for the LstmLayer.
Definition: Descriptors.hpp:923

ILayerVisitor.hpp

armnn::L2NormalizationDescriptor
A L2NormalizationDescriptor for the L2NormalizationLayer.
Definition: Descriptors.hpp:619

armnn::ArgMinMaxDescriptor
An ArgMinMaxDescriptor for ArgMinMaxLayer.
Definition: Descriptors.hpp:56

armnn::OriginsDescriptor
An OriginsDescriptor for the ConcatLayer.
Definition: Descriptors.hpp:163

armnn::ReduceDescriptor
A ReduceDescriptor for the REDUCE operators.
Definition: Descriptors.hpp:1322

Types.hpp

armnn::FullyConnectedDescriptor
A FullyConnectedDescriptor for the FullyConnectedLayer.
Definition: Descriptors.hpp:389

armnn::ConstTensor
A tensor defined by a TensorInfo (shape and data type) and an immutable backing store.
Definition: Tensor.hpp:327

armnn::GatherDescriptor
A GatherDescriptor for the GatherLayer.
Definition: Descriptors.hpp:754

armnn::StandInDescriptor
A StandInDescriptor for the StandIn layer.
Definition: Descriptors.hpp:1072

armnn::QLstmDescriptor
A QLstmDescriptor for the QLstmLayer.
Definition: Descriptors.hpp:1171

armnnSerializer::SerializerStrategy::GetInputIds
std::vector< int > & GetInputIds()
Definition: Serializer.hpp:41

armnn::ActivationDescriptor
An ActivationDescriptor for the ActivationLayer.
Definition: Descriptors.hpp:25

armnn::SliceDescriptor
A SliceDescriptor for the SliceLayer.
Definition: Descriptors.hpp:1019

armnn::SpaceToBatchNdDescriptor
A SpaceToBatchNdDescriptor for the SpaceToBatchNdLayer.
Definition: Descriptors.hpp:864

armnnSerializer::SerializerStrategy::SerializerStrategy
SerializerStrategy()
Definition: Serializer.hpp:33

armnnSerializer::SerializerStrategy::GetOutputIds
std::vector< int > & GetOutputIds()
Definition: Serializer.hpp:46

ArmnnSchema_generated.h

armnn::ElementwiseUnaryDescriptor
A ElementwiseUnaryDescriptor for the ElementwiseUnaryLayer.
Definition: Descriptors.hpp:98

armnn::LayerGuid
profiling::ProfilingGuid LayerGuid
Define LayerGuid type.
Definition: Types.hpp:313

armnn::MeanDescriptor
A MeanDescriptor for the MeanLayer.
Definition: Descriptors.hpp:969

armnn::TransposeDescriptor
A TransposeDescriptor for the TransposeLayer.
Definition: Descriptors.hpp:1281

armnn::StridedSliceDescriptor
A StridedSliceDescriptor for the StridedSliceLayer.
Definition: Descriptors.hpp:1094

LayerVisitorBase.hpp

ARMNN_DEPRECATED_MSG
#define ARMNN_DEPRECATED_MSG(message)
Definition: Deprecated.hpp:43

armnn::Pooling2dDescriptor
A Pooling2dDescriptor for the Pooling2dLayer.
Definition: Descriptors.hpp:329

armnn::NormalizationDescriptor
A NormalizationDescriptor for the NormalizationLayer.
Definition: Descriptors.hpp:579

armnnSerializer::SerializerStrategy::GetSerializedLayers
std::vector< flatbuffers::Offset< armnnSerializer::AnyLayer > > & GetSerializedLayers()
Definition: Serializer.hpp:51

armnnSerializer::SerializerStrategy::GetVersionTable
flatbuffers::Offset< armnnSerializer::FeatureCompatibilityVersions > GetVersionTable()
Definition: Serializer.cpp:1894

armnn::DetectionPostProcessDescriptor
Definition: Descriptors.hpp:523

armnn::InstanceNormalizationDescriptor
An InstanceNormalizationDescriptor for InstanceNormalizationLayer.
Definition: Descriptors.hpp:657

armnn::ResizeBilinearDescriptor
A ResizeBilinearDescriptor for the ResizeBilinearLayer.
Definition: Descriptors.hpp:774

armnnSerializer::LayerType
LayerType
Definition: ArmnnSchema_generated.h:685

armnn::SoftmaxDescriptor
A SoftmaxDescriptor for the SoftmaxLayer.
Definition: Descriptors.hpp:139

armnn::DepthwiseConvolution2dDescriptor
A DepthwiseConvolution2dDescriptor for the DepthwiseConvolution2dLayer.
Definition: Descriptors.hpp:472

armnn::FillDescriptor
A FillDescriptor for the FillLayer.
Definition: Descriptors.hpp:735

armnn::BatchNormalizationDescriptor
A BatchNormalizationDescriptor for the BatchNormalizationLayer.
Definition: Descriptors.hpp:638

armnn::PermuteDescriptor
A PermuteDescriptor for the PermuteLayer.
Definition: Descriptors.hpp:118